rom/intuition/windowclasses.c

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