rom/intuition/gadgets.c

   1 /*
   2     Copyright © 1995-2011, 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 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     Move(rp, x1, y1);
 220
 221     /* We RectFill() because it is generally faster than Draw()
 222        (Draw() uses Set/GetPixel() while RectFill() can do higherlevel
 223        clipping. Also it is MUCH faster in the x11gfx hidd.
 224     */
 225
 226     RectFill(rp, x1, y1, x2 - 1, y1);   /* Top      */
 227     RectFill(rp, x2, y1, x2, y2 - 1);   /* Right    */
 228     RectFill(rp, x1 + 1, y2, x2, y2);   /* Bottom   */
 229     RectFill(rp, x1, y1 + 1, x1, y2);   /* Left     */
 230
 231     return;
 232 }
 233
 234 /**********************************************************************************************/
 235
 236 void GetGadgetDomain(struct Gadget *gad, struct Screen *scr, struct Window *win,
 237                      struct Requester *req, struct IBox *box)
 238 {
 239     switch (gad->GadgetType & (GTYP_GADGETTYPE & ~GTYP_SYSGADGET))
 240     {
 241         case GTYP_SCRGADGET:
 242             box->Left   = 0;
 243             box->Top    = 0;
 244             box->Width  = scr->Width;
 245             box->Height = scr->Height;
 246
 247             break;
 248
 249         case GTYP_GZZGADGET:
 250             /* stegerg: this means gadget is in window border! */
 251
 252             box->Left   = 0;
 253             box->Top    = 0;
 254             box->Width  = win->Width;
 255             box->Height = win->Height;
 256
 257             break;
 258
 259         case GTYP_REQGADGET:
 260             box->Left   = req->LeftEdge + win->BorderLeft;
 261             box->Top    = req->TopEdge + win->BorderTop;
 262             box->Width  = req->Width;
 263             box->Height = req->Height;
 264
 265             break;
 266
 267         default:
 268             if (win->Flags & WFLG_GIMMEZEROZERO)
 269             {
 270                 /* stegerg: domain.left and domain.top must not be added
 271                    to gadget position when it is rendered, because gadgets
 272                    in the innerlayer of a gzz gadget are already shifted
 273                    thanks to the innerlayer. */
 274
 275                 box->Left   = win->BorderLeft;
 276                 box->Top    = win->BorderTop;
 277
 278                 box->Width  = win->Width - win->BorderLeft - win->BorderRight;
 279                 box->Height = win->Height - win->BorderTop - win->BorderBottom;
 280
 281             }
 282             else
 283             {
 284                 box->Left   = 0;
 285                 box->Top    = 0;
 286                 box->Width  = win->Width;
 287                 box->Height = win->Height;
 288
 289             }
 290
 291             break;
 292
 293     } /* switch (gadgettype) */
 294 }
 295
 296 /**********************************************************************************************/
 297
 298 WORD GetGadgetLeft(struct Gadget *gad, struct Screen *scr, struct Window *win, struct Requester *req)
 299 {
 300     struct IBox box;
 301
 302     GetGadgetDomain(gad, scr, win, req, &box);
 303
 304     return gad->LeftEdge + ADDREL(gad, GFLG_RELRIGHT, (&box), Width - 1);
 305 }
 306
 307 /**********************************************************************************************/
 308
 309 WORD GetGadgetTop(struct Gadget *gad, struct Screen *scr, struct Window *win, struct Requester *req)
 310 {
 311     struct IBox box;
 312
 313     GetGadgetDomain(gad, scr, win, req, &box);
 314
 315     return gad->TopEdge + ADDREL(gad, GFLG_RELBOTTOM, (&box), Height - 1);
 316 }
 317
 318 /**********************************************************************************************/
 319
 320 WORD GetGadgetWidth(struct Gadget *gad, struct Screen *scr, struct Window *win, struct Requester *req)
 321 {
 322     struct IBox box;
 323
 324     GetGadgetDomain(gad, scr, win, req, &box);
 325
 326     return gad->Width + ADDREL(gad, GFLG_RELWIDTH, (&box), Width);
 327 }
 328
 329 /**********************************************************************************************/
 330
 331 WORD GetGadgetHeight(struct Gadget *gad, struct Screen *scr, struct Window *win, struct Requester *req)
 332 {
 333     struct IBox box;
 334
 335     GetGadgetDomain(gad, scr, win, req, &box);
 336
 337     return gad->Height + ADDREL(gad, GFLG_RELHEIGHT, (&box), Height);
 338 }
 339
 340 /**********************************************************************************************/
 341
 342 /* gadget box in screen coords */
 343 void GetScrGadgetIBox(struct Gadget *gad, struct Screen *scr, struct Window *win,
 344                       struct Requester *req, struct IBox *box)
 345 {
 346     GetWinGadgetIBox(gad, scr, win, req, box);
 347
 348     if (win)
 349     {
 350         box->Left += win->LeftEdge;
 351         box->Top += win->TopEdge;
 352     }
 353 }
 354
 355 /**********************************************************************************************/
 356
 357 /* gadget box relative to upper left window edge */
 358 void GetWinGadgetIBox(struct Gadget *gad, struct Screen *scr, struct Window *win,
 359                       struct Requester *req, struct IBox *box)
 360 {
 361     struct IBox domain;
 362
 363     GetGadgetDomain(gad, scr, win, req, &domain);
 364
 365     box->Left   = gad->LeftEdge;
 366     box->Top    = gad->TopEdge;
 367     box->Width  = gad->Width;
 368     box->Height = gad->Height;
 369
 370     if (gad->Flags & GFLG_RELRIGHT)
 371         box->Left += domain.Width - 1;
 372
 373     if (gad->Flags & GFLG_RELBOTTOM)
 374         box->Top += domain.Height - 1;
 375
 376     if (gad->Flags & GFLG_RELWIDTH)
 377         box->Width += domain.Width;
 378
 379     if (gad->Flags & GFLG_RELHEIGHT)
 380         box->Height += domain.Height;
 381
 382     box->Left += domain.Left;
 383     box->Top += domain.Top;
 384 }
 385
 386 /**********************************************************************************************/
 387
 388 /* gadget box in domain coords */
 389 void GetDomGadgetIBox(struct Gadget *gad, struct Screen *scr, struct Window *win,
 390                       struct Requester *req, struct IBox *box)
 391 {
 392     struct IBox domain;
 393
 394     GetWinGadgetIBox(gad, scr, win, req, box);
 395     GetGadgetDomain(gad, scr, win, req, &domain);
 396
 397     box->Left -= domain.Left;
 398     box->Top  -= domain.Top;
 399 }
 400
 401 /**********************************************************************************************/
 402
 403 /* gadget bounds in screen coords */
 404 void GetScrGadgetBounds(struct Gadget *gad, struct Screen *scr, struct Window *win,
 405                         struct Requester *req, struct IBox *box)
 406 {
 407     struct IBox domain;
 408
 409     if (gad->Flags & GFLG_EXTENDED)
 410     {
 411         if (EG(gad)->MoreFlags & GMORE_BOUNDS)
 412         {
 413             GetGadgetDomain(gad, scr, win, req, &domain);
 414
 415             box->Left = domain.Left +
 416                         EG(gad)->BoundsLeftEdge + ADDREL(gad, GFLG_RELRIGHT, (&domain), Width - 1) +
 417                         (win ? win->LeftEdge : 0);
 418
 419             box->Top  = domain.Top +
 420                         EG(gad)->BoundsTopEdge + ADDREL(gad, GFLG_RELBOTTOM, (&domain), Height - 1) +
 421                         (win ? win->TopEdge : 0);
 422
 423             box->Width = EG(gad)->BoundsWidth + ADDREL(gad, GFLG_RELWIDTH, (&domain), Width);
 424
 425             box->Height = EG(gad)->BoundsHeight + ADDREL(gad, GFLG_RELHEIGHT, (&domain), Height);
 426
 427             return;
 428
 429         } /* if (gad->MoreFlags & GMORE_BOUNDS) */
 430
 431     } /* if (gad->Flags & GFLG_EXTENDED) */
 432
 433     /* if gadget does not have bounds return box */
 434
 435     GetScrGadgetIBox(gad, scr, win, req, box);
 436 }
 437
 438 /**********************************************************************************************/
 439
 440 /* gadget bounds relative to upper left window edge */
 441 void GetWinGadgetBounds(struct Gadget *gad, struct Screen *scr, struct Window *win,
 442                         struct Requester *req, struct IBox *box)
 443 {
 444     GetScrGadgetBounds(gad, scr, win, req, box);
 445
 446     if (win)
 447     {
 448         box->Left -= win->LeftEdge;
 449         box->Top  -= win->TopEdge;
 450     }
 451 }
 452
 453 /**********************************************************************************************/
 454
 455 /* gadget bounds in domain coords */
 456 void GetDomGadgetBounds(struct Gadget *gad, struct Screen *scr, struct Window *win,
 457                         struct Requester *req, struct IBox *box)
 458 {
 459     struct IBox domain;
 460
 461     GetWinGadgetBounds(gad, scr, win, req, box);
 462     GetGadgetDomain(gad, scr, win, req, &domain);
 463
 464     box->Left -= domain.Left;
 465     box->Top  -= domain.Top;
 466 }
 467
 468 /**********************************************************************************************/
 469
 470 void EraseRelGadgetArea(struct Window *win, struct Rectangle *clipto,
 471                         BOOL onlydamagelist, struct IntuitionBase *IntuitionBase)
 472 {
 473     struct GfxBase  *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 474     struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
 475     struct Gadget   *gad;
 476     struct Region   *old_clipregion = NULL; /* shut up the compiler */
 477     struct RastPort *rp, *rp2;
 478     struct Layer    *lay;
 479     struct IBox      box;
 480     WORD             old_scroll_x = 0, old_scroll_y = 0, i, num_loops;
 481
 482     DEBUG_ERASERELGADGETAREA(dprintf("EraseRelGadgetArea: win 0x%lx onlydamage %d\n",
 483                                      win, onlydamagelist));
 484
 485     rp  = win->RPort;
 486     rp2 = win->BorderRPort;
 487
 488     if (rp->Layer == rp2->Layer)
 489     {
 490         num_loops = 1;
 491     }
 492     else
 493     {
 494         num_loops = 2;
 495         clipto = NULL; /* Don't do any border clipping for GZZ windows */
 496     }
 497
 498     for(i = 0; i < num_loops; i++, rp = rp2)
 499     {
 500         lay = rp->Layer;
 501
 502         LockLayer(0, lay);
 503
 504         if (!onlydamagelist)
 505         {
 506             old_scroll_x = lay->Scroll_X;
 507             old_scroll_y = lay->Scroll_Y;
 508             old_clipregion = InstallClipRegion(lay, NULL);
 509         }
 510
 511         gad = win->FirstGadget;
 512         while(gad)
 513         {
 514             BOOL checkgad = FALSE;
 515
 516             DEBUG_ERASERELGADGETAREA(dprintf("EraseRelGadgetArea: Gadget 0x%lx Flags 0x%lx Type 0x%lx Activation 0x%lx %d,%d %d×%d\n",
 517                                              gad, gad->Flags, gad->GadgetType, gad->Activation,
 518                                              gad->LeftEdge, gad->TopEdge, gad->Width, gad->Height));
 519
 520             if (num_loops == 1)
 521             {
 522                 checkgad = TRUE;
 523             }
 524             else
 525             {
 526                 if (i == 0)
 527                 {
 528                     if (!IS_BORDER_GADGET(gad)) checkgad = TRUE;
 529                 }
 530                 else
 531                 {
 532                     if (IS_BORDER_GADGET(gad)) checkgad = TRUE;
 533                 }
 534             }
 535
 536             if (checkgad)
 537             {
 538                 if (gad->Flags & (GFLG_RELRIGHT | GFLG_RELBOTTOM |
 539                                   GFLG_RELWIDTH | GFLG_RELHEIGHT | GFLG_RELSPECIAL))
 540                 {
 541                     struct Rectangle rect;
 542
 543                     GetDomGadgetBounds(gad, win->WScreen, win, NULL, &box);
 544
 545                     if ((box.Width > 0) && (box.Height > 0))
 546                     {
 547                         rect.MinX = box.Left;
 548                         rect.MinY = box.Top;
 549                         rect.MaxX = box.Left + box.Width  - 1;
 550                         rect.MaxY = box.Top  + box.Height - 1;
 551
 552                         if (!(lay->Flags & LAYERSUPER))
 553                         {
 554                             DEBUG_ERASERELGADGETAREA(dprintf("EraseRelGadgetArea: gad 0x%lx add (%d,%d)-(%d,%d)\n", gad, rect.MinX, rect.MinY, rect.MaxX, rect.MaxY));
 555
 556                             OrRectRegion(lay->DamageList, &rect);
 557                             lay->Flags |= LAYERREFRESH;
 558                         }
 559
 560                         if (!onlydamagelist)
 561                         {
 562                             if (!clipto || AndRectRect(&rect, clipto, &rect))
 563                             {
 564                                 EraseRect(rp, rect.MinX, rect.MinY, rect.MaxX, rect.MaxY);
 565                             }
 566                         }
 567
 568                     }
 569
 570                 }
 571
 572             } /* if (checkgad) */
 573
 574             gad = gad->NextGadget;
 575
 576         } /* while(gad) */
 577
 578         if (!onlydamagelist)
 579         {
 580             InstallClipRegion(lay, old_clipregion);
 581             lay->Scroll_X = old_scroll_x;
 582             lay->Scroll_Y = old_scroll_y;
 583         }
 584
 585         UnlockLayer(lay);
 586
 587     } /* for(i = 0; i < num_loops; i++, rp = rp2) */
 588
 589 }
 590
 591 /**********************************************************************************************/
 592
 593 void RenderDisabledPattern(struct RastPort *rp, struct DrawInfo *dri, WORD x1, WORD y1,
 594                            WORD x2, WORD y2, struct IntuitionBase *IntuitionBase)
 595 {
 596     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 597     UWORD pen;
 598     UWORD pattern[] = { 0x8888, 0x2222 };
 599
 600     DEBUG_RENDERDISABLEPATTERN(dprintf("RenderDisabledPattern: rp 0x%lx dri 0x%lx x1 %ld y1 %ld x2 %ld y2 %ld\n",
 601                                        rp,dri,x1,y1,x2,y2));
 602
 603     if (dri)
 604     {
 605         pen = dri->dri_Pens[SHADOWPEN];
 606     }
 607     else
 608     {
 609         pen = 1;
 610     }
 611
 612     SetDrMd( rp, JAM1 );
 613     SetAPen( rp, pen );
 614     SetAfPt( rp, pattern, 1);
 615
 616     /* render disable pattern */
 617     RectFill(rp, x1, y1, x2, y2);
 618
 619     SetAfPt (rp, NULL, 0);
 620
 621 }
 622
 623 /**********************************************************************************************/
 624
 625 ULONG GetGadgetState(struct Window *window, struct Gadget *gadget)
 626 {
 627     ULONG state = IDS_NORMAL;
 628
 629     if (IS_BORDER_GADGET(gadget)
 630         && !(window->Flags & (WFLG_WINDOWACTIVE | WFLG_TOOLBOX)))
 631     {
 632         if (gadget->Flags & GFLG_DISABLED)
 633         {
 634             if (gadget->Flags & GFLG_SELECTED)
 635             {
 636                 state = IDS_INACTIVEDISABLED; /* Hmm ... there's no INACTIVEDISABLEDSELECTED */
 637             }
 638             else
 639             {
 640                 state = IDS_INACTIVEDISABLED;
 641             }
 642         }
 643         else
 644         {
 645             if (gadget->Flags & GFLG_SELECTED)
 646             {
 647                 state = IDS_INACTIVESELECTED;
 648             }
 649             else
 650             {
 651                 state = IDS_INACTIVENORMAL;
 652             }
 653         }
 654     }
 655     else
 656     {
 657         if (gadget->Flags & GFLG_DISABLED)
 658         {
 659             if (gadget->Flags & GFLG_SELECTED)
 660             {
 661                 state = IDS_SELECTEDDISABLED;
 662             }
 663             else
 664             {
 665                 state = IDS_DISABLED;
 666             }
 667         }
 668         else
 669         {
 670             if (gadget->Flags & GFLG_SELECTED)
 671             {
 672                 state = IDS_SELECTED;
 673             }
 674             else
 675             {
 676                 state = IDS_NORMAL;
 677             }
 678         }
 679     }
 680
 681     return state;
 682 }
 683
 684 /**********************************************************************************************/
 685
 686 void SetupGInfo(struct GadgetInfo *gi, struct Window *win, struct Requester *req,
 687                 struct Gadget *gad, struct IntuitionBase *IntuitionBase)
 688 {
 689     struct Window *tw = 0;
 690
 691     DEBUG_SETUPGINFO(dprintf("SetupGInfo: gi %p win %p req %p gadget %p (Type 0x%x)\n",
 692                              gi, win, req, gad, gad->GadgetType));
 693
 694     memset(gi, 0, sizeof(*gi));
 695
 696     if (req)
 697     {
 698         tw = req->RWindow;
 699     }
 700     else
 701     {
 702         tw = win;
 703     }
 704
 705     if (tw)
 706     {
 707         if (IS_SCREEN_GADGET(gad))
 708         {
 709             gi->gi_Window         = NULL;
 710             gi->gi_Screen         = (struct Screen *)tw;
 711             gi->gi_Pens.DetailPen = 0;
 712             gi->gi_Pens.BlockPen  = 0;
 713         }
 714         else
 715         {
 716             gi->gi_Window         = tw;
 717             gi->gi_Screen         = tw->WScreen;
 718             gi->gi_Pens.DetailPen = tw->DetailPen;
 719             gi->gi_Pens.BlockPen  = tw->BlockPen;
 720         }
 721         gi->gi_Requester = req;
 722         gi->gi_DrInfo    = GetScreenDrawInfo (gi->gi_Screen);
 723
 724         SET_GI_RPORT(gi, tw, req, gad);
 725
 726         gi->gi_Layer = gi->gi_RastPort ? gi->gi_RastPort->Layer : NULL;
 727
 728         GetGadgetDomain(gad, gi->gi_Screen, gi->gi_Window, req, &gi->gi_Domain);
 729     } /* if (tw) */
 730
 731     DEBUG_SETUPGINFO(dprintf("SetGInfo: Win %p Req %p RP %p Layer %p\n",
 732                              gi->gi_Window, gi->gi_Requester, gi->gi_RastPort, gi->gi_Layer));
 733 }
 734
 735 /**********************************************************************************************/