rom/intuition/gadgets.c

   1 /*
   2     Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3     Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5
   6     Common routines for Gadgets.
   7 */
   8
   9 /**********************************************************************************************/
  10
  11 #include <exec/types.h>
  12 #include <proto/intuition.h>
  13 #include <intuition/intuition.h>
  14 #include <intuition/cghooks.h>
  15 #include <intuition/classes.h>
  16 #include <intuition/classusr.h>
  17 #include <intuition/imageclass.h>
  18 #include <proto/graphics.h>
  19 #include <proto/layers.h>
  20 #include <graphics/rastport.h>
  21 #include <graphics/text.h>
  22 #include <graphics/gfxmacros.h>
  23
  24 #include <string.h>
  25
  26 #include "intuition_intern.h"
  27 #include "gadgets.h"
  28
  29 #define DEBUG_RENDERDISABLEPATTERN(x)   ;
  30 #define DEBUG_ERASERELGADGETAREA(x) ;
  31 #define DEBUG_SETUPGINFO(x)     ;
  32
  33
  34 /**********************************************************************************************/
  35
  36 #define EG(o) ((struct ExtGadget *)o)
  37 #define IM(o) ((struct Image *)o)
  38
  39 /**********************************************************************************************/
  40
  41 /* print the label of a gadget object */
  42
  43 void printgadgetlabel(Class *cl, Object *o, struct gpRender *msg,
  44                       struct IntuitionBase *IntuitionBase)
  45 {
  46     struct GfxBase  *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
  47     struct RastPort *rp = msg->gpr_RPort;
  48     struct IBox      container;
  49     UWORD           *pens = msg->gpr_GInfo->gi_DrInfo->dri_Pens;
  50     ULONG            len, x, y;
  51
  52     if (!(EG(o)->GadgetText)) return;
  53
  54     GetGadgetIBox((struct Gadget *)o, msg->gpr_GInfo, &container);
  55     //dprintf("printgadgetlabel: o %p ibox %d %d %d %d\n",o,container.Left,container.Top,container.Width,container.Height);
  56
  57     SetFont(rp, msg->gpr_GInfo->gi_DrInfo->dri_Font);
  58
  59     switch (EG(o)->Flags & GFLG_LABELMASK)
  60     {
  61         case GFLG_LABELITEXT:
  62             /* ITexts must not to be centered! */
  63
  64             /* frbuttonclass sets fg/bg/drawmode attributes */
  65             int_PrintIText(rp, EG(o)->GadgetText, container.Left,container.Top, TRUE, IntuitionBase);
  66             break;
  67
  68         case GFLG_LABELSTRING:
  69             len = strlen ((STRPTR) EG(o)->GadgetText);
  70
  71             if (len > 0UL)
  72             {
  73                 ULONG x;
  74                 ULONG y;
  75
  76                 x = container.Left + (container.Width / 2);
  77                 x -= LabelWidth (rp,
  78                                  (STRPTR)EG(o)->GadgetText, len, IntuitionBase) / 2;
  79                 y = container.Top + (container.Height / 2) +
  80                     rp->Font->tf_Baseline;
  81                 y -= rp->Font->tf_YSize / 2;
  82                 SetAPen (rp, pens[TEXTPEN]);
  83                 Move (rp, x, y);
  84                 RenderLabel (rp,
  85                              (STRPTR) EG(o)->GadgetText, len,
  86                              IntuitionBase);
  87             }
  88             break;
  89
  90         case GFLG_LABELIMAGE:
  91             /* center image position */
  92
  93             x = container.Left + ((container.Width / 2) -
  94                                   (IM(EG(o)->GadgetText)->Width / 2)) - IM(EG(o)->GadgetText)->LeftEdge;
  95
  96             y = container.Top + ((container.Height / 2) -
  97                                  (IM(EG(o)->GadgetText)->Height / 2)) - IM(EG(o)->GadgetText)->TopEdge;
  98             //dprintf("printgadgetlabel: o %p w %d h %d x %d y %d l %d t %d\n", o,IM(EG(o)->GadgetText)->Width,IM(EG(o)->GadgetText)->Height,x,y,IM(EG(o)->GadgetText)->LeftEdge,IM(EG(o)->GadgetText)->TopEdge);
  99
 100             DrawImageState(rp, IM(EG(o)->GadgetText),
 101                            x, y,
 102                            ((EG(o)->Flags & GFLG_SELECTED) ? IDS_SELECTED : IDS_NORMAL ),
 103                            msg->gpr_GInfo->gi_DrInfo);
 104             break;
 105
 106     } /* switch (EG(o)->Flags & GFLG_LABELMASK) */
 107
 108 }
 109
 110 /**********************************************************************************************/
 111
 112 /* Calculate the size of the Bounding Box of the gadget */
 113 void CalcBBox (struct Window * window, struct Requester * req, struct Gadget * gadget,
 114                struct BBox * bbox)
 115 {
 116
 117     GetDomGadgetIBox(gadget, window->WScreen, window, req, (struct IBox *)bbox);
 118
 119 } /* CalcBBox */
 120
 121 /**********************************************************************************************/
 122
 123 /* Figure out the size/position of the gadget rectangle, taking relative
 124  * positioning into account.
 125  */
 126 VOID GetGadgetIBox(struct Gadget *g, struct GadgetInfo *gi, struct IBox *ibox)
 127 {
 128     ibox->Left   = g->LeftEdge;
 129     ibox->Top    = g->TopEdge;
 130     ibox->Width  = g->Width;
 131     ibox->Height = g->Height;
 132
 133     if (gi)
 134     {
 135         if (g->Flags & GFLG_RELRIGHT)
 136             ibox->Left   += gi->gi_Domain.Width - 1;
 137
 138         if (g->Flags & GFLG_RELBOTTOM)
 139             ibox->Top    += gi->gi_Domain.Height - 1;
 140
 141         if (g->Flags & GFLG_RELWIDTH)
 142             ibox->Width  += gi->gi_Domain.Width;
 143
 144         if (g->Flags & GFLG_RELHEIGHT)
 145             ibox->Height += gi->gi_Domain.Height;
 146     }
 147
 148     DEBUG_GETGADGETIBOX(dprintf("GetGadgetIBox: Gadget 0x%lx GInfo 0x%lx Flags 0x%lx Left %ld Top %ld Width %ld Height %ld\n",
 149                                 g, gi, g->Flags, ibox->Left, ibox->Top, ibox->Width, ibox->Height));
 150 }
 151
 152 /**********************************************************************************************/
 153
 154 ULONG LabelWidth (struct RastPort * rp, STRPTR label, ULONG len,
 155                   struct IntuitionBase * IntuitionBase)
 156 {
 157     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 158     ULONG totalwidth, uscorewidth;
 159
 160     totalwidth  = TextLength (rp, label, len);
 161     uscorewidth = TextLength (rp, "_", 1);
 162
 163     while (len && *label)
 164     {
 165         if (*label == '_')
 166             totalwidth -= uscorewidth;
 167
 168         label ++;
 169         len --;
 170     }
 171
 172     return totalwidth;
 173 }
 174
 175 /**********************************************************************************************/
 176
 177 void RenderLabel (struct RastPort * rp, STRPTR label, ULONG len,
 178                   struct IntuitionBase * IntuitionBase)
 179 {
 180     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 181     ULONG renderlen;
 182     ULONG uscorewidth;
 183
 184     while (*label)
 185     {
 186         renderlen = 0;
 187
 188         while (label[renderlen] && label[renderlen] != '_')
 189             renderlen ++;
 190
 191         Text (rp, label, renderlen);
 192
 193         label += renderlen;
 194
 195         if (*label) /* '_' ? */
 196         {
 197             WORD cx, cy;
 198
 199             label ++; /* Skip */
 200
 201             uscorewidth = TextLength (rp, label, 1);
 202
 203             cx = rp->cp_x;
 204             cy = rp->cp_y;
 205
 206             Move (rp, cx, cy+2);
 207             Draw (rp, cx+uscorewidth-1, cy+2);
 208             Move (rp, cx, cy);
 209         }
 210     }
 211 }
 212
 213 /**********************************************************************************************/
 214
 215 VOID drawrect(struct RastPort *rp, WORD x1, WORD y1, WORD x2, WORD y2,
 216               struct IntuitionBase *IntuitionBase)
 217 {
 218     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 219
 220     /* We RectFill() because it is generally faster than Draw()
 221        (Draw() uses Set/GetPixel() while RectFill() can do higherlevel
 222        clipping. Also it is MUCH faster in the x11gfx hidd.
 223     */
 224
 225     RectFill(rp, x1, y1, x2 - 1, y1);   /* Top      */
 226     RectFill(rp, x2, y1, x2, y2 - 1);   /* Right    */
 227     RectFill(rp, x1 + 1, y2, x2, y2);   /* Bottom   */
 228     RectFill(rp, x1, y1 + 1, x1, y2);   /* Left     */
 229
 230     return;
 231 }
 232
 233 /**********************************************************************************************/
 234
 235 void GetGadgetDomain(struct Gadget *gad, struct Screen *scr, struct Window *win,
 236                      struct Requester *req, struct IBox *box)
 237 {
 238     switch (gad->GadgetType & (GTYP_GADGETTYPE & ~GTYP_SYSGADGET))
 239     {
 240         case GTYP_SCRGADGET:
 241             box->Left   = 0;
 242             box->Top    = 0;
 243             box->Width  = scr->Width;
 244             box->Height = scr->Height;
 245
 246             break;
 247
 248         case GTYP_GZZGADGET:
 249             /* stegerg: this means gadget is in window border! */
 250
 251             box->Left   = 0;
 252             box->Top    = 0;
 253             box->Width  = win->Width;
 254             box->Height = win->Height;
 255
 256             break;
 257
 258         case GTYP_REQGADGET:
 259             box->Left   = req->LeftEdge + win->BorderLeft;
 260             box->Top    = req->TopEdge + win->BorderTop;
 261             box->Width  = req->Width;
 262             box->Height = req->Height;
 263
 264             break;
 265
 266         default:
 267             if (win->Flags & WFLG_GIMMEZEROZERO)
 268             {
 269                 /* stegerg: domain.left and domain.top must not be added
 270                    to gadget position when it is rendered, because gadgets
 271                    in the innerlayer of a gzz gadget are already shifted
 272                    thanks to the innerlayer. */
 273
 274                 box->Left   = win->BorderLeft;
 275                 box->Top    = win->BorderTop;
 276
 277                 box->Width  = win->Width - win->BorderLeft - win->BorderRight;
 278                 box->Height = win->Height - win->BorderTop - win->BorderBottom;
 279
 280             }
 281             else
 282             {
 283                 box->Left   = 0;
 284                 box->Top    = 0;
 285                 box->Width  = win->Width;
 286                 box->Height = win->Height;
 287
 288             }
 289
 290             break;
 291
 292     } /* switch (gadgettype) */
 293 }
 294
 295 /**********************************************************************************************/
 296
 297 WORD GetGadgetLeft(struct Gadget *gad, struct Screen *scr, struct Window *win, struct Requester *req)
 298 {
 299     struct IBox box;
 300
 301     GetGadgetDomain(gad, scr, win, req, &box);
 302
 303     return gad->LeftEdge + ADDREL(gad, GFLG_RELRIGHT, (&box), Width - 1);
 304 }
 305
 306 /**********************************************************************************************/
 307
 308 WORD GetGadgetTop(struct Gadget *gad, struct Screen *scr, struct Window *win, struct Requester *req)
 309 {
 310     struct IBox box;
 311
 312     GetGadgetDomain(gad, scr, win, req, &box);
 313
 314     return gad->TopEdge + ADDREL(gad, GFLG_RELBOTTOM, (&box), Height - 1);
 315 }
 316
 317 /**********************************************************************************************/
 318
 319 WORD GetGadgetWidth(struct Gadget *gad, struct Screen *scr, struct Window *win, struct Requester *req)
 320 {
 321     struct IBox box;
 322
 323     GetGadgetDomain(gad, scr, win, req, &box);
 324
 325     return gad->Width + ADDREL(gad, GFLG_RELWIDTH, (&box), Width);
 326 }
 327
 328 /**********************************************************************************************/
 329
 330 WORD GetGadgetHeight(struct Gadget *gad, struct Screen *scr, struct Window *win, struct Requester *req)
 331 {
 332     struct IBox box;
 333
 334     GetGadgetDomain(gad, scr, win, req, &box);
 335
 336     return gad->Height + ADDREL(gad, GFLG_RELHEIGHT, (&box), Height);
 337 }
 338
 339 /**********************************************************************************************/
 340
 341 /* gadget box in screen coords */
 342 void GetScrGadgetIBox(struct Gadget *gad, struct Screen *scr, struct Window *win,
 343                       struct Requester *req, struct IBox *box)
 344 {
 345     GetWinGadgetIBox(gad, scr, win, req, box);
 346
 347     if (win)
 348     {
 349         box->Left += win->LeftEdge;
 350         box->Top += win->TopEdge;
 351     }
 352 }
 353
 354 /**********************************************************************************************/
 355
 356 /* gadget box relative to upper left window edge */
 357 void GetWinGadgetIBox(struct Gadget *gad, struct Screen *scr, struct Window *win,
 358                       struct Requester *req, struct IBox *box)
 359 {
 360     struct IBox domain;
 361
 362     GetGadgetDomain(gad, scr, win, req, &domain);
 363
 364     box->Left   = gad->LeftEdge;
 365     box->Top    = gad->TopEdge;
 366     box->Width  = gad->Width;
 367     box->Height = gad->Height;
 368
 369     if (gad->Flags & GFLG_RELRIGHT)
 370         box->Left += domain.Width - 1;
 371
 372     if (gad->Flags & GFLG_RELBOTTOM)
 373         box->Top += domain.Height - 1;
 374
 375     if (gad->Flags & GFLG_RELWIDTH)
 376         box->Width += domain.Width;
 377
 378     if (gad->Flags & GFLG_RELHEIGHT)
 379         box->Height += domain.Height;
 380
 381     box->Left += domain.Left;
 382     box->Top += domain.Top;
 383 }
 384
 385 /**********************************************************************************************/
 386
 387 /* gadget box in domain coords */
 388 void GetDomGadgetIBox(struct Gadget *gad, struct Screen *scr, struct Window *win,
 389                       struct Requester *req, struct IBox *box)
 390 {
 391     struct IBox domain;
 392
 393     GetWinGadgetIBox(gad, scr, win, req, box);
 394     GetGadgetDomain(gad, scr, win, req, &domain);
 395
 396     box->Left -= domain.Left;
 397     box->Top  -= domain.Top;
 398 }
 399
 400 /**********************************************************************************************/
 401
 402 /* gadget bounds in screen coords */
 403 void GetScrGadgetBounds(struct Gadget *gad, struct Screen *scr, struct Window *win,
 404                         struct Requester *req, struct IBox *box)
 405 {
 406     struct IBox domain;
 407
 408     if (gad->Flags & GFLG_EXTENDED)
 409     {
 410         if (EG(gad)->MoreFlags & GMORE_BOUNDS)
 411         {
 412             GetGadgetDomain(gad, scr, win, req, &domain);
 413
 414             box->Left = domain.Left +
 415                         EG(gad)->BoundsLeftEdge + ADDREL(gad, GFLG_RELRIGHT, (&domain), Width - 1) +
 416                         (win ? win->LeftEdge : 0);
 417
 418             box->Top  = domain.Top +
 419                         EG(gad)->BoundsTopEdge + ADDREL(gad, GFLG_RELBOTTOM, (&domain), Height - 1) +
 420                         (win ? win->TopEdge : 0);
 421
 422             box->Width = EG(gad)->BoundsWidth + ADDREL(gad, GFLG_RELWIDTH, (&domain), Width);
 423
 424             box->Height = EG(gad)->BoundsHeight + ADDREL(gad, GFLG_RELHEIGHT, (&domain), Height);
 425
 426             return;
 427
 428         } /* if (gad->MoreFlags & GMORE_BOUNDS) */
 429
 430     } /* if (gad->Flags & GFLG_EXTENDED) */
 431
 432     /* if gadget does not have bounds return box */
 433
 434     GetScrGadgetIBox(gad, scr, win, req, box);
 435 }
 436
 437 /**********************************************************************************************/
 438
 439 /* gadget bounds relative to upper left window edge */
 440 void GetWinGadgetBounds(struct Gadget *gad, struct Screen *scr, struct Window *win,
 441                         struct Requester *req, struct IBox *box)
 442 {
 443     GetScrGadgetBounds(gad, scr, win, req, box);
 444
 445     if (win)
 446     {
 447         box->Left -= win->LeftEdge;
 448         box->Top  -= win->TopEdge;
 449     }
 450 }
 451
 452 /**********************************************************************************************/
 453
 454 /* gadget bounds in domain coords */
 455 void GetDomGadgetBounds(struct Gadget *gad, struct Screen *scr, struct Window *win,
 456                         struct Requester *req, struct IBox *box)
 457 {
 458     struct IBox domain;
 459
 460     GetWinGadgetBounds(gad, scr, win, req, box);
 461     GetGadgetDomain(gad, scr, win, req, &domain);
 462
 463     box->Left -= domain.Left;
 464     box->Top  -= domain.Top;
 465 }
 466
 467 /**********************************************************************************************/
 468
 469 void EraseRelGadgetArea(struct Window *win, struct Rectangle *clipto,
 470                         BOOL onlydamagelist, struct IntuitionBase *IntuitionBase)
 471 {
 472     struct GfxBase  *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 473     struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
 474     struct Gadget   *gad;
 475     struct Region   *old_clipregion = NULL; /* shut up the compiler */
 476     struct RastPort *rp, *rp2;
 477     struct Layer    *lay;
 478     struct IBox      box;
 479     WORD             old_scroll_x = 0, old_scroll_y = 0, i, num_loops;
 480
 481     DEBUG_ERASERELGADGETAREA(dprintf("EraseRelGadgetArea: win 0x%lx onlydamage %d\n",
 482                                      win, onlydamagelist));
 483
 484     rp  = win->RPort;
 485     rp2 = win->BorderRPort;
 486
 487     if (rp->Layer == rp2->Layer)
 488     {
 489         num_loops = 1;
 490     }
 491     else
 492     {
 493         num_loops = 2;
 494         clipto = NULL; /* Don't do any border clipping for GZZ windows */
 495     }
 496
 497     for(i = 0; i < num_loops; i++, rp = rp2)
 498     {
 499         lay = rp->Layer;
 500
 501         LockLayer(0, lay);
 502
 503         if (!onlydamagelist)
 504         {
 505             old_scroll_x = lay->Scroll_X;
 506             old_scroll_y = lay->Scroll_Y;
 507             old_clipregion = InstallClipRegion(lay, NULL);
 508         }
 509
 510         gad = win->FirstGadget;
 511         while(gad)
 512         {
 513             BOOL checkgad = FALSE;
 514
 515             DEBUG_ERASERELGADGETAREA(dprintf("EraseRelGadgetArea: Gadget 0x%lx Flags 0x%lx Type 0x%lx Activation 0x%lx %d,%d %d×%d\n",
 516                                              gad, gad->Flags, gad->GadgetType, gad->Activation,
 517                                              gad->LeftEdge, gad->TopEdge, gad->Width, gad->Height));
 518
 519             if (num_loops == 1)
 520             {
 521                 checkgad = TRUE;
 522             }
 523             else
 524             {
 525                 if (i == 0)
 526                 {
 527                     if (!IS_BORDER_GADGET(gad)) checkgad = TRUE;
 528                 }
 529                 else
 530                 {
 531                     if (IS_BORDER_GADGET(gad)) checkgad = TRUE;
 532                 }
 533             }
 534
 535             if (checkgad)
 536             {
 537                 if (gad->Flags & (GFLG_RELRIGHT | GFLG_RELBOTTOM |
 538                                   GFLG_RELWIDTH | GFLG_RELHEIGHT | GFLG_RELSPECIAL))
 539                 {
 540                     struct Rectangle rect;
 541
 542                     GetDomGadgetBounds(gad, win->WScreen, win, NULL, &box);
 543
 544                     if ((box.Width > 0) && (box.Height > 0))
 545                     {
 546                         rect.MinX = box.Left;
 547                         rect.MinY = box.Top;
 548                         rect.MaxX = box.Left + box.Width  - 1;
 549                         rect.MaxY = box.Top  + box.Height - 1;
 550
 551                         if (!(lay->Flags & LAYERSUPER))
 552                         {
 553                             DEBUG_ERASERELGADGETAREA(dprintf("EraseRelGadgetArea: gad 0x%lx add (%d,%d)-(%d,%d)\n", gad, rect.MinX, rect.MinY, rect.MaxX, rect.MaxY));
 554
 555                             OrRectRegion(lay->DamageList, &rect);
 556                             lay->Flags |= LAYERREFRESH;
 557                         }
 558
 559                         if (!onlydamagelist)
 560                         {
 561                             if (!clipto || AndRectRect(&rect, clipto, &rect))
 562                             {
 563                                 EraseRect(rp, rect.MinX, rect.MinY, rect.MaxX, rect.MaxY);
 564                             }
 565                         }
 566
 567                     }
 568
 569                 }
 570
 571             } /* if (checkgad) */
 572
 573             gad = gad->NextGadget;
 574
 575         } /* while(gad) */
 576
 577         if (!onlydamagelist)
 578         {
 579             InstallClipRegion(lay, old_clipregion);
 580             lay->Scroll_X = old_scroll_x;
 581             lay->Scroll_Y = old_scroll_y;
 582         }
 583
 584         UnlockLayer(lay);
 585
 586     } /* for(i = 0; i < num_loops; i++, rp = rp2) */
 587
 588 }
 589
 590 /**********************************************************************************************/
 591
 592 void RenderDisabledPattern(struct RastPort *rp, struct DrawInfo *dri, WORD x1, WORD y1,
 593                            WORD x2, WORD y2, struct IntuitionBase *IntuitionBase)
 594 {
 595     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 596     UWORD pen;
 597     UWORD pattern[] = { 0x8888, 0x2222 };
 598
 599     DEBUG_RENDERDISABLEPATTERN(dprintf("RenderDisabledPattern: rp 0x%lx dri 0x%lx x1 %ld y1 %ld x2 %ld y2 %ld\n",
 600                                        rp,dri,x1,y1,x2,y2));
 601
 602     if (dri)
 603     {
 604         pen = dri->dri_Pens[SHADOWPEN];
 605     }
 606     else
 607     {
 608         pen = 1;
 609     }
 610
 611     SetDrMd( rp, JAM1 );
 612     SetAPen( rp, pen );
 613     SetAfPt( rp, pattern, 1);
 614
 615     /* render disable pattern */
 616     RectFill(rp, x1, y1, x2, y2);
 617
 618     SetAfPt (rp, NULL, 0);
 619
 620 }
 621
 622 /**********************************************************************************************/
 623
 624 ULONG GetGadgetState(struct Window *window, struct Gadget *gadget)
 625 {
 626     ULONG state = IDS_NORMAL;
 627
 628     if (IS_BORDER_GADGET(gadget)
 629         && !(window->Flags & (WFLG_WINDOWACTIVE | WFLG_TOOLBOX)))
 630     {
 631         if (gadget->Flags & GFLG_DISABLED)
 632         {
 633             if (gadget->Flags & GFLG_SELECTED)
 634             {
 635                 state = IDS_INACTIVEDISABLED; /* Hmm ... there's no INACTIVEDISABLEDSELECTED */
 636             }
 637             else
 638             {
 639                 state = IDS_INACTIVEDISABLED;
 640             }
 641         }
 642         else
 643         {
 644             if (gadget->Flags & GFLG_SELECTED)
 645             {
 646                 state = IDS_INACTIVESELECTED;
 647             }
 648             else
 649             {
 650                 state = IDS_INACTIVENORMAL;
 651             }
 652         }
 653     }
 654     else
 655     {
 656         if (gadget->Flags & GFLG_DISABLED)
 657         {
 658             if (gadget->Flags & GFLG_SELECTED)
 659             {
 660                 state = IDS_SELECTEDDISABLED;
 661             }
 662             else
 663             {
 664                 state = IDS_DISABLED;
 665             }
 666         }
 667         else
 668         {
 669             if (gadget->Flags & GFLG_SELECTED)
 670             {
 671                 state = IDS_SELECTED;
 672             }
 673             else
 674             {
 675                 state = IDS_NORMAL;
 676             }
 677         }
 678     }
 679
 680     return state;
 681 }
 682
 683 /**********************************************************************************************/
 684
 685 void SetupGInfo(struct GadgetInfo *gi, struct Window *win, struct Requester *req,
 686                 struct Gadget *gad, struct IntuitionBase *IntuitionBase)
 687 {
 688     struct Window *tw = 0;
 689
 690     DEBUG_SETUPGINFO(dprintf("SetupGInfo: gi %p win %p req %p gadget %p (Type 0x%x)\n",
 691                              gi, win, req, gad, gad->GadgetType));
 692
 693     memset(gi, 0, sizeof(*gi));
 694
 695     if (req)
 696     {
 697         tw = req->RWindow;
 698     }
 699     else
 700     {
 701         tw = win;
 702     }
 703
 704     if (tw)
 705     {
 706         if (IS_SCREEN_GADGET(gad))
 707         {
 708             gi->gi_Window         = NULL;
 709             gi->gi_Screen         = (struct Screen *)tw;
 710             gi->gi_Pens.DetailPen = 0;
 711             gi->gi_Pens.BlockPen  = 0;
 712         }
 713         else
 714         {
 715             gi->gi_Window         = tw;
 716             gi->gi_Screen         = tw->WScreen;
 717             gi->gi_Pens.DetailPen = tw->DetailPen;
 718             gi->gi_Pens.BlockPen  = tw->BlockPen;
 719         }
 720         gi->gi_Requester = req;
 721         gi->gi_DrInfo    = GetScreenDrawInfo (gi->gi_Screen);
 722
 723         SET_GI_RPORT(gi, tw, req, gad);
 724
 725         gi->gi_Layer = gi->gi_RastPort ? gi->gi_RastPort->Layer : NULL;
 726
 727         GetGadgetDomain(gad, gi->gi_Screen, gi->gi_Window, req, &gi->gi_Domain);
 728     } /* if (tw) */
 729
 730     DEBUG_SETUPGINFO(dprintf("SetGInfo: Win %p Req %p RP %p Layer %p\n",
 731                              gi->gi_Window, gi->gi_Requester, gi->gi_RastPort, gi->gi_Layer));
 732 }
 733
 734 /**********************************************************************************************/