rom/intuition/intuition_misc.c

   1 /*
   2     Copyright  1995-2004, 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 UWORD DriPens2[NUMDRIPENS] = { 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1 , 1 , 0};
  56         static UWORD DriPens4[NUMDRIPENS] = { 1, 0, 1, 2, 1, 3, 1, 0, 2, 1, 2, 1 , 2 , 1};
  57 #   else
  58         static UWORD DriPens2[NUMDRIPENS] = { 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1};
  59         static 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 #warning 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, ((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, ((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, ((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             D(bug("[intuition] CreateScreenBar: Rendering Bar  ...\n"));
 649             RenderScreenBar(scr, FALSE, IntuitionBase);
 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     if (scr->BarLayer)
 668     {
 669         DeleteLayer(0, scr->BarLayer);
 670         scr->BarLayer = FALSE;
 671     }
 672
 673 }
 674
 675 /**********************************************************************************/
 676
 677 #ifdef SKINS
 678 //RenderScreenBar moved to morphos/mosmisc.c
 679 #endif
 680
 681 #ifndef SKINS
 682
 683 void RenderScreenBar(struct Screen *scr, BOOL refresh, struct IntuitionBase *IntuitionBase)
 684 {
 685
 686     struct DrawInfo *dri = &((struct IntScreen *)scr)->DInfo.dri;
 687     struct RastPort *rp;
 688
 689     D(bug("[intuition] RenderScreenBar()\n"));
 690
 691     if (scr->BarLayer)
 692     {
 693 #if USE_NEWDISPLAYBEEP
 694         BOOL beeping;
 695 #else
 696 #define beeping 0
 697 #endif
 698
 699         D(bug("[intuition] RenderScreenBar: BarLayer @ %p\n", scr->BarLayer));
 700
 701         rp = scr->BarLayer->rp;
 702
 703         D(bug("[intuition] RenderScreenBar: RastPort @ %p\n", rp));
 704         /* must lock GadgetLock to avoid deadlocks with ObtainGIRPort
 705            when calling refreshgadget inside layer update state */
 706         LockLayerInfo(scr->BarLayer->LayerInfo);
 707         LOCKGADGET
 708         LockLayer(0, scr->BarLayer);
 709
 710         D(bug("[intuition] RenderScreenBar: Layer locked\n"));
 711 #if USE_NEWDISPLAYBEEP
 712         beeping = (scr->Flags & BEEPING) && GetBitMapAttr(rp->BitMap, BMA_DEPTH) > 8;
 713 #endif
 714
 715         if (refresh) BeginUpdate(scr->BarLayer);
 716
 717         {
 718             struct sdpDrawScreenBar  msg;
 719
 720             D(bug("[intuition] RenderScreenBar: Begin Refresh .. \n"));
 721
 722             msg.MethodID        = SDM_DRAW_SCREENBAR;
 723             msg.sdp_Layer       = scr->BarLayer;
 724             msg.sdp_RPort       = rp;
 725             msg.sdp_Flags       = 0;
 726             msg.sdp_Screen      = scr;
 727             msg.sdp_Dri         = dri;
 728             msg.sdp_UserBuffer = ((struct IntScreen *)(scr))->DecorUserBuffer;
 729             msg.sdp_TrueColor   = (((struct IntScreen *)(scr))->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
 730
 731             D(bug("[intuition] RenderScreenBar: ScrDecorObj @ %p, DecorUserBuffer @ %p\n", ((struct IntScreen *)(scr))->ScrDecorObj, ((struct IntScreen *)(scr))->DecorUserBuffer));
 732             DoMethodA(((struct IntScreen *)(scr))->ScrDecorObj, (Msg)&msg);
 733         }
 734
 735         D(bug("[intuition] RenderScreenBar: Update gadgets .. \n"));
 736
 737         if (scr->FirstGadget)
 738         {
 739             RefreshBoopsiGadget(scr->FirstGadget, (struct Window *)scr, NULL, IntuitionBase);
 740         }
 741
 742         if (refresh)
 743         {
 744             D(bug("[intuition] RenderScreenBar: End Refresh .. \n"));
 745             scr->BarLayer->Flags &= ~LAYERREFRESH;
 746             EndUpdate(scr->BarLayer, TRUE);
 747         }
 748
 749         D(bug("[intuition] RenderScreenBar: Unlock Layer ..\n"));
 750
 751         UnlockLayer(scr->BarLayer);
 752         UNLOCKGADGET
 753         UnlockLayerInfo(scr->BarLayer->LayerInfo);
 754
 755     } /* if (scr->BarLayer) */
 756     D(bug("[intuition] RenderScreenBar: Done \n"));
 757 }
 758
 759 #endif
 760
 761 /**********************************************************************************/
 762
 763 void UpdateMouseCoords(struct Window *win)
 764 {
 765     WORD scrmousex = win->WScreen->MouseX;
 766     WORD scrmousey = win->WScreen->MouseY;
 767
 768     win->MouseX    = scrmousex - win->LeftEdge;
 769     win->MouseY    = scrmousey - win->TopEdge;
 770
 771     /* stegerg: AmigaOS sets this even if window is not GZZ
 772        so we do the same as they are handy also for non-GZZ
 773        windows */
 774
 775     win->GZZMouseX = scrmousex - (win->LeftEdge + win->BorderLeft);
 776     win->GZZMouseY = scrmousey - (win->TopEdge + win->BorderTop);
 777 }
 778
 779 /**********************************************************************************/
 780
 781 /* subtract rectangle b from rectangle b. resulting rectangles will be put into
 782    destrectarray which must have place for at least 4 rectangles. Returns number
 783    of resulting rectangles */
 784
 785 #if 0  /* use <clib/macros.h> MAX/MIN macros */
 786 #undef MAX
 787 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
 788
 789 #undef MIN
 790 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
 791 #endif
 792
 793 WORD SubtractRectFromRect(struct Rectangle *a, struct Rectangle *b, struct Rectangle *destrectarray)
 794 {
 795     struct Rectangle    intersect;
 796     BOOL                intersecting = FALSE;
 797     WORD                numrects = 0;
 798
 799     /* calc. intersection between a and b */
 800
 801     if (a->MinX <= b->MaxX)
 802     {
 803         if (a->MinY <= b->MaxY)
 804         {
 805             if (a->MaxX >= b->MinX)
 806             {
 807                 if (a->MaxY >= b->MinY)
 808                 {
 809                     intersect.MinX = MAX(a->MinX, b->MinX);
 810                     intersect.MinY = MAX(a->MinY, b->MinY);
 811                     intersect.MaxX = MIN(a->MaxX, b->MaxX);
 812                     intersect.MaxY = MIN(a->MaxY, b->MaxY);
 813
 814                     intersecting = TRUE;
 815                 }
 816             }
 817         }
 818     }
 819
 820     if (!intersecting)
 821     {
 822         destrectarray[numrects++] = *a;
 823
 824     } /* not intersecting */
 825     else
 826     {
 827         if (intersect.MinY > a->MinY) /* upper */
 828         {
 829             destrectarray->MinX = a->MinX;
 830             destrectarray->MinY = a->MinY;
 831             destrectarray->MaxX = a->MaxX;
 832             destrectarray->MaxY = intersect.MinY - 1;
 833
 834             numrects++;
 835             destrectarray++;
 836         }
 837
 838         if (intersect.MaxY < a->MaxY) /* lower */
 839         {
 840             destrectarray->MinX = a->MinX;
 841             destrectarray->MinY = intersect.MaxY + 1;
 842             destrectarray->MaxX = a->MaxX;
 843             destrectarray->MaxY = a->MaxY;
 844
 845             numrects++;
 846             destrectarray++;
 847         }
 848
 849         if (intersect.MinX > a->MinX) /* left */
 850         {
 851             destrectarray->MinX = a->MinX;
 852             destrectarray->MinY = intersect.MinY;
 853             destrectarray->MaxX = intersect.MinX - 1;
 854             destrectarray->MaxY = intersect.MaxY;
 855
 856             numrects++;
 857             destrectarray++;
 858         }
 859
 860         if (intersect.MaxX < a->MaxX) /* right */
 861         {
 862             destrectarray->MinX = intersect.MaxX + 1;
 863             destrectarray->MinY = intersect.MinY;
 864             destrectarray->MaxX = a->MaxX;
 865             destrectarray->MaxY = intersect.MaxY;
 866
 867             numrects++;
 868             destrectarray++;
 869         }
 870
 871     } /* intersecting */
 872
 873     return numrects;
 874
 875 }
 876
 877 ULONG addextragadget(struct Window *w,BOOL is_gzz,struct DrawInfo *dri,LONG relright,ULONG imagetype,ULONG gadgetid,ULONG gadgettype,struct IntuitionBase *IntuitionBase)
 878 {
 879     struct TagItem gadget_tags[] =
 880     {
 881         {GA_Image       , 0                 },
 882         {GA_ToggleSelect, FALSE             },
 883         {GA_Top         , 0                 },
 884         {GA_Height      , TITLEBAR_HEIGHT   },
 885         {GA_TopBorder   , TRUE              },
 886         {GA_GZZGadget   , is_gzz            },
 887         {GA_ID          , gadgetid          },
 888         {GA_RelVerify   , TRUE              },
 889         {TAG_DONE                           }
 890     };
 891     struct TagItem image_tags[] =
 892     {
 893     #ifdef SKINS
 894         {TAG_IGNORE     , 0                                 },
 895     #else
 896         {IA_Left        , -1                                },
 897     #endif
 898         {IA_Height      , TITLEBAR_HEIGHT                   },
 899         {SYSIA_Which    , imagetype                         },
 900         {SYSIA_DrawInfo , (IPTR)dri                         },
 901         {SYSIA_Size     , w->WScreen->Flags & SCREENHIRES ?
 902                       SYSISIZE_MEDRES : SYSISIZE_LOWRES     },
 903         {SYSIA_UserBuffer, ((struct IntWindow *)(w))->DecorUserBuffer                        },
 904
 905         {TAG_DONE                                           }
 906     };
 907     Object *im;
 908
 909     if (gadgettype == LOCKGAD)
 910     gadget_tags[1].ti_Data = TRUE;
 911
 912     im = NewObjectA(NULL, SYSICLASS, image_tags);
 913     if (im)
 914     {
 915         gadget_tags[0].ti_Data = (IPTR)im;
 916
 917         SYSGAD(w, gadgettype) = NewObjectA(NULL, BUTTONGCLASS, gadget_tags);
 918
 919         if (!SYSGAD(w, gadgettype))
 920         {
 921             DisposeObject(im);
 922         }
 923         else
 924         {
 925             IPTR width;
 926             GetAttr(GA_Width, SYSGAD(w, gadgettype), &width);
 927
 928             --width;
 929
 930             {
 931                 struct TagItem gadtags[] =
 932                 {
 933                     {GA_RelRight, relright - width  },
 934                     {TAG_DONE                       }
 935                 };
 936
 937                 SetAttrsA(SYSGAD(w, gadgettype), gadtags);
 938             }
 939
 940             return width;
 941         }
 942     }
 943
 944     return 0;
 945
 946 }
 947
 948 /**********************************************************************************/
 949
 950 LONG CalcResourceHash(APTR resource)
 951 {
 952     LONG l1, l2, l3, l4, hash;
 953
 954     /* FIXME: Probably sucks. I have no clue about this hash stuff */
 955
 956     l1 = ((LONG)resource) & 0xFF;
 957     l2 = (((LONG)resource) >> 8) & 0xFF;
 958     l3 = (((LONG)resource) >> 16) & 0xFF;
 959     l4 = (((LONG)resource) >> 24) & 0xFF;
 960
 961     hash = (l1 + l2 + l3 + l4) % RESOURCELIST_HASHSIZE;
 962
 963     return hash;
 964 }
 965 /**********************************************************************************/
 966
 967 void AddResourceToList(APTR resource, UWORD resourcetype, struct IntuitionBase *IntuitionBase)
 968 {
 969     struct HashNode *hn = NULL;
 970     LONG             hash;
 971     ULONG            ilock;
 972
 973     switch(resourcetype)
 974     {
 975         case RESOURCE_WINDOW:
 976             hn = &((struct IntWindow *)resource)->hashnode;
 977             hn->type = RESOURCE_WINDOW;
 978             break;
 979
 980         case RESOURCE_SCREEN:
 981             hn = &((struct IntScreen *)resource)->hashnode;
 982             hn->type = RESOURCE_SCREEN;
 983             break;
 984
 985         default:
 986             D(bug("AddResourceToList: Unknown resource type!!!\n"));
 987             return;
 988     }
 989
 990     hash = CalcResourceHash(resource);
 991
 992     hn->resource = resource;
 993
 994     ilock = LockIBase(0);
 995     AddTail((struct List *)&GetPrivIBase(IntuitionBase)->ResourceList[hash], (struct Node *)hn);
 996     UnlockIBase(ilock);
 997 }
 998
 999 /**********************************************************************************/
1000
1001 void RemoveResourceFromList(APTR resource, UWORD resourcetype, struct IntuitionBase *IntuitionBase)
1002 {
1003     struct HashNode *hn = NULL;
1004     ULONG            ilock;
1005
1006     switch(resourcetype)
1007     {
1008         case RESOURCE_WINDOW:
1009             hn = &((struct IntWindow *)resource)->hashnode;
1010             break;
1011
1012         case RESOURCE_SCREEN:
1013             hn = &((struct IntScreen *)resource)->hashnode;
1014             break;
1015
1016         default:
1017             D(bug("RemoveResourceFromList: Unknown resource type!!!\n"));
1018             return;
1019     }
1020
1021     if (hn->type != resourcetype)
1022     {
1023         D(bug("RemoveResourceFromList: Panic. Resource Type mismatch!!!\n"));
1024     }
1025
1026     ilock = LockIBase(0);
1027     Remove((struct Node *)hn);
1028     UnlockIBase(ilock);
1029 }
1030
1031 /**********************************************************************************/
1032
1033 BOOL ResourceExisting(APTR resource, UWORD resourcetype, struct IntuitionBase *IntuitionBase)
1034 {
1035     struct HashNode *hn = NULL;
1036     LONG             hash;
1037     ULONG            ilock;
1038     BOOL             exists = FALSE;
1039
1040     hash = CalcResourceHash(resource);
1041
1042     ilock = LockIBase(0);
1043     ForeachNode((struct List *)&GetPrivIBase(IntuitionBase)->ResourceList[hash], hn)
1044     {
1045         if ((hn->resource == resource) && (hn->type == resourcetype))
1046         {
1047             exists = TRUE;
1048             break;
1049         }
1050     }
1051     UnlockIBase(ilock);
1052
1053     return exists;
1054 }
1055
1056 void FireScreenNotifyMessageCode(IPTR data, ULONG flag, ULONG code, struct IntuitionBase *IntuitionBase)
1057 {
1058     ObtainSemaphoreShared(&GetPrivIBase(IntuitionBase)->ScreenNotificationListLock);
1059
1060     struct ScreenNotifyMessage *msg;
1061     struct ReplyPort *reply;
1062
1063     struct IntScreenNotify *sn;
1064     struct Node *node;
1065
1066     if (!IsListEmpty(&GetPrivIBase(IntuitionBase)->ScreenNotificationList))
1067     {
1068         node = GetPrivIBase(IntuitionBase)->ScreenNotificationList.lh_Head;
1069         for (; node->ln_Succ; node = node->ln_Succ)
1070         {
1071             sn = (struct IntScreenNotify *) node;
1072             BOOL leavescreen = FALSE;
1073             if (flag & (SNOTIFY_AFTER_OPENSCREEN | SNOTIFY_BEFORE_OPENSCREEN | SNOTIFY_AFTER_CLOSESCREEN | SNOTIFY_BEFORE_CLOSESCREEN | SNOTIFY_LOCKPUBSCREEN | SNOTIFY_UNLOCKPUBSCREEN))
1074             {
1075             }
1076             if ((sn->flags & flag) && !leavescreen)
1077             {
1078                 if (sn->port)
1079                 {
1080                     msg = AllocMem(sizeof(struct ScreenNotifyMessage), MEMF_CLEAR);
1081                     if (msg)
1082                     {
1083                         msg->snm_Message.mn_Magic = MAGIC_SCREENNOTIFY;
1084                         msg->snm_Message.mn_Version = SCREENNOTIFY_VERSION;
1085                         msg->snm_Object = data;
1086                         msg->snm_Class = flag;
1087                         msg->snm_UserData = sn->userdata;
1088                         msg->snm_Message.mn_Length = sizeof(struct ScreenNotifyMessage);
1089                         if (sn->flags & SNOTIFY_WAIT_REPLY)
1090                         {
1091                             reply = (struct ReplyPort *)CreateMsgPort();
1092                             if (reply)
1093                             {
1094                                 msg->snm_Message.mn_ReplyPort = reply;
1095
1096                                 PutMsg((struct MsgPort *)sn->port, (struct Message *) msg);
1097                                 WaitPort((struct MsgPort *)reply);
1098                                 GetMsg((struct MsgPort *)reply);
1099                                 FreeMem((APTR) msg, sizeof(struct ScreenNotifyMessage));
1100                                 DeleteMsgPort((struct MsgPort *)reply);
1101                             } else FreeMem((APTR) msg, sizeof(struct ScreenNotifyMessage));
1102                         }
1103                         else
1104                         {
1105                             msg->snm_Message.mn_ReplyPort = GetPrivIBase(IntuitionBase)->ScreenNotifyReplyPort;
1106
1107                             PutMsg(sn->port, (struct Message *) msg);
1108                         }
1109                     }
1110
1111                 }
1112                 else if (sn->sigtask)
1113                 {
1114                     Signal(sn->sigtask, 1 << sn->sigbit);
1115                 }
1116                 else if (sn->hook)
1117                 {
1118                     struct ScreenNotifyMessage msg;
1119                     msg.snm_Message.mn_Magic = MAGIC_SCREENNOTIFY;
1120                     msg.snm_Message.mn_Version = SCREENNOTIFY_VERSION;
1121                     msg.snm_Object = data;
1122                     msg.snm_Class = flag;
1123                     msg.snm_UserData = sn->userdata;
1124                     msg.snm_Message.mn_Length = sizeof(struct ScreenNotifyMessage);
1125
1126                     CallHook(sn->hook, NULL, (Msg) &msg);
1127                 }
1128             }
1129         }
1130     }
1131     ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->ScreenNotificationListLock);
1132 }
1133
1134 void FireScreenNotifyMessage(IPTR data, ULONG flag, struct IntuitionBase *IntuitionBase)
1135 {
1136     FireScreenNotifyMessageCode(data, flag, 0, IntuitionBase);
1137 }
1138
1139 /**********************************************************************************/
1140
1141 AROS_UFH3(struct Region *, DefaultWindowShapeFunc,
1142     AROS_UFHA(struct Hook *, hook, A0),
1143     AROS_UFHA(struct Layer *, lay, A2),
1144     AROS_UFHA(struct ShapeHookMsg *, msg, A1))
1145 {
1146     AROS_USERFUNC_INIT
1147
1148     struct IntuitionBase    *IntuitionBase = (struct IntuitionBase *)hook->h_Data;
1149     struct Window           *win = (struct Window *)hook->h_SubEntry;
1150     struct Region           *shape;
1151     struct wdpWindowShape    shapemsg;
1152
1153     shapemsg.MethodID       = WDM_WINDOWSHAPE;
1154     shapemsg.wdp_TrueColor  = (GetPrivScreen(win->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR) ? TRUE : FALSE;
1155     shapemsg.wdp_Width      = msg->NewBounds.MaxX - msg->NewBounds.MinX + 1;
1156     shapemsg.wdp_Height     = msg->NewBounds.MaxY - msg->NewBounds.MinY + 1;
1157     shapemsg.wdp_Window = win;
1158     shapemsg.wdp_UserBuffer = IW(win)->DecorUserBuffer;
1159
1160     shape = (struct Region *)DoMethodA(GetPrivScreen(win->WScreen)->WinDecorObj, (Msg)&shapemsg);
1161
1162     if (IW(win)->OutlineShape) DisposeRegion(IW(win)->OutlineShape);
1163     IW(win)->OutlineShape = shape;
1164     IW(win)->CustomShape = FALSE;
1165
1166     return shape;
1167
1168     AROS_USERFUNC_EXIT
1169 }
1170
1171 /**********************************************************************************/