rom/intuition/windecorclass.c

   1 /*
   2     Copyright  1995-2012, The AROS Development Team. All rights reserved.
   3     Copyright  2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7
   8 #include <dos/dos.h>
   9 #include <dos/dosextens.h>
  10
  11 #include <intuition/intuition.h>
  12 #include <intuition/intuitionbase.h>
  13 #include <intuition/classes.h>
  14 #include <intuition/classusr.h>
  15 #include <intuition/windecorclass.h>
  16 #include <intuition/cghooks.h>
  17 #include <intuition/icclass.h>
  18 #include <intuition/extensions.h>
  19
  20 #include <graphics/gfxbase.h>
  21 #include <graphics/gfxmacros.h>
  22
  23 #include <utility/tagitem.h>
  24 #include <utility/hooks.h>
  25
  26 #include <clib/macros.h>
  27
  28 #include <string.h>
  29
  30 #include <proto/exec.h>
  31 #include <proto/intuition.h>
  32 #include <proto/graphics.h>
  33 #include <proto/utility.h>
  34
  35 #include <proto/alib.h>
  36
  37 #include "intuition_intern.h"
  38 #include "gadgets.h"
  39
  40 /**************************************************************************************************/
  41
  42 #ifdef __AROS__
  43 #define USE_AROS_DEFSIZE 1
  44 #else
  45 #define USE_AROS_DEFSIZE 0
  46 #endif
  47
  48 #define DEFSIZE_WIDTH  14
  49 #define DEFSIZE_HEIGHT 14
  50
  51 #define HSPACING 3
  52 #define VSPACING 3
  53 /* Ralph Schmidt
  54  * heuristics for smaller arrows used in apps
  55  * like filer
  56  */
  57 #define HSPACING_MIDDLE 2
  58 #define VSPACING_MIDDLE 2
  59 #define HSPACING_SMALL 1
  60 #define VSPACING_SMALL 1
  61
  62 #define DRI(dri) ((struct DrawInfo *)(dri))
  63
  64 /**************************************************************************************************/
  65
  66 static void renderimageframe(struct RastPort *rp, ULONG which, ULONG state, UWORD *pens,
  67                              WORD left, WORD top, WORD width, WORD height,
  68                              struct IntuitionBase *IntuitionBase)
  69 {
  70     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
  71     WORD right = left + width - 1;
  72     WORD bottom = top + height - 1;
  73     BOOL leftedgegodown = FALSE;
  74     BOOL topedgegoright = FALSE;
  75
  76     switch(which)
  77     {
  78 #if 0
  79     case CLOSEIMAGE:
  80             /* draw separator line at the right side */
  81             SetAPen(rp, pens[SHINEPEN]);
  82             RectFill(rp, right, top, right, bottom - 1);
  83             SetAPen(rp, pens[SHADOWPEN]);
  84             WritePixel(rp, right, bottom);
  85
  86             right--;
  87             break;
  88
  89     case ZOOMIMAGE:
  90     case DEPTHIMAGE:
  91     case SDEPTHIMAGE:
  92             /* draw separator line at the left side */
  93             SetAPen(rp, pens[SHINEPEN]);
  94             WritePixel(rp, left, top);
  95             SetAPen(rp, pens[SHADOWPEN]);
  96             RectFill(rp, left, top + 1, left, bottom);
  97
  98             left++;
  99             break;
 100 #endif
 101
 102     case UPIMAGE:
 103     case DOWNIMAGE:
 104             leftedgegodown = TRUE;
 105             break;
 106
 107     case LEFTIMAGE:
 108     case RIGHTIMAGE:
 109             topedgegoright = TRUE;
 110             break;
 111     }
 112
 113     if (left == 0) leftedgegodown = TRUE;
 114     if (top == 0) topedgegoright = TRUE;
 115
 116     SetAPen(rp, pens[((state == IDS_SELECTED) || (state == IDS_INACTIVESELECTED)) ? SHADOWPEN : SHINEPEN]);
 117
 118     /* left edge */
 119     RectFill(rp, left,
 120              top,
 121              left,
 122              bottom - (leftedgegodown ? 0 : 1));
 123
 124     /* top edge */
 125     RectFill(rp, left + 1,
 126              top,
 127              right - (topedgegoright ? 0 : 1),
 128              top);
 129
 130     SetAPen(rp, pens[((state == IDS_SELECTED) || (state == IDS_INACTIVESELECTED)) ? SHINEPEN : SHADOWPEN]);
 131
 132     /* right edge */
 133     RectFill(rp, right,
 134              top + (topedgegoright ? 1 : 0),
 135              right,
 136              bottom);
 137
 138     /* bottom edge */
 139     RectFill(rp, left + (leftedgegodown ? 1 : 0),
 140              bottom,
 141              right - 1,
 142              bottom);
 143 }
 144
 145 /**************************************************************************************************/
 146
 147 static UWORD getbgpen(ULONG state, UWORD *pens)
 148 {
 149     UWORD bg;
 150     switch (state)
 151     {
 152     case IDS_NORMAL:
 153     case IDS_SELECTED:
 154             bg = pens[FILLPEN];
 155             break;
 156
 157     default:
 158             bg = pens[BACKGROUNDPEN];
 159             break;
 160     }
 161
 162     return bg;
 163 }
 164
 165
 166 /**************************************************************************************************/
 167
 168 IPTR WinDecorClass__OM_NEW(Class *cl, Object *obj, struct opSet *msg)
 169 {
 170     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 171     struct Library *UtilityBase = GetPrivIBase(IntuitionBase)->UtilityBase;
 172     struct windecor_data *data;
 173
 174     obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
 175     if (obj)
 176     {
 177         data = INST_DATA(cl, obj);
 178     data->userbuffersize = (ULONG) GetTagData(WDA_UserBuffer, 0, msg->ops_AttrList);
 179     }
 180
 181     return (IPTR)obj;
 182 }
 183
 184 /**************************************************************************************************/
 185
 186 IPTR WinDecorClass__OM_GET(Class *cl, Object *obj, struct opGet *msg)
 187 {
 188     struct windecor_data *data = INST_DATA(cl, obj);
 189
 190     switch(msg->opg_AttrID)
 191     {
 192         case WDA_UserBuffer:
 193         *msg->opg_Storage = (IPTR) data->userbuffersize;
 194         break;
 195     case WDA_TrueColorOnly:
 196         *msg->opg_Storage = FALSE;
 197         break;
 198
 199     default:
 200         return DoSuperMethodA(cl, obj, (Msg)msg);
 201     }
 202
 203     return 1;
 204 }
 205
 206
 207 /**************************************************************************************************/
 208
 209 IPTR WinDecorClass__WDM_GETDEFSIZE_SYSIMAGE(Class *cl, Object *obj, struct wdpGetDefSizeSysImage *msg)
 210 {
 211     ULONG def_low_width = DEFSIZE_WIDTH, def_low_height = DEFSIZE_HEIGHT;
 212     ULONG def_med_width = DEFSIZE_WIDTH, def_med_height = DEFSIZE_HEIGHT;
 213     ULONG def_high_width = DEFSIZE_WIDTH, def_high_height = DEFSIZE_HEIGHT;
 214
 215     ULONG refheight = msg->wdp_ReferenceFont->tf_YSize;
 216     ULONG refwidth = refheight;
 217
 218     switch(msg->wdp_Which)
 219     {
 220         case LEFTIMAGE:
 221     case RIGHTIMAGE:
 222     #if USE_AROS_DEFSIZE
 223             def_low_width = def_med_width = def_high_width = DEFSIZE_WIDTH;
 224         def_low_height = def_med_height = def_high_height = DEFSIZE_HEIGHT;
 225     #else
 226             def_low_width = 16;
 227             def_med_width = 16;
 228             def_high_width = 23;
 229             def_low_height = 11;
 230             def_med_height = 10;
 231             def_high_height = 22;
 232     #endif
 233             break;
 234
 235     case UPIMAGE:
 236     case DOWNIMAGE:
 237     #if USE_AROS_DEFSIZE
 238             def_low_width = def_med_width = def_high_width = DEFSIZE_WIDTH;
 239         def_low_height = def_med_height = def_high_height = DEFSIZE_HEIGHT;
 240     #else
 241             def_low_width = 13;
 242             def_med_width = 18;
 243             def_high_width = 23;
 244             def_low_height = 11;
 245             def_med_height = 11;
 246             def_high_height = 22;
 247     #endif
 248             break;
 249
 250     case DEPTHIMAGE:
 251     case ZOOMIMAGE:
 252     case ICONIFYIMAGE:
 253     case LOCKIMAGE:
 254     case MUIIMAGE:
 255     case POPUPIMAGE:
 256     case SNAPSHOTIMAGE:
 257     case JUMPIMAGE:
 258     #if USE_AROS_DEFSIZE
 259         def_low_width = def_med_width = def_high_width = DEFSIZE_WIDTH;
 260         def_low_height = def_med_height = def_high_height = DEFSIZE_HEIGHT;
 261     #else
 262             def_low_width = 18;
 263             def_med_width = 24;
 264             def_high_width = 24;
 265     #endif
 266             break;
 267
 268     case SDEPTHIMAGE:
 269     #if USE_AROS_DEFSIZE
 270             def_low_width = def_med_width = def_high_width = DEFSIZE_WIDTH;
 271         def_low_height = def_med_height = def_high_height = DEFSIZE_HEIGHT;
 272     #else
 273             def_low_width = 17;
 274             def_med_width = 23;
 275             def_high_width = 23;
 276     #endif
 277             break;
 278
 279     case CLOSEIMAGE:
 280     #if USE_AROS_DEFSIZE
 281             def_low_width = def_med_width = def_high_width = DEFSIZE_WIDTH;
 282         def_low_height = def_med_height = def_high_height = DEFSIZE_HEIGHT;
 283     #else
 284             def_low_width = 15;
 285             def_med_width = 20;
 286             def_high_width = 20;
 287     #endif
 288             break;
 289
 290     case SIZEIMAGE:
 291     #if USE_AROS_DEFSIZE
 292             def_low_width = def_med_width = def_high_width = DEFSIZE_WIDTH;
 293         def_low_height = def_med_height = def_high_height = DEFSIZE_HEIGHT;
 294     #else
 295             def_low_width = 13;
 296             def_med_width = 18;
 297             def_high_width = 18;
 298             def_low_height = 11;
 299             def_med_height = 10;
 300             def_high_height = 10;
 301     #endif
 302             break;
 303
 304     case MENUCHECK:
 305             def_low_width  =
 306         def_med_width  =
 307         def_high_width = refwidth / 2 + 4; // reffont->tf_XSize * 3 / 2;
 308             def_low_height =
 309         def_med_height =
 310         def_high_height= refheight;
 311             break;
 312
 313     case MXIMAGE:
 314             def_low_width  =
 315         def_med_width  =
 316         def_high_width = (refwidth + 1) * 2; // reffont->tf_XSize * 3 - 1;
 317             def_low_height =
 318         def_med_height =
 319         def_high_height= refheight + 1;
 320             break;
 321
 322     case CHECKIMAGE:
 323             def_low_width  = (refwidth + 3) * 2;//reffont->tf_XSize * 2;
 324             def_low_height = refheight + 3;
 325             break;
 326
 327     default:
 328         return FALSE;
 329     }
 330
 331     switch(msg->wdp_SysiSize)
 332     {
 333         case SYSISIZE_LOWRES:
 334         *msg->wdp_Width = def_low_width;
 335         *msg->wdp_Height = def_low_height;
 336         break;
 337
 338     case SYSISIZE_MEDRES:
 339         *msg->wdp_Width = def_med_width;
 340         *msg->wdp_Height = def_med_height;
 341         break;
 342
 343         case SYSISIZE_HIRES:
 344         default:
 345         *msg->wdp_Width = def_high_width;
 346         *msg->wdp_Height = def_high_height;
 347         break;
 348     }
 349
 350     return TRUE;
 351 }
 352
 353 /**************************************************************************************************/
 354
 355 IPTR WinDecorClass__WDM_DRAW_SYSIMAGE(Class *cl, Object *obj, struct wdpDrawSysImage *msg)
 356 {
 357     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 358     struct GfxBase       *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 359     struct RastPort      *rp = msg->wdp_RPort;
 360     UWORD                *pens = DRI(msg->wdp_Dri)->dri_Pens;
 361     LONG                  state = msg->wdp_State;
 362     LONG                   left = msg->wdp_X;
 363     LONG                   top = msg->wdp_Y;
 364     LONG                 width = msg->wdp_Width;
 365     LONG                 height = msg->wdp_Height;
 366     LONG                  right = left + width - 1;
 367     LONG                  bottom = top + height - 1;
 368     LONG                  h_spacing, v_spacing;
 369
 370     SetDrMd(rp, JAM1);
 371
 372     switch(msg->wdp_Which)
 373     {
 374
 375     case MUIIMAGE:
 376     {
 377         renderimageframe(rp, CLOSEIMAGE, state, pens, left, top, width, height, IntuitionBase);
 378         /* no code yet */
 379         break;
 380     }
 381     case POPUPIMAGE:
 382     {
 383         renderimageframe(rp, CLOSEIMAGE, state, pens, left, top, width, height, IntuitionBase);
 384         /* code should be added later */
 385         break;
 386     }
 387     case ICONIFYIMAGE:
 388     {
 389         UWORD  bg;
 390         WORD   h_spacing;
 391         WORD   v_spacing;
 392
 393         renderimageframe(rp, ICONIFYIMAGE, state, pens,
 394                          left, top, width, height, IntuitionBase);
 395         left++;
 396         top++;
 397         width -= 2;
 398         height -= 2;
 399
 400         right = left + width - 1;
 401         bottom = top + height - 1 ;
 402         h_spacing = width / 6;
 403         v_spacing = height / 6;
 404
 405         bg = getbgpen(state, pens);
 406
 407         /* Clear background into correct color */
 408         SetAPen(rp, bg);
 409         RectFill(rp, left, top, right, bottom);
 410
 411         left += h_spacing;
 412         right -= h_spacing;
 413         top += v_spacing;
 414         bottom -= v_spacing;
 415
 416         SetAPen(rp, pens[SHADOWPEN]);
 417         RectFill(rp, left, top, right, bottom);
 418
 419         SetAPen(rp, pens[(state == IDS_SELECTED) ? SHINEPEN :
 420                             (state == IDS_NORMAL) ? FILLPEN : BACKGROUNDPEN]);
 421         RectFill(rp, left + 1, top + 1, right - 1, bottom - 1);
 422
 423         right = left + (right - left + 1) / 2;
 424         top = top + (bottom - top + 1) / 2;
 425
 426         if (right - left <  4) right = left + 4;
 427
 428         SetAPen(rp, pens[SHADOWPEN]);
 429         RectFill(rp, left, top, right, bottom);
 430
 431         left += 2;
 432         right -= 2;
 433         top += 1;
 434         bottom -= 1;
 435
 436         SetAPen(rp, pens[(state == IDS_SELECTED) ? FILLPEN :
 437                             (state == IDS_NORMAL) ? SHINEPEN : BACKGROUNDPEN]);
 438         RectFill(rp,left, top, right, bottom);
 439         break;
 440     }
 441     case CLOSEIMAGE:
 442     {
 443         renderimageframe(rp, CLOSEIMAGE, state, pens, left, top, width, height, IntuitionBase);
 444         left++;
 445         top++;
 446         width -= 2;
 447         height -= 2;
 448
 449         right = left + width - 1;
 450         bottom = top + height - 1;
 451         h_spacing = width * 4 / 10;
 452         v_spacing = height * 3 / 10;
 453
 454         SetAPen(rp, getbgpen(state, pens));
 455         RectFill(rp, left, top, right, bottom);
 456
 457             left += h_spacing;
 458             right -= h_spacing;
 459             top += v_spacing;
 460             bottom -= v_spacing;
 461
 462             SetAPen(rp, pens[SHADOWPEN]);
 463             RectFill(rp, left, top, right, bottom);
 464
 465             left++;
 466             top++;
 467             right--;
 468             bottom--;
 469
 470             SetAPen(rp, pens[(state == IDS_NORMAL) ? SHINEPEN : BACKGROUNDPEN]);
 471             RectFill(rp, left, top, right, bottom);
 472
 473             break;
 474     }
 475
 476         case ZOOMIMAGE:
 477         {
 478             UWORD  bg;
 479             WORD   h_spacing;
 480             WORD   v_spacing;
 481
 482             renderimageframe(rp, ZOOMIMAGE, state, pens,
 483                              left, top, width, height, IntuitionBase);
 484             left++;
 485             top++;
 486             width -= 2;
 487             height -= 2;
 488
 489             right = left + width - 1;
 490             bottom = top + height - 1 ;
 491             h_spacing = width / 6;
 492             v_spacing = height / 6;
 493
 494             bg = getbgpen(state, pens);
 495
 496             /* Clear background into correct color */
 497             SetAPen(rp, bg);
 498             RectFill(rp, left, top, right, bottom);
 499
 500             left += h_spacing;
 501             right -= h_spacing;
 502             top += v_spacing;
 503             bottom -= v_spacing;
 504
 505             SetAPen(rp, pens[SHADOWPEN]);
 506             RectFill(rp, left, top, right, bottom);
 507
 508             SetAPen(rp, pens[(state == IDS_SELECTED) ? SHINEPEN :
 509                                 (state == IDS_NORMAL) ? FILLPEN : BACKGROUNDPEN]);
 510             RectFill(rp, left + 1, top + 1, right - 1, bottom - 1);
 511
 512             right = left + (right - left + 1) / 2;
 513             bottom = top + (bottom - top + 1) / 2;
 514
 515             if (right - left <  4) right = left + 4;
 516
 517             SetAPen(rp, pens[SHADOWPEN]);
 518             RectFill(rp, left, top, right, bottom);
 519
 520             left += 2;
 521             right -= 2;
 522             top += 1;
 523             bottom -= 1;
 524
 525             SetAPen(rp, pens[(state == IDS_SELECTED) ? FILLPEN :
 526                                 (state == IDS_NORMAL) ? SHINEPEN : BACKGROUNDPEN]);
 527             RectFill(rp,left, top, right, bottom);
 528             break;
 529         }
 530
 531         case DEPTHIMAGE:
 532         {
 533             UWORD  bg;
 534             WORD   h_spacing;
 535             WORD   v_spacing;
 536
 537             renderimageframe(rp, DEPTHIMAGE, state, pens,
 538                              left, top, width, height, IntuitionBase);
 539             left++;
 540             top++;
 541             right--;
 542             bottom--;
 543             width -= 2;
 544             height -= 2;
 545
 546             h_spacing = width / 6;
 547             v_spacing = height / 6;
 548
 549             bg = getbgpen(state, pens);
 550
 551             /* Clear background into correct color */
 552             SetAPen(rp, bg);
 553             RectFill(rp, left, top, right, bottom);
 554
 555             /* Draw a image of two partly overlapped tiny windows,
 556             */
 557
 558             left += h_spacing;
 559             top  += v_spacing;
 560
 561             width  -= h_spacing * 2;
 562             height -= v_spacing * 2;
 563
 564             right  = left + width  - 1;
 565             bottom = top  + height - 1;
 566
 567             /* Render top left window  */
 568
 569             SetAPen(rp, pens[SHADOWPEN]);
 570             drawrect(rp
 571                      , left
 572                      , top
 573                      , right - (width / 3 )
 574                      , bottom - (height / 3)
 575                      , IntuitionBase);
 576
 577
 578             /* Fill top left window (inside of the frame above) */
 579
 580             if ((state != IDS_INACTIVENORMAL))
 581             {
 582                 SetAPen(rp, pens[BACKGROUNDPEN]);
 583                 RectFill(rp, left + 1, top + 1,
 584                      right - (width / 3) - 1, bottom - (height / 3) - 1);
 585
 586             }
 587
 588             /* Render bottom right window  */
 589             SetAPen(rp, pens[SHADOWPEN]);
 590             drawrect(rp, left + (width / 3), top + (height / 3),
 591                      right, bottom, IntuitionBase);
 592
 593             /* Fill bottom right window (inside of the frame above) */
 594             SetAPen(rp, pens[(state == IDS_INACTIVENORMAL) ? BACKGROUNDPEN : SHINEPEN]);
 595             RectFill(rp, left + (width / 3) + 1, top + (height / 3) + 1,
 596                      right - 1, bottom - 1);
 597
 598             if (state == IDS_SELECTED)
 599             {
 600                 /* Re-Render top left window  */
 601
 602                 SetAPen(rp, pens[SHADOWPEN]);
 603                 drawrect(rp, left, top,
 604                      right - (width / 3 ), bottom - (height / 3), IntuitionBase);
 605             }
 606             break;
 607         }
 608
 609         case SIZEIMAGE:
 610         {
 611             UWORD  bg;
 612             WORD   h_spacing;
 613             WORD   v_spacing;
 614             WORD   x, y;
 615
 616             renderimageframe(rp, SIZEIMAGE, state, pens,
 617                              left, top, width, height, IntuitionBase);
 618             left++;
 619             top++;
 620             right--;
 621             bottom--;
 622             width -= 2;
 623             height -= 2;
 624
 625             h_spacing = width  / 5;
 626             v_spacing = height / 5;
 627
 628             bg = getbgpen(state, pens);
 629
 630             /* Clear background into correct color */
 631             SetAPen(rp, bg);
 632             RectFill(rp, left, top, right, bottom);
 633
 634             /* A triangle image */
 635
 636             left += h_spacing;
 637             top  += v_spacing;
 638
 639             right  = left + width  - 1 - (h_spacing * 2);
 640             bottom = top  + height - 1 - (v_spacing * 2);
 641
 642             width  = right  - left + 1;
 643             height = bottom - top  + 1;
 644
 645             if (state != IDS_INACTIVENORMAL)
 646             {
 647                 SetAPen(rp, pens[SHINEPEN]);
 648
 649                 for(y = top; y <= bottom; y++)
 650                 {
 651                     x = left + (bottom - y) * width / height;
 652                     RectFill(rp, x, y, right, y);
 653                 }
 654             }
 655
 656             SetAPen(rp, pens[SHADOWPEN]);
 657             /* Draw triangle border */
 658             Move(rp, left, bottom);
 659             Draw(rp, right, top);
 660             Draw(rp, right, bottom);
 661             Draw(rp, left, bottom);
 662
 663             break;
 664         }
 665
 666         case LEFTIMAGE:
 667         {
 668             UWORD hspacing,vspacing;
 669             WORD  cy, i;
 670
 671             hspacing = HSPACING;
 672             vspacing = VSPACING;
 673
 674             if (width <= 12)
 675             {
 676                 hspacing = HSPACING_MIDDLE;
 677             }
 678
 679             if (width <= 10)
 680             {
 681                 hspacing = HSPACING_SMALL;
 682             }
 683
 684             if (height <= 12)
 685             {
 686                 vspacing = VSPACING_MIDDLE;
 687             }
 688
 689             if (height <= 10)
 690             {
 691                 vspacing = VSPACING_SMALL;
 692             }
 693
 694             renderimageframe(rp, LEFTIMAGE, state, pens,
 695                              left, top, width, height, IntuitionBase);
 696             left++;
 697             top++;
 698             right--;
 699             bottom--;
 700             width -= 2;
 701             height -= 2;
 702
 703             SetAPen(rp, getbgpen(state, pens));
 704             RectFill(rp, left, top, right, bottom);
 705
 706             left += hspacing;
 707             top += vspacing;
 708             width -= hspacing * 2;
 709             height -= vspacing * 2;
 710
 711             right = left + width - 1;
 712             bottom = top + height - 1;
 713
 714             cy = (height + 1) / 2;
 715
 716             SetAPen(rp, pens[SHADOWPEN]);
 717
 718             for(i = 0; i < cy; i++)
 719             {
 720                 RectFill(rp, left + (cy - i - 1) * width / cy,
 721                          top + i,
 722                          right - i * width / cy / 2,
 723                          top + i);
 724                 RectFill(rp, left + (cy - i - 1) * width / cy,
 725                          bottom - i,
 726                          right - i * width / cy / 2,
 727                          bottom - i);
 728             }
 729             break;
 730         }
 731
 732         case UPIMAGE:
 733         {
 734             UWORD hspacing,vspacing;
 735             WORD  cx, i;
 736
 737             hspacing = HSPACING;
 738             vspacing = VSPACING;
 739
 740             if (width <= 12)
 741             {
 742                 hspacing = HSPACING_MIDDLE;
 743             }
 744
 745             if (width <= 10)
 746             {
 747                 hspacing = HSPACING_SMALL;
 748             }
 749
 750             if (height <= 12)
 751             {
 752                 vspacing = VSPACING_MIDDLE;
 753             }
 754
 755             if (height <= 10)
 756             {
 757                 vspacing = VSPACING_SMALL;
 758             }
 759
 760             renderimageframe(rp, UPIMAGE, state, pens,
 761                              left, top, width, height, IntuitionBase);
 762             left++;
 763             top++;
 764             right--;
 765             bottom--;
 766             width -= 2;
 767             height -= 2;
 768
 769             SetAPen(rp, getbgpen(state, pens));
 770             RectFill(rp, left, top, right, bottom);
 771
 772             left += hspacing;
 773             top += vspacing;
 774             width -= hspacing * 2;
 775             height -= vspacing * 2;
 776
 777             right = left + width - 1;
 778             bottom = top + height - 1;
 779
 780             cx = (width + 1) / 2;
 781
 782             SetAPen(rp, pens[SHADOWPEN]);
 783
 784             for(i = 0; i < cx; i++)
 785             {
 786                 RectFill(rp, left + i,
 787                          top + (cx - i - 1) * height / cx,
 788                          left + i,
 789                          bottom - i * height / cx / 2);
 790                 RectFill(rp, right - i,
 791                          top + (cx - i - 1) * height / cx,
 792                          right - i,
 793                          bottom - i * height / cx / 2);
 794             }
 795
 796             break;
 797         }
 798
 799         case RIGHTIMAGE:
 800         {
 801             UWORD hspacing,vspacing;
 802             WORD  cy, i;
 803
 804             hspacing = HSPACING;
 805             vspacing = VSPACING;
 806
 807             if (width <= 12)
 808             {
 809                 hspacing = HSPACING_MIDDLE;
 810             }
 811
 812             if (width <= 10)
 813             {
 814                 hspacing = HSPACING_SMALL;
 815             }
 816
 817             if (height <= 12)
 818             {
 819                 vspacing = VSPACING_MIDDLE;
 820             }
 821
 822             if (height <= 10)
 823             {
 824                 vspacing = VSPACING_SMALL;
 825             }
 826
 827             renderimageframe(rp, RIGHTIMAGE, state, pens,
 828                              left, top, width, height, IntuitionBase);
 829             left++;
 830             top++;
 831             right--;
 832             bottom--;
 833             width -= 2;
 834             height -= 2;
 835
 836
 837             SetAPen(rp, getbgpen(state, pens));
 838             RectFill(rp, left, top, right, bottom);
 839
 840             left += hspacing;
 841             top += vspacing;
 842             width -= hspacing * 2;
 843             height -= vspacing * 2;
 844
 845             right = left + width - 1;
 846             bottom = top + height - 1;
 847
 848             cy = (height + 1) / 2;
 849
 850             SetAPen(rp, pens[SHADOWPEN]);
 851
 852             for(i = 0; i < cy; i++)
 853             {
 854                 RectFill(rp, left + i * width / cy / 2,
 855                          top + i,
 856                          right - (cy - i - 1) * width / cy,
 857                          top + i);
 858                 RectFill(rp, left + i * width / cy / 2,
 859                          bottom - i,
 860                          right - (cy - i - 1) * width / cy,
 861                          bottom - i);
 862             }
 863             break;
 864         }
 865
 866         case DOWNIMAGE:
 867         {
 868             UWORD hspacing,vspacing;
 869             WORD  cx, i;
 870
 871             hspacing = HSPACING;
 872             vspacing = VSPACING;
 873
 874             if (width <= 12)
 875             {
 876                 hspacing = HSPACING_MIDDLE;
 877             }
 878
 879             if (width <= 10)
 880             {
 881                 hspacing = HSPACING_SMALL;
 882             }
 883
 884             if (height <= 12)
 885             {
 886                 vspacing = VSPACING_MIDDLE;
 887             }
 888
 889             if (height <= 10)
 890             {
 891                 vspacing = VSPACING_SMALL;
 892             }
 893
 894             renderimageframe(rp, DOWNIMAGE, state, pens,
 895                              left, top, width, height, IntuitionBase);
 896             left++;
 897             top++;
 898             right--;
 899             bottom--;
 900             width -= 2;
 901             height -= 2;
 902
 903             SetAPen(rp, getbgpen(state, pens));
 904             RectFill(rp, left, top, right, bottom);
 905
 906             left += hspacing;
 907             top += vspacing;
 908             width -= hspacing * 2;
 909             height -= vspacing * 2;
 910
 911             right = left + width - 1;
 912             bottom = top + height - 1;
 913
 914             cx = (width + 1) / 2;
 915
 916             SetAPen(rp, pens[SHADOWPEN]);
 917
 918             for(i = 0; i < cx; i++)
 919             {
 920                 RectFill(rp, left + i,
 921                          top + i * height / cx / 2,
 922                          left + i,
 923                          bottom - (cx - i - 1) * height / cx);
 924                 RectFill(rp, right - i,
 925                          top + i * height / cx / 2,
 926                          right -  i,
 927                          bottom - (cx - i - 1) * height / cx);
 928
 929             }
 930             break;
 931         }
 932
 933
 934     default:
 935         return FALSE;
 936     }
 937
 938     return TRUE;
 939 }
 940
 941 /**************************************************************************************************/
 942
 943 static void findtitlearea(struct Window *win, LONG *left, LONG *right)
 944 {
 945     struct Gadget *g;
 946
 947     *left = 0;
 948     *right = win->Width - 1;
 949
 950     for (g = win->FirstGadget; g; g = g->NextGadget)
 951     {
 952         if (g->Activation & GACT_TOPBORDER && g != (struct Gadget *)IW(win)->sysgads[DRAGBAR])
 953         {
 954             if (!(g->Flags & GFLG_RELRIGHT))
 955             {
 956                 if (g->LeftEdge + g->Width > *left)
 957                     *left = g->LeftEdge + g->Width;
 958             }
 959             else
 960             {
 961                 if (g->LeftEdge + win->Width - 1 - 1 < *right)
 962                     *right = g->LeftEdge + win->Width - 1 - 1;
 963             }
 964         }
 965     }
 966
 967 }
 968
 969 /**************************************************************************************************/
 970
 971 IPTR INTERNAL_WDM_DRAW_WINTITLE(Class *cl, Object *obj, struct wdpDrawWinBorder *msg)
 972 {
 973     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 974     struct GfxBase       *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
 975     struct RastPort      *rp = msg->wdp_RPort;
 976     struct Window        *window = msg->wdp_Window;
 977     UWORD                *pens = DRI(msg->wdp_Dri)->dri_Pens;
 978     LONG                  right, left;
 979
 980     findtitlearea(window, &left, &right);
 981
 982     SetDrMd(rp, JAM1);
 983     SetAPen(rp, pens[(window->Flags & WFLG_WINDOWACTIVE) ? FILLPEN : BACKGROUNDPEN]);
 984     CheckRectFill(rp, left + 1, 1, right - 1, window->BorderTop - 2, IntuitionBase);
 985
 986     if (right - left > 6)
 987     {
 988         ULONG               textlen, titlelen;
 989         struct TextExtent     te;
 990
 991         SetFont(rp, DRI(msg->wdp_Dri)->dri_Font);
 992
 993         titlelen = strlen(window->Title);
 994         textlen = TextFit(rp
 995                           , window->Title
 996                           , titlelen
 997                           , &te
 998                           , NULL
 999                           , 1
1000                           , right - left - 6
1001                           , window->BorderTop - 2);
1002         if (textlen)
1003     {
1004         left = left + 3;
1005
1006             SetAPen(rp, pens[(window->Flags & WFLG_WINDOWACTIVE) ? FILLTEXTPEN : TEXTPEN]);
1007
1008         Move(rp, left, DRI(msg->wdp_Dri)->dri_Font->tf_Baseline + 2);
1009             Text(rp, window->Title, textlen);
1010     }
1011     }
1012
1013     return TRUE;
1014 }
1015
1016 /**************************************************************************************************/
1017
1018 IPTR WinDecorClass__WDM_DRAW_WINBORDER(Class *cl, Object *obj, struct wdpDrawWinBorder *msg)
1019 {
1020     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
1021     struct GfxBase       *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1022     struct RastPort      *rp = msg->wdp_RPort;
1023     struct Window        *window = msg->wdp_Window;
1024     UWORD                *pens = DRI(msg->wdp_Dri)->dri_Pens;
1025     LONG                  left, right;
1026
1027     SetDrMd(rp, JAM1);
1028     SetAPen(rp, pens[SHINEPEN]);
1029
1030     if (window->BorderTop > 0)
1031     {
1032         /* Outer shine edge on top side */
1033
1034         CheckRectFill(rp, 0, 0, window->Width - 1, 0, IntuitionBase);
1035     }
1036
1037     if (!(msg->wdp_Flags & WDF_DWB_TOP_ONLY))
1038     {
1039     if (window->BorderLeft > 0)
1040     {
1041         /* Outer shine edge on left side */
1042
1043         CheckRectFill(rp, 0, 0, 0, window->Height - 1, IntuitionBase);
1044     }
1045
1046     if (window->BorderRight > 1)
1047     {
1048         /* Inner shine edge on right side */
1049
1050         CheckRectFill(rp,
1051                   window->Width - window->BorderRight, window->BorderTop,
1052                       window->Width - window->BorderRight, window->Height - window->BorderBottom,
1053                       IntuitionBase);
1054     }
1055
1056     if (window->BorderBottom > 1)
1057     {
1058         /* Inner shine edge on bottom side */
1059
1060         CheckRectFill(rp,
1061                       window->BorderLeft, window->Height - window->BorderBottom,
1062                       window->Width - window->BorderRight, window->Height - window->BorderBottom,
1063                       IntuitionBase);
1064     }
1065     }
1066
1067     SetAPen(rp, pens[SHADOWPEN]);
1068
1069     if (!(msg->wdp_Flags & WDF_DWB_TOP_ONLY))
1070     {
1071     if (window->BorderRight > 0)
1072     {
1073             /* Outer shadow edge on right side */
1074
1075             CheckRectFill(rp, window->Width - 1, 1,
1076                       window->Width - 1, window->Height - 1, IntuitionBase);
1077     }
1078
1079     if (window->BorderBottom > 0)
1080     {
1081             /* Outer shadow edge on bottom side */
1082
1083             CheckRectFill(rp, 1, window->Height - 1,
1084                   window->Width - 1, window->Height - 1, IntuitionBase);
1085     }
1086
1087     if (window->BorderLeft > 1)
1088     {
1089             /* Inner shadow edge on left side */
1090
1091             CheckRectFill(rp, window->BorderLeft - 1, window->BorderTop - 1,
1092                       window->BorderLeft - 1, window->Height - window->BorderBottom,
1093                       IntuitionBase);
1094     }
1095
1096     }
1097
1098     if (window->BorderTop > 1)
1099     {
1100         /* Inner shadow edge on top side */
1101
1102     CheckRectFill(rp, window->BorderLeft - 1, window->BorderTop - 1,
1103                       window->Width - window->BorderRight, window->BorderTop - 1,
1104                       IntuitionBase);
1105     }
1106
1107     SetAPen(rp, pens[(window->Flags & WFLG_WINDOWACTIVE) ? FILLPEN : BACKGROUNDPEN]);
1108
1109     if (window->BorderTop > 2)
1110     {
1111         /* Fill on top side */
1112
1113         CheckRectFill(rp, 1, 1, window->Width - 2, window->BorderTop - 2, IntuitionBase);
1114     }
1115
1116     if (!(msg->wdp_Flags & WDF_DWB_TOP_ONLY))
1117     {
1118     if (window->BorderLeft > 2)
1119     {
1120             /* Fill on left side */
1121
1122             CheckRectFill(rp, 1, 1, window->BorderLeft - 2, window->Height - 2, IntuitionBase);
1123
1124     }
1125
1126     if (window->BorderRight > 2)
1127     {
1128             /* Fill on right side */
1129
1130             CheckRectFill(rp, window->Width - window->BorderRight + 1, 1,
1131                       window->Width - 2, window->Height - 2, IntuitionBase);
1132     }
1133
1134     if (window->BorderBottom > 2)
1135     {
1136             /* Fill on bottom side */
1137
1138         CheckRectFill(rp, 1, window->Height - window->BorderBottom + 1,
1139                       window->Width - 2, window->Height - 2, IntuitionBase);
1140     }
1141     }
1142
1143     findtitlearea(window, &left, &right);
1144
1145     if (left != 0)
1146     {
1147         /* Left edge of title area */
1148
1149         SetAPen(rp, pens[SHINEPEN]);
1150         Move(rp, left, 1);
1151         Draw(rp, left, window->BorderTop - 2);
1152     }
1153
1154     if (right != window->Width - 1)
1155     {
1156         /* Right edges of title area */
1157
1158         SetAPen(rp, pens[SHADOWPEN]);
1159         Move(rp, right, 1);
1160     Draw(rp, right, window->BorderTop - 2);
1161     }
1162
1163     if (window->Title) INTERNAL_WDM_DRAW_WINTITLE(cl, obj, msg);
1164
1165     return TRUE;
1166 }
1167
1168 /**************************************************************************************************/
1169
1170 IPTR WinDecorClass__WDM_LAYOUT_BORDERGADGETS(Class *cl, Object *obj, struct wdpLayoutBorderGadgets *msg)
1171 {
1172     struct Gadget        *gadget = msg->wdp_Gadgets;
1173
1174     if (!(msg->wdp_Flags & WDF_LBG_SYSTEMGADGET)) return TRUE;
1175
1176     while(gadget)
1177     {
1178         switch(gadget->GadgetType & GTYP_SYSTYPEMASK)
1179         {
1180         case GTYP_CLOSE:
1181             gadget->LeftEdge = 0;
1182             gadget->Width = gadget->Height;
1183             gadget->Flags &= ~(GFLG_RELRIGHT | GFLG_RELWIDTH);
1184             break;
1185
1186         case GTYP_WDEPTH:
1187             gadget->LeftEdge = -gadget->Height + 1;
1188             gadget->Width = gadget->Height;
1189             gadget->Flags &= ~GFLG_RELWIDTH;
1190             gadget->Flags |= GFLG_RELRIGHT;
1191             break;
1192
1193         case GTYP_WZOOM:
1194             gadget->LeftEdge = -gadget->Height * 2 + 1;
1195             gadget->Width = gadget->Height;
1196             gadget->Flags &= ~GFLG_RELWIDTH;
1197             gadget->Flags |= GFLG_RELRIGHT;
1198             break;
1199
1200         case GTYP_WDRAGGING:
1201             gadget->LeftEdge = 0;
1202             gadget->Width = 0;
1203             gadget->Flags &= ~GFLG_RELRIGHT;
1204             gadget->Flags |= GFLG_RELWIDTH;
1205             break;
1206         }
1207
1208         if (gadget->GadgetType == GTYP_CUSTOMGADGET)
1209         {
1210             switch(gadget->GadgetID)
1211             {
1212             case ETI_Iconify:
1213                 gadget->LeftEdge = -gadget->Height * 3 + 1;
1214                 gadget->Width = gadget->Height;
1215                 gadget->Flags &= ~GFLG_RELWIDTH;
1216                 gadget->Flags |= GFLG_RELRIGHT;
1217                 break;
1218             }
1219         }
1220
1221         if (msg->wdp_Flags & WDF_LBG_MULTIPLE)
1222         {
1223             gadget = gadget->NextGadget;
1224         }
1225         else
1226         {
1227             gadget = NULL;
1228         }
1229     }
1230
1231     return TRUE;
1232 }
1233
1234 /**************************************************************************************************/
1235
1236 IPTR WinDecorClass__WDM_DRAW_BORDERPROPBACK(Class *cl, Object *obj, struct wdpDrawBorderPropBack *msg)
1237 {
1238     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
1239     struct GfxBase       *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1240     struct Window        *window = msg->wdp_Window;
1241     struct RastPort      *rp = msg->wdp_RPort;
1242     struct Gadget        *gadget = msg->wdp_Gadget;
1243     struct Rectangle     *r = msg->wdp_RenderRect;
1244     struct PropInfo      *pi = ((struct PropInfo *)gadget->SpecialInfo);
1245    UWORD                *pens = DRI(msg->wdp_Dri)->dri_Pens;
1246
1247     SetDrMd(rp, JAM2);
1248
1249     if (pi->Flags & PROPNEWLOOK)
1250     {
1251         static CONST UWORD pattern[] = {0x5555,0xAAAA};
1252
1253         SetAfPt(rp, pattern, 1);
1254     SetAPen(rp, pens[SHADOWPEN]);
1255     SetBPen(rp, pens[(window->Flags & WFLG_WINDOWACTIVE) ? FILLPEN : BACKGROUNDPEN]);
1256     RectFill(rp, r->MinX, r->MinY, r->MaxX, r->MaxY);
1257         SetAfPt(rp, NULL, 0);
1258     }
1259     else
1260     {
1261         SetAPen(rp, pens[BACKGROUNDPEN]);
1262     RectFill(rp, r->MinX, r->MinY, r->MaxX, r->MaxY);
1263     }
1264
1265     return TRUE;
1266 }
1267
1268 /**************************************************************************************************/
1269
1270 IPTR WinDecorClass__WDM_DRAW_BORDERPROPKNOB(Class *cl, Object *obj, struct wdpDrawBorderPropKnob *msg)
1271 {
1272     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
1273     struct GfxBase       *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1274     struct Window        *window = msg->wdp_Window;
1275     struct RastPort      *rp = msg->wdp_RPort;
1276     struct Gadget        *gadget = msg->wdp_Gadget;
1277     struct Rectangle     *r = msg->wdp_RenderRect;
1278     struct PropInfo      *pi = ((struct PropInfo *)gadget->SpecialInfo);
1279    UWORD                *pens = DRI(msg->wdp_Dri)->dri_Pens;
1280
1281     SetDrMd(rp, JAM2);
1282
1283     if (pi->Flags & PROPBORDERLESS)
1284     {
1285         SetAPen(rp, pens[SHINEPEN]);
1286
1287         /* Top edge */
1288         RectFill(rp, r->MinX, r->MinY, r->MaxX - 1, r->MinY);
1289
1290         /* Left edge */
1291         RectFill(rp, r->MinX, r->MinY + 1, r->MinX, r->MaxY - 1);
1292
1293         SetAPen(rp, pens[SHADOWPEN]);
1294
1295         /* Right edge */
1296         RectFill(rp, r->MaxX, r->MinY, r->MaxX, r->MaxY);
1297
1298         /* Bottom edge */
1299         RectFill(rp, r->MinX, r->MaxY, r->MaxX - 1, r->MaxY);
1300
1301         r->MinX++;
1302     r->MinY++;
1303     r->MaxX--;
1304     r->MaxY--;
1305
1306     } /* PROPBORDERLESS */
1307     else
1308     {
1309         SetAPen(rp, pens[SHADOWPEN]);
1310
1311         if (pi->Flags & FREEHORIZ)
1312         {
1313             /* black line at the left and at the right */
1314
1315             RectFill(rp, r->MinX, r->MinY, r->MinX, r->MaxY);
1316             RectFill(rp, r->MaxX, r->MinY, r->MaxX, r->MaxY);
1317
1318             r->MinX++;
1319         r->MaxX--;
1320
1321         }
1322
1323         if (pi->Flags & FREEVERT)
1324         {
1325             /* black line at the top and at the bottom */
1326
1327             RectFill(rp, r->MinX, r->MinY, r->MaxX, r->MinY);
1328             RectFill(rp, r->MinX, r->MaxY, r->MaxX, r->MaxY);
1329
1330             r->MinY++,
1331         r->MaxY--;
1332         }
1333
1334
1335     } /* not PROPBORDERLESS */
1336
1337
1338     SetAPen(rp, pens[(window->Flags & WFLG_WINDOWACTIVE) ? FILLPEN : BACKGROUNDPEN]);
1339
1340     /* interior */
1341     RectFill(rp, r->MinX, r->MinY, r->MaxX, r->MaxY);
1342
1343     return TRUE;
1344 }
1345
1346
1347 /**************************************************************************************************/
1348
1349 IPTR WinDecorClass__WDM_INITWINDOW(Class *cl, Object *obj, struct wdpInitWindow *msg)
1350 {
1351     return TRUE;
1352 }
1353
1354 /**************************************************************************************************/
1355
1356 IPTR WinDecorClass__WDM_EXITWINDOW(Class *cl, Object *obj, struct wdpExitWindow *msg)
1357 {
1358     return TRUE;
1359 }
1360
1361 /**************************************************************************************************/
1362
1363 IPTR WinDecorClass__WDM_WINDOWSHAPE(Class *cl, Object *obj, struct wdpWindowShape *msg)
1364 {
1365     return 0;
1366 }