rom/intuition/inputhandler_actions.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     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         /* In case of active window drag/size gadget the master drag/size gadget never
 243            has GZZ flag set, so pass in real gadget (ActiveSysGadget) */
 244
 245         GetGadgetDomain(iihdata->ActiveSysGadget ? iihdata->ActiveSysGadget : iihdata->ActiveGadget,
 246                         iihdata->GadgetInfo.gi_Screen,
 247                         iihdata->GadgetInfo.gi_Window,
 248                         NULL,
 249                         &iihdata->GadgetInfo.gi_Domain);
 250     }
 251
 252     /* Relayout GFLG_REL??? gadgets */
 253     DoGMLayout(targetwindow->FirstGadget, targetwindow, NULL, -1, FALSE, IntuitionBase);
 254
 255     /* Add the new area of all GFLG_REL??? gadgets to the damagelist, but
 256        don't EraseRect() as the gadgets will be re-rendered at their new
 257        position anyway */
 258
 259     {
 260         struct Rectangle innerrect;
 261
 262         innerrect.MinX = targetwindow->BorderLeft;
 263         innerrect.MinY = targetwindow->BorderTop;
 264         innerrect.MaxX = targetwindow->Width - 1 - targetwindow->BorderRight;
 265         innerrect.MaxY = targetwindow->Height - 1 - targetwindow->BorderBottom;
 266
 267         EraseRelGadgetArea(targetwindow, AVOID_WINBORDERERASE ? &innerrect : NULL, TRUE, IntuitionBase);
 268     }
 269
 270     /* If new size is smaller than old size add right/bottom
 271        frame to damagelist */
 272     if ( ((dx < 0) && (targetwindow->BorderRight  > 0)) ||
 273         ((dx > 0) && (targetwindow->BorderTop > 0)) ||
 274         ((dy < 0) && (targetwindow->BorderBottom > 0)) )
 275     {
 276         struct Rectangle rect;
 277
 278         LockLayer(0, lay);
 279
 280         if ((dx < 0) && (targetwindow->BorderRight > 0))
 281         {
 282             rect.MinX = targetwindow->Width - targetwindow->BorderRight;
 283             rect.MinY = 0;
 284             rect.MaxX = targetwindow->Width - 1;
 285             rect.MaxY = targetwindow->Height - 1;
 286
 287             OrRectRegion(lay->DamageList, &rect);
 288             lay->Flags |= LAYERREFRESH;
 289         }
 290
 291         if ((dx > 0) && (targetwindow->BorderTop > 0))
 292         {
 293             rect.MinX = 0;
 294             rect.MinY = 0;
 295             rect.MaxX = targetwindow->Width - 1;
 296             rect.MaxY = targetwindow->BorderTop - 1;
 297
 298             OrRectRegion(lay->DamageList, &rect);
 299             lay->Flags |= LAYERREFRESH;
 300         }
 301
 302         if ((dy < 0) && (targetwindow->BorderBottom > 0))
 303         {
 304             rect.MinX = 0;
 305             rect.MinY = targetwindow->Height - targetwindow->BorderBottom;
 306             rect.MaxX = targetwindow->Width - 1;
 307             rect.MaxY = targetwindow->Height - 1;
 308
 309             OrRectRegion(lay->DamageList, &rect);
 310             lay->Flags |= LAYERREFRESH;
 311         }
 312
 313         UnlockLayer(lay);
 314
 315     } /* if ( ((dx < 0) && (targetwindow->BorderRight > 0)) || ((dy < 0) && (targetwindow->BorderBottom > 0)) ) */
 316
 317     ((struct IntWindow *)(targetwindow))->specialflags |= SPFLAG_LAYERRESIZED;
 318
 319 #if 0
 320     if (IS_GZZWINDOW(targetwindow))
 321     {
 322         lay = targetwindow->BorderRPort->Layer;
 323
 324         if (lay->Flags & LAYERREFRESH)
 325         {
 326             Gad_BeginUpdate(lay, IntuitionBase);
 327             RefreshWindowFrame(targetwindow);
 328             lay->Flags &= ~LAYERREFRESH;
 329             Gad_EndUpdate(lay, TRUE, IntuitionBase);
 330         }
 331
 332         lay = targetwindow->WLayer;
 333
 334         if (lay->Flags & LAYERREFRESH)
 335         {
 336             Gad_BeginUpdate(lay, IntuitionBase);
 337             int_refreshglist(targetwindow->FirstGadget, targetwindow, NULL, -1, 0, REFRESHGAD_BORDER, IntuitionBase);
 338             Gad_EndUpdate(lay, IS_NOCAREREFRESH(targetwindow), IntuitionBase);
 339         }
 340
 341     }
 342     else
 343     {
 344         lay = targetwindow->WLayer;
 345
 346         if (lay->Flags & LAYERREFRESH)
 347         {
 348             Gad_BeginUpdate(lay, IntuitionBase);
 349             RefreshWindowFrame(targetwindow);
 350             int_refreshglist(targetwindow->FirstGadget, targetwindow, NULL, -1, 0, REFRESHGAD_BORDER, IntuitionBase);
 351             Gad_EndUpdate(lay, IS_NOCAREREFRESH(targetwindow), IntuitionBase);
 352         }
 353     }
 354
 355     lay = targetwindow->WLayer;
 356
 357     if (IS_NOCAREREFRESH(targetwindow))
 358     {
 359         LockLayer(0, lay);
 360         lay->Flags &= ~LAYERREFRESH;
 361         UnlockLayer(lay);
 362     }
 363 #endif
 364
 365 #if 0
 366     //if (is_sizewindow)
 367     {
 368         /* Send IDCMP_NEWSIZE to resized window */
 369
 370         ih_fire_intuimessage(targetwindow,
 371                      IDCMP_NEWSIZE,
 372                      0,
 373                      targetwindow,
 374                      IntuitionBase);
 375     }
 376
 377     if (ie = AllocInputEvent(iihdata))
 378     {
 379         ie->ie_Class = IECLASS_EVENT;
 380         ie->ie_Code = IECODE_NEWSIZE;
 381         ie->ie_EventAddress = targetwindow;
 382         CurrentTime(&ie->ie_TimeStamp.tv_secs, &ie->ie_TimeStamp.tv_micro);
 383     }
 384
 385     /* Send IDCMP_CHANGEWINDOW to resized window */
 386
 387     ih_fire_intuimessage(targetwindow,
 388                  IDCMP_CHANGEWINDOW,
 389                  CWCODE_MOVESIZE,
 390                  targetwindow,
 391                  IntuitionBase);
 392 #endif
 393
 394 }
 395
 396 /*******************************************************************************************************/
 397
 398 void DoMoveSizeWindow(struct Window *targetwindow, LONG NewLeftEdge, LONG NewTopEdge,
 399                       LONG NewWidth, LONG NewHeight, BOOL send_newsize, struct IntuitionBase *IntuitionBase)
 400 {
 401     struct IIHData      *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 402   //struct IntWindow    *w       = (struct IntWindow *)targetwindow;
 403     struct Layer        *targetlayer = WLAYER(targetwindow)/*, *L*/;
 404     struct Requester    *req;
 405     struct InputEvent   *ie;
 406     LONG                 OldLeftEdge  = targetwindow->LeftEdge;
 407     LONG                 OldTopEdge   = targetwindow->TopEdge;
 408     LONG                 OldWidth     = targetwindow->Width;
 409     LONG                 OldHeight    = targetwindow->Height;
 410     LONG                 pos_dx, pos_dy, size_dx, size_dy;
 411
 412     /* correct new window coords if necessary */
 413
 414     FixWindowCoords(targetwindow, &NewLeftEdge, &NewTopEdge, &NewWidth, &NewHeight,IntuitionBase);
 415
 416     D(bug("DoMoveSizeWindow to %d,%d %d x %d\n", NewLeftEdge, NewTopEdge, NewWidth, NewHeight));
 417
 418     pos_dx  = NewLeftEdge - OldLeftEdge;
 419     pos_dy  = NewTopEdge  - OldTopEdge;
 420     size_dx = NewWidth    - OldWidth;
 421     size_dy = NewHeight   - OldHeight;
 422
 423     LOCK_REFRESH(targetwindow->WScreen);
 424
 425 /* jDc: intuition 68k doesn't care about that */
 426 //    if (pos_dx || pos_dy || size_dx || size_dy)
 427 //    {
 428
 429         if (size_dx || size_dy)
 430         {
 431             WindowSizeWillChange(targetwindow, size_dx, size_dy, IntuitionBase);
 432         }
 433
 434         targetwindow->LeftEdge    += pos_dx;
 435         targetwindow->TopEdge     += pos_dy;
 436 #ifndef __MORPHOS__
 437         targetwindow->RelLeftEdge += pos_dx;
 438         targetwindow->RelTopEdge  += pos_dy;
 439 #endif
 440
 441         targetwindow->Width     = NewWidth;
 442         targetwindow->Height    = NewHeight;
 443         targetwindow->GZZWidth  = targetwindow->Width  - targetwindow->BorderLeft - targetwindow->BorderRight;
 444         targetwindow->GZZHeight = targetwindow->Height - targetwindow->BorderTop  - targetwindow->BorderBottom;
 445
 446         /* check for GZZ window */
 447         if (BLAYER(targetwindow))
 448         {
 449             /* move outer window first */
 450             MoveSizeLayer(BLAYER(targetwindow), pos_dx, pos_dy, size_dx, size_dy);
 451         }
 452
 453         MoveSizeLayer(targetlayer, pos_dx, pos_dy, size_dx, size_dy);
 454
 455         for (req = targetwindow->FirstRequest; req; req = req->OlderRequest)
 456         {
 457             struct Layer *layer = req->ReqLayer;
 458
 459             if (layer)
 460             {
 461                 int dx, dy, dw, dh;
 462                 int left, top, right, bottom;
 463
 464                 left = NewLeftEdge + req->LeftEdge;
 465                 top = NewTopEdge + req->TopEdge;
 466                 right = left + req->Width - 1;
 467                 bottom = top + req->Height - 1;
 468
 469                 if (left > NewLeftEdge + NewWidth - 1)
 470                     left = NewLeftEdge + NewWidth - 1;
 471
 472                 if (top > NewTopEdge + NewHeight - 1)
 473                     top = NewTopEdge + NewHeight - 1;
 474
 475                 if (right > NewLeftEdge + NewWidth - 1)
 476                     right = NewLeftEdge + NewWidth - 1;
 477
 478                 if (bottom > NewTopEdge + NewHeight - 1)
 479                     bottom = NewTopEdge + NewHeight - 1;
 480
 481                 dx = left - layer->bounds.MinX;
 482                 dy = top - layer->bounds.MinY;
 483                 dw = right - left - layer->bounds.MaxX + layer->bounds.MinX;
 484                 dh = bottom - top - layer->bounds.MaxY + layer->bounds.MinY;
 485
 486                 MoveSizeLayer(layer, dx, dy, dw, dh);
 487             }
 488         }
 489
 490 #if 0
 491         if (w->ZipLeftEdge != ~0) w->ZipLeftEdge = OldLeftEdge;
 492         if (w->ZipTopEdge  != ~0) w->ZipTopEdge  = OldTopEdge;
 493         if (w->ZipWidth    != ~0) w->ZipWidth    = OldWidth;
 494         if (w->ZipHeight   != ~0) w->ZipHeight   = OldHeight;
 495 #endif
 496
 497         if (pos_dx || pos_dy)
 498         {
 499             UpdateMouseCoords(targetwindow);
 500 #ifndef __MORPHOS__
 501             if (HAS_CHILDREN(targetwindow))
 502                 move_family(targetwindow, pos_dx, pos_dy);
 503 #endif
 504         }
 505
 506 //    } /* if (pos_dx || pos_dy || size_dx || size_dy) */
 507
 508     if (size_dx || size_dy)
 509     {
 510         WindowSizeHasChanged(targetwindow, size_dx, size_dy, FALSE, IntuitionBase);
 511     }
 512
 513     ih_fire_intuimessage(targetwindow,
 514                  IDCMP_CHANGEWINDOW,
 515                  CWCODE_MOVESIZE,
 516                  targetwindow,
 517                  IntuitionBase);
 518
 519     if (send_newsize)
 520     {
 521         /* Send IDCMP_NEWSIZE and IDCMP_CHANGEWINDOW to resized window, even
 522            if there was no resizing/position change at all. BGUI for example
 523            relies on this! */
 524
 525         ih_fire_intuimessage(targetwindow,
 526                      IDCMP_NEWSIZE,
 527                      0,
 528                      targetwindow,
 529                      IntuitionBase);
 530
 531         if ((ie = AllocInputEvent(iihdata)))
 532         {
 533             ie->ie_Class = IECLASS_EVENT;
 534             ie->ie_Code = IECODE_NEWSIZE;
 535             ie->ie_EventAddress = targetwindow;
 536             CurrentTime(&ie->ie_TimeStamp.tv_secs, &ie->ie_TimeStamp.tv_micro);
 537         }
 538     }
 539
 540     // jDc: CheckLayers calls LOCK_REFRESH, so there's no reason to UNLOCK here!
 541     //    UNLOCK_REFRESH(targetwindow->WScreen);
 542
 543     CheckLayers(targetwindow->WScreen, IntuitionBase);
 544
 545     UNLOCK_REFRESH(targetwindow->WScreen);
 546
 547 #if 0
 548     if (size_dx || size_dy)
 549     {
 550         if (!(((struct IntWindow *)targetwindow)->CustomShape))
 551         {
 552             struct wdpWindowShape       shapemsg;
 553             struct Region               *shape;
 554             shapemsg.MethodID           = WDM_WINDOWSHAPE;
 555             shapemsg.wdp_Width      = targetwindow->Width;
 556             shapemsg.wdp_Height     = targetwindow->Height;
 557             shapemsg.wdp_Window = targetwindow;
 558             shapemsg.wdp_TrueColor      = (((struct IntScreen *)targetwindow->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
 559             shapemsg.wdp_UserBuffer     = ((struct IntWindow *)targetwindow)->DecorUserBuffer;
 560             shape = DoMethodA(((struct IntScreen *)(targetwindow->WScreen))->WinDecorObj, (Msg)&shapemsg);
 561
 562             if (((struct IntWindow *)targetwindow)->OutlineShape) DisposeRegion(((struct IntWindow *)targetwindow)->OutlineShape);
 563             ((struct IntWindow *)targetwindow)->OutlineShape = shape;
 564             ChangeWindowShape(targetwindow, shape, NULL);
 565             ((struct IntWindow *)targetwindow)->CustomShape = FALSE;
 566         }
 567     }
 568 #endif
 569
 570 }
 571
 572 /*******************************************************************************************************/
 573
 574 void DoSyncAction(void (*func)(struct IntuiActionMsg *, struct IntuitionBase *),
 575                   struct IntuiActionMsg *msg,
 576                   struct IntuitionBase *IntuitionBase)
 577 {
 578     struct IIHData *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 579     struct Task    *me = FindTask(NULL);
 580
 581     if (me == iihd->InputDeviceTask)
 582     {
 583         func(msg, IntuitionBase);
 584     }
 585     else
 586     {
 587         struct IOStdReq   req;
 588         struct MsgPort    port;
 589         struct InputEvent ie;
 590
 591         msg->handler = func;
 592         msg->task    = me;
 593         msg->done    = FALSE;
 594
 595         ObtainSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
 596         AddTail((struct List *)GetPrivIBase(IntuitionBase)->IntuiActionQueue, (struct Node *)msg);
 597         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
 598
 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
 613         if (!msg->done)
 614         {
 615             DoIO((APTR)&req);
 616             while (!msg->done)
 617             {
 618                 Wait(SIGF_INTUITION);
 619             }
 620         }
 621     }
 622 }
 623
 624 /*******************************************************************************************************/
 625
 626 BOOL DoASyncAction(void (*func)(struct IntuiActionMsg *, struct IntuitionBase *),
 627                    struct IntuiActionMsg *msg, ULONG size,
 628                    struct IntuitionBase *IntuitionBase)
 629 {
 630     struct IIHData          *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 631     struct Task             *me = FindTask(NULL);
 632     struct IntuiActionMsg   *new_msg;
 633
 634     if (me == iihd->InputDeviceTask)
 635     {
 636         func(msg, IntuitionBase);
 637         return TRUE;
 638     }
 639     else if ((new_msg = AllocVecPooled(iihd->ActionsMemPool,size)))
 640     {
 641         new_msg->handler = func;
 642         new_msg->task = NULL;
 643         if (size > sizeof(*msg))
 644         {
 645             CopyMem(msg + 1, new_msg + 1, size - sizeof(*msg));
 646         }
 647
 648         ObtainSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
 649         AddTail((struct List *)GetPrivIBase(IntuitionBase)->IntuiActionQueue, (struct Node *)new_msg);
 650         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
 651
 652         return TRUE;
 653     }
 654     else
 655     {
 656         return FALSE;
 657     }
 658 }
 659
 660 /*******************************************************************************************************/
 661
 662 void HandleIntuiActions(struct IIHData *iihdata,
 663                         struct IntuitionBase *IntuitionBase)
 664 {
 665     struct IntuiActionMsg *am;
 666
 667     D(bug("Handle Intuition action messages\n"));
 668
 669     if (iihdata->ActiveSysGadget)
 670     {
 671         D(bug("Handle Intuition action messages. Doing nothing because of active drag or resize gadget!\n"));
 672         return;
 673     }
 674
 675     for (;;)
 676     {
 677         LOCK_ACTIONS();
 678         am = (struct IntuiActionMsg *)RemHead((struct List *)&iihdata->IntuiActionQueue);
 679         UNLOCK_ACTIONS();
 680
 681         if (!am)
 682             break;
 683
 684         am->handler(am, IntuitionBase);
 685
 686         if (am->task)
 687         {
 688             Forbid();
 689             am->done = TRUE;
 690             Signal(am->task, SIGF_INTUITION);
 691             Permit();
 692         }
 693         else
 694         {
 695             FreeVecPooled(iihdata->ActionsMemPool,am);
 696         }
 697     }
 698
 699     D(bug("Intuition action messages handled\n"));
 700 }
 701
 702 #ifndef __MORPHOS__
 703 static void move_family(struct Window * w, int dx, int dy)
 704 {
 705     struct Window * _w = w->firstchild;
 706
 707     while (_w)
 708     {
 709         _w->LeftEdge  += dx,
 710                  _w->TopEdge   += dy;
 711         if (HAS_CHILDREN(_w))
 712             move_family(_w,dx,dy);
 713         _w=_w->nextchild;
 714     }
 715 }
 716 #endif