rom/intuition/inputhandler_support.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     Support functions for InputHandler.
   7 */
   8
   9 /****************************************************************************************/
  10
  11 #include <proto/exec.h>
  12 #include <proto/intuition.h>
  13 #include <proto/alib.h>
  14 #include <proto/layers.h>
  15 #include <proto/graphics.h>
  16 #include <proto/utility.h>
  17 #include <proto/keymap.h>
  18 #include <exec/memory.h>
  19 #include <exec/alerts.h>
  20 #include <exec/interrupts.h>
  21 #include <exec/ports.h>
  22 #include <intuition/intuition.h>
  23 #include <intuition/intuitionbase.h>
  24 #include <intuition/gadgetclass.h>
  25 #include <intuition/cghooks.h>
  26 #include <intuition/sghooks.h>
  27 #include <devices/inputevent.h>
  28 #include <string.h>
  29
  30 #include "inputhandler.h"
  31
  32 #include "boopsigadgets.h"
  33 #include "boolgadgets.h"
  34 #include "propgadgets.h"
  35 #include "strgadgets.h"
  36 #include "gadgets.h"
  37 #include "intuition_intern.h" /* EWFLG_xxx */
  38 #include "inputhandler_actions.h"
  39 #include "inputhandler_support.h"
  40 #include "menus.h"
  41
  42 #ifdef SKINS
  43 #   include "mosmisc.h"
  44 #endif
  45
  46 #undef DEBUG
  47 #define DEBUG 0
  48 #include <aros/debug.h>
  49
  50 #define DEBUG_WINDOWNEEDSREFRESH(x) ;
  51 #define DEBUG_DOGPINPUT(x)      ;
  52 #define DEBUG_HANDLECUSTOMRETVAL(x) ;
  53 #define DEBUG_ACTIVATEGADGET(x)     ;
  54 #define DEBUG_FIREINTUIMSG(x)       ;
  55
  56 #include <stddef.h>
  57
  58 /****************************************************************************************/
  59
  60 /*
  61   All screens and windows will be updated with the current position of
  62   the mouse pointer. The windows will receive relative mouse coordinates.
  63 */
  64
  65 /****************************************************************************************/
  66
  67 void notify_mousemove_screensandwindows(WORD x,
  68                                         WORD y,
  69                                         struct IntuitionBase * IntuitionBase)
  70 {
  71     LONG           lock = LockIBase(0);
  72     struct Screen *scr = IntuitionBase->FirstScreen;
  73
  74     while (NULL != scr)
  75     {
  76         struct Window * win = scr->FirstWindow;
  77
  78         scr->MouseX = x;// - scr->LeftEdge;
  79         scr->MouseY = y;// - scr->TopEdge;
  80
  81         /*
  82         ** Visit all windows of this screen
  83         */
  84
  85         while (NULL != win)
  86         {
  87             UpdateMouseCoords(win);
  88
  89             win = win -> NextWindow;
  90         }
  91
  92         scr = scr->NextScreen;
  93     }
  94
  95     UnlockIBase(lock);
  96 }
  97
  98 /****************************************************************************************/
  99
 100 void send_intuimessage(struct IntuiMessage *imsg, struct Window *w,
 101                        struct IntuitionBase *IntuitionBase)
 102 {
 103     SendIntuiMessage(w, imsg);
 104 }
 105
 106 /****************************************************************************************/
 107
 108 void free_intuimessage(struct IntuiMessage *imsg,
 109                        struct IntuitionBase *IntuitionBase)
 110 {
 111     FreeIntuiMessage(imsg);
 112 }
 113
 114 /****************************************************************************************/
 115
 116 struct IntuiMessage *alloc_intuimessage(struct Window *w,
 117                                 struct IntuitionBase *IntuitionBase)
 118 {
 119     struct IntuiMessage *imsg;
 120
 121     imsg = AllocIntuiMessage(w);
 122     if (imsg)
 123     {
 124         if (w)
 125         {
 126             if (w->IDCMPFlags & IDCMP_DELTAMOVE)
 127             {
 128                 struct IIHData *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 129
 130                 imsg->MouseX = iihd->DeltaMouseX;
 131                 imsg->MouseY = iihd->DeltaMouseY;
 132             }
 133             else
 134             {
 135                 imsg->MouseX = w->MouseX;
 136                 imsg->MouseY = w->MouseY;
 137             }
 138         }
 139         CurrentTime(&imsg->Seconds, &imsg->Micros);
 140     }
 141
 142     return imsg;
 143 }
 144
 145 /****************************************************************************************/
 146
 147 BOOL fire_intuimessage(struct Window *w,
 148                        ULONG Class,
 149                        UWORD Code,
 150                        APTR IAddress,
 151                        struct IntuitionBase *IntuitionBase)
 152 {
 153     struct IntuiMessage *imsg;
 154     BOOL                 result = FALSE;
 155
 156     if ((w->IDCMPFlags & Class) && (w->UserPort))
 157     {
 158         if ((imsg = alloc_intuimessage(w, IntuitionBase)))
 159         {
 160             struct IIHData *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 161
 162             imsg->Class =    Class;
 163             imsg->Code      = Code;
 164             imsg->Qualifier = iihd->ActQualifier;
 165             if (Class == IDCMP_RAWKEY)
 166             {
 167                 INT_INTUIMESSAGE(imsg)->prevCodeQuals = IAddress;
 168                 imsg->IAddress = &INT_INTUIMESSAGE(imsg)->prevCodeQuals;
 169             }
 170             else
 171             {
 172                 imsg->IAddress = IAddress;
 173             }
 174
 175             send_intuimessage(imsg, w, IntuitionBase);
 176
 177             result = TRUE;
 178         }
 179         else
 180         {
 181             DEBUG_FIREINTUIMSG(dprintf("fire_intuimessage: can't alloc imsg\n"));
 182         }
 183     }
 184     else
 185     {
 186         DEBUG_FIREINTUIMSG(dprintf("fire_intuimessage: no Userport or masked out idcmpflags\n"));
 187     }
 188
 189     return result;
 190 }
 191
 192 BOOL fire_message(struct Window *w,ULONG Class, UWORD Code, APTR IAddress, struct IntuitionBase *IntuitionBase)
 193 {
 194     struct ExtIntuiMessage *imsg;
 195     BOOL                    result = FALSE;
 196
 197     if ((w->IDCMPFlags & Class) && (w->UserPort))
 198     {
 199         if ((imsg = (struct ExtIntuiMessage *)alloc_intuimessage(w, IntuitionBase)))
 200         {
 201             struct IIHData *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 202
 203             imsg->eim_IntuiMessage.Class     = Class;
 204             imsg->eim_IntuiMessage.Code      = Code;
 205             imsg->eim_IntuiMessage.Qualifier = iihdata->ActQualifier;
 206             if (Class == IDCMP_RAWKEY)
 207             {
 208                 INT_INTUIMESSAGE(imsg)->prevCodeQuals = IAddress;
 209                 imsg->eim_IntuiMessage.IAddress = &INT_INTUIMESSAGE(imsg)->prevCodeQuals;
 210             }
 211             else
 212             {
 213                 imsg->eim_IntuiMessage.IAddress = IAddress;
 214             }
 215
 216             if (iihdata->ActEventTablet && (w->MoreFlags & WMFLG_TABLETMESSAGES))
 217             {
 218                 if ((imsg->eim_TabletData = AllocPooled(GetPrivIBase(IntuitionBase)->IDCMPPool,sizeof (struct TabletData))))
 219                 {
 220                     memclr(imsg->eim_TabletData,sizeof (struct TabletData));
 221                     imsg->eim_TabletData->td_XFraction = iihdata->ActEventTablet->ient_ScaledXFraction;
 222                     imsg->eim_TabletData->td_YFraction = iihdata->ActEventTablet->ient_ScaledYFraction;
 223                     imsg->eim_TabletData->td_TabletX = iihdata->ActEventTablet->ient_TabletX;
 224                     imsg->eim_TabletData->td_TabletY = iihdata->ActEventTablet->ient_TabletY;
 225                     imsg->eim_TabletData->td_RangeX = iihdata->ActEventTablet->ient_RangeX;
 226                     imsg->eim_TabletData->td_RangeY = iihdata->ActEventTablet->ient_RangeY;
 227                     imsg->eim_TabletData->td_TagList = CloneTagItems(iihdata->ActEventTablet->ient_TagList);
 228                 }
 229             }
 230
 231             send_intuimessage(imsg, w, IntuitionBase);
 232
 233             result = TRUE;
 234         }
 235         else
 236         {
 237             DEBUG_FIREINTUIMSG(dprintf("fire_intuimessage: can't alloc imsg\n"));
 238         }
 239     }
 240     else
 241     {
 242         DEBUG_FIREINTUIMSG(dprintf("fire_intuimessage: no Userport or masked out idcmpflags\n"));
 243     }
 244
 245     return result;
 246 }
 247
 248 /****************************************************************************************/
 249
 250 /*
 251    use ih_fire_intuimessage if A) the inputevent because of which
 252    you call this function might have to be eaten or modified
 253    by Intuition or B) an inputevent might have to be created
 254    by Intuition because of a deferred action.
 255
 256    In any case this function may be called only from inside Intuition's
 257    InputHandler!!!!!!
 258 */
 259
 260 /****************************************************************************************/
 261
 262 BOOL ih_fire_intuimessage(struct Window * w,
 263                           ULONG Class,
 264                           UWORD Code,
 265                           APTR IAddress,
 266                           struct IntuitionBase *IntuitionBase)
 267 {
 268     struct IIHData    *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 269     struct InputEvent *ie/* = iihd->ActInputEvent*/;
 270
 271     BOOL result;
 272
 273     DEBUG_FIREINTUIMSG(dprintf("ih_fire_intuimessage: win 0x%lx class 0x%lx code 0x%lx IAddress 0x%lx\n",
 274                                w,
 275                                Class,
 276                                Code,
 277                                IAddress));
 278
 279     result = fire_message(w, Class, Code, IAddress, IntuitionBase);
 280
 281     DEBUG_FIREINTUIMSG(dprintf("ih_fire_intuimessage: fire_intuimessage result 0x%lx\n",
 282                 result));
 283
 284     if (result /*&& ie*/)
 285     {
 286         /* was sent as IDCMP to window so eat inputevent */
 287
 288         //ie->ie_Class = IECLASS_NULL;
 289
 290     }
 291
 292 #if 0
 293     else if (ie/* && (ie->ie_Class != IECLASS_NULL) && !iihd->ActInputEventUsed*/)
 294     {
 295
 296         /* ih_fire_intuimessage was called from inside Intuition's event handling loop */
 297
 298         //iihd->ActInputEventUsed = TRUE;
 299
 300         ie->ie_SubClass     = 0;
 301         ie->ie_Code         = Code;
 302       //ie->ie_Qualifier    = iihd->ActQualifier;
 303         ie->ie_EventAddress = IAddress;
 304
 305         switch(Class)
 306         {
 307         case IDCMP_GADGETUP:
 308             /* Note: on the Amiga if a boopsi Gadget which is GA_Immediate
 309                and GA_RelVerify immediately in GM_GOACTIVE returns GMR_VERIFY,
 310                then this sends IDCMP_GADGETDOWN + IDCMP_GADGETUP. AROS does
 311                the same. But for changed inputevents (if window does not have this
 312                IDCMP Flags set) there will be only one IECLASS_GADGETDOWN
 313             */
 314
 315             ie->ie_Class = IECLASS_GADGETUP;
 316             break;
 317
 318         case IDCMP_GADGETDOWN:
 319             ie->ie_Class = IECLASS_GADGETDOWN;
 320             break;
 321
 322         case IDCMP_ACTIVEWINDOW:
 323             ie->ie_Class = IECLASS_ACTIVEWINDOW;
 324             break;
 325
 326         case IDCMP_INACTIVEWINDOW:
 327             ie->ie_Class = IECLASS_INACTIVEWINDOW;
 328             break;
 329
 330         case IDCMP_CLOSEWINDOW:
 331             ie->ie_Class = IECLASS_CLOSEWINDOW;
 332             break;
 333
 334         case IDCMP_MENUHELP:
 335             ie->ie_Class = IECLASS_MENUHELP;
 336             break;
 337
 338         case IDCMP_MENUPICK:
 339             ie->ie_Class = IECLASS_MENULIST;
 340             break;
 341
 342         case IDCMP_MOUSEBUTTONS:
 343         case IDCMP_MOUSEMOVE:
 344         case IDCMP_RAWKEY:
 345         case IDCMP_VANILLAKEY:
 346             break;
 347
 348         default:
 349             D(bug("ih_fireintuimessage: unexpected IDCMP (%x) for an inputevent-handling-fireintuimessage!\n", Class));
 350             break;
 351
 352         }
 353     }
 354 #endif
 355     else //if (!ie)
 356     {
 357         /* ih_fire_intuimessage was called from inside Intuition's defered action handling routines */
 358
 359         if ((ie = AllocInputEvent(iihd)))
 360         {
 361             switch(Class)
 362             {
 363             case IDCMP_NEWSIZE:
 364                 ie->ie_Class = IECLASS_SIZEWINDOW;
 365                 break;
 366
 367             case IDCMP_CHANGEWINDOW:
 368                 ie->ie_Class = IECLASS_CHANGEWINDOW;
 369                 break;
 370
 371             case IDCMP_ACTIVEWINDOW:
 372                 ie->ie_Class = IECLASS_ACTIVEWINDOW;
 373                 break;
 374
 375             case IDCMP_INACTIVEWINDOW:
 376                 ie->ie_Class = IECLASS_INACTIVEWINDOW;
 377                 break;
 378
 379             case IDCMP_CLOSEWINDOW:
 380                 ie->ie_Class = IECLASS_CLOSEWINDOW;
 381                 break;
 382
 383             case IDCMP_GADGETUP:
 384                 ie->ie_Class = IECLASS_GADGETUP;
 385                 break;
 386
 387             case IDCMP_GADGETDOWN:
 388                 ie->ie_Class = IECLASS_GADGETDOWN;
 389                 break;
 390
 391             case IDCMP_REFRESHWINDOW:
 392                 ie->ie_Class = IECLASS_REFRESHWINDOW;
 393                 break;
 394
 395             case IDCMP_MENUHELP:
 396                 ie->ie_Class = IECLASS_MENUHELP;
 397                 break;
 398
 399             case IDCMP_MENUPICK:
 400                 ie->ie_Class = IECLASS_MENULIST;
 401                 break;
 402
 403             default:
 404                 D(bug("ih_fireintuimessage: unexpected IDCMP (0x%X) for a deferred-action-fireintuimessage!\n", Class));
 405                 break;
 406
 407             } /* switch(Class) */
 408
 409             ie->ie_Code         = Code;
 410             ie->ie_Qualifier    = iihd->ActQualifier;
 411             ie->ie_EventAddress = IAddress;
 412             CurrentTime(&ie->ie_TimeStamp.tv_secs, &ie->ie_TimeStamp.tv_micro);
 413
 414             D(bug("ih_fireintuimessage: generated InputEvent. Class = 0x%X  Code = %d  EventAddress = 0x%X\n",
 415                   ie->ie_Class,
 416                   ie->ie_Code,
 417                   ie->ie_EventAddress));
 418
 419         } /* if ((ie = AllocInputEvent(iihd))) */
 420     }
 421
 422     DEBUG_FIREINTUIMSG(dprintf("ih_fire_intuimessage: result 0x%lx\n",
 423                 result));
 424
 425     return result;
 426 }
 427
 428 /*********************************************************************/
 429
 430 /* This function must never be called with the layer/layerinfo locked,
 431  * otherwise a deadlock with ObtainGIRPort can happen.
 432  */
 433 IPTR Locked_DoMethodA (struct Window *w, struct Gadget *g, Msg message, struct IntuitionBase *IntuitionBase)
 434 {
 435     IPTR rc;
 436     BOOL lock = w && (g->GadgetType & GTYP_SYSGADGET &&
 437             ((g->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING ||
 438              (g->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SIZING));
 439
 440     if (lock)
 441     {
 442         LOCK_REFRESH(w->WScreen);
 443     }
 444
 445     LOCKGADGET
 446     rc = Custom_DoMethodA(g, message);
 447     UNLOCKGADGET
 448
 449     if (lock)
 450     {
 451         UNLOCK_REFRESH(w->WScreen);
 452     }
 453
 454     return rc;
 455 }
 456
 457 /*********************************************************************/
 458
 459 #undef Custom_DoMethodA
 460 IPTR Custom_DoMethodA (struct IntuitionBase *IntuitionBase, struct Gadget *g, Msg message)
 461 {
 462     if (g->MutualExclude)
 463     {
 464         return AROS_UFC4(IPTR, ((struct Hook *)g->MutualExclude)->h_Entry,
 465                  AROS_UFCA(struct Hook *, (struct Hook *)g->MutualExclude, A0),
 466                  AROS_UFCA(struct Gadget *, g, A2),
 467                  AROS_UFCA(APTR, message, A1),
 468                  AROS_UFCA(struct IntuitionBase *, IntuitionBase, A6));
 469     }
 470     else /* Not needed since gadgetclass sets MutualExclude, but doesn't hurt. */
 471         return DoMethodA((Object *)g, message);
 472 }
 473
 474 /****************************************************************************************/
 475
 476 void NotifyDepthArrangement(struct Window *w, struct IntuitionBase *IntuitionBase)
 477 {
 478     if(w->MoreFlags & WMFLG_NOTIFYDEPTH)
 479     {
 480         ih_fire_intuimessage(w,
 481                              IDCMP_CHANGEWINDOW,
 482                              CWCODE_DEPTH,
 483                              0,
 484                              IntuitionBase);
 485     }
 486 }
 487
 488
 489 /****************************************************************************************/
 490
 491 void PrepareGadgetInfo(struct GadgetInfo *gi, struct Screen *scr, struct Window *win,
 492                        struct Requester *req)
 493 {
 494     gi->gi_Screen           = scr;
 495     gi->gi_Window           = win;
 496     gi->gi_Requester        = req;
 497     gi->gi_RastPort         = 0;
 498     gi->gi_Pens.DetailPen   = scr->DetailPen;
 499     gi->gi_Pens.BlockPen    = scr->BlockPen;
 500     gi->gi_DrInfo           = (APTR)&(((struct IntScreen *)gi->gi_Screen)->DInfo);
 501 }
 502
 503 /****************************************************************************************/
 504
 505 void SetGadgetInfoGadget(struct GadgetInfo *gi, struct Gadget *gad,
 506                          struct IntuitionBase *IntuitionBase)
 507 {
 508     struct IIHData *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 509
 510     SET_GI_RPORT(gi, gi->gi_Window, gi->gi_Requester, gad);
 511     InitRastPort(&iihd->GadgetInfoRastPort);
 512
 513     iihd->GadgetInfoRastPort.Layer = gi->gi_RastPort->Layer;
 514     iihd->GadgetInfoRastPort.BitMap = gi->gi_RastPort->BitMap;
 515
 516     SetFont(&iihd->GadgetInfoRastPort, gi->gi_DrInfo->dri_Font);
 517
 518     gi->gi_Layer = gi->gi_RastPort->Layer;
 519     gi->gi_RastPort = &iihd->GadgetInfoRastPort;
 520
 521     GetGadgetDomain(gad, gi->gi_Screen, gi->gi_Window, gi->gi_Requester, &gi->gi_Domain);
 522 }
 523
 524 /****************************************************************************************/
 525
 526 void SetGPIMouseCoords(struct gpInput *gpi, struct Gadget *gad)
 527 {
 528     struct GadgetInfo *gi = gpi->gpi_GInfo;
 529
 530     WORD mousex, mousey;
 531
 532     if (IS_SCREEN_GADGET(gad) || !gi->gi_Window)
 533     {
 534         mousex = gi->gi_Screen->MouseX;
 535         mousey = gi->gi_Screen->MouseY;
 536     }
 537     else
 538     {
 539
 540         mousex = gi->gi_Window->MouseX;
 541         mousey = gi->gi_Window->MouseY;
 542     }
 543
 544     gpi->gpi_Mouse.X = mousex - gi->gi_Domain.Left - GetGadgetLeft(gad, gi->gi_Screen, gi->gi_Window, gi->gi_Requester);
 545     gpi->gpi_Mouse.Y = mousey - gi->gi_Domain.Top  - GetGadgetTop(gad, gi->gi_Screen, gi->gi_Window, gi->gi_Requester);
 546
 547 }
 548
 549 /****************************************************************************************/
 550
 551 void HandleSysGadgetVerify(struct GadgetInfo *gi, struct Gadget *gadget,
 552                            struct IntuitionBase *IntuitionBase)
 553 {
 554     switch(gadget->GadgetType & GTYP_SYSTYPEMASK)
 555     {
 556     case GTYP_CLOSE:
 557 #ifdef __MORPHOS__
 558         if (((struct IntWindow *)(gi->gi_Window))->specialflags & SPFLAG_IAMDEAD)
 559         {
 560             CrashedDispose(gi->gi_Window,IntuitionBase);
 561         }
 562         else
 563         {
 564 #endif
 565             ih_fire_intuimessage(gi->gi_Window,
 566                          IDCMP_CLOSEWINDOW,
 567                          0,
 568                          gi->gi_Window,
 569                          IntuitionBase);
 570 #ifdef __MORPHOS__
 571         }
 572 #endif
 573         break;
 574
 575     case GTYP_WDEPTH:
 576         if (!IsLayerHiddenBySibling(WLAYER(gi->gi_Window), FALSE))
 577         {
 578             /* Send window to back */
 579             WindowToBack(gi->gi_Window);
 580         }
 581         else
 582         {
 583             /* Send window to front */
 584             WindowToFront(gi->gi_Window);
 585         }
 586         break;
 587
 588     case GTYP_WZOOM:
 589         ZipWindow(gi->gi_Window);
 590         break;
 591
 592     case GTYP_SDEPTH:
 593         if (gi->gi_Screen == IntuitionBase->FirstScreen)
 594         {
 595             ScreenToBack(gi->gi_Screen);
 596         }
 597         else
 598         {
 599             ScreenToFront(gi->gi_Screen);
 600         }
 601         break;
 602
 603     } /* switch(gad->GadgetType & GTYP_SYSTYPEMASK) */
 604 }
 605
 606 /****************************************************************************************/
 607
 608 struct Gadget *HandleCustomGadgetRetVal(IPTR retval, struct GadgetInfo *gi, struct Gadget *gadget,
 609                                 ULONG termination, BOOL *reuse_event,
 610                                 struct IntuitionBase *IntuitionBase)
 611 {
 612     struct IIHData  *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 613
 614     DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: retval %ld gi 0x%lx gadget 0x%lx termination %ld reuse %ld\n",
 615                      retval,
 616                      gi,
 617                      gadget,
 618                      termination,
 619                      *reuse_event));
 620
 621     if (retval != GMR_MEACTIVE)
 622     {
 623         struct gpGoInactive gpgi;
 624
 625         DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: !GMR_MEACTIVE\n"));
 626
 627         if (retval & GMR_REUSE)
 628         {
 629             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: GMR_REUSE\n"));
 630             *reuse_event = TRUE;
 631         }
 632
 633         if (retval & GMR_VERIFY)
 634         {
 635             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: GMR_VERIFY\n"));
 636             if (IS_SYS_GADGET(gadget))
 637             {
 638                 DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: SysGad\n"));
 639                 HandleSysGadgetVerify(gi, gadget, IntuitionBase);
 640             }
 641             else
 642             {
 643                 /* Not a system gadget. Send IDCMP_GADGETUP, but not
 644                    if it is a screen gadget where gi->gi_Window would
 645                    be NULL */
 646
 647                 DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: no sysgad\n"));
 648                 if ((gadget->Activation & GACT_RELVERIFY) &&
 649                     (gi->gi_Window))
 650                 {
 651                     DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: Send IDCMP_GADGETUP\n"));
 652                     ih_fire_intuimessage(gi->gi_Window,
 653                                  IDCMP_GADGETUP,
 654                                  termination & 0x0000FFFF,
 655                                  gadget,
 656                                  IntuitionBase);
 657                 }
 658
 659             } /* switch(gad->GadgetType & GTYP_SYSTYPEMASK) */
 660
 661         } /* if (retval & GMR_VERIFY) */
 662
 663         DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: Send GM_GOINACTIVE\n"));
 664
 665         gpgi.MethodID   = GM_GOINACTIVE;
 666         gpgi.gpgi_GInfo = gi;
 667         gpgi.gpgi_Abort = 0;
 668
 669         Locked_DoMethodA(gi->gi_Window, gadget, (Msg)&gpgi, IntuitionBase);
 670
 671         if (SYSGADGET_ACTIVE)
 672         {
 673             /* Switch back from Master Drag or Size Gadget to
 674                real/original/app Size or Drag Gadget */
 675
 676             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: SYSGADGET_ACTIVE\n"));
 677             gadget = iihdata->ActiveSysGadget;
 678             iihdata->ActiveSysGadget = NULL;
 679
 680             if (IS_BOOPSI_GADGET(gadget))
 681             {
 682                 Locked_DoMethodA(gi->gi_Window, gadget, (Msg)&gpgi, IntuitionBase);
 683             }
 684
 685             #ifdef __MORPHOS__
 686             if ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING2)
 687             {
 688                 ih_fire_intuimessage(gi->gi_Window,
 689                                      IDCMP_GADGETUP,
 690                                      0,
 691                                      gadget,
 692                                      IntuitionBase);
 693             }
 694             #endif
 695
 696             retval = 0;
 697         }
 698
 699         if (retval & GMR_VERIFY && gi->gi_Requester && gadget->Activation & GACT_ENDGADGET)
 700         {
 701             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: EndRequest\n"));
 702             EndRequest(gi->gi_Requester, gi->gi_Window);
 703             retval = 0;
 704         }
 705
 706         gadget->Activation &= ~GACT_ACTIVEGADGET;
 707
 708         DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: TabCycle 0x%lx retval 0x%lx\n",
 709                                          (gadget->Flags & GFLG_TABCYCLE),
 710                                          retval));
 711
 712         if ((gadget->Flags & GFLG_TABCYCLE) && (retval & GMR_NEXTACTIVE))
 713         {
 714             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: TabCycle+GMR_NEXTACTIVE\n"));
 715             gadget = FindCycleGadget(gi->gi_Window, gi->gi_Requester, gadget, GMR_NEXTACTIVE);
 716         }
 717         else if ((gadget->Flags & GFLG_TABCYCLE) && (retval & GMR_PREVACTIVE))
 718         {
 719             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: TabCycle+GMR_PREVACTIVE\n"));
 720             gadget = FindCycleGadget(gi->gi_Window, gi->gi_Requester, gadget, GMR_PREVACTIVE);
 721         }
 722         else
 723         {
 724             gadget = NULL;
 725             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: No gadget\n"));
 726         }
 727
 728         if (gadget)
 729         {
 730             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: activate gadget 0x%lx\n",gadget));
 731             gadget = DoActivateGadget(gi->gi_Window, gi->gi_Requester, gadget, IntuitionBase);
 732         }
 733
 734     } /* if (retval != GMR_MEACTIVE) */
 735     else
 736     {
 737         DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: set GACT_ACTIVEGADGET\n"));
 738         gadget->Activation |= GACT_ACTIVEGADGET;
 739     }
 740
 741     DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: return 0x%x\n", gadget));
 742     return gadget;
 743 }
 744
 745 /****************************************************************************************/
 746
 747 /* This function must never be called with the layer/layerinfo locked,
 748  * otherwise a deadlock with ObtainGIRPort can happen.
 749  */
 750 struct Gadget *DoGPInput(struct GadgetInfo *gi, struct Gadget *gadget,
 751                          struct InputEvent *ie, STACKULONG methodid,
 752                          BOOL *reuse_event, struct IntuitionBase *IntuitionBase)
 753 {
 754     struct IIHData  *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 755     struct gpInput   gpi;
 756     IPTR             retval;
 757     ULONG            termination;
 758     ie->ie_Qualifier = iihdata->ActQualifier;
 759
 760     gpi.MethodID        = methodid;
 761     gpi.gpi_GInfo       = gi;
 762     gpi.gpi_IEvent      = ie;
 763     gpi.gpi_Termination = &termination;
 764     gpi.gpi_TabletData  = NULL;
 765
 766     SetGPIMouseCoords(&gpi, gadget);
 767
 768     retval = Locked_DoMethodA (gi->gi_Window, gadget, (Msg)&gpi, IntuitionBase);
 769
 770     DEBUG_DOGPINPUT(dprintf("DoGPInput: Locked_DoMethod gadget %p method 0x%lx retval %ld termination 0x%lx\n",
 771                 gadget, methodid, retval, termination));
 772
 773     return HandleCustomGadgetRetVal(retval, gi, gadget, termination,
 774                     reuse_event, IntuitionBase);
 775
 776 }
 777
 778 /****************************************************************************************/
 779
 780 struct Gadget * FindGadget (struct Screen *scr, struct Window * window,
 781                             struct Requester * req, int x, int y,
 782                             struct GadgetInfo * gi,BOOL sysonly,
 783                             struct IntuitionBase *IntuitionBase)
 784 {
 785     struct Gadget       *gadget, *firstgadget, *draggadget = 0;
 786     struct gpHitTest     gpht;
 787     struct IBox          ibox;
 788     WORD                 xrel, yrel;
 789     BOOL                 sys_only = sysonly;
 790
 791     gpht.MethodID     = GM_HITTEST;
 792     gpht.gpht_GInfo   = gi;
 793
 794     while (req || window || scr)
 795     {
 796         if (req)
 797         {
 798             firstgadget = req->ReqGadget;
 799         }
 800         else if (window)
 801         {
 802             firstgadget = window->FirstGadget;
 803         }
 804         else
 805         {
 806             if (draggadget) return draggadget;
 807             firstgadget = scr->FirstGadget;
 808         }
 809
 810         for (gadget = firstgadget; gadget; gadget = gadget->NextGadget)
 811         {
 812             if (!(gadget->Flags & GFLG_DISABLED) &&
 813                 (!sys_only ||
 814                  (gadget->GadgetType & GTYP_SYSGADGET &&
 815                    ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SIZING ||
 816                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING ||
 817                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDEPTH ||
 818                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SDEPTH ||
 819                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WZOOM ||
 820                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_CLOSE))))
 821             {
 822                 /* stegerg: domain depends on gadgettype and windowflags! */
 823                 GetGadgetDomain(gadget, scr, window, req, &gi->gi_Domain);
 824
 825                 /* Get coords relative to window */
 826
 827                 GetGadgetIBox(gadget, gi, &ibox);
 828
 829                 xrel = x - gi->gi_Domain.Left;
 830                 yrel = y - gi->gi_Domain.Top;
 831
 832                 /*if (req)
 833             {
 834                     xrel -= req->LeftEdge + window->BorderLeft;
 835                     yrel -= req->TopEdge + window->BorderTop;
 836             }*/
 837
 838                 if (window)
 839                 {
 840                     xrel -= window->LeftEdge;
 841                     yrel -= window->TopEdge;
 842                 }
 843
 844                 if ((xrel >= ibox.Left) &&
 845                     (yrel >= ibox.Top) &&
 846                     (xrel < ibox.Left + ibox.Width) &&
 847                     (yrel < ibox.Top  + ibox.Height))
 848                 {
 849                     if ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING)
 850                     {
 851                         if (!draggadget) draggadget = gadget;
 852                     }
 853                     else
 854                     {
 855
 856                         if ((gadget->GadgetType & GTYP_GTYPEMASK) == GTYP_CUSTOMGADGET)
 857                         {
 858
 859                             gpht.gpht_Mouse.X = xrel - ibox.Left;
 860                             gpht.gpht_Mouse.Y = yrel - ibox.Top;
 861
 862                             /* jDc: don't check for == GMR_GADGETHIT since some reaction classes*/
 863                             /* (BURN IN HELL!) return TRUE here (related to imageclass HITEST?)*/
 864                             if (Locked_DoMethodA (window, gadget, (Msg)&gpht, IntuitionBase))
 865                                 return (gadget);
 866                         }
 867                         else
 868                         {
 869                             return (gadget);
 870                         }
 871                     }
 872                 }
 873
 874             } /* if (!(gadget->Flags & GFLG_DISABLED)) */
 875
 876         } /* for (gadget = window->FirstGadget; gadget; gadget = gadget->NextGadget) */
 877
 878         sys_only = sysonly;
 879
 880         if (req)
 881         {
 882             req = NULL;
 883             sys_only = TRUE;
 884         }
 885         else if (window)
 886         {
 887         #ifdef SKINS
 888             draggadget = findbordergadget(window,draggadget,IntuitionBase);
 889         #endif
 890             window = NULL;
 891         }
 892         else
 893             scr = NULL;
 894     }
 895
 896     return (draggadget);
 897
 898 } /* FindGadget */
 899
 900
 901 /****************************************************************************************/
 902
 903 struct Gadget * FindHelpGadget (struct Window * window,
 904                             int x, int y, struct IntuitionBase *IntuitionBase)
 905 {
 906     struct Gadget       *gadget, *firstgadget;
 907     struct Requester    *req = window->FirstRequest;
 908
 909     while (req || window)
 910     {
 911         if (req)
 912         {
 913             firstgadget = req->ReqGadget;
 914         }
 915         else
 916         {
 917             firstgadget = window->FirstGadget;
 918         }
 919
 920         for (gadget = firstgadget; gadget; gadget = gadget->NextGadget)
 921         {
 922             if ((gadget->Flags & GFLG_EXTENDED) &&
 923                 (((struct ExtGadget *)gadget)->MoreFlags & GMORE_GADGETHELP))
 924             {
 925                 if (InsideGadget(window->WScreen, window, req, gadget, x, y))
 926                 {
 927                     return (gadget);
 928                 }
 929             }
 930
 931         }
 932
 933         if (req)
 934             req = req->OlderRequest;
 935         else
 936             window = NULL;
 937     }
 938
 939     return (NULL);
 940
 941 } /* FindGadget */
 942
 943
 944 /****************************************************************************************/
 945
 946 BOOL InsideGadget(struct Screen *scr, struct Window *win, struct Requester *req,
 947                   struct Gadget *gad, WORD x, WORD y)
 948 {
 949     struct IBox box;
 950     BOOL        rc = FALSE;
 951
 952     GetScrGadgetIBox(gad, scr, win, req, &box);
 953
 954     if ((x >= box.Left) &&
 955         (y >= box.Top)  &&
 956         (x < box.Left + box.Width) &&
 957         (y < box.Top + box.Height))
 958     {
 959         rc = TRUE;
 960     }
 961
 962     return rc;
 963 }
 964
 965 /****************************************************************************************/
 966
 967 struct Gadget *DoActivateGadget(struct Window *win, struct Requester *req, struct Gadget *gad,
 968                                 struct IntuitionBase *IntuitionBase)
 969 {
 970     struct IIHData      *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 971     struct GadgetInfo   *gi = &iihd->GadgetInfo;
 972     struct Gadget       *result = NULL;
 973
 974     DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: Window 0x%lx Req 0x%lx Gadget 0x%lx\n",
 975                                  win,
 976                                  req,
 977                                  gad));
 978
 979     DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: Activation 0x%lx\n",
 980                                  gad->Activation));
 981
 982     if (gad->Activation & GACT_IMMEDIATE)
 983     {
 984         DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: Send GADGETDOWN msg\n"));
 985         ih_fire_intuimessage(win,
 986                              IDCMP_GADGETDOWN,
 987                              0,
 988                              gad,
 989                              IntuitionBase);
 990     }
 991
 992     PrepareGadgetInfo(gi, win->WScreen, win, req);
 993     SetGadgetInfoGadget(gi, gad, IntuitionBase);
 994
 995     DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: Type 0x%lx\n",
 996                     gad->GadgetType & GTYP_GTYPEMASK));
 997
 998     switch(gad->GadgetType & GTYP_GTYPEMASK)
 999     {
1000         case GTYP_STRGADGET:
1001         {
1002             struct StringInfo *si = (struct StringInfo *)gad->SpecialInfo;
1003
1004             DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: GTYP_STRGADGET\n"));
1005
1006             gad->Flags |= GFLG_SELECTED;
1007             if (si && si->UndoBuffer)
1008             {
1009                 strcpy(si->UndoBuffer, si->Buffer);
1010             }
1011
1012             gad->Activation |= GACT_ACTIVEGADGET;
1013             UpdateStrGadget(gad, win, req, IntuitionBase);
1014             result = gad;
1015             break;
1016         }
1017
1018         case GTYP_CUSTOMGADGET:
1019         {
1020             struct gpInput  gpi;
1021             ULONG           termination;
1022             IPTR            retval;
1023             BOOL            reuse_event;
1024
1025             DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: GTYP_CUSTOMGADGET\n"));
1026
1027             gpi.MethodID        = GM_GOACTIVE;
1028             gpi.gpi_GInfo       = gi;
1029             gpi.gpi_IEvent      = NULL;
1030             gpi.gpi_Termination = &termination;
1031             gpi.gpi_Mouse.X     = win->MouseX - gi->gi_Domain.Left - GetGadgetLeft(gad, gi->gi_Screen, gi->gi_Window, NULL);
1032             gpi.gpi_Mouse.Y     = win->MouseY - gi->gi_Domain.Top  - GetGadgetTop(gad, gi->gi_Screen, gi->gi_Window, NULL);
1033             gpi.gpi_TabletData  = NULL;
1034
1035             retval = Locked_DoMethodA (win, gad, (Msg)&gpi, IntuitionBase);
1036
1037             gad = HandleCustomGadgetRetVal(retval, gi, gad,termination,
1038                                &reuse_event, IntuitionBase);
1039
1040             if (gad)
1041             {
1042                 gad->Activation |= GACT_ACTIVEGADGET;
1043                 result = gad;
1044             }
1045             break;
1046         }
1047
1048     } /* switch(gad->GadgetType & GTYP_GTYPEMASK) */
1049
1050     DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: result 0x%lx\n",
1051                     result));
1052
1053     if (result) iihd->ActiveGadget = result;
1054
1055     return result;
1056 }
1057
1058
1059 /****************************************************************************************/
1060
1061 struct Gadget *FindCycleGadget(struct Window *win, struct Requester *req,
1062                                struct Gadget *gad, WORD direction)
1063 {
1064     struct Gadget *g = NULL, *gg, *prev, *first;
1065
1066     D(bug("FindCycleGadget: win = %p  req %p gad = %p  direction = %d\n", win, req, gad, direction));
1067
1068     if (req)
1069         first = req->ReqGadget;
1070     else
1071         first = win->FirstGadget;
1072
1073     switch(direction)
1074     {
1075     case GMR_NEXTACTIVE:
1076         g = gad->NextGadget;
1077         if (!g) g = first;
1078
1079         while(g)
1080         {
1081             if (g == gad)
1082             {
1083                 if (!(gad->Flags & GFLG_TABCYCLE) || (gad->Flags & GFLG_DISABLED))
1084                 {
1085                     /* should never happen */
1086                     g = NULL;
1087                 }
1088                 break;
1089             }
1090             if (!(g->Flags & GFLG_DISABLED) && (g->Flags & GFLG_TABCYCLE)) break;
1091
1092             g = g->NextGadget;
1093             if (!g) g = first;
1094         }
1095         break;
1096
1097     case GMR_PREVACTIVE:
1098         prev = 0;
1099         g = 0;
1100         gg = first;
1101
1102         /* find a TABCYCLE gadget which is before gad in window's gadgetlist */
1103         while (gg)
1104         {
1105             if (gg == gad)
1106             {
1107                 if (prev) g = prev;
1108                 break;
1109             }
1110             if (!(gg->Flags & GFLG_DISABLED) && (gg->Flags & GFLG_TABCYCLE)) prev = gg;
1111             gg = gg->NextGadget;
1112         }
1113
1114         if (gg && !g)
1115         {
1116             /* There was no TABCYCLE gadget before gad in window's gadgetlist */
1117
1118             gg = gg->NextGadget;
1119             if (!gg)
1120             {
1121                 if (!(gad->Flags & GFLG_DISABLED) && (gad->Flags & GFLG_TABCYCLE)) g = gad;
1122                 break;
1123             }
1124             prev = 0;
1125
1126             while(gg)
1127             {
1128                 if (!(gg->Flags & GFLG_DISABLED) && (gg->Flags & GFLG_TABCYCLE)) prev = gg;
1129                 gg = gg->NextGadget;
1130             }
1131
1132             if (prev)
1133             {
1134                 g = prev;
1135             }
1136             else
1137             {
1138                 if (!(gad->Flags & GFLG_DISABLED) && (gad->Flags & GFLG_TABCYCLE)) g = gad;
1139             }
1140         }
1141
1142
1143         break;
1144
1145     default: /* Unused, but well... */
1146         g = first;
1147         break;
1148
1149     } /* switch(direction) */
1150
1151     return g;
1152 }
1153
1154 /****************************************************************************************/
1155
1156 void FixWindowCoords(struct Window *win, LONG *left, LONG *top, LONG *width, LONG *height,struct IntuitionBase *IntuitionBase)
1157 {
1158     struct Screen *scr = win->WScreen;
1159
1160     if (*width < 1) *width = 1;
1161     if (*height < 1) *height = 1;
1162
1163     if (*width > scr->Width) *width = scr->Width;
1164     if (*height > scr->Height) *height = scr->Height;
1165
1166     if ((GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OFFSCREENLAYERS) && (win->WScreen->LayerInfo.Flags & LIFLG_SUPPORTS_OFFSCREEN_LAYERS))
1167     {
1168         if (*left > scr->Width - 1) *left = scr->Width - 1;
1169         if (*top > scr->Height - 1) *top = scr->Height -1;
1170     }
1171     else
1172     {
1173
1174         if ((*left + *width) > scr->Width)
1175         {
1176             *left = scr->Width - *width;
1177         }
1178         else if (*left < 0)
1179         {
1180             *left = 0;
1181         }
1182
1183         if ((*top + *height) > scr->Height)
1184         {
1185             *top = scr->Height - *height;
1186         }
1187         else if (*top < 0)
1188         {
1189             *top = 0;
1190         }
1191     }
1192 }
1193
1194 /****************************************************************************************/
1195
1196 void WindowNeedsRefresh(struct Window * w,
1197                         struct IntuitionBase * IntuitionBase )
1198 {
1199     /* Supposed to send a message to this window, saying that it needs a
1200        refresh. I will check whether there is no such a message queued in
1201        its messageport, though. It only needs one such message!
1202     */
1203
1204     /* Refresh the window's gadgetry ...
1205        ... stegerg: and in the actual implementation
1206        call RefershWindowFrame first, as the border gadgets dont
1207        cover the whole border area.*/
1208
1209     /*
1210         jDc: in actual implementation sizeevent means that we need to send
1211         idcmp, etc and do not clear the flag for smart_refresh window that
1212         has no idcmp_refreshwindow, otherwise we clear the flag!
1213     */
1214
1215     DEBUG_WINDOWNEEDSREFRESH(dprintf("WindowNeedsRefresh: window 0x%lx gzz %d nocarerefresh %d\n",
1216                      w, IS_GZZWINDOW(w), IS_NOCAREREFRESH(w)));
1217
1218     //trashregion means that we use delayed refreshing!
1219
1220     if (
1221     #ifdef DAMAGECACHE
1222         (!IW(w)->trashregion) ||
1223     #else
1224         (!(w->Flags & WFLG_SIMPLE_REFRESH)) ||
1225     #endif
1226          IS_NOCAREREFRESH(w))
1227     {
1228
1229         Gad_BeginUpdate(WLAYER(w), IntuitionBase);
1230
1231         if (IS_NOCAREREFRESH(w) || (!((!(w->Flags & WFLG_SIMPLE_REFRESH)) && (!(IW(w)->specialflags & SPFLAG_LAYERRESIZED)))))
1232         {
1233             if (!IS_GZZWINDOW(w))
1234             {
1235                 if (w->Flags & WFLG_BORDERLESS)
1236                 {
1237                     int_refreshglist(w->FirstGadget, w, NULL, -1, 0, 0, IntuitionBase);
1238                 }
1239                 else
1240                 {
1241                     int_refreshwindowframe(w,0,0,IntuitionBase);
1242                 }
1243             }
1244             else
1245             {
1246                 /* refresh all gadgets except border gadgets */
1247                 int_refreshglist(w->FirstGadget, w, NULL, -1, 0, REFRESHGAD_BORDER, IntuitionBase);
1248             }
1249             IW(w)->specialflags &= ~SPFLAG_LAYERRESIZED;
1250         }
1251
1252         if (IS_NOCAREREFRESH(w)) WLAYER(w)->Flags &= ~LAYERREFRESH;
1253
1254         Gad_EndUpdate(WLAYER(w), IS_NOCAREREFRESH(w) ? TRUE : FALSE, IntuitionBase);
1255
1256     } else {
1257     #ifdef DAMAGECACHE
1258         struct Rectangle rect;
1259         BOOL doclear = (w->Flags & WFLG_BORDERLESS) ? FALSE : TRUE;
1260
1261         rect.MinX = w->BorderLeft;
1262         rect.MinY = w->BorderTop;
1263         rect.MaxX = w->Width - w->BorderRight - 1;
1264         rect.MaxY = w->Height - w->BorderBottom - 1;
1265     #endif
1266
1267     #ifndef BEGINUPDATEGADGETREFRESH
1268         Gad_BeginUpdate(WLAYER(w), IntuitionBase);
1269     #else
1270     #ifdef DAMAGECACHE
1271         LockLayer(0,WLAYER(w));
1272     #endif
1273     #endif
1274
1275     #ifndef BEGINUPDATEGADGETREFRESH
1276         if (!IS_GZZWINDOW(w))
1277         {
1278             if (w->Flags & WFLG_BORDERLESS)
1279             {
1280                 int_refreshglist(w->FirstGadget, w, NULL, -1, 0, 0, IntuitionBase);
1281             }
1282             else
1283             {
1284                 int_refreshwindowframe(w,0,0,IntuitionBase);
1285             }
1286         }
1287         else
1288         {
1289             /* refresh all gadgets except border and gadtools gadgets */
1290             int_refreshglist(w->FirstGadget, w, NULL, -1, 0, REFRESHGAD_BORDER , IntuitionBase);
1291         }
1292     #endif
1293
1294     #ifdef DAMAGECACHE
1295         //add rects to trashregion here
1296         OrRegionRegion(WLAYER(w)->DamageList,IW(w)->trashregion);
1297
1298         if (doclear)
1299         {
1300             ClearRectRegion(IW(w)->trashregion,&rect);
1301             AndRectRegion(WLAYER(w)->DamageList,&rect);
1302         }
1303
1304         IW(w)->specialflags |= SPFLAG_LAYERREFRESH;
1305     #else
1306     #ifdef BEGINUPDATEGADGETREFRESH
1307         IW(w)->specialflags |= SPFLAG_LAYERREFRESH;
1308     #endif
1309     #endif
1310
1311     #ifndef BEGINUPDATEGADGETREFRESH
1312         Gad_EndUpdate(WLAYER(w), FALSE, IntuitionBase);
1313     #else
1314     #ifdef DAMAGECACHE
1315         UnlockLayer(WLAYER(w));
1316     #endif
1317     #endif
1318
1319     }
1320
1321     if (IS_DOCAREREFRESH(w))
1322     {
1323         if (w->UserPort && (w->IDCMPFlags & IDCMP_REFRESHWINDOW))
1324         {
1325             struct IntuiMessage *IM;
1326             BOOL                 found = FALSE;
1327
1328             /* Can use Forbid() for this */
1329             Forbid();
1330
1331             IM = (struct IntuiMessage *)w->UserPort->mp_MsgList.lh_Head;
1332
1333             ForeachNode(&w->UserPort->mp_MsgList, IM)
1334             {
1335                 /* Does the window already have such a message? */
1336                 if (IDCMP_REFRESHWINDOW == IM->Class && IM->IAddress == w)
1337                 {
1338                     DEBUG_WINDOWNEEDSREFRESH(dprintf("WindowNeedsRefresh: refresh pending\n"));
1339                     D(bug("Window %s already has a refresh message pending!!\n",
1340                           w->Title ? w->Title : (STRPTR)"<NONAME>"));
1341                     found = TRUE;
1342                     break;
1343                 }
1344             }
1345
1346             Permit();
1347
1348             if (!found)
1349             {
1350                 struct InputEvent *new_ie;
1351                 struct IIHData    *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
1352
1353                 D(bug("Sending a refresh message to window %s  %d %d %d %d!!\n",
1354                       w->Title ? w->Title : (STRPTR)"<NONAME>",
1355                       w->LeftEdge,
1356                       w->TopEdge,
1357                       w->Width,
1358                       w->Height));
1359
1360                 DEBUG_WINDOWNEEDSREFRESH(dprintf("WindowNeedsRefresh: sending idcmp message\n"));
1361
1362                 if ((new_ie = AllocInputEvent(iihdata)))
1363                 {
1364                     new_ie->ie_Class        = IECLASS_EVENT;
1365                     new_ie->ie_Code         = IECODE_REFRESH;
1366                     new_ie->ie_EventAddress = w;
1367                     CurrentTime(&new_ie->ie_TimeStamp.tv_secs, &new_ie->ie_TimeStamp.tv_micro);
1368                 }
1369
1370                 fire_intuimessage(w,
1371                                   IDCMP_REFRESHWINDOW,
1372                                   0,
1373                                   w,
1374                                   IntuitionBase);
1375             } /* if (!found) */
1376
1377         } /* if (w->UserPort && (w->IDCMPFlags & IDCMP_REFRESHWINDOW)) */
1378         else
1379         {
1380             struct IIHData *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
1381
1382             if (FindTask(NULL) == iihdata->InputDeviceTask)
1383             {
1384                 struct InputEvent *new_ie;
1385
1386                 DEBUG_WINDOWNEEDSREFRESH(dprintf("WindowNeedsRefresh: sending inputevent\n"));
1387
1388                 if ((new_ie = AllocInputEvent(iihdata)))
1389                 {
1390                     new_ie->ie_Class = IECLASS_EVENT;
1391                     new_ie->ie_Code = IECODE_REFRESH;
1392                     new_ie->ie_EventAddress = w;
1393                     CurrentTime(&new_ie->ie_TimeStamp.tv_secs, &new_ie->ie_TimeStamp.tv_micro);
1394                 }
1395
1396                 ih_fire_intuimessage(w,
1397                              IDCMP_REFRESHWINDOW,
1398                              0,
1399                              w,
1400                              IntuitionBase);
1401             }
1402         }
1403
1404     } /* if (!IS_NOCAREREFRESH(w)) */
1405
1406 }
1407
1408 /****************************************************************************************/
1409
1410 struct Window *FindActiveWindow(struct InputEvent *ie,ULONG *stitlebarhit,
1411                             struct IntuitionBase *IntuitionBase)
1412 {
1413     /* The caller has checked that the input event is a IECLASS_RAWMOUSE, SELECTDOWN event */
1414     /* NOTE: may be called with NULL ie ptr! */
1415     struct Screen   *scr;
1416     struct Layer    *l;
1417     struct Window   *new_w;
1418     ULONG            lock;
1419
1420     lock = LockIBase(0UL);
1421
1422     new_w = IntuitionBase->ActiveWindow;
1423     scr   = IntuitionBase->FirstScreen;
1424
1425     UnlockIBase(lock);
1426
1427     D(bug("FindActiveWindow: scr %p win %p\n",scr,new_w));
1428
1429     if (stitlebarhit) *stitlebarhit = FALSE;
1430
1431     if (scr)
1432     {
1433         D(bug("FindActiveWindow: Click at (%d,%d)\n",scr->MouseX,scr->MouseY));
1434
1435         /* What layer ? */
1436         LockLayerInfo(&scr->LayerInfo);
1437
1438         l = WhichLayer(&scr->LayerInfo, scr->MouseX, scr->MouseY);
1439
1440         UnlockLayerInfo(&scr->LayerInfo);
1441
1442         if (NULL == l)
1443         {
1444             new_w = NULL;
1445             D(bug("FindActiveWindow: Click not inside layer\n"));
1446         }
1447         else if (l == scr->BarLayer)
1448         {
1449             D(bug("FindActiveWindow: Click on screen bar layer -> active window stays the same\n"));
1450             if (stitlebarhit) *stitlebarhit = TRUE;
1451         }
1452         else
1453         {
1454             new_w = (struct Window *)l->Window;
1455             if (!new_w)
1456             {
1457                 D(bug("FindActiveWindow: Selected layer is not a window\n"));
1458             }
1459
1460             D(bug("FindActiveWindow: Found layer %p\n", l));
1461         }
1462     }
1463
1464     D(bug("FindActiveWindow: New window %p\n", new_w));
1465     return new_w;
1466 }
1467
1468 /****************************************************************************************/
1469
1470 struct Window *FindDesktopWindow(struct Screen *screen,struct IntuitionBase *IntuitionBase)
1471 {
1472     struct Window *win;
1473
1474     for (win = screen->FirstWindow; win; win = win->NextWindow)
1475     {
1476         if (win->Flags & WFLG_BACKDROP &&
1477             win->Width == screen->Width &&
1478             win->Height >= screen->Height - (screen->BarHeight + 2))
1479         {
1480             return win;
1481         }
1482     }
1483
1484     return NULL;
1485 }
1486
1487
1488 /****************************************************************************************/
1489
1490 struct InputEvent *AllocInputEvent(struct IIHData *iihdata)
1491 {
1492     struct IntuitionBase        *IntuitionBase = iihdata->IntuitionBase;
1493     struct GeneratedInputEvent  *gie;
1494     struct InputEvent           *ie;
1495
1496     /* There might be an inputevent from someone else that our handler discarded.
1497      * We may as well use it. This can only happen inside our main loop.
1498      */
1499     ie = iihdata->FreeInputEvents;
1500     if (ie)
1501     {
1502         iihdata->FreeInputEvents = ie->ie_NextEvent;
1503         DEBUG_INPUTEVENT(dprintf("AllocInputEvent: reuse 0x%lx event\n", ie));
1504     }
1505     else
1506     {
1507         gie = AllocPooled(iihdata->InputEventMemPool, sizeof(struct GeneratedInputEvent));
1508         if (gie)
1509         {
1510             /* Allocated events are put in the list of events that have not yet been
1511              * propagated.
1512              */
1513             AddTail((struct List *)&iihdata->NewAllocatedInputEventList, (struct Node *)gie);
1514             ie = &gie->ie;
1515         }
1516         DEBUG_INPUTEVENT(dprintf("AllocInputEvent: allocated 0x%lx (0x%lx)\n", ie, gie));
1517     }
1518
1519     if (ie)
1520     {
1521         *iihdata->EndInputEventChain = ie;
1522         iihdata->EndInputEventChain = &ie->ie_NextEvent;
1523     }
1524
1525     return ie;
1526 }
1527
1528 /****************************************************************************************/
1529
1530 void FreeGeneratedInputEvents(struct IIHData *iihdata)
1531 {
1532     struct IntuitionBase    *IntuitionBase = iihdata->IntuitionBase;
1533     struct Node             *node, *succ;
1534
1535     /* Free the list of allocated events that have already been propagated. */
1536     ForeachNodeSafe(&iihdata->AllocatedInputEventList, node, succ)
1537     {
1538         DEBUG_INPUTEVENT(dprintf("FreeGeneratedInputEvent: free 0x%lx\n", node));
1539         FreePooled(iihdata->InputEventMemPool, node, sizeof(struct GeneratedInputEvent));
1540     }
1541
1542     /* The list is not in a valid state at this point, and NewList() should
1543      * be called, but since we won't use it until the list of not-yet-propagated
1544      * events is copied in it, we won't bother.
1545      */
1546     //NEWLIST(&iihdata->AllocatedInputEventList);
1547 }
1548
1549 /****************************************************************************************/
1550
1551 BOOL FireMenuMessage(WORD code, struct Window *win,
1552                      struct InputEvent *ie, struct IntuitionBase *IntuitionBase)
1553 {
1554     struct MenuMessage *msg;
1555     BOOL                result = FALSE;
1556
1557     if ((msg = AllocMenuMessage(IntuitionBase)))
1558     {
1559         msg->code = code;
1560         msg->win  = win;
1561         if (ie) msg->ie = *ie;
1562         SendMenuMessage(msg, IntuitionBase);
1563
1564         result = TRUE;
1565     }
1566
1567     return result;
1568 }
1569
1570 /****************************************************************************************/
1571
1572 LONG Gad_BeginUpdate(struct Layer *layer, struct IntuitionBase *IntuitionBase)
1573 {
1574     /* Must lock GadgetLock to avoid deadlocks with ObtainGirPort
1575        from other tasks, because ObtainGirPort first obtains
1576        GadgetLock and then layer lock through LockLayer!!!! */
1577     LOCKGADGET
1578     return BeginUpdate(layer);
1579 }
1580
1581 /****************************************************************************************/
1582
1583 void Gad_EndUpdate(struct Layer *layer, UWORD flag, struct IntuitionBase *IntuitionBase)
1584 {
1585     EndUpdate(layer, flag);
1586     UNLOCKGADGET
1587 }
1588
1589 /****************************************************************************************/