rom/intuition/intuition_misc.c

   1 /*
   2     Copyright © 1995-2015, The AROS Development Team. All rights reserved.
   3     Copyright © 2001-2013, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7 #include <exec/types.h>
   8 #include <exec/memory.h>
   9 #include <proto/exec.h>
  10 #include <proto/graphics.h>
  11 #include <proto/layers.h>
  12 #include <proto/intuition.h>
  13 #include <proto/cybergraphics.h>
  14 #include <proto/oop.h>
  15 #include <clib/macros.h>
  16 #include <intuition/intuitionbase.h>
  17 #include <intuition/gadgetclass.h>
  18 #include <intuition/imageclass.h>
  19 #include <intuition/windecorclass.h>
  20 #include <intuition/scrdecorclass.h>
  21 #include <intuition/preferences.h>
  22 #include <intuition/extensions.h>
  23 #include <graphics/layers.h>
  24 #include <graphics/rpattr.h>
  25 #include <graphics/gfxmacros.h>
  26 #include <cybergraphx/cybergraphics.h>
  27 #include <hidd/graphics.h>
  28
  29 #ifdef SKINS
  30 #   include "intuition_customize.h"
  31 #   include "intuition_extend.h"
  32 #   include "mosmisc.h"
  33 #endif
  34
  35 #include "intuition_preferences.h"
  36 #include "intuition_intern.h"
  37
  38 #include "boopsigadgets.h"
  39 #include "showhide.h"
  40
  41 #include <string.h>
  42
  43
  44 #undef DEBUG
  45 #define DEBUG 0
  46 #   include <aros/debug.h>
  47
  48 ULONG addextragadget(struct Window *w,BOOL is_gzz,struct DrawInfo *dri,LONG relright,ULONG imagetype,ULONG gadgetid,ULONG gadgettype,struct IntuitionBase *IntuitionBase);
  49 extern IPTR HookEntry();
  50
  51 /**********************************************************************************/
  52
  53 void SetDisplayDefaults(struct IntuitionBase * IntuitionBase)
  54 {
  55     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
  56     struct GfxBase *GfxBase = _intuitionBase->GfxBase;
  57     struct MonitorSpec *defmon;
  58     BOOL done = FALSE;
  59
  60     D(bug("[Intuition] %s()\n", __PRETTY_FUNCTION__, defmon));
  61
  62     if (!_intuitionBase->ScreenModePrefs)
  63         _intuitionBase->ScreenModePrefs = AllocMem(sizeof(struct IScreenModePrefs), MEMF_ANY);
  64
  65     _intuitionBase->ScreenModePrefs->smp_DisplayID  = INVALID_ID;
  66     _intuitionBase->ScreenModePrefs->smp_Control         = 0;
  67
  68     if ((defmon = OpenMonitor(NULL, INVALID_ID)) != NULL)
  69     {
  70         OOP_Object *sync = (OOP_Object *)defmon->ms_Object, *drv = NULL;
  71
  72         D(bug("[Intuition] %s: default monitor @ 0x%p\n", __PRETTY_FUNCTION__, defmon));
  73
  74         if (sync)
  75         {
  76             OOP_AttrBase HiddSyncAttrBase = _intuitionBase->HiddSyncAttrBase;
  77             struct Library *OOPBase = _intuitionBase->OOPBase;
  78
  79             D(bug("[Intuition] %s: monitor sync obj @ 0x%p\n", __PRETTY_FUNCTION__, sync));
  80
  81             OOP_GetAttr(sync, aHidd_Sync_GfxHidd, (IPTR *)&drv);
  82             if (drv)
  83             {
  84                 OOP_MethodID HiddGfxBase = _intuitionBase->ib_HiddGfxBase;
  85                 UBYTE depth;
  86
  87                 HIDD_Gfx_NominalDimensions(drv,
  88                     &_intuitionBase->ScreenModePrefs->smp_Width,
  89                     &_intuitionBase->ScreenModePrefs->smp_Height,
  90                     &depth);
  91                 _intuitionBase->ScreenModePrefs->smp_Depth = depth;
  92                 done = TRUE;
  93             }
  94         }
  95         CloseMonitor(defmon);
  96     }
  97     if (!done)
  98     {
  99         D(bug("[Intuition] %s: using system defaults..\n", __PRETTY_FUNCTION__));
 100
 101         _intuitionBase->ScreenModePrefs->smp_Width          = GfxBase->NormalDisplayColumns;
 102         _intuitionBase->ScreenModePrefs->smp_Height         = GfxBase->NormalDisplayRows;
 103         _intuitionBase->ScreenModePrefs->smp_Depth          = AROS_NOMINAL_DEPTH;
 104     }
 105 }
 106
 107 void LoadDefaultPreferences(struct IntuitionBase * IntuitionBase)
 108 {
 109     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
 110 #   ifdef SKINS
 111         static CONST UWORD DriPens2[NUMDRIPENS] = { 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1 , 1 , 0};
 112         static CONST UWORD DriPens4[NUMDRIPENS] = { 1, 0, 1, 2, 1, 3, 1, 0, 2, 1, 2, 1 , 2 , 1};
 113 #   else
 114         static CONST UWORD DriPens2[NUMDRIPENS] = { 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1};
 115         static CONST UWORD DriPens4[NUMDRIPENS] = { 1, 0, 1, 2, 1, 3, 1, 0, 2, 1, 2, 1};
 116 #   endif /* SKINS */
 117
 118     /* Default IControl prefs are AROS addition. Keep while backporting. */
 119     _intuitionBase->IControlPrefs.ic_TimeOut  = 50;
 120     _intuitionBase->IControlPrefs.ic_MetaDrag = IEQUALIFIER_LCOMMAND;
 121     _intuitionBase->IControlPrefs.ic_Flags    = ICF_3DMENUS |
 122                                                                                          ICF_OFFSCREENLAYERS |
 123                                                              ICF_AVOIDWINBORDERERASE |
 124                                                                          ICF_MODEPROMOTE |
 125                                                                          ICF_MENUSNAP |
 126                                                              ICF_STRGAD_FILTER |
 127                                                              ICF_COERCE_LACE;
 128     _intuitionBase->IControlPrefs.ic_WBtoFront   = 'N';
 129     _intuitionBase->IControlPrefs.ic_FrontToBack = 'M';
 130     _intuitionBase->IControlPrefs.ic_ReqTrue     = 'V';
 131     _intuitionBase->IControlPrefs.ic_ReqFalse    = 'B';
 132
 133
 134     /*
 135      * Mouse default.
 136      */
 137     _intuitionBase->DefaultPreferences.PointerTicks = 2;
 138
 139     CopyMem(&IntuitionDefaultPreferences,
 140                 &_intuitionBase->DefaultPreferences,
 141                 sizeof(struct Preferences));
 142     CopyMem(&_intuitionBase->DefaultPreferences,
 143             &_intuitionBase->ActivePreferences,
 144             sizeof(struct Preferences));
 145
 146     CopyMem(DriPens2, _intuitionBase->DriPens2, sizeof(DriPens2));
 147     CopyMem(DriPens4, _intuitionBase->DriPens4, sizeof(DriPens4));
 148     CopyMem(DriPens4, _intuitionBase->DriPens8, sizeof(DriPens4));
 149 }
 150
 151 /**********************************************************************************/
 152
 153 void CheckRectFill(struct RastPort *rp, WORD x1, WORD y1, WORD x2, WORD y2,
 154                    struct IntuitionBase * IntuitionBase)
 155 {
 156     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
 157     struct GfxBase *GfxBase = _intuitionBase->GfxBase;
 158
 159     if ((x2 >= x1) && (y2 >= y1))
 160     {
 161         RectFill(rp, x1, y1, x2, y2);
 162     }
 163 }
 164
 165 /**********************************************************************************/
 166
 167 Object* CreateStdSysImage(WORD which, WORD preferred_height, struct Screen *scr,
 168                                       struct DrawInfo *dri, struct IntuitionBase *IntuitionBase)
 169 {
 170     Object *im;
 171
 172     struct TagItem image_tags[] =
 173     {
 174         {SYSIA_Which    , which                                            },
 175         {SYSIA_DrawInfo , (IPTR)dri                                 },
 176         {SYSIA_Size         , scr->Flags & SCREENHIRES ?
 177                           SYSISIZE_MEDRES : SYSISIZE_LOWRES },
 178         {TAG_DONE                                                       }
 179     };
 180
 181     im = NewObjectA(NULL, SYSICLASS, image_tags);
 182     if (im)
 183     {
 184             struct TagItem size_tags[] =
 185         {
 186             {IA_Width        , 0                         },
 187             {IA_Height        , preferred_height  },
 188             {TAG_DONE                                    }
 189         };
 190             IPTR width, height;
 191
 192         GetAttr(IA_Width, im, &width);
 193         GetAttr(IA_Height, im, &height);
 194
 195         size_tags[0].ti_Data = preferred_height * width / height;
 196
 197         SetAttrsA(im, size_tags);
 198     }
 199
 200     return im;
 201 }
 202
 203 /**********************************************************************************/
 204
 205 BOOL CreateWinSysGadgets(struct Window *w, struct IntuitionBase *IntuitionBase)
 206 {
 207
 208     struct DrawInfo *dri;
 209     BOOL                 is_gzz;
 210     ULONG            TitleHeight = w->BorderTop;
 211
 212     EnterFunc(bug("CreateWinSysGadgets(w=%p)\n", w));
 213
 214     is_gzz = (w->Flags & WFLG_GIMMEZEROZERO) ? TRUE : FALSE;
 215
 216     dri = GetScreenDrawInfo(w->WScreen);
 217     if (dri)
 218     {
 219         LONG db_left, db_width, relright,ewidth; /* dragbar sizes */
 220         BOOL sysgads_ok = TRUE;
 221
 222
 223         db_left = 0;
 224         db_width = 0; /* Georg Steger: was w->Width; */
 225
 226         /* Relright of rightmost button */
 227         //relright = - (TitleHeight - 1);
 228
 229         relright = 1;
 230
 231         /* Now try to create the various gadgets */
 232
 233         if (w->Flags & WFLG_SIZEGADGET)
 234         {
 235             /* this code must not change the 'relright' variable */
 236             WORD width  = ((struct IntWindow *)w)->sizeimage_width;
 237             WORD height = ((struct IntWindow *)w)->sizeimage_height;
 238
 239             struct TagItem size_tags[] =
 240             {
 241                 {GA_Image           , 0             },
 242                 {GA_RelRight    , -width  + 1   },
 243                 {GA_RelBottom   , -height + 1   },
 244                 {GA_Width           , width             },
 245                 {GA_Height          , height            },
 246                 {GA_SysGadget   , TRUE              },
 247                 {GA_SysGType    , GTYP_SIZING   },
 248                 {GA_BottomBorder, TRUE              },
 249                 {GA_RightBorder , TRUE              },
 250                 {GA_GZZGadget   , is_gzz            },
 251                 {TAG_DONE                               }
 252             };
 253
 254             struct TagItem image_tags[] =
 255             {
 256                 {IA_Width           , width                                                                                          },
 257                 {IA_Height          , height                                                                                         },
 258                 {SYSIA_Which    , SIZEIMAGE                                                                                      },
 259                 {SYSIA_DrawInfo , (IPTR)dri                                                                                      },
 260                 {SYSIA_Size         , w->WScreen->Flags & SCREENHIRES ? SYSISIZE_MEDRES : SYSISIZE_LOWRES},
 261                 {TAG_DONE                                                                                                            }
 262             };
 263             Object *im;
 264
 265             im = NewObjectA(NULL, SYSICLASS, image_tags);
 266             if (!im)
 267             {
 268                 sysgads_ok = FALSE;
 269             }
 270             else
 271             {
 272                 size_tags[0].ti_Data = (IPTR)im;
 273
 274                 SYSGAD(w, SIZEGAD) = NewObjectA(NULL, BUTTONGCLASS, size_tags);
 275
 276                 if (!SYSGAD(w, SIZEGAD))
 277                 {
 278                     DisposeObject(im);
 279                     sysgads_ok = FALSE;
 280                 }
 281             }
 282         }
 283
 284         if (w->Flags & WFLG_DEPTHGADGET)
 285         {
 286             struct TagItem depth_tags[] =
 287             {
 288                 {GA_Image           , 0                 },
 289               //{GA_RelRight          , relright          },
 290                 {GA_Top             , 0                 },
 291             #if SQUARE_WIN_GADGETS
 292                 {GA_Width           , TitleHeight       },
 293             #endif
 294                 {GA_Height          , TitleHeight       },
 295                 {GA_SysGadget   , TRUE              },
 296                 {GA_SysGType    , GTYP_WDEPTH       },
 297                 {GA_TopBorder   , TRUE              },
 298                 {GA_GZZGadget   , is_gzz            },
 299                 {GA_RelVerify   , TRUE              },
 300                 {TAG_DONE                               }
 301             };
 302             Object *im;
 303
 304             im = CreateStdSysImage(DEPTHIMAGE, TitleHeight, w->WScreen, dri, IntuitionBase);
 305             if (!im)
 306             {
 307                 sysgads_ok = FALSE;
 308             }
 309             else
 310             {
 311                 depth_tags[0].ti_Data = (IPTR)im;
 312
 313                 SYSGAD(w, DEPTHGAD) = NewObjectA(NULL, BUTTONGCLASS, depth_tags);
 314
 315                 if (!SYSGAD(w, DEPTHGAD))
 316                 {
 317                     DisposeObject(im);
 318                     sysgads_ok = FALSE;
 319                 }
 320                 else
 321                 {
 322                     IPTR width;
 323                     GetAttr(GA_Width, SYSGAD(w, DEPTHGAD), &width);
 324
 325                     /*****/
 326
 327                     relright -= width;
 328                     db_width -= width;
 329
 330                     {
 331                         struct TagItem gadtags[] =
 332                         {
 333                             {GA_RelRight, relright  },
 334                          /* {GA_Width   , width     }, */
 335                             {TAG_DONE               }
 336                         };
 337
 338                         SetAttrsA(SYSGAD(w, DEPTHGAD), gadtags);
 339                     }
 340                 }
 341             }
 342
 343         }
 344
 345             /* RKRMs: window gets zoom gadget if WA_Zoom tag was used,
 346            or if window has both a sizegadget and a depthgadget */
 347
 348         if ((w->Flags & WFLG_HASZOOM) ||
 349             ((w->Flags & WFLG_SIZEGADGET) && (w->Flags & WFLG_DEPTHGADGET)))
 350         {
 351             struct TagItem zoom_tags[] =
 352             {
 353                 {GA_Image           , 0                 },
 354                 //{GA_RelRight  , relright          },
 355                 {GA_Top             , 0                 },
 356             #if SQUARE_WIN_GADGETS
 357                 {GA_Width           , TitleHeight       },
 358             #endif
 359                 {GA_Height          , TitleHeight       },
 360                 {GA_SysGadget   , TRUE              },
 361                 {GA_SysGType    , GTYP_WZOOM        },
 362                 {GA_TopBorder   , TRUE              },
 363                 {GA_GZZGadget   , is_gzz            },
 364                 {GA_RelVerify   , TRUE              },
 365                 {TAG_DONE                               }
 366             };
 367
 368             Object *im;
 369
 370             im = CreateStdSysImage(ZOOMIMAGE, TitleHeight, w->WScreen, dri, IntuitionBase);
 371             if (!im)
 372             {
 373                 sysgads_ok = FALSE;
 374             }
 375             else
 376             {
 377                 zoom_tags[0].ti_Data = (IPTR)im;
 378
 379                 SYSGAD(w, ZOOMGAD) = NewObjectA(NULL, BUTTONGCLASS, zoom_tags);
 380
 381                 if (!SYSGAD(w, ZOOMGAD))
 382                 {
 383                     DisposeObject(im);
 384                     sysgads_ok = FALSE;
 385                 }
 386                 else
 387                 {
 388                     IPTR width;
 389                     GetAttr(GA_Width, SYSGAD(w, ZOOMGAD), &width);
 390
 391                     relright -= width;
 392                     db_width -= width;
 393
 394                     {
 395                         struct TagItem gadtags[] =
 396                             {
 397                                 {GA_RelRight, relright},
 398                                 {TAG_DONE             }
 399                             };
 400
 401
 402                         SetAttrsA(SYSGAD(w, ZOOMGAD), gadtags);
 403                     }
 404                 }
 405             }
 406         }
 407
 408         if (((struct IntWindow *)(w))->extrabuttons & ETG_LOCK)
 409         {
 410             ewidth = addextragadget(w,is_gzz,dri,relright,LOCKIMAGE,((struct IntWindow *)w)->extrabuttonsid + ETD_Lock,LOCKGAD,IntuitionBase);
 411             relright -= ewidth;
 412             db_width -= ewidth;
 413         }
 414
 415         if (((struct IntWindow *)(w))->extrabuttons & ETG_ICONIFY)
 416         {
 417             ewidth = addextragadget(w,is_gzz,dri,relright,ICONIFYIMAGE,((struct IntWindow *)w)->extrabuttonsid + ETD_Iconify,ICONIFYGAD,IntuitionBase);
 418             relright -= ewidth;
 419             db_width -= ewidth;
 420         }
 421
 422         if (((struct IntWindow *)(w))->extrabuttons & ETG_JUMP)
 423         {
 424             ewidth = addextragadget(w,is_gzz,dri,relright,JUMPIMAGE,((struct IntWindow *)w)->extrabuttonsid + ETD_Jump,JUMPGAD,IntuitionBase);
 425             relright -= ewidth;
 426             db_width -= ewidth;
 427         }
 428
 429         if (((struct IntWindow *)(w))->extrabuttons & ETG_SNAPSHOT)
 430         {
 431             ewidth = addextragadget(w,is_gzz,dri,relright,SNAPSHOTIMAGE,((struct IntWindow *)w)->extrabuttonsid + ETD_Snapshot,SNAPSHOTGAD,IntuitionBase);
 432             relright -= ewidth;
 433             db_width -= ewidth;
 434         }
 435
 436         if (((struct IntWindow *)(w))->extrabuttons & ETG_MUI)
 437         {
 438             ewidth = addextragadget(w,is_gzz,dri,relright,MUIIMAGE,((struct IntWindow *)w)->extrabuttonsid + ETD_MUI,MUIGAD,IntuitionBase);
 439             relright -= ewidth;
 440             db_width -= ewidth;
 441         }
 442
 443         if (((struct IntWindow *)(w))->extrabuttons & ETG_POPUP)
 444         {
 445             ewidth = addextragadget(w,is_gzz,dri,relright,POPUPIMAGE,((struct IntWindow *)w)->extrabuttonsid + ETD_PopUp,POPUPGAD,IntuitionBase);
 446             relright -= ewidth;
 447             db_width -= ewidth;
 448         }
 449
 450         if (w->Flags & WFLG_CLOSEGADGET)
 451         {
 452             struct TagItem close_tags[] =
 453             {
 454                 {GA_Image           , 0                     },
 455                 {GA_Left            , 0                     },
 456                 {GA_Top             , 0                     },
 457             #if SQUARE_WIN_GADGETS
 458                 {GA_Width           , TitleHeight       },
 459             #endif
 460                 {GA_Height          , TitleHeight       },
 461                 {GA_SysGadget   , TRUE              },
 462                 {GA_SysGType    , GTYP_CLOSE        },
 463                 {GA_TopBorder   , TRUE              },
 464                 {GA_GZZGadget   , is_gzz            },
 465                 {GA_RelVerify   , TRUE              },
 466                 {TAG_DONE                               }
 467             };
 468             Object *im;
 469
 470             im = CreateStdSysImage(CLOSEIMAGE, TitleHeight, w->WScreen, dri,IntuitionBase);
 471             if (!im)
 472             {
 473                 sysgads_ok = FALSE;
 474             }
 475             else
 476             {
 477                 close_tags[0].ti_Data = (IPTR)im;
 478
 479                 SYSGAD(w, CLOSEGAD) = NewObjectA(NULL, BUTTONGCLASS, close_tags);
 480
 481                 if (!SYSGAD(w, CLOSEGAD))
 482                 {
 483                     DisposeObject(im);
 484                     sysgads_ok = FALSE;
 485                 }
 486                 else
 487                 {
 488                     IPTR width;
 489                     GetAttr(GA_Width, SYSGAD(w, CLOSEGAD), &width);
 490
 491                     db_left  += width;
 492                     db_width -= width;
 493                 }
 494             }
 495         }
 496
 497         if (w->Flags & WFLG_DRAGBAR)
 498         {
 499
 500             struct TagItem dragbar_tags[] =
 501             {
 502                 {GA_Left            , 0/*db_left*/            },
 503                 {GA_Top             , 0                     },
 504                 {GA_RelWidth    , 0/*db_width*/     },
 505                 {GA_Height          , TitleHeight       },
 506                 {GA_SysGadget   , TRUE              },
 507                 {GA_SysGType    , GTYP_WDRAGGING    },
 508                 {GA_TopBorder   , TRUE              },
 509                 {GA_GZZGadget   , is_gzz            },
 510                 {TAG_DONE                                }
 511             };
 512             SYSGAD(w, DRAGBAR) = NewObjectA(NULL, BUTTONGCLASS, dragbar_tags);
 513
 514             if (!SYSGAD(w, DRAGBAR))
 515                 sysgads_ok = FALSE;
 516
 517         }
 518
 519
 520         D(bug("Dragbar:  %p\n", SYSGAD(w, DRAGBAR ) ));
 521         D(bug("Depthgad: %p\n", SYSGAD(w, DEPTHGAD) ));
 522         D(bug("Zoomgad:  %p\n", SYSGAD(w, ZOOMGAD ) ));
 523         D(bug("Closegad: %p\n", SYSGAD(w, CLOSEGAD) ));
 524         D(bug("Sizegad:  %p\n", SYSGAD(w, SIZEGAD ) ));
 525
 526         /* Don't need drawinfo anymore */
 527         FreeScreenDrawInfo(w->WScreen, dri);
 528
 529         if (sysgads_ok)
 530         {
 531             int i;
 532
 533
 534             D(bug("Adding gadgets\n"));
 535             for (i = NUM_SYSGADS; --i >= 0; )
 536             {
 537                 if (SYSGAD(w, i))
 538                 {
 539                         struct wdpLayoutBorderGadgets  msg;
 540
 541                     msg.MethodID    = WDM_LAYOUT_BORDERGADGETS;
 542                     msg.wdp_Window  = w;
 543                     msg.wdp_Gadgets = (struct Gadget *)SYSGAD(w, i);
 544                     msg.wdp_Flags   = WDF_LBG_SYSTEMGADGET | WDF_LBG_INITIAL;
 545                     msg.wdp_UserBuffer  = ((struct IntWindow *)(w))->DecorUserBuffer;
 546                     msg.wdp_ExtraButtons = ((struct IntWindow *)w)->extrabuttons;
 547
 548                     msg.wdp_TrueColor = (((struct IntScreen *)w->WScreen)->DInfo.dri_Flags & DRIF_DIRECTCOLOR) ? TRUE : FALSE;
 549                     msg.wdp_Dri = dri;
 550
 551                     DoMethodA(((struct IntScreen *)(w->WScreen))->WinDecorObj, (Msg)&msg);
 552
 553                     AddGadget(w, (struct Gadget *)SYSGAD(w, i), 0);
 554                 }
 555             }
 556
 557             ReturnBool("CreateWinSysGadgets", TRUE);
 558
 559         } /* if (sysgads created) */
 560
 561         KillWinSysGadgets(w, IntuitionBase);
 562
 563     } /* if (got DrawInfo) */
 564     ReturnBool("CreateWinSysGadgets", FALSE);
 565
 566 }
 567
 568 /**********************************************************************************/
 569
 570 VOID KillWinSysGadgets(struct Window *w, struct IntuitionBase *IntuitionBase)
 571 {
 572     /* Free system gadgets */
 573     UWORD i;
 574
 575     for (i = 0; i < NUM_SYSGADS; i ++)
 576     {
 577         if (SYSGAD(w, i))
 578         {
 579             RemoveGadget( w, (struct Gadget *)SYSGAD(w, i));
 580             DisposeObject((Object *)((struct Gadget *)SYSGAD(w, i))->GadgetRender);
 581             DisposeObject( SYSGAD(w, i) );
 582         }
 583     }
 584 }
 585
 586 /**********************************************************************************/
 587
 588 void CreateScreenBar(struct Screen *scr, struct IntuitionBase *IntuitionBase)
 589 {
 590     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
 591     struct GfxBase *GfxBase = _intuitionBase->GfxBase;
 592     struct LayersBase *LayersBase = _intuitionBase->LayersBase;
 593     BOOL  front = TRUE;
 594     ULONG backdrop = LAYERBACKDROP;
 595     WORD  ypos = 0;
 596
 597     D(bug("[intuition] CreateScreenBar()\n"));
 598
 599 #ifdef SKINS
 600     if ((scr->Flags & SCREENQUIET) || (GetPrivScreen(scr)->SpecialFlags & SF_InvisibleBar))
 601         front = FALSE;
 602
 603     if (GetPrivScreen(scr)->SpecialFlags & SF_AppearingBar)
 604     {
 605         backdrop = 0;
 606         ypos = - (scr->BarHeight + 1);
 607     }
 608 #else
 609     if (scr->Flags & SCREENQUIET) front = FALSE;
 610 #endif
 611     D(bug("[intuition] CreateScreenBar: Got initial flags\n"));
 612
 613     if (!scr->BarLayer)
 614     {
 615         D(bug("[intuition] CreateScreenBar: No current BarLayer\n"));
 616         if (front)
 617         {
 618             scr->BarLayer = CreateUpfrontHookLayer(&scr->LayerInfo,
 619                                                    scr->RastPort.BitMap,
 620                                                    0,
 621                                                    ypos,
 622                                                    scr->Width - 1,
 623                                                    scr->BarHeight + ypos, /* 1 pixel heigher than scr->BarHeight */
 624                                                    LAYERSIMPLE | backdrop,
 625                                                    LAYERS_NOBACKFILL,
 626                                                    NULL);
 627         }
 628         else
 629         {
 630             scr->BarLayer = CreateBehindHookLayer(&scr->LayerInfo,
 631                                                    scr->RastPort.BitMap,
 632                                                    0,
 633                                                    ypos,
 634                                                    scr->Width - 1,
 635                                                    scr->BarHeight + ypos, /* 1 pixel heigher than scr->BarHeight */
 636                                                    LAYERSIMPLE | backdrop,
 637                                                    LAYERS_NOBACKFILL,
 638                                                    NULL);
 639         }
 640
 641         if (scr->BarLayer)
 642         {
 643             D(bug("[intuition] CreateScreenBar: Adding BarLayer @ %p\n", scr->BarLayer));
 644             D(bug("[intuition] CreateScreenBar: Rastport @ %p, Font @ %p\n", scr->BarLayer->rp, ((struct IntScreen *)scr)->DInfo.dri_Font));
 645             SetFont(scr->BarLayer->rp, ((struct IntScreen *)scr)->DInfo.dri_Font);
 646             if (!(scr->Flags & SCREENQUIET)) {
 647                 D(bug("[intuition] CreateScreenBar: Rendering Bar  ...\n"));
 648                 RenderScreenBar(scr, FALSE, IntuitionBase);
 649             }
 650             D(bug("[intuition] CreateScreenBar:    ... done\n"));
 651         }
 652         else
 653         {
 654             D(bug("[intuition] CreateScreenBar: Failed to create BarLayer!!\n"));
 655         }
 656     }
 657     else
 658     {
 659         D(bug("[intuition] CreateScreenBar: Screen already has BarLayer\n"));
 660     }
 661 }
 662
 663 /**********************************************************************************/
 664
 665 void KillScreenBar(struct Screen *scr, struct IntuitionBase *IntuitionBase)
 666 {
 667     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
 668     struct LayersBase *LayersBase = _intuitionBase->LayersBase;
 669
 670     if (scr->BarLayer)
 671     {
 672         DeleteLayer(0, scr->BarLayer);
 673         scr->BarLayer = FALSE;
 674     }
 675
 676 }
 677
 678 /**********************************************************************************/
 679
 680 #ifdef SKINS
 681 //RenderScreenBar moved to morphos/mosmisc.c
 682 #endif
 683
 684 #ifndef SKINS
 685
 686 void RenderScreenBar(struct Screen *scr, BOOL refresh, struct IntuitionBase *IntuitionBase)
 687 {
 688     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
 689     struct GfxBase *GfxBase = _intuitionBase->GfxBase;
 690     struct LayersBase *LayersBase = _intuitionBase->LayersBase;
 691     struct RastPort *rp;
 692
 693     D(bug("[intuition] RenderScreenBar()\n"));
 694
 695     if (scr->BarLayer)
 696     {
 697 #if USE_NEWDISPLAYBEEP
 698         BOOL beeping;
 699 #else
 700 #define beeping 0
 701 #endif
 702
 703         D(bug("[intuition] RenderScreenBar: BarLayer @ %p\n", scr->BarLayer));
 704
 705         rp = scr->BarLayer->rp;
 706
 707         D(bug("[intuition] RenderScreenBar: RastPort @ %p\n", rp));
 708         /* must lock GadgetLock to avoid deadlocks with ObtainGIRPort
 709            when calling refreshgadget inside layer update state */
 710         LockLayerInfo(scr->BarLayer->LayerInfo);
 711         LOCKGADGET(IntuitionBase)
 712         LockLayer(0, scr->BarLayer);
 713
 714         D(bug("[intuition] RenderScreenBar: Layer locked\n"));
 715 #if USE_NEWDISPLAYBEEP
 716         beeping = (scr->Flags & BEEPING) && GetBitMapAttr(rp->BitMap, BMA_DEPTH) > 8;
 717 #endif
 718
 719         if (refresh) BeginUpdate(scr->BarLayer);
 720
 721         {
 722                 struct sdpDrawScreenBar  msg;
 723
 724             D(bug("[intuition] RenderScreenBar: Begin Refresh .. \n"));
 725
 726             msg.MethodID        = SDM_DRAW_SCREENBAR;
 727             msg.sdp_Layer        = scr->BarLayer;
 728             msg.sdp_RPort        = rp;
 729                 msg.sdp_Flags        = 0;
 730             msg.sdp_Screen        = scr;
 731             msg.sdp_Dri           = (struct DrawInfo *)&((struct IntScreen *)scr)->DInfo;
 732             msg.sdp_UserBuffer = ((struct IntScreen *)(scr))->DecorUserBuffer;
 733             msg.sdp_TrueColor   = (((struct IntScreen *)(scr))->DInfo.dri_Flags & DRIF_DIRECTCOLOR) ? TRUE : FALSE;
 734
 735             D(bug("[intuition] RenderScreenBar: ScrDecorObj @ %p, DecorUserBuffer @ %p\n", ((struct IntScreen *)(scr))->ScrDecorObj, ((struct IntScreen *)(scr))->DecorUserBuffer));
 736             DoMethodA(((struct IntScreen *)(scr))->ScrDecorObj, (Msg)&msg);
 737         }
 738
 739         D(bug("[intuition] RenderScreenBar: Update gadgets .. \n"));
 740
 741         if (scr->FirstGadget)
 742         {
 743             RefreshBoopsiGadget(scr->FirstGadget, (struct Window *)scr, NULL, IntuitionBase);
 744         }
 745
 746         if (refresh)
 747         {
 748             D(bug("[intuition] RenderScreenBar: End Refresh .. \n"));
 749             scr->BarLayer->Flags &= ~LAYERREFRESH;
 750             EndUpdate(scr->BarLayer, TRUE);
 751         }
 752
 753 #if USE_NEWDISPLAYBEEP
 754         if (beeping) {
 755             /* FIXME: Shouldn't we 'beep' at this point? */
 756             D(bug("[intuition] RenderScreenBar: Beep\n"));
 757         }
 758 #endif
 759
 760         D(bug("[intuition] RenderScreenBar: Unlock Layer ..\n"));
 761
 762         UnlockLayer(scr->BarLayer);
 763         UNLOCKGADGET(IntuitionBase)
 764         UnlockLayerInfo(scr->BarLayer->LayerInfo);
 765
 766     } /* if (scr->BarLayer) */
 767     D(bug("[intuition] RenderScreenBar: Done \n"));
 768 }
 769
 770 #endif
 771
 772 /**********************************************************************************/
 773
 774 void UpdateMouseCoords(struct Window *win)
 775 {
 776     WORD scrmousex = win->WScreen->MouseX;
 777     WORD scrmousey = win->WScreen->MouseY;
 778
 779     win->MouseX    = scrmousex - win->LeftEdge;
 780     win->MouseY    = scrmousey - win->TopEdge;
 781
 782     /* stegerg: AmigaOS sets this even if window is not GZZ
 783        so we do the same as they are handy also for non-GZZ
 784        windows */
 785
 786     win->GZZMouseX = scrmousex - (win->LeftEdge + win->BorderLeft);
 787     win->GZZMouseY = scrmousey - (win->TopEdge + win->BorderTop);
 788 }
 789
 790 /**********************************************************************************/
 791
 792 /* subtract rectangle b from rectangle b. resulting rectangles will be put into
 793    destrectarray which must have place for at least 4 rectangles. Returns number
 794    of resulting rectangles */
 795
 796 #if 0  /* use <clib/macros.h> MAX/MIN macros */
 797 #undef MAX
 798 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
 799
 800 #undef MIN
 801 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
 802 #endif
 803
 804 WORD SubtractRectFromRect(struct Rectangle *a, struct Rectangle *b, struct Rectangle *destrectarray)
 805 {
 806     struct Rectangle    intersect;
 807     BOOL                    intersecting = FALSE;
 808     WORD                    numrects = 0;
 809
 810     /* calc. intersection between a and b */
 811
 812     if (a->MinX <= b->MaxX)
 813     {
 814         if (a->MinY <= b->MaxY)
 815         {
 816             if (a->MaxX >= b->MinX)
 817             {
 818                 if (a->MaxY >= b->MinY)
 819                 {
 820                     intersect.MinX = MAX(a->MinX, b->MinX);
 821                     intersect.MinY = MAX(a->MinY, b->MinY);
 822                     intersect.MaxX = MIN(a->MaxX, b->MaxX);
 823                     intersect.MaxY = MIN(a->MaxY, b->MaxY);
 824
 825                     intersecting = TRUE;
 826                 }
 827             }
 828         }
 829     }
 830
 831     if (!intersecting)
 832     {
 833         destrectarray[numrects++] = *a;
 834
 835     } /* not intersecting */
 836     else
 837     {
 838         if (intersect.MinY > a->MinY) /* upper */
 839         {
 840             destrectarray->MinX = a->MinX;
 841             destrectarray->MinY = a->MinY;
 842             destrectarray->MaxX = a->MaxX;
 843             destrectarray->MaxY = intersect.MinY - 1;
 844
 845             numrects++;
 846             destrectarray++;
 847         }
 848
 849         if (intersect.MaxY < a->MaxY) /* lower */
 850         {
 851             destrectarray->MinX = a->MinX;
 852             destrectarray->MinY = intersect.MaxY + 1;
 853             destrectarray->MaxX = a->MaxX;
 854             destrectarray->MaxY = a->MaxY;
 855
 856             numrects++;
 857             destrectarray++;
 858         }
 859
 860         if (intersect.MinX > a->MinX) /* left */
 861         {
 862             destrectarray->MinX = a->MinX;
 863             destrectarray->MinY = intersect.MinY;
 864             destrectarray->MaxX = intersect.MinX - 1;
 865             destrectarray->MaxY = intersect.MaxY;
 866
 867             numrects++;
 868             destrectarray++;
 869         }
 870
 871         if (intersect.MaxX < a->MaxX) /* right */
 872         {
 873             destrectarray->MinX = intersect.MaxX + 1;
 874             destrectarray->MinY = intersect.MinY;
 875             destrectarray->MaxX = a->MaxX;
 876             destrectarray->MaxY = intersect.MaxY;
 877
 878             numrects++;
 879             destrectarray++;
 880         }
 881
 882     } /* intersecting */
 883
 884     return numrects;
 885
 886 }
 887
 888 ULONG addextragadget(struct Window *w,BOOL is_gzz,struct DrawInfo *dri,LONG relright,ULONG imagetype,ULONG gadgetid,ULONG gadgettype,struct IntuitionBase *IntuitionBase)
 889 {
 890     ULONG TitleHeight = w->BorderTop;
 891     struct TagItem gadget_tags[] =
 892     {
 893         {GA_Image           , 0                 },
 894         {GA_ToggleSelect, FALSE             },
 895         {GA_Top             , 0                 },
 896         {GA_Height          , TitleHeight       },
 897         {GA_TopBorder   , TRUE              },
 898         {GA_GZZGadget   , is_gzz            },
 899         {GA_ID              , gadgetid          },
 900         {GA_RelVerify        , TRUE              },
 901         {TAG_DONE                           }
 902     };
 903
 904     Object *im;
 905
 906     if (gadgettype == LOCKGAD)
 907         gadget_tags[1].ti_Data = TRUE;
 908
 909     im = CreateStdSysImage(imagetype, TitleHeight, w->WScreen, dri,IntuitionBase);
 910     if (im)
 911     {
 912         gadget_tags[0].ti_Data = (IPTR)im;
 913
 914         SYSGAD(w, gadgettype) = NewObjectA(NULL, BUTTONGCLASS, gadget_tags);
 915
 916         if (!SYSGAD(w, gadgettype))
 917         {
 918             DisposeObject(im);
 919         }
 920         else
 921         {
 922             IPTR width;
 923             GetAttr(GA_Width, SYSGAD(w, gadgettype), &width);
 924
 925             --width;
 926
 927             {
 928                 struct TagItem gadtags[] =
 929                 {
 930                     {GA_RelRight, relright - width  },
 931                     {TAG_DONE                           }
 932                 };
 933
 934                 SetAttrsA(SYSGAD(w, gadgettype), gadtags);
 935             }
 936
 937             return width;
 938         }
 939     }
 940
 941     return 0;
 942
 943 }
 944
 945 /**********************************************************************************/
 946
 947 /* Use the FNV-1 hash function over the object's pointer.
 948  * http://en.wikipedia.org/wiki/Fowler-Noll-Vo_hash_function
 949  */
 950 LONG CalcResourceHash(APTR resource)
 951 {
 952     const ULONG FNV1_32_Offset = 2166136261UL;
 953     const ULONG FNV1_32_Prime  = 16777619UL;
 954     IPTR data = (IPTR)resource;
 955     ULONG hash;
 956     int i;
 957
 958     hash = FNV1_32_Offset;
 959     for (i = 0; i < AROS_SIZEOFPTR; i++) {
 960                 hash *= FNV1_32_Prime;
 961                 hash ^= data & 0xff;
 962                 data >>= 8;
 963     }
 964
 965     return hash & (RESOURCELIST_HASHSIZE-1);
 966 }
 967
 968 /**********************************************************************************/
 969
 970 void AddResourceToList(APTR resource, UWORD resourcetype, struct IntuitionBase *IntuitionBase)
 971 {
 972     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
 973     struct HashNode *hn = NULL;
 974     LONG                 hash;
 975     ULONG                ilock;
 976
 977     switch(resourcetype)
 978     {
 979             case RESOURCE_WINDOW:
 980             hn = &((struct IntWindow *)resource)->hashnode;
 981             hn->type = RESOURCE_WINDOW;
 982             break;
 983
 984             case RESOURCE_SCREEN:
 985             hn = &((struct IntScreen *)resource)->hashnode;
 986             hn->type = RESOURCE_SCREEN;
 987             break;
 988
 989         default:
 990             D(bug("AddResourceToList: Unknown resource type!!!\n"));
 991             return;
 992     }
 993
 994     hash = CalcResourceHash(resource);
 995
 996     hn->resource = resource;
 997
 998     ilock = LockIBase(0);
 999     AddTail((struct List *)&_intuitionBase->ResourceList[hash], (struct Node *)hn);
1000     UnlockIBase(ilock);
1001 }
1002
1003 /**********************************************************************************/
1004
1005 void RemoveResourceFromList(APTR resource, UWORD resourcetype, struct IntuitionBase *IntuitionBase)
1006 {
1007     struct HashNode *hn = NULL;
1008     ULONG                ilock;
1009
1010     switch(resourcetype)
1011     {
1012             case RESOURCE_WINDOW:
1013             hn = &((struct IntWindow *)resource)->hashnode;
1014             break;
1015
1016             case RESOURCE_SCREEN:
1017             hn = &((struct IntScreen *)resource)->hashnode;
1018             break;
1019
1020         default:
1021             D(bug("RemoveResourceFromList: Unknown resource type!!!\n"));
1022             return;
1023     }
1024
1025     if (hn->type != resourcetype)
1026     {
1027             D(bug("RemoveResourceFromList: Panic. Resource Type mismatch!!!\n"));
1028     }
1029
1030     ilock = LockIBase(0);
1031     Remove((struct Node *)hn);
1032     UnlockIBase(ilock);
1033 }
1034
1035 /**********************************************************************************/
1036
1037 BOOL ResourceExisting(APTR resource, UWORD resourcetype, struct IntuitionBase *IntuitionBase)
1038 {
1039     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
1040     struct HashNode *hn = NULL;
1041     LONG                 hash;
1042     ULONG                ilock;
1043     BOOL                 exists = FALSE;
1044
1045     hash = CalcResourceHash(resource);
1046
1047     ilock = LockIBase(0);
1048     ForeachNode(&_intuitionBase->ResourceList[hash], hn)
1049     {
1050         if ((hn->resource == resource) && (hn->type == resourcetype))
1051         {
1052             exists = TRUE;
1053             break;
1054         }
1055     }
1056     UnlockIBase(ilock);
1057
1058     return exists;
1059 }
1060
1061 void FireScreenNotifyMessageCode(IPTR data, ULONG flag, ULONG code, struct IntuitionBase *IntuitionBase)
1062 {
1063     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
1064     ObtainSemaphoreShared(&_intuitionBase->ScreenNotificationListLock);
1065
1066     struct ScreenNotifyMessage *msg;
1067     struct ReplyPort *reply;
1068
1069     struct IntScreenNotify *sn;
1070     struct Node *node;
1071
1072     BOOL ignorescreen = FALSE;
1073
1074     if (!IsListEmpty(&_intuitionBase->ScreenNotificationList))
1075     {
1076         node = _intuitionBase->ScreenNotificationList.lh_Head;
1077         for (; node->ln_Succ; node = node->ln_Succ)
1078         {
1079             sn = (struct IntScreenNotify *) node;
1080             if (flag & (  SNOTIFY_AFTER_OPENSCREEN  | SNOTIFY_BEFORE_OPENSCREEN
1081                         | SNOTIFY_AFTER_CLOSESCREEN | SNOTIFY_BEFORE_CLOSESCREEN
1082                         | SNOTIFY_LOCKPUBSCREEN     | SNOTIFY_UNLOCKPUBSCREEN
1083                         | SNOTIFY_SCREENDEPTH       | SNOTIFY_PUBSCREENSTATE    ))
1084             {
1085                 /*
1086                  * If sn->pubname is supplied, only notify for it
1087                  * (data must be a screen, and it must be public)
1088                  */
1089                 if (sn->pubname)
1090                 {
1091                     D(bug("[intuition] FSNMC() sn->pubname is non-NULL... '%s'\n", sn->pubname));
1092                     LockPubScreenList();
1093                     if (!(   (ResourceExisting((struct Screen*)data, RESOURCE_SCREEN, IntuitionBase))
1094                           && (NULL != GetPrivScreen(data)->pubScrNode)
1095                           && (NULL != GetPrivScreen(data)->pubScrNode->psn_Node.ln_Name)
1096                           && (0 == strcmp(sn->pubname, (const char *)GetPrivScreen(data)->pubScrNode->psn_Node.ln_Name)) ))
1097                     {
1098                         ignorescreen = TRUE;
1099                     }
1100                     else
1101                     {
1102                         D(bug("[intuition] FSNMC() IntScreen->pubScrNode->psn_Node.ln_Name is non-NULL... '%s'\n", GetPrivScreen(data)->pubScrNode->psn_Node.ln_Name));
1103                     }
1104                     UnlockPubScreenList();
1105                 }
1106                 D(bug("[intuition] FSNMC() ignorescreen = %s\n", ignorescreen ? "TRUE" : "FALSE"));
1107             }
1108
1109             if ((sn->flags & flag) && !ignorescreen)
1110             {
1111                 if (sn->port)
1112                 {
1113                     msg = AllocMem(sizeof(struct ScreenNotifyMessage), MEMF_CLEAR);
1114                     if (msg)
1115                     {
1116                         msg->snm_Message.mn_Magic = MAGIC_SCREENNOTIFY;
1117                         msg->snm_Message.mn_Version = SCREENNOTIFY_VERSION;
1118                         msg->snm_Object = data;
1119                         msg->snm_Class = flag;
1120                         msg->snm_Code = code;
1121                         msg->snm_UserData = sn->userdata;
1122                         msg->snm_Message.mn_Length = sizeof(struct ScreenNotifyMessage);
1123                         if (sn->flags & SNOTIFY_WAIT_REPLY)
1124                         {
1125                             reply = (struct ReplyPort *)CreateMsgPort();
1126                             if (reply)
1127                             {
1128                                 msg->snm_Message.mn_ReplyPort = (struct MsgPort *)reply;
1129
1130                                 PutMsg((struct MsgPort *)sn->port, (struct Message *) msg);
1131                                 WaitPort((struct MsgPort *)reply);
1132                                 GetMsg((struct MsgPort *)reply);
1133                                 FreeMem((APTR) msg, sizeof(struct ScreenNotifyMessage));
1134                                 DeleteMsgPort((struct MsgPort *)reply);
1135                             } else FreeMem((APTR) msg, sizeof(struct ScreenNotifyMessage));
1136                         }
1137                         else
1138                         {
1139                             msg->snm_Message.mn_ReplyPort = _intuitionBase->ScreenNotifyReplyPort;
1140
1141                             PutMsg(sn->port, (struct Message *) msg);
1142                         }
1143                     }
1144
1145                 }
1146                 else if (sn->sigtask)
1147                 {
1148                     Signal(sn->sigtask, 1 << sn->sigbit);
1149                 }
1150                 else if (sn->hook)
1151                 {
1152                     struct ScreenNotifyMessage msg;
1153                     msg.snm_Message.mn_Magic = MAGIC_SCREENNOTIFY;
1154                     msg.snm_Message.mn_Version = SCREENNOTIFY_VERSION;
1155                     msg.snm_Object = data;
1156                     msg.snm_Class = flag;
1157                     msg.snm_UserData = sn->userdata;
1158                     msg.snm_Message.mn_Length = sizeof(struct ScreenNotifyMessage);
1159
1160                     CallHook(sn->hook, NULL, (Msg) &msg);
1161                 }
1162             }
1163         }
1164     }
1165     ReleaseSemaphore(&_intuitionBase->ScreenNotificationListLock);
1166 }
1167
1168 void FireScreenNotifyMessage(IPTR data, ULONG flag, struct IntuitionBase *IntuitionBase)
1169 {
1170     FireScreenNotifyMessageCode(data, flag, 0, IntuitionBase);
1171 }
1172
1173 /**********************************************************************************/
1174
1175 AROS_UFH3(BOOL, DefaultWindowShapeFunc,
1176     AROS_UFHA(struct Hook *, hook, A0),
1177     AROS_UFHA(struct Layer *, lay, A2),
1178     AROS_UFHA(struct ShapeHookMsg *, msg, A1))
1179 {
1180     AROS_USERFUNC_INIT
1181
1182     struct IntuitionBase    *IntuitionBase = (struct IntuitionBase *)hook->h_Data;
1183     struct IntIntuitionBase *_intuitionBase = GetPrivIBase(IntuitionBase);
1184     struct GfxBase *GfxBase = _intuitionBase->GfxBase;
1185     struct Window               *win = (struct Window *)hook->h_SubEntry;
1186     struct Region               *shape;
1187     struct wdpWindowShape    shapemsg;
1188
1189     shapemsg.MethodID            = WDM_WINDOWSHAPE;
1190     shapemsg.wdp_TrueColor  = (GetPrivScreen(win->WScreen)->DInfo.dri_Flags & DRIF_DIRECTCOLOR) ? TRUE : FALSE;
1191     shapemsg.wdp_Width             = msg->NewBounds->MaxX - msg->NewBounds->MinX + 1;
1192     shapemsg.wdp_Height     = msg->NewBounds->MaxY - msg->NewBounds->MinY + 1;
1193     shapemsg.wdp_Window = win;
1194     shapemsg.wdp_UserBuffer = IW(win)->DecorUserBuffer;
1195
1196     shape = (struct Region *)DoMethodA(GetPrivScreen(win->WScreen)->WinDecorObj, (Msg)&shapemsg);
1197
1198     if (IW(win)->OutlineShape) DisposeRegion(IW(win)->OutlineShape);
1199     IW(win)->OutlineShape = shape;
1200     IW(win)->CustomShape = FALSE;
1201
1202     msg->NewShape = shape;
1203     return TRUE;
1204
1205     AROS_USERFUNC_EXIT
1206 }
1207
1208 /**********************************************************************************/