rom/intuition/inputhandler_support.c

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