rom/intuition/windecorclass.c

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