rom/intuition/sysiclass_aros.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
   9 #include <exec/types.h>
  10
  11 #include <proto/intuition.h>
  12 #include <proto/layers.h>
  13 #include <intuition/classes.h>
  14 #include <intuition/classusr.h>
  15 #include <intuition/imageclass.h>
  16 #include <intuition/windecorclass.h>
  17 #include <intuition/scrdecorclass.h>
  18 #include <intuition/intuition.h>
  19 #include <intuition/intuitionbase.h>
  20 #include <intuition/extensions.h>
  21 #include <intuition/screens.h>
  22
  23 #include <proto/graphics.h>
  24 #include <graphics/rastport.h>
  25
  26 #include <proto/utility.h>
  27 #include <utility/tagitem.h>
  28
  29 #include <proto/alib.h>
  30
  31 #include <aros/asmcall.h>
  32 #include "intuition_intern.h"
  33 #ifdef __MORPHOS__
  34 #include "intuition_extend.h"
  35 #endif
  36
  37 #include "gadgets.h" /* Some handy rendering funtions */
  38
  39 #define INTDRI(dri) ((struct IntDrawInfo *)(dri))
  40
  41 #if 0
  42 extern BYTE *ibPrefs;
  43 extern BYTE *ibSnapshot;
  44 extern BYTE *ibSnapshotSel;
  45 extern BYTE *ibPopupSel;
  46 extern BYTE *ibPopup;
  47 extern BYTE *ibIconify;
  48 extern BYTE *ibIconifySel;
  49 extern BYTE *ibLock;
  50 extern BYTE *ibLockSel;
  51 extern VOID DrawIB(struct RastPort *rp,BYTE *ib,LONG cx,LONG cy,struct IntuitionBase *IntuitionBase);
  52 extern void DrawJUMP(struct RastPort *rp,ULONG state,LONG cx,LONG cy,struct IntuitionBase *IntuitionBase);
  53 #endif
  54
  55 #undef DEBUG
  56 #define DEBUG 0
  57 #include <aros/debug.h>
  58
  59 /**************************************************************************************************/
  60
  61 #define DEFSIZE_WIDTH  14
  62 #define DEFSIZE_HEIGHT 14
  63
  64 /**************************************************************************************************/
  65
  66 /* Some handy transparent base class object casting defines.
  67  */
  68 #define IM(o) ((struct Image *)o)
  69
  70 static UWORD getbgpen(ULONG state, UWORD *pens);
  71 static UWORD getbgpen_gt(ULONG state, UWORD *pens);
  72 static void renderimageframe(struct RastPort *rp, ULONG which, ULONG state, UWORD *pens,
  73                              WORD left, WORD top, WORD width, WORD height,
  74                              struct IntuitionBase *IntuitionBase);
  75
  76 #undef IntuitionBase
  77 #define IntuitionBase   ((struct IntuitionBase *)(cl->cl_UserData))
  78
  79
  80 /**************************************************************************************************/
  81
  82 #define SYSIFLG_GADTOOLS 1
  83 #define SYSIFLG_NOBORDER 2
  84
  85 /**************************************************************************************************/
  86
  87 /* Some handy drawing functions */
  88
  89 void draw_thick_line(Class *cl, struct RastPort *rport,
  90                      LONG x1, LONG y1, LONG x2, LONG y2,
  91                      UWORD thickness)
  92 {
  93     Move(rport, x1, y1);
  94     Draw(rport, x2, y2);
  95     /* Georg Steger */
  96     Move(rport, x1 + 1, y1);
  97     Draw(rport, x2 + 1, y2);
  98 }
  99
 100 /**************************************************************************************************/
 101
 102 BOOL sysi_setnew(Class *cl, Object *obj, struct opSet *msg)
 103 {
 104     struct SysIData     *data = INST_DATA(cl, obj);
 105     struct TagItem      *taglist, *tag;
 106     struct TextFont     *reffont = NULL;
 107     int                  size = SYSISIZE_MEDRES;
 108     BOOL                 unsupported = FALSE;
 109     BOOL                 set_width = FALSE, set_height = FALSE;
 110
 111     taglist = msg->ops_AttrList;
 112     while ((tag = NextTagItem((const struct TagItem **)&taglist)))
 113     {
 114         switch(tag->ti_Tag)
 115         {
 116             case IA_Width:
 117                 set_width = TRUE;
 118                 break;
 119
 120             case IA_Height:
 121                 set_height = TRUE;
 122                 break;
 123
 124             case SYSIA_DrawInfo:
 125                 data->dri = (struct DrawInfo *)tag->ti_Data;
 126                 reffont = data->dri->dri_Font;
 127                 break;
 128
 129             case SYSIA_Which:
 130                 data->type = tag->ti_Data;
 131
 132                 D(bug("SYSIA_Which type: %d\n", data->type));
 133
 134                 switch (tag->ti_Data)
 135                 {
 136                     #warning "if IA_Width, IA_Height was not specified sysiclass should choose size depending on drawinfo (screen resolution)"
 137
 138                     case LEFTIMAGE:
 139                     case UPIMAGE:
 140                     case RIGHTIMAGE:
 141                     case DOWNIMAGE:
 142                     case CHECKIMAGE:
 143                     case MXIMAGE:
 144                     case DEPTHIMAGE:
 145                     case SDEPTHIMAGE:
 146                     case ZOOMIMAGE:
 147                     case CLOSEIMAGE:
 148                     case SIZEIMAGE:
 149                     case MENUCHECK:
 150                     case AMIGAKEY:
 151                     case ICONIFYIMAGE:
 152                     case LOCKIMAGE:
 153                     case JUMPIMAGE:
 154                     case MUIIMAGE:
 155                     case POPUPIMAGE:
 156                     case SNAPSHOTIMAGE:
 157                         break;
 158
 159                     default:
 160                         unsupported = TRUE;
 161                         break;
 162                 }
 163                 break;
 164
 165             case SYSIA_ReferenceFont:
 166                 if (tag->ti_Data) reffont = (struct TextFont *)tag->ti_Data;
 167                 break;
 168
 169             case SYSIA_Size:
 170                 size = tag->ti_Data;
 171                 break;
 172
 173                 /* private tags */
 174
 175             case SYSIA_WithBorder:
 176                 if (tag->ti_Data == FALSE)
 177                 {
 178                     data->flags |= SYSIFLG_NOBORDER;
 179                 }
 180                 break;
 181
 182             case SYSIA_Style:
 183                 if (tag->ti_Data == SYSISTYLE_GADTOOLS)
 184                 {
 185                     data->flags |= SYSIFLG_GADTOOLS;
 186                 }
 187                 break;
 188
 189         } /* switch(tag->ti_Tag) */
 190
 191     } /* while ((tag = NextTagItem(&taglist))) */
 192
 193     D(bug("dri: %p, unsupported: %d\n", data->dri, unsupported));
 194
 195     if ((!data->dri) || (unsupported))
 196         return FALSE;
 197
 198     {
 199         struct wdpGetDefSizeSysImage  msg;
 200         ULONG                         width = DEFSIZE_WIDTH, height = DEFSIZE_HEIGHT;
 201
 202         msg.MethodID            = (data->type == SDEPTHIMAGE) ? SDM_GETDEFSIZE_SYSIMAGE :
 203                                                                 WDM_GETDEFSIZE_SYSIMAGE;
 204         msg.wdp_Which           = data->type;
 205         msg.wdp_SysiSize        = size;
 206         msg.wdp_ReferenceFont   = reffont;
 207         msg.wdp_Width           = &width;
 208         msg.wdp_Height          = &height;
 209         msg.wdp_Flags           = 0;
 210
 211         if (data->type == SDEPTHIMAGE)
 212         {
 213             LOCKSHARED_SCRDECOR(data->dri);
 214             DoMethodA(INTDRI(data->dri)->dri_ScrDecorObj, (Msg)&msg);
 215             UNLOCK_SCRDECOR(data->dri);
 216         }
 217         else
 218         {
 219             LOCKSHARED_WINDECOR(data->dri);
 220             DoMethodA(INTDRI(data->dri)->dri_WinDecorObj, (Msg)&msg);
 221             UNLOCK_WINDECOR(data->dri);
 222         }
 223
 224         if (!set_width) IM(obj)->Width = width;
 225         if (!set_height) IM(obj)->Height = height;
 226     }
 227
 228     return TRUE;
 229 }
 230
 231 /**************************************************************************************************/
 232
 233 Object *SysIClass__OM_NEW(Class *cl, Class *rootcl, struct opSet *msg)
 234 {
 235     struct SysIData *data;
 236     Object          *obj;
 237
 238     D(bug("sysi_new()\n"));
 239     obj = (Object *)DoSuperMethodA(cl, (Object *)rootcl, (Msg)msg);
 240     if (!obj)
 241         return NULL;
 242
 243     D(bug("sysi_new,: obj=%p\n", obj));
 244
 245     data = INST_DATA(cl, obj);
 246     data->type  = 0L;
 247     data->dri   = NULL;
 248     data->frame = NULL;
 249     data->flags = 0;
 250
 251     if (!sysi_setnew(cl, obj, (struct opSet *)msg))
 252     {
 253         STACKULONG method = OM_DISPOSE;
 254         CoerceMethodA(cl, obj, (Msg)&method);
 255         return NULL;
 256     }
 257
 258     D(bug("sysi_setnew called successfully\n"));
 259
 260     switch (data->type)
 261     {
 262         case CHECKIMAGE:
 263         {
 264             struct TagItem tags[] =
 265             {
 266                 {IA_FrameType, FRAME_BUTTON },
 267                 {IA_EdgesOnly, FALSE            },
 268                 {TAG_MORE                       }
 269             };
 270
 271             tags[2].ti_Data = (IPTR)msg->ops_AttrList;
 272
 273             data->frame = NewObjectA(NULL, FRAMEICLASS, tags);
 274             if (!data->frame)
 275             {
 276                 STACKULONG method = OM_DISPOSE;
 277                 CoerceMethodA(cl, obj, (Msg)&method);
 278                 return NULL;
 279             }
 280             break;
 281         }
 282
 283             /* Just to prevent it from reaching default: */
 284         case MXIMAGE:
 285         case LEFTIMAGE:
 286         case UPIMAGE:
 287         case RIGHTIMAGE:
 288         case DOWNIMAGE:
 289
 290         case SDEPTHIMAGE:
 291         case DEPTHIMAGE:
 292         case ZOOMIMAGE:
 293         case CLOSEIMAGE:
 294         case SIZEIMAGE:
 295
 296         case MENUCHECK:
 297         case AMIGAKEY:
 298
 299         case ICONIFYIMAGE:
 300         case LOCKIMAGE:
 301         case MUIIMAGE:
 302         case POPUPIMAGE:
 303         case SNAPSHOTIMAGE:
 304         case JUMPIMAGE:
 305             break;
 306
 307         default:
 308             {
 309                 STACKULONG method = OM_DISPOSE;
 310
 311                 CoerceMethodA(cl, obj, (Msg)&method);
 312             }
 313             return NULL;
 314     }
 315
 316     return obj;
 317 }
 318
 319 /**************************************************************************************************/
 320
 321 /* Georg Steger
 322  */
 323 #define HSPACING 3
 324 #define VSPACING 3
 325 /* Ralph Schmidt
 326  * heuristics for smaller arrows used in apps
 327  * like filer
 328  */
 329 #define HSPACING_MIDDLE 2
 330 #define VSPACING_MIDDLE 2
 331 #define HSPACING_SMALL 1
 332 #define VSPACING_SMALL 1
 333
 334 IPTR SysIClass__IM_DRAW(Class *cl, Object *obj, struct impDraw *msg)
 335 {
 336     struct SysIData         *data = INST_DATA(cl, obj);
 337     struct RastPort         *rport = msg->imp_RPort;
 338     WORD                     left = IM(obj)->LeftEdge + msg->imp_Offset.X;
 339     WORD                     top = IM(obj)->TopEdge + msg->imp_Offset.Y;
 340     UWORD                    width = IM(obj)->Width;
 341     UWORD                    height = IM(obj)->Height;
 342     WORD                     right = left + width - 1;
 343     WORD                     bottom = top + height - 1;
 344     struct wdpDrawSysImage   decormsg;
 345
 346     decormsg.MethodID  = WDM_DRAW_SYSIMAGE;
 347     decormsg.wdp_RPort = rport;
 348     decormsg.wdp_X = left;
 349     decormsg.wdp_Y = top;
 350     decormsg.wdp_Width = width;
 351     decormsg.wdp_Height = height;
 352     decormsg.wdp_Which = data->type;
 353     decormsg.wdp_State = msg->imp_State;
 354     decormsg.wdp_Flags = 0;
 355
 356     SetDrMd(rport, JAM1);
 357
 358     switch(data->type)
 359     {
 360         case CHECKIMAGE:
 361         {
 362             WORD h_spacing = width / 4;
 363             WORD v_spacing = height / 4;
 364
 365             /* Draw frame */
 366             DrawImageState(rport, data->frame,
 367                            msg->imp_Offset.X, msg->imp_Offset.Y,
 368                            IDS_NORMAL, data->dri);
 369
 370             /* Draw checkmark (only if image is in selected state) */
 371             if (msg->imp_State == IDS_SELECTED)
 372             {
 373                 left += h_spacing;
 374                 right -= h_spacing;
 375                 width -= h_spacing * 2;
 376                 top += v_spacing;
 377                 bottom -= v_spacing;
 378                 height -= v_spacing * 2;
 379
 380                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 381                 draw_thick_line(cl, rport, left, top + height / 3 , left, bottom, 0);
 382                 draw_thick_line(cl, rport, left + 1, bottom, right - 1, top, 0);
 383             }
 384             break;
 385         }
 386
 387         case MXIMAGE:
 388         {
 389             BOOL selected = FALSE;
 390             WORD col1 = SHINEPEN;
 391             WORD col2 = SHADOWPEN;
 392
 393             if ((msg->imp_State == IDS_SELECTED) || (msg->imp_State == IDS_INACTIVESELECTED))
 394             {
 395                 col1 = SHADOWPEN;
 396                 col2 = SHINEPEN;
 397                 selected = TRUE;
 398             }
 399
 400             SetAPen(rport, data->dri->dri_Pens[BACKGROUNDPEN]);
 401             RectFill(rport, left, top, right, bottom);
 402
 403         #if 0
 404             /* THICK MX IMAGE */
 405
 406             SetAPen(rport, data->dri->dri_Pens[col1]);
 407             RectFill(rport, left + 2, top, right - 3, top + 1);
 408             RectFill(rport, left + 1, top + 2, left + 2, top + 3);
 409             RectFill(rport, left, top + 4, left + 1, bottom - 4);
 410             RectFill(rport, left + 1, bottom - 3, left + 2, bottom - 2);
 411             RectFill(rport, left + 2, bottom - 1, left + 2, bottom);
 412
 413             SetAPen(rport, data->dri->dri_Pens[col2]);
 414             RectFill(rport, right - 2, top, right - 2, top + 1);
 415             RectFill(rport, right - 2, top + 2, right - 1, top + 3);
 416             RectFill(rport, right - 1, top + 4, right, bottom - 4);
 417             RectFill(rport, right - 2, bottom - 3, right - 1, bottom - 2);
 418             RectFill(rport, left + 3, bottom - 1, right - 2, bottom);
 419
 420             if (selected)
 421             {
 422                 left += 4;
 423                 right -= 4;
 424                 width -= 8;
 425                 top += 4;
 426                 bottom -= 4;
 427                 height -= 8;
 428
 429                 SetAPen(rport, data->dri->dri_Pens[FILLPEN]);
 430                 if ((width >= 3) && (height >= 3))
 431                 {
 432                     RectFill(rport, left + 1, top, right - 1, top);
 433                     RectFill(rport, left, top + 1, right, bottom - 1);
 434                     RectFill(rport, left + 1, bottom, right - 1, bottom);
 435                 }
 436                 else
 437                 {
 438                     RectFill(rport, left, top, right, bottom);
 439                 }
 440             }
 441         #else
 442             /* THIN MX IMAGE */
 443
 444             SetAPen(rport, data->dri->dri_Pens[col1]);
 445             RectFill(rport, left + 3, top, right - 3, top);
 446             WritePixel(rport, left + 2, top + 1);
 447             RectFill(rport, left + 1, top + 2, left + 1, top + 3);
 448             RectFill(rport, left, top + 4, left, bottom - 4);
 449             RectFill(rport, left + 1, bottom - 3, left + 1, bottom - 2);
 450             WritePixel(rport, left + 2, bottom - 1);
 451
 452             SetAPen(rport, data->dri->dri_Pens[col2]);
 453             WritePixel(rport, right - 2, top + 1);
 454             RectFill(rport, right - 1, top + 2, right - 1, top + 3);
 455             RectFill(rport, right, top + 4, right, bottom - 4);
 456             RectFill(rport, right - 1, bottom - 3, right - 1, bottom - 2);
 457             WritePixel(rport, right - 2, bottom - 1);
 458             RectFill(rport, left + 3, bottom, right - 3, bottom);
 459
 460             if (selected)
 461             {
 462                 left += 3;
 463                 right -= 3;
 464                 width -= 6;
 465                 top += 3;
 466                 bottom -= 3;
 467                 height -= 6;
 468
 469                 SetAPen(rport, data->dri->dri_Pens[FILLPEN]);
 470                 if ((width >= 5) && (height >= 5))
 471                 {
 472                     RectFill(rport, left, top + 2, left, bottom - 2);
 473                     RectFill(rport, left + 1, top + 1, left + 1, bottom - 1);
 474                     RectFill(rport, left + 2, top, right - 2, bottom);
 475                     RectFill(rport, right - 1, top + 1, right - 1, bottom - 1);
 476                     RectFill(rport, right, top + 2, right, bottom - 2);
 477                 }
 478                 else
 479                 {
 480                     RectFill(rport, left, top, right, bottom);
 481                 }
 482             }
 483
 484         #endif
 485             break;
 486         }
 487
 488         case LEFTIMAGE:
 489         {
 490             UWORD hspacing,vspacing;
 491             WORD  cy;
 492
 493             if (!(data->flags & (SYSIFLG_NOBORDER | SYSIFLG_GADTOOLS)))
 494             {
 495                 LOCKSHARED_WINDECOR(data->dri)
 496                 DoMethodA(INTDRI(data->dri)->dri_WinDecorObj, (Msg)&decormsg);
 497                 UNLOCK_WINDECOR(data->dri)
 498                 break;
 499             }
 500
 501             hspacing = HSPACING;
 502             vspacing = VSPACING;
 503
 504             if (width <= 12)
 505             {
 506                 hspacing = HSPACING_MIDDLE;
 507             }
 508
 509             if (width <= 10)
 510             {
 511                 hspacing = HSPACING_SMALL;
 512             }
 513
 514             if (height <= 12)
 515             {
 516                 vspacing = VSPACING_MIDDLE;
 517             }
 518
 519             if (height <= 10)
 520             {
 521                 vspacing = VSPACING_SMALL;
 522             }
 523
 524             if (!(data->flags & SYSIFLG_NOBORDER))
 525             {
 526                 renderimageframe(rport, LEFTIMAGE, msg->imp_State, data->dri->dri_Pens,
 527                                  left, top, width, height, IntuitionBase);
 528                 left++;
 529                 top++;
 530                 right--;
 531                 bottom--;
 532                 width -= 2;
 533                 height -= 2;
 534
 535                 if (data->flags & SYSIFLG_GADTOOLS)
 536                 {
 537                     SetAPen(rport, getbgpen_gt(msg->imp_State, data->dri->dri_Pens));
 538                     RectFill(rport, left, top, right, bottom);
 539                 }
 540             }
 541
 542             if (data->flags & SYSIFLG_GADTOOLS)
 543             {
 544                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 545
 546                 cy = height / 2;
 547
 548                 Move(rport, left + width - 1 - hspacing, top + vspacing + 1);
 549                 Draw(rport, left + hspacing, top + height - cy);
 550                 Move(rport, left + width - 1 - hspacing, top + vspacing);
 551                 Draw(rport, left + hspacing, top + height - cy - 1);
 552
 553                 Move(rport, left + width - 1 - hspacing, top + height - 1- vspacing - 1);
 554                 Draw(rport, left + hspacing, top + cy - 1);
 555                 Move(rport, left + width - 1 - hspacing, top + height - 1 - vspacing);
 556                 Draw(rport, left + hspacing, top + cy);
 557             }
 558             else
 559             {
 560                 WORD i;
 561
 562                 SetAPen(rport, getbgpen(msg->imp_State, data->dri->dri_Pens));
 563
 564                 RectFill(rport, left, top, right, bottom);
 565
 566                 left += hspacing;
 567                 top += vspacing;
 568                 width -= hspacing * 2;
 569                 height -= vspacing * 2;
 570
 571                 right = left + width - 1;
 572                 bottom = top + height - 1;
 573
 574                 cy = (height + 1) / 2;
 575
 576                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 577
 578                 for(i = 0; i < cy; i++)
 579                 {
 580                     RectFill(rport, left + (cy - i - 1) * width / cy,
 581                              top + i,
 582                              right - i * width / cy / 2,
 583                              top + i);
 584                     RectFill(rport, left + (cy - i - 1) * width / cy,
 585                              bottom - i,
 586                              right - i * width / cy / 2,
 587                              bottom - i);
 588                 }
 589
 590             }
 591             break;
 592         }
 593
 594         case UPIMAGE:
 595         {
 596             UWORD hspacing,vspacing;
 597             WORD  cx;
 598
 599             if (!(data->flags & (SYSIFLG_NOBORDER | SYSIFLG_GADTOOLS)))
 600             {
 601                 LOCKSHARED_WINDECOR(data->dri)
 602                 DoMethodA(INTDRI(data->dri)->dri_WinDecorObj, (Msg)&decormsg);
 603                 UNLOCK_WINDECOR(data->dri)
 604                 break;
 605             }
 606
 607             hspacing = HSPACING;
 608             vspacing = VSPACING;
 609
 610             if (width <= 12)
 611             {
 612                 hspacing = HSPACING_MIDDLE;
 613             }
 614
 615             if (width <= 10)
 616             {
 617                 hspacing = HSPACING_SMALL;
 618             }
 619
 620             if (height <= 12)
 621             {
 622                 vspacing = VSPACING_MIDDLE;
 623             }
 624
 625             if (height <= 10)
 626             {
 627                 vspacing = VSPACING_SMALL;
 628             }
 629
 630             if (!(data->flags & SYSIFLG_NOBORDER))
 631             {
 632                 renderimageframe(rport, UPIMAGE, msg->imp_State, data->dri->dri_Pens,
 633                                  left, top, width, height, IntuitionBase);
 634                 left++;
 635                 top++;
 636                 right--;
 637                 bottom--;
 638                 width -= 2;
 639                 height -= 2;
 640
 641                 if (data->flags & SYSIFLG_GADTOOLS)
 642                 {
 643                     SetAPen(rport, getbgpen_gt(msg->imp_State, data->dri->dri_Pens));
 644                     RectFill(rport, left, top, right, bottom);
 645                 }
 646
 647             }
 648
 649             if (data->flags & SYSIFLG_GADTOOLS)
 650             {
 651                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 652
 653                 cx = width / 2;
 654
 655                 Move(rport, left + hspacing + 1, top + height - 1 - vspacing);
 656                 Draw(rport, left + width - cx, top + vspacing);
 657                 Move(rport, left + hspacing, top + height - 1 - vspacing);
 658                 Draw(rport, left + width - cx - 1, top + vspacing);
 659
 660                 Move(rport, left + width - 1 - hspacing - 1, top + height - 1 - vspacing);
 661                 Draw(rport, left + cx - 1, top + vspacing);
 662                 Move(rport, left + width - 1 - hspacing, top + height - 1 - vspacing);
 663                 Draw(rport, left + cx, top + vspacing);
 664             }
 665             else
 666             {
 667                 WORD i;
 668
 669                 SetAPen(rport, getbgpen(msg->imp_State, data->dri->dri_Pens));
 670
 671                 RectFill(rport, left, top, right, bottom);
 672
 673                 left += hspacing;
 674                 top += vspacing;
 675                 width -= hspacing * 2;
 676                 height -= vspacing * 2;
 677
 678                 right = left + width - 1;
 679                 bottom = top + height - 1;
 680
 681                 cx = (width + 1) / 2;
 682
 683                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 684
 685                 for(i = 0; i < cx; i++)
 686                 {
 687                     RectFill(rport, left + i,
 688                              top + (cx - i - 1) * height / cx,
 689                              left + i,
 690                              bottom - i * height / cx / 2);
 691                     RectFill(rport, right - i,
 692                              top + (cx - i - 1) * height / cx,
 693                              right - i,
 694                              bottom - i * height / cx / 2);
 695                 }
 696
 697             }
 698             break;
 699         }
 700
 701         case RIGHTIMAGE:
 702         {
 703             UWORD hspacing,vspacing;
 704             WORD  cy;
 705
 706             if (!(data->flags & (SYSIFLG_NOBORDER | SYSIFLG_GADTOOLS)))
 707             {
 708                 LOCKSHARED_WINDECOR(data->dri)
 709                 DoMethodA(INTDRI(data->dri)->dri_WinDecorObj, (Msg)&decormsg);
 710                 UNLOCK_WINDECOR(data->dri)
 711                 break;
 712             }
 713
 714             hspacing = HSPACING;
 715             vspacing = VSPACING;
 716
 717             if (width <= 12)
 718             {
 719                 hspacing = HSPACING_MIDDLE;
 720             }
 721
 722             if (width <= 10)
 723             {
 724                 hspacing = HSPACING_SMALL;
 725             }
 726
 727             if (height <= 12)
 728             {
 729                 vspacing = VSPACING_MIDDLE;
 730             }
 731
 732             if (height <= 10)
 733             {
 734                 vspacing = VSPACING_SMALL;
 735             }
 736
 737             if (!(data->flags & SYSIFLG_NOBORDER))
 738             {
 739                 renderimageframe(rport, RIGHTIMAGE, msg->imp_State, data->dri->dri_Pens,
 740                                  left, top, width, height, IntuitionBase);
 741                 left++;
 742                 top++;
 743                 right--;
 744                 bottom--;
 745                 width -= 2;
 746                 height -= 2;
 747
 748                 if (data->flags & SYSIFLG_GADTOOLS)
 749                 {
 750                     SetAPen(rport, getbgpen_gt(msg->imp_State, data->dri->dri_Pens));
 751                     RectFill(rport, left, top, right, bottom);
 752                 }
 753
 754             }
 755
 756             if (data->flags & SYSIFLG_GADTOOLS)
 757             {
 758                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 759
 760                 cy = height / 2;
 761
 762                 Move(rport, left + hspacing, top + vspacing + 1);
 763                 Draw(rport, left + width - 1 - hspacing, top + height - cy);
 764                 Move(rport, left + hspacing, top + vspacing);
 765                 Draw(rport, left + width - 1 - hspacing, top + height - cy - 1);
 766
 767                 Move(rport, left + hspacing, top + height - 1- vspacing - 1);
 768                 Draw(rport, left + width - 1 - hspacing, top + cy - 1);
 769                 Move(rport, left + hspacing, top + height - 1 - vspacing);
 770                 Draw(rport, left + width - 1 - hspacing, top + cy);
 771
 772             }
 773             else
 774             {
 775                 WORD i;
 776
 777                 SetAPen(rport, getbgpen(msg->imp_State, data->dri->dri_Pens));
 778
 779                 RectFill(rport, left, top, right, bottom);
 780
 781                 left += hspacing;
 782                 top += vspacing;
 783                 width -= hspacing * 2;
 784                 height -= vspacing * 2;
 785
 786                 right = left + width - 1;
 787                 bottom = top + height - 1;
 788
 789                 cy = (height + 1) / 2;
 790
 791                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 792
 793                 for(i = 0; i < cy; i++)
 794                 {
 795                     RectFill(rport, left + i * width / cy / 2,
 796                              top + i,
 797                              right - (cy - i - 1) * width / cy,
 798                              top + i);
 799                     RectFill(rport, left + i * width / cy / 2,
 800                              bottom - i,
 801                              right - (cy - i - 1) * width / cy,
 802                              bottom - i);
 803                 }
 804
 805             }
 806             break;
 807         }
 808
 809         case DOWNIMAGE:
 810         {
 811             UWORD hspacing,vspacing;
 812             WORD  cx;
 813
 814             if (!(data->flags & (SYSIFLG_NOBORDER | SYSIFLG_GADTOOLS)))
 815             {
 816                 LOCKSHARED_WINDECOR(data->dri)
 817                 DoMethodA(INTDRI(data->dri)->dri_WinDecorObj, (Msg)&decormsg);
 818                 UNLOCK_WINDECOR(data->dri)
 819                 break;
 820             }
 821
 822             hspacing = HSPACING;
 823             vspacing = VSPACING;
 824
 825             if (width <= 12)
 826             {
 827                 hspacing = HSPACING_MIDDLE;
 828             }
 829
 830             if (width <= 10)
 831             {
 832                 hspacing = HSPACING_SMALL;
 833             }
 834
 835             if (height <= 12)
 836             {
 837                 vspacing = VSPACING_MIDDLE;
 838             }
 839
 840             if (height <= 10)
 841             {
 842                 vspacing = VSPACING_SMALL;
 843             }
 844
 845             if (!(data->flags & SYSIFLG_NOBORDER))
 846             {
 847                 renderimageframe(rport, DOWNIMAGE, msg->imp_State, data->dri->dri_Pens,
 848                                  left, top, width, height, IntuitionBase);
 849                 left++;
 850                 top++;
 851                 right--;
 852                 bottom--;
 853                 width -= 2;
 854                 height -= 2;
 855
 856                 if (data->flags & SYSIFLG_GADTOOLS)
 857                 {
 858                     SetAPen(rport, getbgpen_gt(msg->imp_State, data->dri->dri_Pens));
 859                     RectFill(rport, left, top, right, bottom);
 860                 }
 861             }
 862
 863             if (data->flags & SYSIFLG_GADTOOLS)
 864             {
 865                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 866
 867                 cx = width / 2;
 868
 869                 Move(rport, left + hspacing + 1, top + vspacing);
 870                 Draw(rport, left + width - cx, top + height - 1 - vspacing);
 871                 Move(rport, left + hspacing, top + vspacing);
 872                 Draw(rport, left + width - cx - 1, top + height - 1 - vspacing);
 873
 874                 Move(rport, left + width - 1 - hspacing - 1, top + vspacing);
 875                 Draw(rport, left + cx - 1, top + height - 1 - vspacing);
 876                 Move(rport, left + width - 1 - hspacing, top + vspacing);
 877                 Draw(rport, left + cx, top + height - 1 - vspacing);
 878             }
 879             else
 880             {
 881                 WORD i;
 882
 883                 SetAPen(rport, getbgpen(msg->imp_State, data->dri->dri_Pens));
 884
 885                 RectFill(rport, left, top, right, bottom);
 886
 887                 left += hspacing;
 888                 top += vspacing;
 889                 width -= hspacing * 2;
 890                 height -= vspacing * 2;
 891
 892                 right = left + width - 1;
 893                 bottom = top + height - 1;
 894
 895                 cx = (width + 1) / 2;
 896
 897                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 898
 899                 for(i = 0; i < cx; i++)
 900                 {
 901                     RectFill(rport, left + i,
 902                              top + i * height / cx / 2,
 903                              left + i,
 904                              bottom - (cx - i - 1) * height / cx);
 905                     RectFill(rport, right - i,
 906                              top + i * height / cx / 2,
 907                              right -  i,
 908                              bottom - (cx - i - 1) * height / cx);
 909
 910                 }
 911
 912             }
 913             break;
 914         }
 915
 916         case CLOSEIMAGE:
 917         case ZOOMIMAGE:
 918         case DEPTHIMAGE:
 919         case SIZEIMAGE:
 920         {
 921             LOCKSHARED_WINDECOR(data->dri)
 922             DoMethodA(INTDRI(data->dri)->dri_WinDecorObj, (Msg)&decormsg);
 923             UNLOCK_WINDECOR(data->dri)
 924             break;
 925         }
 926
 927         case SDEPTHIMAGE:
 928         {
 929             decormsg.MethodID  = SDM_DRAW_SYSIMAGE;
 930
 931             LOCKSHARED_SCRDECOR(data->dri)
 932             DoMethodA(INTDRI(data->dri)->dri_ScrDecorObj, (Msg)&decormsg);
 933             UNLOCK_SCRDECOR(data->dri)
 934             break;
 935         }
 936
 937         case MENUCHECK:
 938         {
 939             UWORD *pens = data->dri->dri_Pens;
 940
 941             if (MENUS_AMIGALOOK)
 942             {
 943                 SetAPen(rport, pens[BARBLOCKPEN]);
 944             }
 945             else
 946             {
 947                 SetAPen(rport, pens[(msg->imp_State == IDS_SELECTED) ? FILLPEN : BACKGROUNDPEN]);
 948             }
 949
 950             RectFill(rport, left, top, right, bottom);
 951
 952             SetAPen(rport, pens[BARDETAILPEN]);
 953             draw_thick_line(cl, rport, left + 1, top + height / 3 , left + 1, bottom, 0);
 954             draw_thick_line(cl, rport, left + 2, bottom, right - 2, top, 0);
 955
 956             break;
 957         }
 958
 959         case AMIGAKEY:
 960         {
 961             UWORD           *pens = data->dri->dri_Pens;
 962             struct TextFont *oldfont;
 963             UBYTE            oldstyle;
 964
 965             if (MENUS_AMIGALOOK)
 966             {
 967                 SetAPen(rport, pens[BARDETAILPEN]);
 968             }
 969             else
 970             {
 971                 SetAPen(rport, pens[SHINEPEN]);
 972             }
 973
 974             RectFill(rport, left, top, right, bottom);
 975
 976             if (MENUS_AMIGALOOK)
 977             {
 978                 SetAPen(rport, pens[BARBLOCKPEN]);
 979
 980                 oldfont = rport->Font;
 981                 oldstyle = rport->AlgoStyle;
 982
 983                 SetFont(rport, GfxBase->DefaultFont);
 984                 SetSoftStyle(rport, FSF_ITALIC, AskSoftStyle(rport));
 985
 986                 Move(rport, left + (width - rport->TxWidth) / 2,
 987                      top  + (height - rport->TxHeight) / 2 + rport->TxBaseline);
 988                 Text(rport, "A", 1);
 989
 990                 SetSoftStyle(rport, oldstyle, AskSoftStyle(rport));
 991                 SetFont(rport, oldfont);
 992
 993                 SetAPen(rport, pens[BARBLOCKPEN]);
 994             }
 995             else
 996             {
 997                 SetAPen(rport, pens[SHADOWPEN]);
 998
 999                 RectFill(rport, left + 1, top, right - 1, top);
1000                 RectFill(rport, right, top + 1, right, bottom - 1);
1001                 RectFill(rport, left + 1, bottom, right - 1, bottom);
1002                 RectFill(rport, left, top + 1, left, bottom - 1);
1003
1004                 SetAPen(rport, pens[BACKGROUNDPEN]);
1005                 RectFill(rport, left + 1, bottom - 1, right - 1, bottom - 1);
1006                 RectFill(rport, right - 1, top + 1, right - 1, bottom - 2);
1007
1008                 RectFill(rport, left + 2, top + 2, left + 4, top + 2);
1009                 RectFill(rport, left + 2, top + 3, left + 2, top + 4);
1010
1011                 SetAPen(rport, pens[SHADOWPEN]);
1012                 RectFill(rport, left + 2, bottom - 2, right - 2, bottom - 2);
1013                 RectFill(rport, right - 2, top + 2, right - 2, bottom - 4);
1014
1015                 {
1016                     WORD a_size   = height - 7;
1017                     WORD a_left   = left + 5;
1018                     WORD a_top    = top + 2;
1019                     WORD a_right  = a_left + a_size;
1020                     WORD a_bottom = a_top + a_size;
1021
1022                     Move(rport, a_left, a_bottom);
1023                     Draw(rport, a_right, a_top);
1024                     Draw(rport, a_right, a_bottom);
1025                     Move(rport, a_right - 1, a_top + 1);
1026                     Draw(rport, a_right - 1, a_bottom);
1027                 }
1028
1029                 SetAPen(rport, pens[(msg->imp_State == IDS_SELECTED) ? FILLPEN : BACKGROUNDPEN]);
1030             }
1031
1032             WritePixel(rport, left, top);
1033             WritePixel(rport, right, top);
1034             WritePixel(rport, right, bottom);
1035             WritePixel(rport, left, bottom);
1036
1037             break;
1038         }
1039
1040         /* MUI and other non-std images */
1041     #if 0
1042         case MUIIMAGE:
1043         {
1044             UWORD *pens = data->dri->dri_Pens;
1045             UWORD bg;
1046
1047             if (!(data->flags & SYSIFLG_NOBORDER))
1048             {
1049                 renderimageframe(rport, SIZEIMAGE, msg->imp_State, pens,
1050                                  left, top, width, height, IntuitionBase);
1051                 left++;
1052                 top++;
1053                 right--;
1054                 bottom--;
1055                 width -= 2;
1056                 height -= 2;
1057             }
1058
1059             bg = getbgpen(msg->imp_State, pens);
1060
1061             /* Clear background into correct color */
1062             SetAPen(rport, bg);
1063             RectFill(rport, left, top, right, bottom);
1064
1065             /* DRAW IMAGE :) */
1066
1067             DrawIB(rport,(BYTE *)ibPrefs,left+(width/2),top+(height/2),IntuitionBase);
1068
1069             break;
1070         }
1071
1072         case SNAPSHOTIMAGE:
1073         case POPUPIMAGE:
1074         case ICONIFYIMAGE:
1075         case LOCKIMAGE:
1076         {
1077             UWORD *pens = data->dri->dri_Pens;
1078             UWORD  bg;
1079
1080             if (!(data->flags & SYSIFLG_NOBORDER))
1081             {
1082                 renderimageframe(rport, SIZEIMAGE, msg->imp_State, pens,
1083                                  left, top, width, height, IntuitionBase);
1084                 left++;
1085                 top++;
1086                 right--;
1087                 bottom--;
1088                 width -= 2;
1089                 height -= 2;
1090             }
1091
1092             bg = getbgpen(msg->imp_State, pens);
1093
1094             /* Clear background into correct color */
1095             SetAPen(rport, bg);
1096             RectFill(rport, left, top, right, bottom);
1097
1098             /* DRAW IMAGE :) */
1099
1100             if (data->type == SNAPSHOTIMAGE)
1101             {
1102                 if (msg->imp_State == IDS_SELECTED)
1103                 {
1104                     DrawIB(rport,(BYTE *)ibSnapshotSel,left+(width/2),top+(height/2),IntuitionBase);
1105                 }
1106                 else
1107                 {
1108                     DrawIB(rport,(BYTE *)ibSnapshot,left+(width/2),top+(height/2),IntuitionBase);
1109                 }
1110             }
1111
1112             if (data->type == POPUPIMAGE)
1113             {
1114                 if (msg->imp_State == IDS_SELECTED)
1115                 {
1116                     DrawIB(rport,(BYTE *)ibPopupSel,left+(width/2),top+(height/2),IntuitionBase);
1117                 }
1118                 else
1119                 {
1120                     DrawIB(rport,(BYTE *)ibPopup,left+(width/2),top+(height/2),IntuitionBase);
1121                 }
1122             }
1123
1124             if (data->type == ICONIFYIMAGE)
1125             {
1126                 if (msg->imp_State == IDS_SELECTED)
1127                 {
1128                     DrawIB(rport,(BYTE *)ibIconifySel,left+(width/2),top+(height/2),IntuitionBase);
1129                 }
1130                 else
1131                 {
1132                     DrawIB(rport,(BYTE *)ibIconify,left+(width/2),top+(height/2),IntuitionBase);
1133                 }
1134             }
1135
1136             if (data->type == LOCKIMAGE)
1137             {
1138                 if ((msg->imp_State == IDS_SELECTED) || (msg->imp_State == IDS_INACTIVESELECTED))
1139                 {
1140                     DrawIB(rport,(BYTE *)ibLockSel,left+(width/2),top+(height/2),IntuitionBase);
1141                 }
1142                 else
1143                 {
1144                     DrawIB(rport,(BYTE *)ibLock,left+(width/2),top+(height/2),IntuitionBase);
1145                 }
1146             }
1147
1148             break;
1149         }
1150
1151         case JUMPIMAGE:
1152         {
1153             UWORD *pens = data->dri->dri_Pens;
1154             UWORD  bg;
1155
1156             if (!(data->flags & SYSIFLG_NOBORDER))
1157             {
1158                 renderimageframe(rport, SIZEIMAGE, msg->imp_State, pens,
1159                                  left, top, width, height, IntuitionBase);
1160                 left++;
1161                 top++;
1162                 right--;
1163                 bottom--;
1164                 width -= 2;
1165                 height -= 2;
1166             }
1167
1168             bg = getbgpen(msg->imp_State, pens);
1169
1170             /* Clear background into correct color */
1171             SetAPen(rport, bg);
1172             RectFill(rport, left, top, right, bottom);
1173
1174             /* DRAW IMAGE :) */
1175
1176             DrawJUMP(rport,msg->imp_State,left+(width/2),top+(height/2),IntuitionBase);
1177
1178             break;
1179         }
1180     #endif
1181     } /* switch (image type) */
1182
1183     return (IPTR)0;
1184 }
1185
1186 IPTR SysIClass__OM_DISPOSE(Class *cl, Object *obj, Msg msg)
1187 {
1188     struct SysIData *data = INST_DATA(cl, obj);
1189
1190     DisposeObject(data->frame);
1191     return DoSuperMethodA(cl, obj, msg);
1192 }
1193
1194 IPTR SysIClass__OM_SET(Class *cl, Object *obj, Msg msg)
1195 {
1196     struct SysIData *data = INST_DATA(cl, obj);
1197
1198     if (data->frame)
1199         DoMethodA((Object *)data->frame, msg);
1200     return DoSuperMethodA(cl, obj, msg);
1201 }
1202
1203 /**************************************************************************************************/
1204
1205 #undef IntuitionBase
1206
1207 /**************************************************************************************************/
1208
1209 static UWORD getbgpen(ULONG state, UWORD *pens)
1210 {
1211     UWORD bg;
1212
1213     switch (state)
1214     {
1215         case IDS_NORMAL:
1216         case IDS_SELECTED:
1217             bg = pens[FILLPEN];
1218             break;
1219
1220         default:
1221             bg = pens[BACKGROUNDPEN];
1222             break;
1223     }
1224
1225     return bg;
1226 }
1227
1228 /**************************************************************************************************/
1229
1230 static UWORD getbgpen_gt(ULONG state, UWORD *pens)
1231 {
1232     UWORD bg;
1233
1234     switch (state)
1235     {
1236         case IDS_SELECTED:
1237         case IDS_INACTIVESELECTED:
1238             bg = pens[FILLPEN];
1239             break;
1240
1241         default:
1242             bg = pens[BACKGROUNDPEN];
1243             break;
1244     }
1245
1246     return bg;
1247 }
1248
1249 /**************************************************************************************************/
1250
1251 static void renderimageframe(struct RastPort *rp, ULONG which, ULONG state, UWORD *pens,
1252                              WORD left, WORD top, WORD width, WORD height,
1253                              struct IntuitionBase *IntuitionBase)
1254 {
1255     WORD right = left + width - 1;
1256     WORD bottom = top + height - 1;
1257     BOOL leftedgegodown = FALSE;
1258     BOOL topedgegoright = FALSE;
1259
1260     switch(which)
1261     {
1262         case CLOSEIMAGE:
1263             /* draw separator line at the right side */
1264             SetAPen(rp, pens[SHINEPEN]);
1265             RectFill(rp, right, top, right, bottom - 1);
1266             SetAPen(rp, pens[SHADOWPEN]);
1267             WritePixel(rp, right, bottom);
1268
1269             right--;
1270             break;
1271
1272         case ZOOMIMAGE:
1273         case DEPTHIMAGE:
1274         case SDEPTHIMAGE:
1275             /* draw separator line at the left side */
1276             SetAPen(rp, pens[SHINEPEN]);
1277             WritePixel(rp, left, top);
1278             SetAPen(rp, pens[SHADOWPEN]);
1279             RectFill(rp, left, top + 1, left, bottom);
1280
1281             left++;
1282             break;
1283
1284         case UPIMAGE:
1285         case DOWNIMAGE:
1286             leftedgegodown = TRUE;
1287             break;
1288
1289         case LEFTIMAGE:
1290         case RIGHTIMAGE:
1291             topedgegoright = TRUE;
1292             break;
1293     }
1294
1295     if (left == 0) leftedgegodown = TRUE;
1296     if (top == 0) topedgegoright = TRUE;
1297
1298     SetAPen(rp, pens[((state == IDS_SELECTED) || (state == IDS_INACTIVESELECTED)) ? SHADOWPEN : SHINEPEN]);
1299
1300     /* left edge */
1301     RectFill(rp, left,
1302              top,
1303              left,
1304              bottom - (leftedgegodown ? 0 : 1));
1305
1306     /* top edge */
1307     RectFill(rp, left + 1,
1308              top,
1309              right - (topedgegoright ? 0 : 1),
1310              top);
1311
1312     SetAPen(rp, pens[((state == IDS_SELECTED) || (state == IDS_INACTIVESELECTED)) ? SHINEPEN : SHADOWPEN]);
1313
1314     /* right edge */
1315     RectFill(rp, right,
1316              top + (topedgegoright ? 1 : 0),
1317              right,
1318              bottom);
1319
1320     /* bottom edge */
1321     RectFill(rp, left + (leftedgegodown ? 1 : 0),
1322              bottom,
1323              right - 1,
1324              bottom);
1325 }
1326
1327 /**************************************************************************************************/