rom/intuition/inputhandler_support.c

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