rom/intuition/intuition_misc.c

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