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