rom/intuition/gadgets.c

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