rom/intuition/inputhandler_actions.c

   1 /*
   2     Copyright  1995-2003, The AROS Development Team. All rights reserved.
   3     Copyright  2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5
   6     Responsible for executing deferred Intuition actions like MoveWindow,
   7     SizeWindow, ActivateWindow, etc.
   8 */
   9
  10 #include <proto/exec.h>
  11 #include <proto/intuition.h>
  12 #include <proto/alib.h>
  13 #include <proto/layers.h>
  14 #include <proto/graphics.h>
  15 #include <proto/keymap.h>
  16 #include <proto/input.h>
  17 #include <exec/memory.h>
  18 #include <exec/alerts.h>
  19 #include <exec/interrupts.h>
  20 #include <exec/ports.h>
  21 #include <intuition/intuition.h>
  22 #include <intuition/intuitionbase.h>
  23 #include <intuition/gadgetclass.h>
  24 #include <intuition/cghooks.h>
  25 #include <intuition/sghooks.h>
  26 #include <devices/input.h>
  27 #include <devices/inputevent.h>
  28 #include "inputhandler.h"
  29
  30 #include "boopsigadgets.h"
  31 #include "boolgadgets.h"
  32 #include "propgadgets.h"
  33 #include "strgadgets.h"
  34 #include "gadgets.h"
  35 #include "intuition_intern.h" /* EWFLG_xxx */
  36 #include "inputhandler_support.h"
  37 #include "inputhandler_actions.h"
  38 #include "menus.h"
  39
  40 #undef DEBUG
  41 #define DEBUG 0
  42 #include <aros/debug.h>
  43
  44 #define LOCK_ACTIONS()      ObtainSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
  45 #define UNLOCK_ACTIONS()    ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
  46
  47 #ifndef __MORPHOS__
  48 static void move_family(struct Window *, int , int);
  49 #endif
  50
  51 /*******************************************************************************************************/
  52
  53 static void CheckLayerRefresh(struct Layer *lay, struct Screen *targetscreen,
  54                               struct IntuitionBase *IntuitionBase)
  55 {
  56   //if (lay->Flags & LAYERREFRESH)
  57     {
  58         struct Window *win = (struct Window *)lay->Window;
  59
  60         if (lay == targetscreen->BarLayer)
  61         {
  62             RenderScreenBar(targetscreen, TRUE, IntuitionBase);
  63         }
  64         else if (win)
  65         {
  66             /* Does it belong to a GZZ window and is it
  67                the outer window of that GZZ window? */
  68             if (IS_GZZWINDOW(win) && (lay == BLAYER(win)))
  69             {
  70                 /* simply refresh that window's frame */
  71                 Gad_BeginUpdate(lay, IntuitionBase);
  72                 int_refreshwindowframe(win,REFRESHGAD_BORDER,0,IntuitionBase);
  73                 lay->Flags &= ~LAYERREFRESH;
  74                 Gad_EndUpdate(lay, TRUE, IntuitionBase);
  75             }
  76             /* Is it the window layer ? */
  77             else if (lay == WLAYER(win))
  78             {
  79                 WindowNeedsRefresh(win, IntuitionBase);
  80             }
  81             /* Otherwise, it's a requester. */
  82             else
  83             {
  84                 struct Requester *req;
  85
  86                 for (req = win->FirstRequest; req && req->ReqLayer != lay; req = req->OlderRequest);
  87
  88                 if (req)
  89                 {
  90                     /* FIXME: should send an IDCMP refresh message too. */
  91                     Gad_BeginUpdate(lay, IntuitionBase);
  92                     render_requester(req, IntuitionBase);
  93                     lay->Flags &= ~LAYERREFRESH;
  94                     Gad_EndUpdate(lay, TRUE, IntuitionBase);
  95                 }
  96             }
  97         }
  98
  99     } /* if (lay->Flags & LAYERREFRESH) */
 100 }
 101
 102 /*******************************************************************************************************/
 103
 104 void CheckLayers(struct Screen *screen, struct IntuitionBase *IntuitionBase)
 105 {
 106     struct Layer *L;
 107
 108     LOCK_REFRESH(screen);
 109
 110     for (L = screen->LayerInfo.top_layer; L; L = L->back)
 111     {
 112         if (L->Flags & LAYERREFRESH)
 113         {
 114             CheckLayerRefresh(L, screen, IntuitionBase);
 115         }
 116     }
 117
 118     UNLOCK_REFRESH(screen);
 119 }
 120
 121 void WindowSizeWillChange(struct Window *targetwindow, WORD dx, WORD dy,
 122                                  struct IntuitionBase *IntuitionBase)
 123 {
 124     struct Rectangle *clipto = NULL;
 125     struct Rectangle  final_innerrect;
 126
 127     /* Erase the old frame on the right/lower side if
 128        new size is bigger than old size
 129     */
 130
 131     D(bug("********* WindowSizeWillChange ******** dx = %d  dy = %d\n", dx, dy));
 132
 133     if (AVOID_WINBORDERERASE)
 134     {
 135         final_innerrect.MinX = targetwindow->BorderLeft;
 136         final_innerrect.MinY = targetwindow->BorderTop;
 137         final_innerrect.MaxX = targetwindow->Width  + dx - 1 - targetwindow->BorderRight;
 138         final_innerrect.MaxY = targetwindow->Height + dy - 1 - targetwindow->BorderBottom;
 139         clipto = &final_innerrect;
 140     }
 141
 142     if ( ((dx > 0) && (targetwindow->BorderRight  > 0)) ||
 143         ((dy > 0) && (targetwindow->BorderBottom > 0)) )
 144     {
 145         struct RastPort     *rp = targetwindow->BorderRPort;
 146         struct Layer        *L = (BLAYER(targetwindow)) ? BLAYER(targetwindow) : WLAYER(targetwindow);
 147         struct Rectangle     rect;
 148         struct Region       *oldclipregion;
 149         WORD                 ScrollX;
 150         WORD                 ScrollY;
 151
 152         /*
 153         ** In case a clip region is installed then I have to
 154         ** install the regular cliprects of the layer
 155         ** first. Otherwise the frame might not get cleared correctly.
 156         */
 157
 158         LockLayer(0, L);
 159
 160         oldclipregion = InstallClipRegion(L, NULL);
 161
 162         ScrollX = L->Scroll_X;
 163         ScrollY = L->Scroll_Y;
 164
 165         L->Scroll_X = 0;
 166         L->Scroll_Y = 0;
 167
 168         if ((dx > 0) && (targetwindow->BorderRight > 0))
 169         {
 170             rect.MinX = targetwindow->Width - targetwindow->BorderRight;
 171             rect.MinY = 0;
 172             rect.MaxX = targetwindow->Width - 1;
 173             rect.MaxY = targetwindow->Height - 1;
 174
 175             OrRectRegion(L->DamageList, &rect);
 176             L->Flags |= LAYERREFRESH;
 177
 178             if (!AVOID_WINBORDERERASE || AndRectRect(&rect, &final_innerrect, &rect))
 179             {
 180                 EraseRect(rp, rect.MinX, rect.MinY, rect.MaxX, rect.MaxY);
 181             }
 182
 183         }
 184
 185         if ((dy > 0) && (targetwindow->BorderBottom > 0))
 186
 187         {
 188             rect.MinX = 0;
 189             rect.MinY = targetwindow->Height - targetwindow->BorderBottom;
 190             rect.MaxX = targetwindow->Width - 1;
 191             rect.MaxY = targetwindow->Height - 1;
 192
 193             OrRectRegion(L->DamageList, &rect);
 194             L->Flags |= LAYERREFRESH;
 195
 196             if (!AVOID_WINBORDERERASE || AndRectRect(&rect, &final_innerrect, &rect))
 197             {
 198                 EraseRect(rp, rect.MinX, rect.MinY, rect.MaxX, rect.MaxY);
 199             }
 200
 201         }
 202
 203         /*
 204         ** Reinstall the clipregions rectangles if there are any.
 205         */
 206         if (NULL != oldclipregion)
 207         {
 208             InstallClipRegion(L, oldclipregion);
 209         }
 210
 211         L->Scroll_X = ScrollX;
 212         L->Scroll_Y = ScrollY;
 213
 214         UnlockLayer(L);
 215
 216     } /* if ( ((dx > 0) && (targetwindow->BorderRight  > 0)) || ((dy > 0) && (targetwindow->BorderBottom > 0)) ) */
 217
 218     /* Before resizing the layers eraserect the area of all
 219        GFLG_REL??? gadgets and add the area to the damagelist */
 220
 221     EraseRelGadgetArea(targetwindow, clipto, FALSE, IntuitionBase);
 222
 223 }
 224
 225 /*******************************************************************************************************/
 226
 227 void WindowSizeHasChanged(struct Window *targetwindow, WORD dx, WORD dy,
 228                                  BOOL is_sizewindow, struct IntuitionBase *IntuitionBase)
 229 {
 230     struct IIHData  *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 231     struct Layer    *lay;
 232
 233     D(bug("********* WindowSizeHasChanged ********\n"));
 234
 235     lay = (BLAYER(targetwindow)) ? BLAYER(targetwindow) : WLAYER(targetwindow);
 236
 237     /* Fix GadgetInfo domain if there is an active gadget in window
 238        which was resized */
 239
 240     if ((iihdata->ActiveGadget) && (targetwindow == iihdata->GadgetInfo.gi_Window))
 241     {
 242         GetGadgetDomain(iihdata->ActiveGadget,
 243                         iihdata->GadgetInfo.gi_Screen,
 244                         iihdata->GadgetInfo.gi_Window,
 245                         NULL,
 246                         &iihdata->GadgetInfo.gi_Domain);
 247     }
 248
 249     /* Relayout GFLG_REL??? gadgets */
 250     DoGMLayout(targetwindow->FirstGadget, targetwindow, NULL, -1, FALSE, IntuitionBase);
 251
 252     /* Add the new area of all GFLG_REL??? gadgets to the damagelist, but
 253        don't EraseRect() as the gadgets will be re-rendered at their new
 254        position anyway */
 255
 256     {
 257         struct Rectangle innerrect;
 258
 259         innerrect.MinX = targetwindow->BorderLeft;
 260         innerrect.MinY = targetwindow->BorderTop;
 261         innerrect.MaxX = targetwindow->Width - 1 - targetwindow->BorderRight;
 262         innerrect.MaxY = targetwindow->Height - 1 - targetwindow->BorderBottom;
 263
 264         EraseRelGadgetArea(targetwindow, AVOID_WINBORDERERASE ? &innerrect : NULL, TRUE, IntuitionBase);
 265     }
 266
 267     /* If new size is smaller than old size add right/bottom
 268        frame to damagelist */
 269     if ( ((dx < 0) && (targetwindow->BorderRight  > 0)) ||
 270         ((dx > 0) && (targetwindow->BorderTop > 0)) ||
 271         ((dy < 0) && (targetwindow->BorderBottom > 0)) )
 272     {
 273         struct Rectangle rect;
 274
 275         LockLayer(0, lay);
 276
 277         if ((dx < 0) && (targetwindow->BorderRight > 0))
 278         {
 279             rect.MinX = targetwindow->Width - targetwindow->BorderRight;
 280             rect.MinY = 0;
 281             rect.MaxX = targetwindow->Width - 1;
 282             rect.MaxY = targetwindow->Height - 1;
 283
 284             OrRectRegion(lay->DamageList, &rect);
 285             lay->Flags |= LAYERREFRESH;
 286         }
 287
 288         if ((dx > 0) && (targetwindow->BorderTop > 0))
 289         {
 290             rect.MinX = 0;
 291             rect.MinY = 0;
 292             rect.MaxX = targetwindow->Width - 1;
 293             rect.MaxY = targetwindow->BorderTop - 1;
 294
 295             OrRectRegion(lay->DamageList, &rect);
 296             lay->Flags |= LAYERREFRESH;
 297         }
 298
 299         if ((dy < 0) && (targetwindow->BorderBottom > 0))
 300         {
 301             rect.MinX = 0;
 302             rect.MinY = targetwindow->Height - targetwindow->BorderBottom;
 303             rect.MaxX = targetwindow->Width - 1;
 304             rect.MaxY = targetwindow->Height - 1;
 305
 306             OrRectRegion(lay->DamageList, &rect);
 307             lay->Flags |= LAYERREFRESH;
 308         }
 309
 310         UnlockLayer(lay);
 311
 312     } /* if ( ((dx < 0) && (targetwindow->BorderRight > 0)) || ((dy < 0) && (targetwindow->BorderBottom > 0)) ) */
 313
 314     ((struct IntWindow *)(targetwindow))->specialflags |= SPFLAG_LAYERRESIZED;
 315
 316 #if 0
 317     if (IS_GZZWINDOW(targetwindow))
 318     {
 319         lay = targetwindow->BorderRPort->Layer;
 320
 321         if (lay->Flags & LAYERREFRESH)
 322         {
 323             Gad_BeginUpdate(lay, IntuitionBase);
 324             RefreshWindowFrame(targetwindow);
 325             lay->Flags &= ~LAYERREFRESH;
 326             Gad_EndUpdate(lay, TRUE, IntuitionBase);
 327         }
 328
 329         lay = targetwindow->WLayer;
 330
 331         if (lay->Flags & LAYERREFRESH)
 332         {
 333             Gad_BeginUpdate(lay, IntuitionBase);
 334             int_refreshglist(targetwindow->FirstGadget, targetwindow, NULL, -1, 0, REFRESHGAD_BORDER, IntuitionBase);
 335             Gad_EndUpdate(lay, IS_NOCAREREFRESH(targetwindow), IntuitionBase);
 336         }
 337
 338     }
 339     else
 340     {
 341         lay = targetwindow->WLayer;
 342
 343         if (lay->Flags & LAYERREFRESH)
 344         {
 345             Gad_BeginUpdate(lay, IntuitionBase);
 346             RefreshWindowFrame(targetwindow);
 347             int_refreshglist(targetwindow->FirstGadget, targetwindow, NULL, -1, 0, REFRESHGAD_BORDER, IntuitionBase);
 348             Gad_EndUpdate(lay, IS_NOCAREREFRESH(targetwindow), IntuitionBase);
 349         }
 350     }
 351
 352     lay = targetwindow->WLayer;
 353
 354     if (IS_NOCAREREFRESH(targetwindow))
 355     {
 356         LockLayer(0, lay);
 357         lay->Flags &= ~LAYERREFRESH;
 358         UnlockLayer(lay);
 359     }
 360 #endif
 361
 362 #if 0
 363     //if (is_sizewindow)
 364     {
 365         /* Send IDCMP_NEWSIZE to resized window */
 366
 367         ih_fire_intuimessage(targetwindow,
 368                      IDCMP_NEWSIZE,
 369                      0,
 370                      targetwindow,
 371                      IntuitionBase);
 372     }
 373
 374     if (ie = AllocInputEvent(iihdata))
 375     {
 376         ie->ie_Class = IECLASS_EVENT;
 377         ie->ie_Code = IECODE_NEWSIZE;
 378         ie->ie_EventAddress = targetwindow;
 379         CurrentTime(&ie->ie_TimeStamp.tv_secs, &ie->ie_TimeStamp.tv_micro);
 380     }
 381
 382     /* Send IDCMP_CHANGEWINDOW to resized window */
 383
 384     ih_fire_intuimessage(targetwindow,
 385                  IDCMP_CHANGEWINDOW,
 386                  CWCODE_MOVESIZE,
 387                  targetwindow,
 388                  IntuitionBase);
 389 #endif
 390
 391 }
 392
 393 /*******************************************************************************************************/
 394
 395 void DoMoveSizeWindow(struct Window *targetwindow, LONG NewLeftEdge, LONG NewTopEdge,
 396                       LONG NewWidth, LONG NewHeight, BOOL send_newsize, struct IntuitionBase *IntuitionBase)
 397 {
 398     struct IIHData      *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 399   //struct IntWindow    *w       = (struct IntWindow *)targetwindow;
 400     struct Layer        *targetlayer = WLAYER(targetwindow)/*, *L*/;
 401     struct Requester    *req;
 402     struct InputEvent   *ie;
 403     LONG                 OldLeftEdge  = targetwindow->LeftEdge;
 404     LONG                 OldTopEdge   = targetwindow->TopEdge;
 405     LONG                 OldWidth     = targetwindow->Width;
 406     LONG                 OldHeight    = targetwindow->Height;
 407     LONG                 pos_dx, pos_dy, size_dx, size_dy;
 408
 409     /* correct new window coords if necessary */
 410
 411     FixWindowCoords(targetwindow, &NewLeftEdge, &NewTopEdge, &NewWidth, &NewHeight,IntuitionBase);
 412
 413     D(bug("DoMoveSizeWindow to %d,%d %d x %d\n", NewLeftEdge, NewTopEdge, NewWidth, NewHeight));
 414
 415     pos_dx  = NewLeftEdge - OldLeftEdge;
 416     pos_dy  = NewTopEdge  - OldTopEdge;
 417     size_dx = NewWidth    - OldWidth;
 418     size_dy = NewHeight   - OldHeight;
 419
 420     LOCK_REFRESH(targetwindow->WScreen);
 421
 422 /* jDc: intuition 68k doesn't care about that */
 423 //    if (pos_dx || pos_dy || size_dx || size_dy)
 424 //    {
 425
 426         if (size_dx || size_dy)
 427         {
 428             WindowSizeWillChange(targetwindow, size_dx, size_dy, IntuitionBase);
 429         }
 430
 431         targetwindow->LeftEdge    += pos_dx;
 432         targetwindow->TopEdge     += pos_dy;
 433 #ifndef __MORPHOS__
 434         targetwindow->RelLeftEdge += pos_dx;
 435         targetwindow->RelTopEdge  += pos_dy;
 436 #endif
 437
 438         targetwindow->Width     = NewWidth;
 439         targetwindow->Height    = NewHeight;
 440         targetwindow->GZZWidth  = targetwindow->Width  - targetwindow->BorderLeft - targetwindow->BorderRight;
 441         targetwindow->GZZHeight = targetwindow->Height - targetwindow->BorderTop  - targetwindow->BorderBottom;
 442
 443         /* check for GZZ window */
 444         if (BLAYER(targetwindow))
 445         {
 446             /* move outer window first */
 447             MoveSizeLayer(BLAYER(targetwindow), pos_dx, pos_dy, size_dx, size_dy);
 448         }
 449
 450         MoveSizeLayer(targetlayer, pos_dx, pos_dy, size_dx, size_dy);
 451
 452         for (req = targetwindow->FirstRequest; req; req = req->OlderRequest)
 453         {
 454             struct Layer *layer = req->ReqLayer;
 455
 456             if (layer)
 457             {
 458                 int dx, dy, dw, dh;
 459                 int left, top, right, bottom;
 460
 461                 left = NewLeftEdge + req->LeftEdge;
 462                 top = NewTopEdge + req->TopEdge;
 463                 right = left + req->Width - 1;
 464                 bottom = top + req->Height - 1;
 465
 466                 if (left > NewLeftEdge + NewWidth - 1)
 467                     left = NewLeftEdge + NewWidth - 1;
 468
 469                 if (top > NewTopEdge + NewHeight - 1)
 470                     top = NewTopEdge + NewHeight - 1;
 471
 472                 if (right > NewLeftEdge + NewWidth - 1)
 473                     right = NewLeftEdge + NewWidth - 1;
 474
 475                 if (bottom > NewTopEdge + NewHeight - 1)
 476                     bottom = NewTopEdge + NewHeight - 1;
 477
 478                 dx = left - layer->bounds.MinX;
 479                 dy = top - layer->bounds.MinY;
 480                 dw = right - left - layer->bounds.MaxX + layer->bounds.MinX;
 481                 dh = bottom - top - layer->bounds.MaxY + layer->bounds.MinY;
 482
 483                 MoveSizeLayer(layer, dx, dy, dw, dh);
 484             }
 485         }
 486
 487 #if 0
 488         if (w->ZipLeftEdge != ~0) w->ZipLeftEdge = OldLeftEdge;
 489         if (w->ZipTopEdge  != ~0) w->ZipTopEdge  = OldTopEdge;
 490         if (w->ZipWidth    != ~0) w->ZipWidth    = OldWidth;
 491         if (w->ZipHeight   != ~0) w->ZipHeight   = OldHeight;
 492 #endif
 493
 494         if (pos_dx || pos_dy)
 495         {
 496             UpdateMouseCoords(targetwindow);
 497 #ifndef __MORPHOS__
 498             if (HAS_CHILDREN(targetwindow))
 499                 move_family(targetwindow, pos_dx, pos_dy);
 500 #endif
 501         }
 502
 503 //    } /* if (pos_dx || pos_dy || size_dx || size_dy) */
 504
 505     if (size_dx || size_dy)
 506     {
 507         WindowSizeHasChanged(targetwindow, size_dx, size_dy, FALSE, IntuitionBase);
 508     }
 509
 510     ih_fire_intuimessage(targetwindow,
 511                  IDCMP_CHANGEWINDOW,
 512                  CWCODE_MOVESIZE,
 513                  targetwindow,
 514                  IntuitionBase);
 515
 516     if (send_newsize)
 517     {
 518         /* Send IDCMP_NEWSIZE and IDCMP_CHANGEWINDOW to resized window, even
 519            if there was no resizing/position change at all. BGUI for example
 520            relies on this! */
 521
 522         ih_fire_intuimessage(targetwindow,
 523                      IDCMP_NEWSIZE,
 524                      0,
 525                      targetwindow,
 526                      IntuitionBase);
 527
 528         if ((ie = AllocInputEvent(iihdata)))
 529         {
 530             ie->ie_Class = IECLASS_EVENT;
 531             ie->ie_Code = IECODE_NEWSIZE;
 532             ie->ie_EventAddress = targetwindow;
 533             CurrentTime(&ie->ie_TimeStamp.tv_secs, &ie->ie_TimeStamp.tv_micro);
 534         }
 535     }
 536
 537     // jDc: CheckLayers calls LOCK_REFRESH, so there's no reason to UNLOCK here!
 538     //    UNLOCK_REFRESH(targetwindow->WScreen);
 539
 540     CheckLayers(targetwindow->WScreen, IntuitionBase);
 541
 542     UNLOCK_REFRESH(targetwindow->WScreen);
 543
 544 #if 0
 545     if (size_dx || size_dy)
 546     {
 547         if (!(((struct IntWindow *)targetwindow)->CustomShape))
 548         {
 549             struct wdpWindowShape       shapemsg;
 550             struct Region               *shape;
 551             shapemsg.MethodID           = WDM_WINDOWSHAPE;
 552             shapemsg.wdp_Width      = targetwindow->Width;
 553             shapemsg.wdp_Height     = targetwindow->Height;
 554             shapemsg.wdp_Window = targetwindow;
 555             shapemsg.wdp_TrueColor      = (((struct IntScreen *)targetwindow->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
 556             shapemsg.wdp_UserBuffer     = ((struct IntWindow *)targetwindow)->DecorUserBuffer;
 557             shape = DoMethodA(((struct IntScreen *)(targetwindow->WScreen))->WinDecorObj, (Msg)&shapemsg);
 558
 559             if (((struct IntWindow *)targetwindow)->OutlineShape) DisposeRegion(((struct IntWindow *)targetwindow)->OutlineShape);
 560             ((struct IntWindow *)targetwindow)->OutlineShape = shape;
 561             ChangeWindowShape(targetwindow, shape, NULL);
 562             ((struct IntWindow *)targetwindow)->CustomShape = FALSE;
 563         }
 564     }
 565 #endif
 566
 567 }
 568
 569 /*******************************************************************************************************/
 570
 571 void DoSyncAction(void (*func)(struct IntuiActionMsg *, struct IntuitionBase *),
 572                   struct IntuiActionMsg *msg,
 573                   struct IntuitionBase *IntuitionBase)
 574 {
 575     struct IIHData *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 576     struct Task    *me = FindTask(NULL);
 577
 578     if (me == iihd->InputDeviceTask)
 579     {
 580         func(msg, IntuitionBase);
 581     }
 582     else
 583     {
 584     #ifdef __MORPHOS__
 585         struct IOStdReq   req;
 586         struct MsgPort    port;
 587         struct InputEvent ie;
 588     #endif
 589
 590         msg->handler = func;
 591         msg->task    = me;
 592         msg->done    = FALSE;
 593
 594         ObtainSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
 595         AddTail((struct List *)GetPrivIBase(IntuitionBase)->IntuiActionQueue, (struct Node *)msg);
 596         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
 597
 598     #ifdef __MORPHOS__
 599         port.mp_Flags   = PA_SIGNAL;
 600         port.mp_SigTask = me;
 601         port.mp_SigBit  = SIGB_INTUITION;
 602         NEWLIST(&port.mp_MsgList);
 603
 604         req.io_Message.mn_ReplyPort = &port;
 605         req.io_Device               = GetPrivIBase(IntuitionBase)->InputIO->io_Device;
 606         req.io_Unit                 = GetPrivIBase(IntuitionBase)->InputIO->io_Unit;
 607         req.io_Command              = IND_WRITEEVENT;
 608         req.io_Length               = sizeof(ie);
 609         req.io_Data                 = &ie;
 610
 611         ie.ie_Class = IECLASS_NULL;
 612     #endif
 613
 614         if (!msg->done)
 615         {
 616         #ifdef __MORPHOS__
 617             DoIO((APTR)&req);
 618         #else
 619             AddNullEvent();
 620         #endif
 621             while (!msg->done)
 622             {
 623                 Wait(SIGF_INTUITION);
 624             }
 625         }
 626     }
 627 }
 628
 629 /*******************************************************************************************************/
 630
 631 BOOL DoASyncAction(void (*func)(struct IntuiActionMsg *, struct IntuitionBase *),
 632                    struct IntuiActionMsg *msg, ULONG size,
 633                    struct IntuitionBase *IntuitionBase)
 634 {
 635     struct IIHData          *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 636     struct Task             *me = FindTask(NULL);
 637     struct IntuiActionMsg   *new_msg;
 638
 639     if (me == iihd->InputDeviceTask)
 640     {
 641         func(msg, IntuitionBase);
 642         return TRUE;
 643     }
 644     else if ((new_msg = AllocVecPooled(iihd->ActionsMemPool,size)))
 645     {
 646         new_msg->handler = func;
 647         new_msg->task = NULL;
 648         if (size > sizeof(*msg))
 649         {
 650             CopyMem(msg + 1, new_msg + 1, size - sizeof(*msg));
 651         }
 652
 653         ObtainSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
 654         AddTail((struct List *)GetPrivIBase(IntuitionBase)->IntuiActionQueue, (struct Node *)new_msg);
 655         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
 656
 657     #ifndef __MORPHOS__
 658         AddNullEvent();
 659     #endif
 660         return TRUE;
 661     }
 662     else
 663     {
 664         return FALSE;
 665     }
 666 }
 667
 668 /*******************************************************************************************************/
 669
 670 void HandleIntuiActions(struct IIHData *iihdata,
 671                         struct IntuitionBase *IntuitionBase)
 672 {
 673     struct IntuiActionMsg *am;
 674
 675     D(bug("Handle Intuition action messages\n"));
 676
 677     if (iihdata->ActiveSysGadget)
 678     {
 679         D(bug("Handle Intuition action messages. Doing nothing because of active drag or resize gadget!\n"));
 680         return;
 681     }
 682
 683     for (;;)
 684     {
 685         LOCK_ACTIONS();
 686         am = (struct IntuiActionMsg *)RemHead((struct List *)&iihdata->IntuiActionQueue);
 687         UNLOCK_ACTIONS();
 688
 689         if (!am)
 690             break;
 691
 692         am->handler(am, IntuitionBase);
 693
 694         if (am->task)
 695         {
 696             Forbid();
 697             am->done = TRUE;
 698             Signal(am->task, SIGF_INTUITION);
 699             Permit();
 700         }
 701         else
 702         {
 703             FreeVecPooled(iihdata->ActionsMemPool,am);
 704         }
 705     }
 706
 707     D(bug("Intuition action messages handled\n"));
 708 }
 709
 710 #ifndef __MORPHOS__
 711 static void move_family(struct Window * w, int dx, int dy)
 712 {
 713     struct Window * _w = w->firstchild;
 714
 715     while (_w)
 716     {
 717         _w->LeftEdge  += dx,
 718                  _w->TopEdge   += dy;
 719         if (HAS_CHILDREN(_w))
 720             move_family(_w,dx,dy);
 721         _w=_w->nextchild;
 722     }
 723 }
 724 #endif