rom/intuition/windowclasses.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5
   6     Classes for window decor stuff, like dragbar, close etc.
   7 */
   8
   9 /***********************************************************************************/
  10
  11 #include <string.h>
  12
  13 #include <proto/exec.h>
  14 #include <proto/intuition.h>
  15 #include <proto/graphics.h>
  16 #include <proto/utility.h>
  17 #include <proto/layers.h>
  18
  19 #include <intuition/classes.h>
  20 #include <intuition/gadgetclass.h>
  21 #include <intuition/cghooks.h>
  22 #include <intuition/imageclass.h>
  23 #include <intuition/extensions.h>
  24 #include <aros/asmcall.h>
  25
  26 #include "gadgets.h"
  27
  28 #include "intuition_intern.h"
  29 #include "inputhandler.h"
  30 #include "inputhandler_support.h"
  31 #include "inputhandler_actions.h"
  32
  33 #ifdef SKINS
  34 #include "intuition_customizesupport.h"
  35 #include "renderwindowframe.h"
  36 #include "mosmisc.h"
  37 #endif
  38
  39 #undef SDEBUG
  40 #undef DEBUG
  41 #define SDEBUG 0
  42 #define DEBUG 0
  43 #include <aros/debug.h>
  44
  45 /*
  46
  47 jDc: opaque resize code is NOT suitable for other apps than MUI, I have no intentions in fixing it so that
  48 it would work with all apps out there. Use mui or die :)
  49
  50 The idea behind the trick is that we use a func that checks if apps reply to idcmps in some period
  51 of time. As long as they are replying fast we can do another layer resize, send idcmp to app.
  52 If they do not then we wait for a while and after some time, if one or more apps don't reply
  53 we do the resize again (the timeout is also useful when we have some dead app with windows
  54 on screen.
  55
  56 */
  57
  58 #if USE_OPAQUESIZE
  59 #   define OPAQUESIZE (w->MoreFlags & WMFLG_IAMMUI)
  60 #else
  61 #   define OPAQUESIZE 0
  62 #endif
  63
  64 //#define DELAYEDDRAG
  65 /* Delayed resizing is enabled, due to a layer deadlock
  66  * that can occur between console.device and this
  67  * gadget when Commodities/ClickToFront is enabled and
  68  * DELAYEDSIZE is disabled.
  69  */
  70 #define DELAYEDSIZE
  71
  72 /***********************************************************************************/
  73
  74 #define WSIG_MOVE SIGF_INTUITION
  75 #define WSIG_DIE  SIGF_ABORT
  76
  77 /***********************************************************************************/
  78
  79 void MoveTask(struct dragbar_data *data,struct Window *w,struct Screen *screen,struct IntuitionBase *IntuitionBase)
  80 {
  81     struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
  82     ULONG signals;
  83
  84     for (;;)
  85     {
  86         signals = Wait(WSIG_DIE|WSIG_MOVE);
  87
  88         if (signals & WSIG_DIE)
  89         {
  90             Forbid();
  91             data->movetask = 0;
  92             Permit();
  93             WindowAction(w,WAC_CHANGEWINDOWBOX,0);
  94             return;
  95         }
  96
  97         if (signals & WSIG_MOVE)
  98         {
  99             struct Layer *L;
 100
 101             LockLayers(&screen->LayerInfo);
 102
 103             for (L = screen->LayerInfo.top_layer; L; L = L->back)
 104             {
 105                 if (L->Window == w)
 106                 {
 107                     //window not closed yet!
 108                     if (data->curleft != w->LeftEdge || data->curtop != w->TopEdge)
 109                     {
 110                         struct Requester    *req;
 111
 112                         if (BLAYER(w))
 113                         {
 114                             /* move outer window first */
 115                             MoveSizeLayer(BLAYER(w), data->curleft - w->LeftEdge, data->curtop - w->TopEdge, 0, 0);
 116                         }
 117
 118                         MoveSizeLayer(WLAYER(w), data->curleft - w->LeftEdge, data->curtop - w->TopEdge, 0, 0);
 119
 120                         for (req = w->FirstRequest; req; req = req->OlderRequest)
 121                         {
 122                             struct Layer *layer = req->ReqLayer;
 123
 124                             if (layer)
 125                             {
 126                                 int dx, dy, dw, dh;
 127                                 int left, top, right, bottom;
 128
 129                                 left = data->curleft + req->LeftEdge;
 130                                 top = data->curtop + req->TopEdge;
 131                                 right = left + req->Width - 1;
 132                                 bottom = top + req->Height - 1;
 133
 134                                 if (left > data->curleft + w->Width - 1)
 135                                     left = data->curleft + w->Width - 1;
 136
 137                                 if (top > data->curtop + w->Height - 1)
 138                                     top = data->curtop + w->Height - 1;
 139
 140                                 if (right > data->curleft + w->Width - 1)
 141                                     right = data->curleft + w->Width - 1;
 142
 143                                 if (bottom > data->curtop + w->Height - 1)
 144                                     bottom = data->curtop + w->Height - 1;
 145
 146                                 dx = left - layer->bounds.MinX;
 147                                 dy = top - layer->bounds.MinY;
 148                                 dw = right - left - layer->bounds.MaxX + layer->bounds.MinX;
 149                                 dh = bottom - top - layer->bounds.MaxY + layer->bounds.MinY;
 150
 151                                 MoveSizeLayer(layer, dx, dy, dw, dh);
 152                             }
 153                         }
 154
 155                         w->LeftEdge = data->curleft;
 156                         w->TopEdge = data->curtop;
 157                         UpdateMouseCoords(w);
 158
 159                     }
 160                 }
 161             }
 162
 163             #ifdef DAMAGECACHE
 164             RecordDamage(screen,IntuitionBase);
 165             #endif
 166             data->drag_refreshed = FALSE;
 167
 168             UnlockLayers(&screen->LayerInfo);
 169         }
 170     }
 171 }
 172
 173 /***********************************************************************************/
 174
 175 /* drawwindowframe is used when the user drags or resizes a window */
 176
 177 #define DWF_THICK_X 2
 178 #define DWF_THICK_Y 2
 179
 180 /***********************************************************************************/
 181
 182 static void cliprectfill(struct Screen *scr, struct RastPort *rp,
 183                          WORD x1, WORD y1, WORD x2, WORD y2,
 184                          struct IntuitionBase *IntuitionBase)
 185 {
 186     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 187     WORD scrx2 = scr->Width  - 1;
 188     WORD scry2 = scr->Height - 1;
 189
 190     /* Check if inside at all */
 191
 192     if (!((x1 > scrx2) || (x2 < 0) || (y1 > scry2) || (y2 < 0)))
 193     {
 194         if (x1 < 0) x1 = 0;
 195         if (y1 < 0) y1 = 0;
 196         if (x2 > scrx2) x2 = scrx2;
 197         if (y2 > scry2) y2 = scry2;
 198
 199         /* paranoia */
 200
 201         if ((x2 >= x1) && (y2 >= y1))
 202         {
 203             RectFill(rp, x1, y1, x2, y2);
 204         }
 205     }
 206
 207 }
 208
 209 /***********************************************************************************/
 210
 211 static void drawwindowframe(struct Screen *scr, struct RastPort *rp,
 212                             WORD x1, WORD y1, WORD x2, WORD y2,
 213                             struct IntuitionBase *IntuitionBase)
 214 {
 215     /* this checks should not be necessary, but just to be sure */
 216
 217     if (x2 < x1)
 218     {
 219         /* swap x2 and x1 */
 220         x2 ^= x1;
 221         x1 ^= x2;
 222         x2 ^= x1;
 223     }
 224
 225     if (y2 < y1)
 226     {
 227         /* swap y2 and y1 */
 228         y2 ^= y1;
 229         y1 ^= y2;
 230         y2 ^= y1;
 231     }
 232
 233     if (((x2 - x1) < (DWF_THICK_X * 2)) ||
 234         ((y2 - y1) < (DWF_THICK_Y * 2)))
 235     {
 236         cliprectfill(scr, rp, x1, y1, x2, y2, IntuitionBase);
 237     }
 238     else
 239     {
 240         cliprectfill(scr, rp, x1, y1, x2, y1 + DWF_THICK_Y - 1, IntuitionBase);
 241         cliprectfill(scr, rp, x2 - DWF_THICK_X + 1, y1 + DWF_THICK_Y, x2, y2, IntuitionBase);
 242         cliprectfill(scr, rp, x1, y2 - DWF_THICK_Y + 1, x2 - DWF_THICK_X, y2, IntuitionBase);
 243         cliprectfill(scr, rp, x1, y1 + DWF_THICK_Y, x1 + DWF_THICK_X - 1, y2 - DWF_THICK_Y, IntuitionBase);
 244     }
 245 }
 246
 247 /***********************************************************************************/
 248
 249 #if 0
 250 IPTR DragBarClass__GM_RENDER(Class *cl, struct Gadget *g, struct gpRender * msg)
 251 {
 252     EnterFunc(bug("DragBar::Render()\n"));
 253     /* We will let the AROS gadgetclass test if it is safe to render */
 254
 255     if ( DoSuperMethodA(cl, (Object *)g, (Msg)msg) != 0)
 256     {
 257         struct DrawInfo     *dri = msg->gpr_GInfo->gi_DrInfo;
 258         UWORD               *pens = dri->dri_Pens;
 259         struct RastPort     *rp = msg->gpr_RPort;
 260         struct IBox          container;
 261         struct Window       *win = msg->gpr_GInfo->gi_Window;
 262         struct TextExtent    te;
 263
 264         GetGadgetIBox(g, msg->gpr_GInfo, &container);
 265
 266         if (container.Width <= 1 || container.Height <= 1)
 267             return;
 268
 269
 270         /* Clear the dragbar */
 271
 272         SetAPen(rp, (win->Flags & WFLG_WINDOWACTIVE) ?
 273                 pens[FILLPEN] : pens[BACKGROUNDPEN]);
 274
 275         SetDrMd(rp, JAM1);
 276
 277         D(bug("Filling from (%d, %d) to (%d, %d)\n",
 278               container.Left,
 279               container.Top,
 280               container.Left + container.Width - 1,
 281               container.Top + container.Height - 1));
 282
 283         RectFill(rp,
 284                  container.Left,
 285                  container.Top,
 286                  container.Left + container.Width - 1,
 287                  container.Top + container.Height - 2);
 288
 289         /* Draw a thin dark line around the bar */
 290
 291         SetAPen(rp, pens[SHINEPEN]);
 292         RectFill(rp,container.Left,
 293                  container.Top,
 294                  container.Left,
 295                  container.Top + container.Height - 1 - ((container.Left == 0) ? 0 : 1));
 296         RectFill(rp,container.Left + 1,
 297                  container.Top,
 298                  container.Left + container.Width - 1,
 299                  container.Top);
 300
 301         SetAPen(rp,pens[SHADOWPEN]);
 302         RectFill(rp,container.Left + container.Width - 1,
 303                  container.Top + 1,
 304                  container.Left + container.Width - 1,
 305                  container.Top + container.Height - 1);
 306         RectFill(rp,container.Left + ((container.Left == 0) ? 1 : 0),
 307                  container.Top + container.Height - 1,
 308                  container.Left + container.Width - 2,
 309                  container.Top + container.Height - 1);
 310
 311         /* Render the titlebar */
 312         if (NULL != win->Title)
 313         {
 314             ULONG textlen, titlelen;
 315
 316             SetFont(rp, dri->dri_Font);
 317
 318             titlelen = strlen(win->Title);
 319             textlen = TextFit(rp
 320                       , win->Title
 321                       , titlelen
 322                       , &te
 323                       , NULL
 324                       , 1
 325                       , container.Width - 6
 326                       , container.Height);
 327
 328             SetAPen(rp, pens[(win->Flags & WFLG_WINDOWACTIVE) ? FILLTEXTPEN : TEXTPEN]);
 329             Move(rp, container.Left + 3, container.Top + dri->dri_Font->tf_Baseline + 2);
 330
 331             Text(rp, win->Title, textlen);
 332         }
 333
 334     }  /* if (allowed to render) */
 335
 336     return (IPTR)0;
 337 }
 338 #endif
 339
 340 /***********************************************************************************/
 341
 342 IPTR DragBarClass__GM_GOACTIVE(Class *cl, struct Gadget *g, struct gpInput *msg)
 343 {
 344     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 345     struct GfxBase    *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 346     struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
 347     struct InputEvent *ie = msg->gpi_IEvent;
 348     IPTR               retval = GMR_NOREUSE;
 349
 350     if (ie)
 351     {
 352         /* The gadget was activated via mouse input */
 353         struct dragbar_data *data;
 354         struct Window       *w;
 355
 356         /* There is no point in rerendering ourseleves here, as this is done
 357            by a call to RefreshWindowFrame() in the intuition inputhandler
 358         */
 359
 360         w = msg->gpi_GInfo->gi_Window;
 361
 362         data = INST_DATA(cl, g);
 363
 364     #ifdef USEWINDOWLOCK
 365         /* do NOT ObtainSemaphore here since this would lead to deadlocks!!! */
 366         /* when the semaphore can not be obtained we simply ignore gadget activation */
 367
 368         /* in movehack the task that locks windowlock is the one that calls MoveWindow*/
 369         if (!(AttemptSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock)))
 370         {
 371             goto fail;
 372         }
 373         data->drag_windowlock = TRUE;
 374     #endif
 375
 376         data->curleft = w->LeftEdge;
 377         data->curtop  = w->TopEdge;
 378
 379         data->startleft = w->LeftEdge;
 380         data->starttop = w->TopEdge;
 381
 382         data->mousex = w->WScreen->MouseX - data->curleft;
 383         data->mousey = w->WScreen->MouseY - data->curtop;
 384
 385         data->drag_refreshed = TRUE;
 386
 387         data->rp = CloneRastPort(&w->WScreen->RastPort);
 388         if (data->rp)
 389         {
 390
 391             /* Lock all layers while the window is dragged.
 392              * Get the gadget lock first to avoid deadlocks
 393              * with ObtainGIRPort. */
 394
 395             D(bug("locking all layers\n"));
 396
 397             if (!(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE))
 398             {
 399             #ifdef USEGADGETLOCK
 400                 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->InputHandlerLock);
 401                 data->drag_inputhandlerlock = TRUE;
 402
 403                 if (AttemptSemaphore(&GetPrivIBase(IntuitionBase)->GadgetLock))
 404                 {
 405                     data->drag_gadgetlock = TRUE;
 406                 }
 407                 else
 408                 {
 409                     goto fail;
 410                 }
 411             #endif
 412             #ifndef DELAYEDDRAG
 413                 LockLayers(&w->WScreen->LayerInfo);
 414                 data->drag_layerlock = TRUE;
 415             #endif
 416             } else {
 417                 /* MOVEHACK ? */
 418                 if (GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_PRIVILEDGEDREFRESH)
 419                 {
 420                 #ifdef __MORPHOS__
 421                     data->movetask =
 422                         NewCreateTask(TASKTAG_CODETYPE, CODETYPE_PPC, TASKTAG_PC, (ULONG)MoveTask,
 423                                         TASKTAG_PRI, 0,
 424                                         TASKTAG_PPC_ARG1,(ULONG)data,
 425                                         TASKTAG_PPC_ARG2,(ULONG)w,
 426                                         TASKTAG_PPC_ARG3,(ULONG)w->WScreen,
 427                                         TASKTAG_PPC_ARG4,(ULONG)IntuitionBase,
 428                                         TAG_DONE);
 429                 #else
 430                 // FIXME!
 431                 /* FIXME: Implemente MOVEHACK support for AROS (?) */
 432                 #endif
 433                 }
 434             }
 435
 436             SetDrMd(data->rp, COMPLEMENT);
 437
 438         #ifndef DELAYEDDRAG
 439             if (!(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE))
 440                 drawwindowframe(w->WScreen
 441                         , data->rp
 442                         , data->curleft
 443                         , data->curtop
 444                         , data->curleft + w->Width  - 1
 445                         , data->curtop  + w->Height - 1
 446                         , IntuitionBase
 447                            );
 448
 449             data->isrendered = TRUE;
 450         #endif
 451
 452             data->drag_canceled = FALSE;
 453
 454             {
 455                 UQUAD currenttime;
 456
 457                 currenttime = ie->ie_TimeStamp.tv_secs;
 458                 currenttime = currenttime * 50;
 459                 currenttime += ie->ie_TimeStamp.tv_micro / 20000;
 460
 461                 data->lasteventtime = currenttime;
 462             }
 463
 464             /* size mouse bounds such that mouse pointer cannot move if window cannot move, if offscreenlayers is turned off */
 465             if (!(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OFFSCREENLAYERS)) {
 466                 struct IIHData *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 467                 iihd->MouseBoundsActiveFlag = TRUE;
 468                 iihd->MouseBoundsLeft = data->mousex;
 469                 iihd->MouseBoundsRight = w->WScreen->Width - (w->Width - data->mousex);
 470                 iihd->MouseBoundsTop = data->mousey;
 471                 iihd->MouseBoundsBottom = w->WScreen->Height - (w->Height - data->mousey);
 472             }
 473
 474             return GMR_MEACTIVE;
 475         }
 476
 477 fail:
 478         if (data->drag_layerlock)
 479         {
 480             UnlockLayers(&w->WScreen->LayerInfo);
 481             data->drag_layerlock = FALSE;
 482             ;
 483         }
 484
 485     #ifdef USEGADGETLOCK
 486         if (data->drag_gadgetlock)
 487         {
 488             ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->GadgetLock);
 489             data->drag_gadgetlock = FALSE;
 490         }
 491
 492         if (data->drag_inputhandlerlock);
 493         {
 494             ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->InputHandlerLock);
 495             data->drag_inputhandlerlock = FALSE;
 496         }
 497     #endif
 498
 499     #ifdef USEWINDOWLOCK
 500         if (data->drag_windowlock)
 501         {
 502             ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
 503             data->drag_windowlock = FALSE;
 504         }
 505     #endif
 506     }
 507
 508     return retval;
 509
 510 }
 511
 512 /***********************************************************************************/
 513
 514 IPTR DragBarClass__GM_MOVETEST(Class *cl, struct Gadget *g, struct gpInput *msg)
 515 {
 516     IPTR                 retval = MOVETEST_MOVE;
 517 #ifdef SKINS
 518     struct dragbar_data *data = INST_DATA(cl, g);
 519     struct Window       *w = msg->gpi_GInfo->gi_Window;
 520     struct InputEvent    myie;
 521     LONG                 new_left;
 522     LONG                 new_top;
 523
 524     CopyMem(msg->gpi_IEvent,&myie,sizeof (struct InputEvent));
 525     myie.ie_Code = 0x68; //mouse_leftpress
 526
 527     /* Can we move to the new position, or is window at edge of display ? */
 528     new_left = msg->gpi_Mouse.X - data->mousex;
 529     new_top  = msg->gpi_Mouse.Y - data->mousey;
 530
 531     if ((!((GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OFFSCREENLAYERS) && (w->WScreen->LayerInfo.Flags & LIFLG_SUPPORTS_OFFSCREEN_LAYERS))) ||
 532         MatchHotkey(&myie,IA_TOGGLEOFFSCREEN,IntuitionBase))
 533     {
 534         if (new_left < 0)
 535         {
 536             msg->gpi_Mouse.X -= new_left;
 537             retval = MOVETEST_ADJUSTPOS;
 538         }
 539
 540         if (new_top < 0)
 541         {
 542             msg->gpi_Mouse.Y -= new_top;
 543             retval = MOVETEST_ADJUSTPOS;
 544         }
 545
 546         if (new_left + w->Width > w->WScreen->Width)
 547         {
 548             msg->gpi_Mouse.X -= new_left - (w->WScreen->Width - w->Width);
 549             retval = MOVETEST_ADJUSTPOS;
 550         }
 551
 552         if (new_top + w->Height > w->WScreen->Height)
 553         {
 554             msg->gpi_Mouse.Y -= new_top - (w->WScreen->Height - w->Height);
 555             retval =  MOVETEST_ADJUSTPOS;
 556         }
 557     }
 558 #endif
 559
 560     return retval;
 561
 562 }
 563
 564 /***********************************************************************************/
 565
 566 IPTR DragBarClass__GM_HANDLEINPUT(Class *cl, struct Gadget *g, struct gpInput *msg)
 567 {
 568     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 569     struct GfxBase    *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 570     struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
 571     struct GadgetInfo *gi = msg->gpi_GInfo;
 572     IPTR               retval = GMR_MEACTIVE;
 573
 574     if (gi)
 575     {
 576         struct InputEvent   *ie = msg->gpi_IEvent;
 577         struct dragbar_data *data = INST_DATA(cl, g);
 578         struct Window       *w = msg->gpi_GInfo->gi_Window;
 579
 580         switch (ie->ie_Class)
 581         {
 582         case IECLASS_RAWMOUSE:
 583             switch (ie->ie_Code)
 584             {
 585             case MENUDOWN:
 586                 retval = GMR_NOREUSE;
 587                 data->drag_canceled = TRUE;
 588                 break;
 589
 590             case SELECTUP:
 591                 retval = GMR_NOREUSE;
 592                 break;
 593
 594
 595             case IECODE_NOBUTTON:
 596                 {
 597                     struct Screen       *scr = w->WScreen;
 598                     struct InputEvent    myie;
 599                     LONG                 new_left;
 600                     LONG                 new_top;
 601
 602                     /* Can we move to the new position, or is window at edge of display ? */
 603                     new_left = scr->MouseX - data->mousex;
 604                     new_top  = scr->MouseY - data->mousey;
 605
 606                     CopyMem(ie,&myie,sizeof (struct InputEvent));
 607                     myie.ie_Code = SELECTDOWN; //mouse_leftpress
 608
 609                 #ifdef SKINS
 610                     if ((!((GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OFFSCREENLAYERS) && (w->WScreen->LayerInfo.Flags & LIFLG_SUPPORTS_OFFSCREEN_LAYERS))) ||
 611                         MatchHotkey(&myie,IA_TOGGLEOFFSCREEN,IntuitionBase))
 612                 #else
 613                     if (!((GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OFFSCREENLAYERS) && (w->WScreen->LayerInfo.Flags & LIFLG_SUPPORTS_OFFSCREEN_LAYERS)))
 614                 #endif
 615                     {
 616                         if (new_left < 0)
 617                         {
 618                             data->mousex += new_left;
 619                             new_left = 0;
 620                         }
 621
 622                         if (new_top < 0)
 623                         {
 624                             data->mousey += new_top;
 625                             new_top = 0;
 626                         }
 627
 628                         if (new_left + w->Width > scr->Width)
 629                         {
 630                             LONG correct_left;
 631                             correct_left = scr->Width - w->Width; /* align to screen border */
 632                             data->mousex += new_left - correct_left;
 633                             new_left = correct_left;
 634                         }
 635
 636                         if (new_top + w->Height > scr->Height)
 637                         {
 638                             LONG correct_top;
 639                             correct_top = scr->Height - w->Height; /* align to screen border */
 640                             data->mousey += new_top - correct_top;
 641                             new_top = correct_top;
 642                         }
 643                     }
 644
 645                     if (data->curleft != new_left || data->curtop != new_top)
 646                     {
 647                         SetDrMd(data->rp, COMPLEMENT);
 648
 649                         if ((data->isrendered) && (!(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE)))
 650                         {
 651                             /* Erase old frame */
 652                             drawwindowframe(w->WScreen
 653                                             , data->rp
 654                                             , data->curleft
 655                                             , data->curtop
 656                                             , data->curleft + w->Width  - 1
 657                                             , data->curtop  + w->Height - 1
 658                                             , IntuitionBase
 659                                             );
 660                         }
 661
 662                         data->curleft = new_left;
 663                         data->curtop  = new_top;
 664
 665                         if (GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE)
 666                         {
 667                             WORD newx = new_left - w->LeftEdge, newy = new_top - w->TopEdge;
 668
 669                             if (newx || newy)
 670                             {
 671                                 UQUAD currenttime;
 672
 673                                 currenttime = ie->ie_TimeStamp.tv_secs;
 674                                 currenttime = currenttime * 50;
 675                                 currenttime += ie->ie_TimeStamp.tv_micro / 20000;
 676
 677                                 if (currenttime > data->lasteventtime + 10) //10 delay should result in intuitick freq
 678                                 {
 679                                     ih_fire_intuimessage(w,
 680                                                          IDCMP_CHANGEWINDOW,
 681                                                          CWCODE_MOVESIZE,
 682                                                          w,
 683                                                          IntuitionBase);
 684                                     data->lasteventtime = currenttime;
 685                                 }
 686
 687                                 if (data->movetask)
 688                                 {
 689                                     Forbid();
 690                                     Signal(data->movetask,WSIG_MOVE);
 691                                     Permit();
 692
 693                                     CheckLayers(w->WScreen, IntuitionBase);
 694                                 }
 695                                 else
 696                                 {
 697                                     struct Requester *req;
 698
 699                                     LockLayers(&w->WScreen->LayerInfo);
 700
 701                                     w->LeftEdge    += newx;
 702                                     w->TopEdge     += newy;
 703
 704                                     if (BLAYER(w))
 705                                     {
 706                                         MoveSizeLayer(BLAYER(w), newx, newy , 0, 0);
 707                                     }
 708
 709                                     MoveSizeLayer(WLAYER(w), newx, newy, 0, 0);
 710
 711                                     for (req = w->FirstRequest; req; req = req->OlderRequest)
 712                                     {
 713                                         struct Layer *layer = req->ReqLayer;
 714
 715                                         if (layer)
 716                                         {
 717                                             int dx, dy, dw, dh;
 718                                             int left, top, right, bottom;
 719
 720                                             left = data->curleft + req->LeftEdge;
 721                                             top = data->curtop + req->TopEdge;
 722                                             right = left + req->Width - 1;
 723                                             bottom = top + req->Height - 1;
 724
 725                                             if (left > data->curleft + w->Width - 1)
 726                                                 left = data->curleft + w->Width - 1;
 727
 728                                             if (top > data->curtop + w->Height - 1)
 729                                                 top = data->curtop + w->Height - 1;
 730
 731                                             if (right > data->curleft + w->Width - 1)
 732                                                 right = data->curleft + w->Width - 1;
 733
 734                                             if (bottom > data->curtop + w->Height - 1)
 735                                                 bottom = data->curtop + w->Height - 1;
 736
 737                                             dx = left - layer->bounds.MinX;
 738                                             dy = top - layer->bounds.MinY;
 739                                             dw = right - left - layer->bounds.MaxX + layer->bounds.MinX;
 740                                             dh = bottom - top - layer->bounds.MaxY + layer->bounds.MinY;
 741
 742                                             MoveSizeLayer(layer, dx, dy, dw, dh);
 743                                         }
 744                                     }
 745
 746                                     CheckLayers(w->WScreen, IntuitionBase);
 747
 748                                     UnlockLayers(&w->WScreen->LayerInfo);
 749                                 }
 750                             }
 751                         }
 752                         else
 753                         {
 754                             #ifdef DELAYEDDRAG
 755                             if ((!(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE)) && (!data->drag_layerlock))
 756                             {
 757                                 LockLayers(&w->WScreen->LayerInfo);
 758                                 data->drag_layerlock = TRUE;
 759                             }
 760                             #endif
 761                                 /* Rerender the window frame */
 762                             drawwindowframe(w->WScreen
 763                                             , data->rp
 764                                             , data->curleft
 765                                             , data->curtop
 766                                             , data->curleft + w->Width  - 1
 767                                             , data->curtop  + w->Height - 1
 768                                             , IntuitionBase);
 769                             data->isrendered = TRUE;
 770                         }
 771
 772                     }
 773
 774                     retval = GMR_MEACTIVE;
 775
 776                     break;
 777                 }
 778
 779             default:
 780                 retval = GMR_NOREUSE;
 781                 if (!(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE)) data->drag_canceled = TRUE;
 782                 break;
 783
 784             } /* switch (ie->ie_Code) */
 785             break;
 786
 787     case IECLASS_TIMER:
 788             #ifdef DELAYEDDRAG
 789             if ((!(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE)) && (!data->drag_layerlock))
 790             {
 791                 UQUAD currenttime;
 792
 793                 currenttime = ie->ie_TimeStamp.tv_secs;
 794                 currenttime = currenttime * 50;
 795                 currenttime += ie->ie_TimeStamp.tv_micro / 20000;
 796
 797                 if (currenttime > data->lasteventtime + 10)
 798                 {
 799                     LockLayers(&w->WScreen->LayerInfo);
 800                     data->drag_layerlock = TRUE;
 801
 802                     drawwindowframe(w->WScreen
 803                         , data->rp
 804                         , data->curleft
 805                         , data->curtop
 806                         , data->curleft + w->Width  - 1
 807                         , data->curtop  + w->Height - 1
 808                         , IntuitionBase
 809                         );
 810                     data->lasteventtime = currenttime;
 811                     data->isrendered = TRUE;
 812                 }
 813             }
 814             #endif
 815
 816             if (data->movetask)
 817             {
 818                 UQUAD currenttime;
 819
 820                 currenttime = ie->ie_TimeStamp.tv_secs;
 821                 currenttime = currenttime * 50;
 822                 currenttime += ie->ie_TimeStamp.tv_micro / 20000;
 823
 824                 if ((!data->drag_refreshed) && currenttime > data->lasteventtime + 10) //10 delay should result in intuitick freq
 825                 {
 826                     ih_fire_intuimessage(   w,
 827                           IDCMP_CHANGEWINDOW,
 828                           CWCODE_MOVESIZE,
 829                           w,
 830                           IntuitionBase);
 831                     data->drag_refreshed = TRUE;
 832                     data->lasteventtime = currenttime;
 833                 }
 834                 CheckLayers(w->WScreen,IntuitionBase);
 835             }
 836             break;
 837         } /* switch (ie->ie_Class) */
 838
 839     } /* if (gi) */
 840
 841     return retval;
 842 }
 843
 844 /***********************************************************************************/
 845
 846 IPTR DragBarClass__GM_GOINACTIVE(Class *cl, struct Gadget *g, struct gpGoInactive *msg)
 847 {
 848     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 849     struct GfxBase      *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 850     struct LayersBase   *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
 851     struct dragbar_data *data;
 852     struct Window       *w;
 853
 854     data = INST_DATA(cl, g);
 855
 856     w = msg->gpgi_GInfo->gi_Window;
 857
 858     /* Always clear last drawn frame */
 859
 860     if (data->isrendered && data->rp && (!(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE)))
 861     {
 862
 863         SetDrMd(data->rp, COMPLEMENT);
 864
 865         /* Erase old frame */
 866         drawwindowframe(w->WScreen
 867                 , data->rp
 868                 , data->curleft
 869                 , data->curtop
 870                 , data->curleft + w->Width  - 1
 871                 , data->curtop  + w->Height - 1
 872                 , IntuitionBase
 873                    );
 874
 875     }
 876
 877     data->isrendered = FALSE;
 878
 879     if (!data->drag_refreshed) CheckLayers(w->WScreen, IntuitionBase);
 880
 881     Forbid();
 882     if (data->movetask)
 883     {
 884         Signal(data->movetask,WSIG_DIE);
 885         data->movetask = 0;
 886     }
 887     Permit();
 888
 889     if (!data->drag_canceled)// && !(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE))
 890     {
 891         MoveWindow(w
 892                    , data->curleft - w->LeftEdge    /* dx */
 893                    , data->curtop  - w->TopEdge /* dy */
 894                   );
 895
 896     }
 897
 898     if (data->drag_canceled && (GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OPAQUEMOVE))
 899     {
 900         MoveWindow(w
 901                    , data->startleft - w->LeftEdge /* dx */
 902                    , data->starttop - w->TopEdge /* dy */
 903                   );
 904     }
 905
 906
 907     ih_fire_intuimessage(w,
 908                          IDCMP_CHANGEWINDOW,
 909                          CWCODE_MOVESIZE,
 910                          w,
 911                          IntuitionBase);
 912
 913     data->drag_canceled = TRUE;
 914
 915     if (data->drag_layerlock)
 916     {
 917         UnlockLayers(&w->WScreen->LayerInfo);
 918         data->drag_layerlock = FALSE;
 919     }
 920
 921 #ifdef USEGADGETLOCK
 922     if (data->drag_gadgetlock)
 923     {
 924         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->GadgetLock);
 925         data->drag_gadgetlock = FALSE;
 926     }
 927
 928     if (data->drag_inputhandlerlock)
 929     {
 930         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->InputHandlerLock);
 931         data->drag_inputhandlerlock = FALSE;
 932     }
 933 #endif
 934
 935 #ifdef USEWINDOWLOCK
 936     if (data->drag_windowlock)
 937     {
 938         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
 939         data->drag_windowlock = FALSE;
 940     }
 941 #endif
 942
 943     /* User throught with drag operation. Unlock layesr and free
 944     rastport clone
 945     */
 946
 947     if (data->rp)
 948     {
 949         FreeRastPort(data->rp);
 950         data->rp = NULL;
 951     }
 952
 953     /* shut off mouse bounds checking.  */
 954     struct IIHData *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
 955     iihd->MouseBoundsActiveFlag = FALSE;
 956
 957     return TRUE;
 958
 959
 960 }
 961
 962 /***********************************************************************************/
 963
 964 IPTR DragBarClass__NOP(Class *cl, Object *o, Msg msg)
 965 {
 966     return (IPTR)0;
 967 }
 968
 969 /***********************************************************************************/
 970
 971 IPTR DragBarClass__GM_HITTEST(Class *cl, Object *o, Msg msg)
 972 {
 973     return (IPTR)1;
 974 }
 975
 976 /***********************************************************************************/
 977
 978 IPTR DragBarClass__OM_NEW(Class *cl, Object *o, Msg msg)
 979 {
 980     struct Gadget *g = (struct Gadget *)DoSuperMethodA(cl, o, msg);
 981     if (g)
 982     {
 983         g->GadgetType |= GTYP_SYSGADGET | GTYP_WDRAGGING;
 984     }
 985
 986     return (IPTR)g;
 987 }
 988
 989 /***********************************************************************************/
 990
 991 /*********************
 992 ** The SizeButtonClass
 993 *********************/
 994
 995 #ifdef SKINS
 996 #define SIZETYPE_RIGHTBOTTOM 1
 997 #define SIZETYPE_RIGHT       2
 998 #define SIZETYPE_BOTTOM      3
 999 #define SIZETYPE_LEFTBOTTOM  4
1000 #define SIZETYPE_LEFT        5
1001 #define SIZETYPE_LEFTTOP     6
1002 #define SIZETYPE_TOP         7
1003 #define SIZETYPE_RIGHTTOP    8
1004 #endif
1005
1006 /***********************************************************************************/
1007
1008 void smartresize(struct Window *w,struct sizebutton_data *data,Class *cl)
1009 {
1010     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
1011     struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
1012     struct IIHData  *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
1013
1014     LockLayers(&w->WScreen->LayerInfo);
1015
1016     if (BLAYER(w))
1017     {
1018         struct Hook *backfill;
1019
1020         backfill = BLAYER(w)->BackFill;
1021         BLAYER(w)->BackFill = LAYERS_NOBACKFILL;
1022
1023         /* move outer window first */
1024         MoveSizeLayer(BLAYER(w), data->left - w->LeftEdge, data->top - w->TopEdge, data->width - w->Width, data->height - w->Height);
1025
1026         BLAYER(w)->BackFill = backfill;
1027     }
1028
1029     {
1030         struct Hook *backfill;
1031
1032         backfill = WLAYER(w)->BackFill;
1033         WLAYER(w)->BackFill = LAYERS_NOBACKFILL;
1034         MoveSizeLayer(WLAYER(w), data->left - w->LeftEdge, data->top - w->TopEdge, data->width - w->Width, data->height - w->Height);
1035         WLAYER(w)->BackFill = backfill;
1036     }
1037
1038     w->TopEdge = data->top;
1039     w->LeftEdge = data->left;
1040     w->Width = data->width;
1041     w->Height = data->height;
1042
1043     IW(w)->specialflags |= SPFLAG_LAYERRESIZED;
1044
1045     if ((iihdata->ActiveGadget) && (w == iihdata->GadgetInfo.gi_Window))
1046     {
1047         GetGadgetDomain(iihdata->ActiveGadget,
1048                 iihdata->GadgetInfo.gi_Screen,
1049                 iihdata->GadgetInfo.gi_Window,
1050                 NULL,
1051                 &iihdata->GadgetInfo.gi_Domain);
1052     }
1053
1054     /* Relayout GFLG_REL??? gadgets */
1055     DoGMLayout(w->FirstGadget, w, NULL, -1, FALSE, IntuitionBase);
1056
1057     ih_fire_intuimessage(w,
1058                      IDCMP_NEWSIZE,
1059                      0,
1060                      w,
1061                      IntuitionBase);
1062
1063     CheckLayers(w->WScreen, IntuitionBase);
1064
1065     UnlockLayers(&w->WScreen->LayerInfo);
1066 }
1067
1068 /***********************************************************************************/
1069
1070 IPTR SizeButtonClass__GM_GOACTIVE(Class *cl, struct Gadget *g, struct gpInput *msg)
1071 {
1072     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
1073     struct GfxBase      *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1074     struct LayersBase   *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
1075     struct InputEvent   *ie = msg->gpi_IEvent;
1076     IPTR                 retval = GMR_NOREUSE;
1077
1078     if (ie)
1079     {
1080         /* The gadget was activated via mouse input */
1081         struct sizebutton_data  *data;
1082         struct Window           *w;
1083
1084         /* There is no point in rerendering ourseleves her, as this
1085            is done by a call to RefreshWindowFrame() in the intuition inputhandler
1086         */
1087
1088         w = msg->gpi_GInfo->gi_Window;
1089
1090         data = INST_DATA(cl, g);
1091
1092     #ifdef USEWINDOWLOCK
1093         /* do NOT ObtainSemaphore here since this would lead to deadlocks!!! */
1094         /* when the semaphore can not be obtained we simply ignore gadget activation */
1095         if (!(AttemptSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock)))
1096         {
1097             goto fail;
1098         }
1099         data->drag_windowlock = TRUE;
1100     #endif
1101
1102         data->height = data->Height = w->Height;
1103         data->width  = data->Width = w->Width;
1104         data->left = data->LeftEdge = w->LeftEdge;
1105         data->top = data->TopEdge = w->TopEdge;
1106
1107         data->mouseoffsetx = w->WScreen->MouseX;
1108         data->mouseoffsety = w->WScreen->MouseY;
1109
1110         data->drag_refreshed = TRUE;
1111         data->drag_ticks = 2;
1112
1113     #ifdef SKINS
1114         data->drag_type = 0;
1115
1116         if (w->MouseX < IW(w)->sizeimage_width)
1117         {
1118             if (w->MouseY < IW(w)->sizeimage_height) data->drag_type = SIZETYPE_LEFTTOP;
1119             if (w->MouseY > w->Height - IW(w)->sizeimage_height - 1) data->drag_type = SIZETYPE_LEFTBOTTOM;
1120             if (!data->drag_type) data->drag_type = SIZETYPE_LEFT;
1121         }
1122
1123         if ((!data->drag_type) && (w->MouseX >= IW(w)->sizeimage_width) && (w->MouseX <= w->Width - 1 - IW(w)->sizeimage_width))
1124         {
1125             if (w->MouseY < w->BorderTop)
1126             {
1127                 data->drag_type = SIZETYPE_TOP;
1128             } else {
1129                 data->drag_type = SIZETYPE_BOTTOM;
1130             }
1131         }
1132
1133         if ((!data->drag_type) && (w->MouseX > IW(w)->sizeimage_width))
1134         {
1135             if (w->MouseY < IW(w)->sizeimage_height) data->drag_type = SIZETYPE_RIGHTTOP;
1136             if (w->MouseY > w->Height - IW(w)->sizeimage_height - 1) data->drag_type = SIZETYPE_RIGHTBOTTOM;
1137             if (!data->drag_type) data->drag_type = SIZETYPE_RIGHT;
1138         }
1139
1140         if (!data->drag_type) goto fail;
1141     #endif
1142
1143         data->rp = CloneRastPort(&w->WScreen->RastPort);
1144         if (data->rp)
1145         {
1146             /* Lock all layers while the window is resized.
1147              * Get the gadget lock first to avoid deadlocks
1148              * with ObtainGIRPort. */
1149
1150             if (!OPAQUESIZE)
1151             {
1152             #ifdef USEGADGETLOCK
1153                 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->InputHandlerLock);
1154                 data->drag_inputhandlerlock = TRUE;
1155
1156                 if (AttemptSemaphore(&GetPrivIBase(IntuitionBase)->GadgetLock))
1157                 {
1158                     data->drag_gadgetlock = TRUE;
1159                 }
1160                 else
1161                 {
1162                     goto fail;
1163                 }
1164             #endif
1165             #ifndef DELAYEDSIZE
1166                 LockLayers(&w->WScreen->LayerInfo);
1167                 data->drag_layerlock = TRUE;
1168             #endif
1169             }
1170
1171             SetDrMd(data->rp, COMPLEMENT);
1172
1173         #ifndef DELAYEDSIZE
1174             if(!OPAQUESIZE)
1175                 drawwindowframe(w->WScreen
1176                                 , data->rp
1177                                 , data->left
1178                                 , data->top
1179                                 , data->left + data->width  - 1
1180                                 , data->top  + data->height - 1
1181                                 , IntuitionBase
1182                                 );
1183
1184             data->isrendered = TRUE;
1185         #endif
1186
1187             {
1188                 UQUAD currenttime;
1189
1190                 currenttime = ie->ie_TimeStamp.tv_secs;
1191                 currenttime = currenttime * 50;
1192                 currenttime += ie->ie_TimeStamp.tv_micro / 20000;
1193                 data->lasteventtime = currenttime;
1194             }
1195
1196             data->drag_canceled = FALSE;
1197
1198             /* size mouse bounds such that mouse pointer cannot move if window cannot size, if offscreenlayers is turned off */
1199             if (!(GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OFFSCREENLAYERS)) {
1200                 struct IIHData *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
1201                 LONG mousex = data->mouseoffsetx - data->LeftEdge;
1202                 LONG mousey = data->mouseoffsety - data->TopEdge;
1203
1204                 iihd->MouseBoundsActiveFlag = TRUE;
1205                 iihd->MouseBoundsLeft = 0;
1206                 iihd->MouseBoundsRight = w->WScreen->Width - (w->Width - mousex);
1207                 iihd->MouseBoundsTop = 0;
1208                 iihd->MouseBoundsBottom = w->WScreen->Height - (w->Height - mousey);
1209             }
1210
1211             return GMR_MEACTIVE;
1212         }
1213
1214 fail:
1215         if (data->drag_layerlock)
1216         {
1217             UnlockLayers(&w->WScreen->LayerInfo);
1218             data->drag_layerlock = FALSE;
1219             ;
1220         }
1221
1222 #ifdef USEGADGETLOCK
1223         if (data->drag_gadgetlock)
1224         {
1225             ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->GadgetLock);
1226             data->drag_gadgetlock = FALSE;
1227         }
1228
1229         if (data->drag_inputhandlerlock);
1230         {
1231             ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->InputHandlerLock);
1232             data->drag_inputhandlerlock = FALSE;
1233         }
1234 #endif
1235
1236 #ifdef USEWINDOWLOCK
1237         if (data->drag_windowlock)
1238         {
1239             ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
1240             data->drag_windowlock = FALSE;
1241         }
1242 #endif
1243     }
1244
1245     return retval;
1246
1247 }
1248
1249 /***********************************************************************************/
1250
1251 IPTR SizeButtonClass__GM_HANDLEINPUT(Class *cl, struct Gadget *g, struct gpInput *msg)
1252 {
1253     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
1254 #ifdef DELAYEDSIZE
1255     struct LayersBase   *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
1256 #endif
1257     struct GfxBase      *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1258     struct GadgetInfo   *gi = msg->gpi_GInfo;
1259     IPTR                 retval = GMR_MEACTIVE;
1260
1261     if (gi)
1262     {
1263         struct InputEvent       *ie = msg->gpi_IEvent;
1264         struct sizebutton_data  *data = INST_DATA(cl, g);
1265         struct Window           *w = msg->gpi_GInfo->gi_Window;
1266
1267         switch (ie->ie_Class)
1268         {
1269         case IECLASS_RAWMOUSE:
1270             switch (ie->ie_Code)
1271             {
1272             case SELECTUP:
1273                 retval = GMR_NOREUSE;
1274                 break;
1275
1276
1277             case IECODE_NOBUTTON:
1278                 {
1279                     struct Screen   *scr = w->WScreen;
1280                     LONG             new_width = 0;
1281                     LONG             new_height = 0;
1282
1283                     /* Can we move to the new position, or is window at edge of display ? */
1284                 #ifdef SKINS
1285                     switch(data->drag_type)
1286                     {
1287                         case SIZETYPE_BOTTOM:
1288                             new_height  = data->Height + scr->MouseY - data->mouseoffsety;
1289                             new_width   = data->Width;
1290                             break;
1291
1292                         case SIZETYPE_TOP:
1293                             new_height  = data->Height + data->mouseoffsety - scr->MouseY;
1294                             new_width = data->Width;
1295                             break;
1296
1297                         case SIZETYPE_RIGHTBOTTOM:
1298                             new_width   = data->Width + scr->MouseX - data->mouseoffsetx;
1299                             new_height  = data->Height + scr->MouseY - data->mouseoffsety;
1300                             break;
1301
1302                         case SIZETYPE_LEFTTOP:
1303                             new_width   = data->Width + data->mouseoffsetx - scr->MouseX;
1304                             new_height  = data->Height + data->mouseoffsety - scr->MouseY;
1305                             break;
1306
1307                         case SIZETYPE_RIGHTTOP:
1308                             new_width   = data->Width + scr->MouseX - data->mouseoffsetx;
1309                             new_height  = data->Height + data->mouseoffsety - scr->MouseY;
1310                             break;
1311
1312                         case SIZETYPE_LEFTBOTTOM:
1313                             new_width   = data->Width + data->mouseoffsetx - scr->MouseX;
1314                             new_height  = data->Height + scr->MouseY - data->mouseoffsety;
1315                             break;
1316
1317                         case SIZETYPE_LEFT:
1318                             new_width   = data->Width + data->mouseoffsetx - scr->MouseX;
1319                             new_height = data->Height;
1320                             break;
1321
1322                         case SIZETYPE_RIGHT:
1323                             new_width   = data->Width + scr->MouseX - data->mouseoffsetx;
1324                             new_height = data->Height;
1325                             break;
1326                     }
1327                 #else
1328                     new_width   = data->Width + scr->MouseX - data->mouseoffsetx;
1329                     new_height  = data->Height + scr->MouseY - data->mouseoffsety;
1330                 #endif
1331                     if (new_width < 0)
1332                         new_width = 1;
1333
1334                     if (w->MinWidth != 0 && new_width < (ULONG)w->MinWidth)
1335                         new_width = w->MinWidth;
1336
1337                     if (w->MaxWidth != 0 && new_width > (ULONG)w->MaxWidth)
1338                         new_width = w->MaxWidth;
1339
1340                     if (new_height < 0)
1341                         new_height = 1;
1342
1343                     if (w->MinHeight != 0 && new_height < (ULONG)w->MinHeight)
1344                         new_height = w->MinHeight;
1345
1346                     if (w->MaxHeight != 0 && new_height > (ULONG)w->MaxHeight)
1347                         new_height = w->MaxHeight;
1348
1349
1350                     #ifdef SKINS
1351                     if (!((GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_OFFSCREENLAYERS) && (w->WScreen->LayerInfo.Flags & LIFLG_SUPPORTS_OFFSCREEN_LAYERS)))
1352                     {
1353                         /* limit dimensions so window fits on the screen */
1354                         switch (data->drag_type)
1355                         {
1356                             case SIZETYPE_RIGHT:
1357                             case SIZETYPE_RIGHTTOP:
1358                             case SIZETYPE_RIGHTBOTTOM:
1359                                 if (data->left + new_width > scr->Width)
1360                                     new_width = scr->Width - data->left;
1361                                 break;
1362
1363                             case SIZETYPE_LEFT:
1364                             case SIZETYPE_LEFTBOTTOM:
1365                             case SIZETYPE_LEFTTOP:
1366                                 if (data->LeftEdge + data->Width - new_width < 0)
1367                                     new_width += (data->LeftEdge + data->Width - new_width);
1368                                 break;
1369                         }
1370
1371                         switch (data->drag_type)
1372                         {
1373                             case SIZETYPE_LEFTBOTTOM:
1374                             case SIZETYPE_BOTTOM:
1375                             case SIZETYPE_RIGHTBOTTOM:
1376                                 if (data->top + new_height > scr->Height)
1377                                     new_height = scr->Height - data->top;
1378                                 break;
1379
1380                             case SIZETYPE_TOP:
1381                             case SIZETYPE_LEFTTOP:
1382                             case SIZETYPE_RIGHTTOP:
1383                                 if (data->TopEdge + data->Height - new_height < 0)
1384                                     new_height += (data->TopEdge + data->Height - new_height);
1385                                 break;
1386                         }
1387                     }
1388                     #endif
1389
1390                     if (data->height != new_height || data->width != new_width)
1391                     {
1392                         SetDrMd(data->rp, COMPLEMENT);
1393
1394                         if (data->isrendered && !OPAQUESIZE)
1395                         {
1396                             /* Erase old frame */
1397                             drawwindowframe(w->WScreen
1398                                             , data->rp
1399                                             , data->left
1400                                             , data->top
1401                                             , data->left + data->width  - 1
1402                                             , data->top  + data->height - 1
1403                                             , IntuitionBase
1404                                             );
1405
1406                         }
1407
1408                         #ifdef SKINS
1409                         switch(data->drag_type)
1410                         {
1411                             case SIZETYPE_LEFT:
1412                                 data->left = data->LeftEdge + data->Width - new_width;
1413                                 break;
1414
1415                             case SIZETYPE_LEFTTOP:
1416                                 data->left = data->LeftEdge + data->Width - new_width;
1417                                 data->top = data->TopEdge + data->Height - new_height;
1418                                 break;
1419
1420                             case SIZETYPE_LEFTBOTTOM:
1421                                 data->left = data->LeftEdge + data->Width - new_width;
1422                                 break;
1423
1424                             case SIZETYPE_RIGHTTOP:
1425                                 data->top = data->TopEdge + data->Height - new_height;
1426                                 break;
1427
1428                             case SIZETYPE_TOP:
1429                                 data->top = data->TopEdge + data->Height - new_height;
1430                                 break;
1431                         }
1432                         #endif
1433
1434                         data->width   = new_width;
1435                         data->height  = new_height;
1436
1437                         /* Rerender the window frame */
1438
1439                         #ifdef DELAYEDSIZE
1440                         if (!data->drag_layerlock && !OPAQUESIZE)
1441                         {
1442                             LockLayers(&w->WScreen->LayerInfo);
1443                             data->drag_layerlock = TRUE;
1444                         }
1445                         #endif
1446
1447                         data->drag_refreshed = FALSE;
1448                         data->drag_ticks = 2;
1449
1450                         if (!OPAQUESIZE)
1451                             drawwindowframe(w->WScreen
1452                                             , data->rp
1453                                             , data->left
1454                                             , data->top
1455                                             , data->left + data->width  - 1
1456                                             , data->top  + data->height - 1
1457                                             , IntuitionBase
1458                                             );
1459
1460                         data->isrendered = TRUE;
1461
1462                     }
1463
1464                     retval = GMR_MEACTIVE;
1465
1466                     break;
1467                 }
1468
1469             default:
1470                 retval = GMR_NOREUSE;
1471                 data->drag_canceled = TRUE;
1472                 break;
1473
1474
1475
1476             } /* switch (ie->ie_Code) */
1477             break;
1478
1479         case IECLASS_TIMER:
1480             #ifdef DELAYEDSIZE
1481             if (!data->drag_layerlock && !OPAQUESIZE)
1482             {
1483                 UQUAD currenttime;
1484                 currenttime = ie->ie_TimeStamp.tv_secs;
1485                 currenttime = currenttime * 50;
1486                 currenttime += ie->ie_TimeStamp.tv_micro / 20000;
1487
1488                 if (currenttime > data->lasteventtime + 10)
1489                 {
1490                     LockLayers(&w->WScreen->LayerInfo);
1491                     data->drag_layerlock = TRUE;
1492
1493                     drawwindowframe(w->WScreen
1494                                     , data->rp
1495                                     , data->left
1496                                     , data->top
1497                                     , data->left + data->width  - 1
1498                                     , data->top  + data->height - 1
1499                                     , IntuitionBase
1500                                     );
1501                     data->lasteventtime = currenttime;
1502                     data->isrendered = TRUE;
1503                 }
1504             }
1505             #endif
1506
1507         #if USE_OPAQUESIZE
1508             if (OPAQUESIZE)
1509             {
1510                 data->drag_ticks --;
1511                 if (!data->drag_refreshed && !data->drag_ticks && WindowsReplied(w->WScreen,IntuitionBase))
1512                 {
1513                     smartresize(w,data,cl);
1514                     data->drag_refreshed = TRUE;
1515                     data->drag_ticks = 2;
1516                 }
1517             }
1518         #endif /* USE_OPAQUESIZE */
1519
1520             break;
1521
1522     #ifdef __MORPHOS__
1523         case IECLASS_NEWTIMER:
1524             if (OPAQUESIZE && !data->drag_refreshed && WindowsReplied(w->WScreen,IntuitionBase))
1525             {
1526                 smartresize(w,data,cl);
1527                 data->drag_refreshed = TRUE;
1528                 data->drag_ticks = 2;
1529             }
1530             break;
1531     #endif /* __MORPHOS__ */
1532
1533         } /* switch (ie->ie_Class) */
1534
1535     } /* if (gi) */
1536
1537     return retval;
1538 }
1539
1540 /***********************************************************************************/
1541
1542 IPTR SizeButtonClass__GM_GOINACTIVE(Class *cl, struct Gadget *g, struct gpGoInactive *msg)
1543 {
1544     struct IntuitionBase    *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
1545     struct GfxBase          *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1546     struct LayersBase       *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
1547     struct sizebutton_data  *data;
1548     struct Window           *w;
1549
1550     data = INST_DATA(cl, g);
1551     w = msg->gpgi_GInfo->gi_Window;
1552
1553     /* Allways clear last drawn frame */
1554
1555     if (data->isrendered && data->rp)
1556     {
1557
1558         SetDrMd(data->rp, COMPLEMENT);
1559
1560         /* Erase old frame */
1561         if (!OPAQUESIZE)
1562             drawwindowframe(w->WScreen
1563                             , data->rp
1564                             , data->left
1565                             , data->top
1566                             , data->left + data->width  - 1
1567                             , data->top  + data->height - 1
1568                             , IntuitionBase
1569                             );
1570
1571     }
1572     else
1573     {
1574         if (!OPAQUESIZE)
1575         {
1576             data->drag_canceled = TRUE;
1577         }
1578     }
1579     data->isrendered = FALSE;
1580
1581     if (data->drag_layerlock)
1582     {
1583         UnlockLayers(&w->WScreen->LayerInfo);
1584         data->drag_layerlock = FALSE;
1585     }
1586
1587 #ifdef USEGADGETLOCK
1588     if (data->drag_gadgetlock)
1589     {
1590         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->GadgetLock);
1591         data->drag_gadgetlock = FALSE;
1592     }
1593
1594     if (data->drag_inputhandlerlock)
1595     {
1596         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->InputHandlerLock);
1597         data->drag_inputhandlerlock = FALSE;
1598     }
1599 #endif
1600
1601 #ifdef USEWINDOWLOCK
1602     if (data->drag_windowlock)
1603     {
1604         ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
1605         data->drag_windowlock = FALSE;
1606     }
1607 #endif
1608
1609     //jDc: workarounds refresh pb on GZZ window resize
1610     ((struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data)->ActiveSysGadget->Flags &= ~GFLG_SELECTED;
1611
1612     if (!data->drag_canceled || OPAQUESIZE)
1613     {
1614         if (OPAQUESIZE && data->drag_canceled)
1615         {
1616             DoMoveSizeWindow(w,data->LeftEdge,data->TopEdge,data->Width,data->Height,TRUE,IntuitionBase);
1617         }
1618         else
1619         {
1620             DoMoveSizeWindow(w,data->left,data->top,data->width,data->height,TRUE,IntuitionBase);
1621         }
1622         //ChangeWindowBox(w,data->left,data->top,data->width,data->height);
1623     }
1624     data->drag_canceled = TRUE;
1625
1626     /* User throught with drag operation. Unlock layesr and free
1627     rastport clone
1628     */
1629     if (data->rp)
1630     {
1631         FreeRastPort(data->rp);
1632         data->rp = NULL;
1633     }
1634
1635     /* shut off mouse bounds checking.  */
1636     ((struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data)->MouseBoundsActiveFlag = FALSE;
1637
1638     return TRUE;
1639 }
1640
1641 /***********************************************************************************/
1642
1643 IPTR SizeButtonClass__OM_NEW(Class *cl, Object *o, Msg msg)
1644 {
1645     struct Gadget *g = (struct Gadget *)DoSuperMethodA(cl, o, msg);
1646     if (g)
1647     {
1648         g->GadgetType |= GTYP_SYSGADGET | GTYP_SIZING;
1649     }
1650
1651     return (IPTR)g;
1652 }
1653
1654 /***********************************************************************************/
1655