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         mousex = gi->gi_Window->MouseX;
 540         mousey = gi->gi_Window->MouseY;
 541     }
 542
 543     gpi->gpi_Mouse.X = mousex - gi->gi_Domain.Left - GetGadgetLeft(gad, gi->gi_Screen, gi->gi_Window, gi->gi_Requester);
 544     gpi->gpi_Mouse.Y = mousey - gi->gi_Domain.Top  - GetGadgetTop(gad, gi->gi_Screen, gi->gi_Window, gi->gi_Requester);
 545 }
 546
 547 /****************************************************************************************/
 548
 549 void HandleSysGadgetVerify(struct GadgetInfo *gi, struct Gadget *gadget,
 550                            struct IntuitionBase *IntuitionBase)
 551 {
 552     switch(gadget->GadgetType & GTYP_SYSTYPEMASK)
 553     {
 554     case GTYP_CLOSE:
 555 #ifdef __MORPHOS__
 556         if (((struct IntWindow *)(gi->gi_Window))->specialflags & SPFLAG_IAMDEAD)
 557         {
 558             CrashedDispose(gi->gi_Window,IntuitionBase);
 559         }
 560         else
 561         {
 562 #endif
 563             ih_fire_intuimessage(gi->gi_Window,
 564                          IDCMP_CLOSEWINDOW,
 565                          0,
 566                          gi->gi_Window,
 567                          IntuitionBase);
 568 #ifdef __MORPHOS__
 569         }
 570 #endif
 571         break;
 572
 573     case GTYP_WDEPTH:
 574         if (FALSE == IsLayerHiddenBySibling(WLAYER(gi->gi_Window),FALSE))
 575         {
 576             /* Send window to back */
 577             WindowToBack(gi->gi_Window);
 578         }
 579         else
 580         {
 581             /* Send window to front */
 582             WindowToFront(gi->gi_Window);
 583         }
 584         break;
 585
 586     case GTYP_WZOOM:
 587         ZipWindow(gi->gi_Window);
 588         break;
 589
 590     case GTYP_SDEPTH:
 591         if (gi->gi_Screen == IntuitionBase->FirstScreen)
 592         {
 593             ScreenToBack(gi->gi_Screen);
 594         }
 595         else
 596         {
 597             ScreenToFront(gi->gi_Screen);
 598         }
 599         break;
 600
 601     } /* switch(gad->GadgetType & GTYP_SYSTYPEMASK) */
 602 }
 603
 604 /****************************************************************************************/
 605
 606 struct Gadget *HandleCustomGadgetRetVal(IPTR retval, struct GadgetInfo *gi, struct Gadget *gadget,
 607                                 ULONG termination, BOOL *reuse_event,
 608                                 struct IntuitionBase *IntuitionBase)
 609 {
 610     struct IIHData  *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 611
 612     DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: retval %ld gi 0x%lx gadget 0x%lx termination %ld reuse %ld\n",
 613                      retval,
 614                      gi,
 615                      gadget,
 616                      termination,
 617                      *reuse_event));
 618
 619     if (retval != GMR_MEACTIVE)
 620     {
 621         struct gpGoInactive gpgi;
 622
 623         DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: !GMR_MEACTIVE\n"));
 624
 625         if (retval & GMR_REUSE)
 626         {
 627             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: GMR_REUSE\n"));
 628             *reuse_event = TRUE;
 629         }
 630
 631         if (retval & GMR_VERIFY)
 632         {
 633             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: GMR_VERIFY\n"));
 634             if (IS_SYS_GADGET(gadget))
 635             {
 636                 DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: SysGad\n"));
 637                 HandleSysGadgetVerify(gi, gadget, IntuitionBase);
 638             }
 639             else
 640             {
 641                 /* Not a system gadget. Send IDCMP_GADGETUP, but not
 642                    if it is a screen gadget where gi->gi_Window would
 643                    be NULL */
 644
 645                 DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: no sysgad\n"));
 646                 if ((gadget->Activation & GACT_RELVERIFY) &&
 647                     (gi->gi_Window))
 648                 {
 649                     DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: Send IDCMP_GADGETUP\n"));
 650                     ih_fire_intuimessage(gi->gi_Window,
 651                                  IDCMP_GADGETUP,
 652                                  termination & 0x0000FFFF,
 653                                  gadget,
 654                                  IntuitionBase);
 655                 }
 656
 657             } /* switch(gad->GadgetType & GTYP_SYSTYPEMASK) */
 658
 659         } /* if (retval & GMR_VERIFY) */
 660
 661         DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: Send GM_GOINACTIVE\n"));
 662
 663         gpgi.MethodID   = GM_GOINACTIVE;
 664         gpgi.gpgi_GInfo = gi;
 665         gpgi.gpgi_Abort = 0;
 666
 667         Locked_DoMethodA(gi->gi_Window, gadget, (Msg)&gpgi, IntuitionBase);
 668
 669         if (SYSGADGET_ACTIVE)
 670         {
 671             /* Switch back from Master Drag or Size Gadget to
 672                real/original/app Size or Drag Gadget */
 673
 674             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: SYSGADGET_ACTIVE\n"));
 675             gadget = iihdata->ActiveSysGadget;
 676             iihdata->ActiveSysGadget = NULL;
 677
 678             if (IS_BOOPSI_GADGET(gadget))
 679             {
 680                 Locked_DoMethodA(gi->gi_Window, gadget, (Msg)&gpgi, IntuitionBase);
 681             }
 682
 683             #ifdef __MORPHOS__
 684             if ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING2)
 685             {
 686                 ih_fire_intuimessage(gi->gi_Window,
 687                                      IDCMP_GADGETUP,
 688                                      0,
 689                                      gadget,
 690                                      IntuitionBase);
 691             }
 692             #endif
 693
 694             retval = 0;
 695         }
 696
 697         if (retval & GMR_VERIFY && gi->gi_Requester && gadget->Activation & GACT_ENDGADGET)
 698         {
 699             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: EndRequest\n"));
 700             EndRequest(gi->gi_Requester, gi->gi_Window);
 701             retval = 0;
 702         }
 703
 704         gadget->Activation &= ~GACT_ACTIVEGADGET;
 705
 706         DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: TabCycle 0x%lx retval 0x%lx\n",
 707                                          (gadget->Flags & GFLG_TABCYCLE),
 708                                          retval));
 709
 710         if ((gadget->Flags & GFLG_TABCYCLE) && (retval & GMR_NEXTACTIVE))
 711         {
 712             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: TabCycle+GMR_NEXTACTIVE\n"));
 713             gadget = FindCycleGadget(gi->gi_Window, gi->gi_Requester, gadget, GMR_NEXTACTIVE);
 714         }
 715         else if ((gadget->Flags & GFLG_TABCYCLE) && (retval & GMR_PREVACTIVE))
 716         {
 717             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: TabCycle+GMR_PREVACTIVE\n"));
 718             gadget = FindCycleGadget(gi->gi_Window, gi->gi_Requester, gadget, GMR_PREVACTIVE);
 719         }
 720         else
 721         {
 722             gadget = NULL;
 723             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: No gadget\n"));
 724         }
 725
 726         if (gadget)
 727         {
 728             DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: activate gadget 0x%lx\n",gadget));
 729             gadget = DoActivateGadget(gi->gi_Window, gi->gi_Requester, gadget, IntuitionBase);
 730         }
 731
 732     } /* if (retval != GMR_MEACTIVE) */
 733     else
 734     {
 735         DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: set GACT_ACTIVEGADGET\n"));
 736         gadget->Activation |= GACT_ACTIVEGADGET;
 737     }
 738
 739     DEBUG_HANDLECUSTOMRETVAL(dprintf("HandleCustomGadgetRetVal: return 0x%x\n", gadget));
 740     return gadget;
 741 }
 742
 743 /****************************************************************************************/
 744
 745 /* This function must never be called with the layer/layerinfo locked,
 746  * otherwise a deadlock with ObtainGIRPort can happen.
 747  */
 748 struct Gadget *DoGPInput(struct GadgetInfo *gi, struct Gadget *gadget,
 749                          struct InputEvent *ie, STACKULONG methodid,
 750                          BOOL *reuse_event, struct IntuitionBase *IntuitionBase)
 751 {
 752     struct IIHData  *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 753     struct gpInput   gpi;
 754     IPTR             retval;
 755     ULONG            termination;
 756
 757     ie->ie_Qualifier = iihdata->ActQualifier;
 758
 759     gpi.MethodID        = methodid;
 760     gpi.gpi_GInfo       = gi;
 761     gpi.gpi_IEvent      = ie;
 762     gpi.gpi_Termination = &termination;
 763     gpi.gpi_TabletData  = NULL;
 764
 765     SetGPIMouseCoords(&gpi, gadget);
 766
 767     retval = Locked_DoMethodA (gi->gi_Window, gadget, (Msg)&gpi, IntuitionBase);
 768
 769     DEBUG_DOGPINPUT(dprintf("DoGPInput: Locked_DoMethod gadget %p method 0x%lx retval %ld termination 0x%lx\n",
 770                 gadget, methodid, retval, termination));
 771
 772     return HandleCustomGadgetRetVal(retval, gi, gadget, termination,
 773                     reuse_event, IntuitionBase);
 774
 775 }
 776
 777 /****************************************************************************************/
 778
 779 struct Gadget * FindGadget (struct Screen *scr, struct Window * window,
 780                             struct Requester * req, int x, int y,
 781                             struct GadgetInfo * gi,BOOL sysonly,
 782                             struct IntuitionBase *IntuitionBase)
 783 {
 784     struct Gadget       *gadget, *firstgadget, *draggadget = 0;
 785     struct gpHitTest     gpht;
 786     struct IBox          ibox;
 787     WORD                 xrel, yrel;
 788     BOOL                 sys_only = sysonly;
 789
 790     gpht.MethodID     = GM_HITTEST;
 791     gpht.gpht_GInfo   = gi;
 792
 793     while (req || window || scr)
 794     {
 795         if (req)
 796         {
 797             firstgadget = req->ReqGadget;
 798         }
 799         else if (window)
 800         {
 801             firstgadget = window->FirstGadget;
 802         }
 803         else
 804         {
 805             if (draggadget) return draggadget;
 806             firstgadget = scr->FirstGadget;
 807         }
 808
 809         for (gadget = firstgadget; gadget; gadget = gadget->NextGadget)
 810         {
 811             if (!(gadget->Flags & GFLG_DISABLED) &&
 812                 (!sys_only ||
 813                  (gadget->GadgetType & GTYP_SYSGADGET &&
 814                    ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SIZING ||
 815                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING ||
 816                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDEPTH ||
 817                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SDEPTH ||
 818                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WZOOM ||
 819                    (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_CLOSE))))
 820             {
 821                 /* stegerg: domain depends on gadgettype and windowflags! */
 822                 GetGadgetDomain(gadget, scr, window, req, &gi->gi_Domain);
 823
 824                 /* Get coords relative to window */
 825
 826                 GetGadgetIBox(gadget, gi, &ibox);
 827
 828                 xrel = x - gi->gi_Domain.Left;
 829                 yrel = y - gi->gi_Domain.Top;
 830
 831                 /*if (req)
 832             {
 833                     xrel -= req->LeftEdge + window->BorderLeft;
 834                     yrel -= req->TopEdge + window->BorderTop;
 835             }*/
 836
 837                 if (window)
 838                 {
 839                     xrel -= window->LeftEdge;
 840                     yrel -= window->TopEdge;
 841                 }
 842
 843                 if ((xrel >= ibox.Left) &&
 844                     (yrel >= ibox.Top) &&
 845                     (xrel < ibox.Left + ibox.Width) &&
 846                     (yrel < ibox.Top  + ibox.Height))
 847                 {
 848                     if ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING)
 849                     {
 850                         if (!draggadget) draggadget = gadget;
 851                     }
 852                     else
 853                     {
 854
 855                         if ((gadget->GadgetType & GTYP_GTYPEMASK) == GTYP_CUSTOMGADGET)
 856                         {
 857
 858                             gpht.gpht_Mouse.X = xrel - ibox.Left;
 859                             gpht.gpht_Mouse.Y = yrel - ibox.Top;
 860
 861                             /* jDc: don't check for == GMR_GADGETHIT since some reaction classes*/
 862                             /* (BURN IN HELL!) return TRUE here (related to imageclass HITEST?)*/
 863                             if (Locked_DoMethodA (window, gadget, (Msg)&gpht, IntuitionBase))
 864                                 return (gadget);
 865                         }
 866                         else
 867                         {
 868                             return (gadget);
 869                         }
 870                     }
 871                 }
 872
 873             } /* if (!(gadget->Flags & GFLG_DISABLED)) */
 874
 875         } /* for (gadget = window->FirstGadget; gadget; gadget = gadget->NextGadget) */
 876
 877         sys_only = sysonly;
 878
 879         if (req)
 880         {
 881             req = NULL;
 882             sys_only = TRUE;
 883         }
 884         else if (window)
 885         {
 886         #ifdef SKINS
 887             draggadget = findbordergadget(window,draggadget,IntuitionBase);
 888         #endif
 889             window = NULL;
 890         }
 891         else
 892             scr = NULL;
 893     }
 894
 895     return (draggadget);
 896
 897 } /* FindGadget */
 898
 899
 900 /****************************************************************************************/
 901
 902 struct Gadget * FindHelpGadget (struct Window * window,
 903                             int x, int y, struct IntuitionBase *IntuitionBase)
 904 {
 905     struct Gadget       *gadget, *firstgadget;
 906     struct Requester    *req = window->FirstRequest;
 907
 908     while (req || window)
 909     {
 910         if (req)
 911         {
 912             firstgadget = req->ReqGadget;
 913         }
 914         else
 915         {
 916             firstgadget = window->FirstGadget;
 917         }
 918
 919         for (gadget = firstgadget; gadget; gadget = gadget->NextGadget)
 920         {
 921             if ((gadget->Flags & GFLG_EXTENDED) &&
 922                 (((struct ExtGadget *)gadget)->MoreFlags & GMORE_GADGETHELP))
 923             {
 924                 if (InsideGadget(window->WScreen, window, req, gadget, x, y))
 925                 {
 926                     return (gadget);
 927                 }
 928             }
 929
 930         }
 931
 932         if (req)
 933             req = req->OlderRequest;
 934         else
 935             window = NULL;
 936     }
 937
 938     return (NULL);
 939
 940 } /* FindGadget */
 941
 942
 943 /****************************************************************************************/
 944
 945 BOOL InsideGadget(struct Screen *scr, struct Window *win, struct Requester *req,
 946                   struct Gadget *gad, WORD x, WORD y)
 947 {
 948     struct IBox box;
 949     BOOL        rc = FALSE;
 950
 951     GetScrGadgetIBox(gad, scr, win, req, &box);
 952
 953     if ((x >= box.Left) &&
 954         (y >= box.Top)  &&
 955         (x < box.Left + box.Width) &&
 956         (y < box.Top + box.Height))
 957     {
 958         rc = TRUE;
 959     }
 960
 961     return rc;
 962 }
 963
 964 /****************************************************************************************/
 965
 966 struct Gadget *DoActivateGadget(struct Window *win, struct Requester *req, struct Gadget *gad,
 967                                 struct IntuitionBase *IntuitionBase)
 968 {
 969     struct IIHData      *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 970     struct GadgetInfo   *gi = &iihd->GadgetInfo;
 971     struct Gadget       *result = NULL;
 972
 973     DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: Window 0x%lx Req 0x%lx Gadget 0x%lx\n",
 974                                  win,
 975                                  req,
 976                                  gad));
 977
 978     DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: Activation 0x%lx\n",
 979                                  gad->Activation));
 980
 981     if (gad->Activation & GACT_IMMEDIATE)
 982     {
 983         DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: Send GADGETDOWN msg\n"));
 984         ih_fire_intuimessage(win,
 985                              IDCMP_GADGETDOWN,
 986                              0,
 987                              gad,
 988                              IntuitionBase);
 989     }
 990
 991     PrepareGadgetInfo(gi, win->WScreen, win, req);
 992     SetGadgetInfoGadget(gi, gad, IntuitionBase);
 993
 994     DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: Type 0x%lx\n",
 995                     gad->GadgetType & GTYP_GTYPEMASK));
 996
 997     switch(gad->GadgetType & GTYP_GTYPEMASK)
 998     {
 999         case GTYP_STRGADGET:
1000             DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: GTYP_STRGADGET\n"));
1001             gad->Activation |= GACT_ACTIVEGADGET;
1002             UpdateStrGadget(gad, win, req, IntuitionBase);
1003             result = gad;
1004             break;
1005
1006         case GTYP_CUSTOMGADGET:
1007         {
1008             struct gpInput  gpi;
1009             ULONG           termination;
1010             IPTR            retval;
1011             BOOL            reuse_event;
1012
1013             DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: GTYP_CUSTOMGADGET\n"));
1014
1015             gpi.MethodID        = GM_GOACTIVE;
1016             gpi.gpi_GInfo       = gi;
1017             gpi.gpi_IEvent      = NULL;
1018             gpi.gpi_Termination = &termination;
1019             gpi.gpi_Mouse.X     = win->MouseX - gi->gi_Domain.Left - GetGadgetLeft(gad, gi->gi_Screen, gi->gi_Window, NULL);
1020             gpi.gpi_Mouse.Y     = win->MouseY - gi->gi_Domain.Top  - GetGadgetTop(gad, gi->gi_Screen, gi->gi_Window, NULL);
1021             gpi.gpi_TabletData  = NULL;
1022
1023             retval = Locked_DoMethodA (win, gad, (Msg)&gpi, IntuitionBase);
1024
1025             gad = HandleCustomGadgetRetVal(retval, gi, gad,termination,
1026                                &reuse_event, IntuitionBase);
1027
1028             if (gad)
1029             {
1030                 gad->Activation |= GACT_ACTIVEGADGET;
1031                 result = gad;
1032             }
1033             break;
1034         }
1035
1036     } /* switch(gad->GadgetType & GTYP_GTYPEMASK) */
1037
1038     DEBUG_ACTIVATEGADGET(dprintf("DoActivateGadget: result 0x%lx\n",
1039                     result));
1040
1041     if (result) iihd->ActiveGadget = result;
1042
1043     return result;
1044 }
1045
1046
1047 /****************************************************************************************/
1048
1049 struct Gadget *FindCycleGadget(struct Window *win, struct Requester *req,
1050                                struct Gadget *gad, WORD direction)
1051 {
1052     struct Gadget *g = NULL, *gg, *prev, *first;
1053
1054     D(bug("FindCycleGadget: win = %p  req %p gad = %p  direction = %d\n", win, req, gad, direction));
1055
1056     if (req)
1057         first = req->ReqGadget;
1058     else
1059         first = win->FirstGadget;
1060
1061     switch(direction)
1062     {
1063     case GMR_NEXTACTIVE:
1064         g = gad->NextGadget;
1065         if (!g) g = first;
1066
1067         while(g)
1068         {
1069             if (g == gad)
1070             {
1071                 if (!(gad->Flags & GFLG_TABCYCLE) || (gad->Flags & GFLG_DISABLED))
1072                 {
1073                     /* should never happen */
1074                     g = NULL;
1075                 }
1076                 break;
1077             }
1078             if (!(g->Flags & GFLG_DISABLED) && (g->Flags & GFLG_TABCYCLE)) break;
1079
1080             g = g->NextGadget;
1081             if (!g) g = first;
1082         }
1083         break;
1084
1085     case GMR_PREVACTIVE:
1086         prev = 0;
1087         g = 0;
1088         gg = first;
1089
1090         /* find a TABCYCLE gadget which is before gad in window's gadgetlist */
1091         while (gg)
1092         {
1093             if (gg == gad)
1094             {
1095                 if (prev) g = prev;
1096                 break;
1097             }
1098             if (!(gg->Flags & GFLG_DISABLED) && (gg->Flags & GFLG_TABCYCLE)) prev = gg;
1099             gg = gg->NextGadget;
1100         }
1101
1102         if (gg && !g)
1103         {
1104             /* There was no TABCYCLE gadget before gad in window's gadgetlist */
1105
1106             gg = gg->NextGadget;
1107             if (!gg)
1108             {
1109                 if (!(gad->Flags & GFLG_DISABLED) && (gad->Flags & GFLG_TABCYCLE)) g = gad;
1110                 break;
1111             }
1112             prev = 0;
1113
1114             while(gg)
1115             {
1116                 if (!(gg->Flags & GFLG_DISABLED) && (gg->Flags & GFLG_TABCYCLE)) prev = gg;
1117                 gg = gg->NextGadget;
1118             }
1119
1120             if (prev)
1121             {
1122                 g = prev;
1123             }
1124             else
1125             {
1126                 if (!(gad->Flags & GFLG_DISABLED) && (gad->Flags & GFLG_TABCYCLE)) g = gad;
1127             }
1128         }
1129
1130
1131         break;
1132
1133     default: /* Unused, but well... */
1134         g = first;
1135         break;
1136
1137     } /* switch(direction) */
1138
1139     return g;
1140 }
1141
1142 /****************************************************************************************/
1143
1144 void FixWindowCoords(struct Window *win, LONG *left, LONG *top, LONG *width, LONG *height,struct IntuitionBase *IntuitionBase)
1145 {
1146     struct Screen *scr = win->WScreen;
1147
1148     if (*width < 1) *width = 1;
1149     if (*height < 1) *height = 1;
1150
1151     if (*width > scr->Width) *width = scr->Width;
1152     if (*height > scr->Height) *height = scr->Height;
1153
1154     if ((GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OFFSCREENLAYERS) && (win->WScreen->LayerInfo.Flags & LIFLG_SUPPORTS_OFFSCREEN_LAYERS))
1155     {
1156         if (*left > scr->Width - 1) *left = scr->Width - 1;
1157         if (*top > scr->Height - 1) *top = scr->Height -1;
1158     }
1159     else
1160     {
1161
1162         if ((*left + *width) > scr->Width)
1163         {
1164             *left = scr->Width - *width;
1165         }
1166         else if (*left < 0)
1167         {
1168             *left = 0;
1169         }
1170
1171         if ((*top + *height) > scr->Height)
1172         {
1173             *top = scr->Height - *height;
1174         }
1175         else if (*top < 0)
1176         {
1177             *top = 0;
1178         }
1179     }
1180 }
1181
1182 /****************************************************************************************/
1183
1184 void WindowNeedsRefresh(struct Window * w,
1185                         struct IntuitionBase * IntuitionBase )
1186 {
1187     /* Supposed to send a message to this window, saying that it needs a
1188        refresh. I will check whether there is no such a message queued in
1189        its messageport, though. It only needs one such message!
1190     */
1191
1192     /* Refresh the window's gadgetry ...
1193        ... stegerg: and in the actual implementation
1194        call RefershWindowFrame first, as the border gadgets don´t
1195        cover the whole border area.*/
1196
1197     /*
1198         jDc: in actual implementation sizeevent means that we need to send
1199         idcmp, etc and do not clear the flag for smart_refresh window that
1200         has no idcmp_refreshwindow, otherwise we clear the flag!
1201     */
1202
1203     DEBUG_WINDOWNEEDSREFRESH(dprintf("WindowNeedsRefresh: window 0x%lx gzz %d nocarerefresh %d\n",
1204                      w, IS_GZZWINDOW(w), IS_NOCAREREFRESH(w)));
1205
1206     //trashregion means that we use delayed refreshing!
1207
1208     if (
1209     #ifdef DAMAGECACHE
1210         (!IW(w)->trashregion) ||
1211     #else
1212         (!(w->Flags & WFLG_SIMPLE_REFRESH)) ||
1213     #endif
1214          IS_NOCAREREFRESH(w))
1215     {
1216
1217         Gad_BeginUpdate(WLAYER(w), IntuitionBase);
1218
1219         if (IS_NOCAREREFRESH(w) || (!((!(w->Flags & WFLG_SIMPLE_REFRESH)) && (!(IW(w)->specialflags & SPFLAG_LAYERRESIZED)))))
1220         {
1221             if (!IS_GZZWINDOW(w))
1222             {
1223                 if (w->Flags & WFLG_BORDERLESS)
1224                 {
1225                     int_refreshglist(w->FirstGadget, w, NULL, -1, 0, 0, IntuitionBase);
1226                 }
1227                 else
1228                 {
1229                     int_refreshwindowframe(w,0,0,IntuitionBase);
1230                 }
1231             }
1232             else
1233             {
1234                 /* refresh all gadgets except border gadgets */
1235                 int_refreshglist(w->FirstGadget, w, NULL, -1, 0, REFRESHGAD_BORDER, IntuitionBase);
1236             }
1237             IW(w)->specialflags &= ~SPFLAG_LAYERRESIZED;
1238         }
1239
1240         if (IS_NOCAREREFRESH(w)) WLAYER(w)->Flags &= ~LAYERREFRESH;
1241
1242         Gad_EndUpdate(WLAYER(w), IS_NOCAREREFRESH(w) ? TRUE : FALSE, IntuitionBase);
1243
1244     } else {
1245     #ifdef DAMAGECACHE
1246         struct Rectangle rect;
1247         BOOL doclear = (w->Flags & WFLG_BORDERLESS) ? FALSE : TRUE;
1248
1249         rect.MinX = w->BorderLeft;
1250         rect.MinY = w->BorderTop;
1251         rect.MaxX = w->Width - w->BorderRight - 1;
1252         rect.MaxY = w->Height - w->BorderBottom - 1;
1253     #endif
1254
1255     #ifndef BEGINUPDATEGADGETREFRESH
1256         Gad_BeginUpdate(WLAYER(w), IntuitionBase);
1257     #else
1258     #ifdef DAMAGECACHE
1259         LockLayer(0,WLAYER(w));
1260     #endif
1261     #endif
1262
1263     #ifndef BEGINUPDATEGADGETREFRESH
1264         if (!IS_GZZWINDOW(w))
1265         {
1266             if (w->Flags & WFLG_BORDERLESS)
1267             {
1268                 int_refreshglist(w->FirstGadget, w, NULL, -1, 0, 0, IntuitionBase);
1269             }
1270             else
1271             {
1272                 int_refreshwindowframe(w,0,0,IntuitionBase);
1273             }
1274         }
1275         else
1276         {
1277             /* refresh all gadgets except border and gadtools gadgets */
1278             int_refreshglist(w->FirstGadget, w, NULL, -1, 0, REFRESHGAD_BORDER , IntuitionBase);
1279         }
1280     #endif
1281
1282     #ifdef DAMAGECACHE
1283         //add rects to trashregion here
1284         OrRegionRegion(WLAYER(w)->DamageList,IW(w)->trashregion);
1285
1286         if (doclear)
1287         {
1288             ClearRectRegion(IW(w)->trashregion,&rect);
1289             AndRectRegion(WLAYER(w)->DamageList,&rect);
1290         }
1291
1292         IW(w)->specialflags |= SPFLAG_LAYERREFRESH;
1293     #else
1294     #ifdef BEGINUPDATEGADGETREFRESH
1295         IW(w)->specialflags |= SPFLAG_LAYERREFRESH;
1296     #endif
1297     #endif
1298
1299     #ifndef BEGINUPDATEGADGETREFRESH
1300         Gad_EndUpdate(WLAYER(w), FALSE, IntuitionBase);
1301     #else
1302     #ifdef DAMAGECACHE
1303         UnlockLayer(WLAYER(w));
1304     #endif
1305     #endif
1306
1307     }
1308
1309     if (IS_DOCAREREFRESH(w))
1310     {
1311         if (w->UserPort && (w->IDCMPFlags & IDCMP_REFRESHWINDOW))
1312         {
1313             struct IntuiMessage *IM;
1314             BOOL                 found = FALSE;
1315
1316             /* Can use Forbid() for this */
1317             Forbid();
1318
1319             IM = (struct IntuiMessage *)w->UserPort->mp_MsgList.lh_Head;
1320
1321             ForeachNode(&w->UserPort->mp_MsgList, IM)
1322             {
1323                 /* Does the window already have such a message? */
1324                 if (IDCMP_REFRESHWINDOW == IM->Class && IM->IAddress == w)
1325                 {
1326                     DEBUG_WINDOWNEEDSREFRESH(dprintf("WindowNeedsRefresh: refresh pending\n"));
1327                     D(bug("Window %s already has a refresh message pending!!\n",
1328                           w->Title ? w->Title : (STRPTR)"<NONAME>"));
1329                     found = TRUE;
1330                     break;
1331                 }
1332             }
1333
1334             Permit();
1335
1336             if (!found)
1337             {
1338                 struct InputEvent *new_ie;
1339                 struct IIHData    *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
1340
1341                 D(bug("Sending a refresh message to window %s  %d %d %d %d!!\n",
1342                       w->Title ? w->Title : (STRPTR)"<NONAME>",
1343                       w->LeftEdge,
1344                       w->TopEdge,
1345                       w->Width,
1346                       w->Height));
1347
1348                 DEBUG_WINDOWNEEDSREFRESH(dprintf("WindowNeedsRefresh: sending idcmp message\n"));
1349
1350                 if ((new_ie = AllocInputEvent(iihdata)))
1351                 {
1352                     new_ie->ie_Class        = IECLASS_EVENT;
1353                     new_ie->ie_Code         = IECODE_REFRESH;
1354                     new_ie->ie_EventAddress = w;
1355                     CurrentTime(&new_ie->ie_TimeStamp.tv_secs, &new_ie->ie_TimeStamp.tv_micro);
1356                 }
1357
1358                 fire_intuimessage(w,
1359                                   IDCMP_REFRESHWINDOW,
1360                                   0,
1361                                   w,
1362                                   IntuitionBase);
1363             } /* if (!found) */
1364
1365         } /* if (w->UserPort && (w->IDCMPFlags & IDCMP_REFRESHWINDOW)) */
1366         else
1367         {
1368             struct IIHData *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
1369
1370             if (FindTask(NULL) == iihdata->InputDeviceTask)
1371             {
1372                 struct InputEvent *new_ie;
1373
1374                 DEBUG_WINDOWNEEDSREFRESH(dprintf("WindowNeedsRefresh: sending inputevent\n"));
1375
1376                 if ((new_ie = AllocInputEvent(iihdata)))
1377                 {
1378                     new_ie->ie_Class = IECLASS_EVENT;
1379                     new_ie->ie_Code = IECODE_REFRESH;
1380                     new_ie->ie_EventAddress = w;
1381                     CurrentTime(&new_ie->ie_TimeStamp.tv_secs, &new_ie->ie_TimeStamp.tv_micro);
1382                 }
1383
1384                 ih_fire_intuimessage(w,
1385                              IDCMP_REFRESHWINDOW,
1386                              0,
1387                              w,
1388                              IntuitionBase);
1389             }
1390         }
1391
1392     } /* if (!IS_NOCAREREFRESH(w)) */
1393
1394 }
1395
1396 /****************************************************************************************/
1397
1398 struct Window *FindActiveWindow(struct InputEvent *ie,ULONG *stitlebarhit,
1399                             struct IntuitionBase *IntuitionBase)
1400 {
1401     /* The caller has checked that the input event is a IECLASS_RAWMOUSE, SELECTDOWN event */
1402     /* NOTE: may be called with NULL ie ptr! */
1403     struct Screen   *scr;
1404     struct Layer    *l;
1405     struct Window   *new_w;
1406     ULONG            lock;
1407
1408     lock = LockIBase(0UL);
1409
1410     new_w = IntuitionBase->ActiveWindow;
1411     scr   = IntuitionBase->FirstScreen;
1412
1413     UnlockIBase(lock);
1414
1415     D(bug("FindActiveWindow: scr %p win %p\n",scr,new_w));
1416
1417     if (stitlebarhit) *stitlebarhit = FALSE;
1418
1419     if (scr)
1420     {
1421         D(bug("FindActiveWindow: Click at (%d,%d)\n",scr->MouseX,scr->MouseY));
1422
1423         /* What layer ? */
1424         LockLayerInfo(&scr->LayerInfo);
1425
1426         l = WhichLayer(&scr->LayerInfo, scr->MouseX, scr->MouseY);
1427
1428         UnlockLayerInfo(&scr->LayerInfo);
1429
1430         if (NULL == l)
1431         {
1432             new_w = NULL;
1433             D(bug("FindActiveWindow: Click not inside layer\n"));
1434         }
1435         else if (l == scr->BarLayer)
1436         {
1437             D(bug("FindActiveWindow: Click on screen bar layer -> active window stays the same\n"));
1438             if (stitlebarhit) *stitlebarhit = TRUE;
1439         }
1440         else
1441         {
1442             new_w = (struct Window *)l->Window;
1443             if (!new_w)
1444             {
1445                 D(bug("FindActiveWindow: Selected layer is not a window\n"));
1446             }
1447
1448             D(bug("FindActiveWindow: Found layer %p\n", l));
1449         }
1450     }
1451
1452     D(bug("FindActiveWindow: New window %p\n", new_w));
1453     return new_w;
1454 }
1455
1456 /****************************************************************************************/
1457
1458 struct Window *FindDesktopWindow(struct Screen *screen,struct IntuitionBase *IntuitionBase)
1459 {
1460     struct Window *win;
1461
1462     for (win = screen->FirstWindow; win; win = win->NextWindow)
1463     {
1464         if (win->Flags & WFLG_BACKDROP &&
1465             win->Width == screen->Width &&
1466             win->Height >= screen->Height - (screen->BarHeight + 2))
1467         {
1468             return win;
1469         }
1470     }
1471
1472     return NULL;
1473 }
1474
1475
1476 /****************************************************************************************/
1477
1478 struct InputEvent *AllocInputEvent(struct IIHData *iihdata)
1479 {
1480     struct IntuitionBase        *IntuitionBase = iihdata->IntuitionBase;
1481     struct GeneratedInputEvent  *gie;
1482     struct InputEvent           *ie;
1483
1484     /* There might be an inputevent from someone else that our handler discarded.
1485      * We may as well use it. This can only happen inside our main loop.
1486      */
1487     ie = iihdata->FreeInputEvents;
1488     if (ie)
1489     {
1490         iihdata->FreeInputEvents = ie->ie_NextEvent;
1491         DEBUG_INPUTEVENT(dprintf("AllocInputEvent: reuse 0x%lx event\n", ie));
1492     }
1493     else
1494     {
1495         gie = AllocPooled(iihdata->InputEventMemPool, sizeof(struct GeneratedInputEvent));
1496         if (gie)
1497         {
1498             /* Allocated events are put in the list of events that have not yet been
1499              * propagated.
1500              */
1501             AddTail((struct List *)&iihdata->NewAllocatedInputEventList, (struct Node *)gie);
1502             ie = &gie->ie;
1503         }
1504         DEBUG_INPUTEVENT(dprintf("AllocInputEvent: allocated 0x%lx (0x%lx)\n", ie, gie));
1505     }
1506
1507     if (ie)
1508     {
1509         *iihdata->EndInputEventChain = ie;
1510         iihdata->EndInputEventChain = &ie->ie_NextEvent;
1511     }
1512
1513     return ie;
1514 }
1515
1516 /****************************************************************************************/
1517
1518 void FreeGeneratedInputEvents(struct IIHData *iihdata)
1519 {
1520     struct IntuitionBase    *IntuitionBase = iihdata->IntuitionBase;
1521     struct Node             *node, *succ;
1522
1523     /* Free the list of allocated events that have already been propagated. */
1524     ForeachNodeSafe(&iihdata->AllocatedInputEventList, node, succ)
1525     {
1526         DEBUG_INPUTEVENT(dprintf("FreeGeneratedInputEvent: free 0x%lx\n", node));
1527         FreePooled(iihdata->InputEventMemPool, node, sizeof(struct GeneratedInputEvent));
1528     }
1529
1530     /* The list is not in a valid state at this point, and NewList() should
1531      * be called, but since we won't use it until the list of not-yet-propagated
1532      * events is copied in it, we won't bother.
1533      */
1534     //NEWLIST(&iihdata->AllocatedInputEventList);
1535 }
1536
1537 /****************************************************************************************/
1538
1539 BOOL FireMenuMessage(WORD code, struct Window *win,
1540                      struct InputEvent *ie, struct IntuitionBase *IntuitionBase)
1541 {
1542     struct MenuMessage *msg;
1543     BOOL                result = FALSE;
1544
1545     if ((msg = AllocMenuMessage(IntuitionBase)))
1546     {
1547         msg->code = code;
1548         msg->win  = win;
1549         if (ie) msg->ie = *ie;
1550         SendMenuMessage(msg, IntuitionBase);
1551
1552         result = TRUE;
1553     }
1554
1555     return result;
1556 }
1557
1558 /****************************************************************************************/
1559
1560 LONG Gad_BeginUpdate(struct Layer *layer, struct IntuitionBase *IntuitionBase)
1561 {
1562     /* Must lock GadgetLock to avoid deadlocks with ObtainGirPort
1563        from other tasks, because ObtainGirPort first obtains
1564        GadgetLock and then layer lock through LockLayer!!!! */
1565     LOCKGADGET
1566     return BeginUpdate(layer);
1567 }
1568
1569 /****************************************************************************************/
1570
1571 void Gad_EndUpdate(struct Layer *layer, UWORD flag, struct IntuitionBase *IntuitionBase)
1572 {
1573     EndUpdate(layer, flag);
1574     UNLOCKGADGET
1575 }
1576
1577 /****************************************************************************************/