rom/intuition/sysiclass_morphos.c

   1 /*
   2     Copyright © 1995-2003, 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/intuition.h>
  17 #include <intuition/intuitionbase.h>
  18 #include <intuition/screens.h>
  19
  20 #include <proto/graphics.h>
  21 #include <proto/cybergraphics.h>
  22 #include <graphics/rastport.h>
  23 #include <cybergraphx/cybergraphics.h>
  24
  25 #include <proto/utility.h>
  26 #include <utility/tagitem.h>
  27
  28 #include <proto/alib.h>
  29
  30 #include <aros/asmcall.h>
  31 #include "intuition_intern.h"
  32 #include "intuition_customize.h"
  33 #include "intuition_extend.h"
  34 #include "renderwindowframe.h"
  35
  36 #include "gadgets.h" /* Some handy rendering funtions */
  37
  38 #include "sysiclass.h"
  39
  40 extern ULONG HookEntry();
  41
  42 #undef DEBUG
  43 #define DEBUG 0
  44 #include <aros/debug.h>
  45
  46 /**************************************************************************************************/
  47
  48 #define DEFSIZE_WIDTH  14
  49 #define DEFSIZE_HEIGHT 14
  50
  51 /**************************************************************************************************/
  52
  53 /* Some handy transparent base class object casting defines.
  54  */
  55 #define IM(o) ((struct Image *)o)
  56
  57
  58 /**************************************************************************************************/
  59
  60 #ifndef SYSIDATA
  61 struct SysIData
  62 {
  63     ULONG                type;
  64     struct IntDrawInfo  *dri;
  65     struct Image        *frame;
  66     UWORD                flags;
  67     struct Window       *window;
  68 };
  69
  70 #define SYSIFLG_GADTOOLS 1
  71 #define SYSIFLG_NOBORDER 2
  72 #define SYSIFLG_STDLOOK  16
  73 #define SYSIFLG_WINDOWOK 32
  74
  75 void renderimageframe(struct RastPort *rp, ULONG which, ULONG state, UWORD *pens,
  76                              WORD left, WORD top, WORD width, WORD height,
  77                              struct IntuitionBase *IntuitionBase);
  78 #endif
  79
  80 /**************************************************************************************************/
  81 #if 0
  82 static UWORD getbgpen(ULONG state, UWORD *pens);
  83 #endif
  84
  85 #undef IntuitionBase
  86 #define IntuitionBase   ((struct IntuitionBase *)(cl->cl_UserData))
  87
  88 /* Some handy drawing functions */
  89
  90 void draw_thick_line(Class *cl, struct RastPort *rport,
  91                      LONG x1, LONG y1, LONG x2, LONG y2,
  92                      UWORD thickness)
  93 {
  94     Move(rport, x1, y1);
  95     Draw(rport, x2, y2);
  96     /* Georg Steger */
  97     Move(rport, x1 + 1, y1);
  98     Draw(rport, x2 + 1, y2);
  99 }
 100
 101 /**************************************************************************************************/
 102
 103 BOOL sysi_setnew(Class *cl, Object *obj, struct opSet *msg)
 104 {
 105     struct SysIData *data = INST_DATA(cl, obj);
 106     struct TagItem *taglist, *tag;
 107     struct TextFont *reffont = NULL;
 108     int size = SYSISIZE_MEDRES;
 109     int def_low_width = DEFSIZE_WIDTH, def_low_height = DEFSIZE_HEIGHT;
 110     int def_med_width = DEFSIZE_WIDTH, def_med_height = DEFSIZE_HEIGHT;
 111     int def_high_width = DEFSIZE_WIDTH, def_high_height = DEFSIZE_HEIGHT;
 112     //ULONG  type = 0;
 113
 114     BOOL unsupported = FALSE;
 115     BOOL set_width = FALSE, set_height = FALSE;
 116
 117     taglist = msg->ops_AttrList;
 118     while ((tag = NextTagItem((struct TagItem **)&taglist)))
 119     {
 120         switch(tag->ti_Tag)
 121         {
 122         case IA_Width:
 123             set_width = TRUE;
 124             break;
 125
 126         case IA_Height:
 127             set_height = TRUE;
 128             break;
 129
 130         case SYSIA_DrawInfo:
 131             data->dri = (struct IntDrawInfo *)tag->ti_Data;
 132             reffont = data->dri->dri_Font;
 133             break;
 134
 135         case SYSIA_Which:
 136             data->type = tag->ti_Data;
 137
 138             D(bug("SYSIA_Which type: %d\n", data->type));
 139
 140             switch (tag->ti_Data)
 141             {
 142
 143 #warning if IA_Width, IA_Height was not specified sysiclass should choose size depending on drawinfo (screen resolution)
 144
 145             case LEFTIMAGE:
 146             case UPIMAGE:
 147             case RIGHTIMAGE:
 148             case DOWNIMAGE:
 149             case CHECKIMAGE:
 150             case MXIMAGE:
 151             case DEPTHIMAGE:
 152             case SDEPTHIMAGE:
 153             case ZOOMIMAGE:
 154             case CLOSEIMAGE:
 155             case SIZEIMAGE:
 156             case MENUCHECK:
 157             case AMIGAKEY:
 158             case ICONIFYIMAGE:
 159             case LOCKIMAGE:
 160             case JUMPIMAGE:
 161             case MUIIMAGE:
 162             case POPUPIMAGE:
 163             case SNAPSHOTIMAGE:
 164             case MENUTOGGLEIMAGE:
 165             case SUBMENUIMAGE:
 166                 break;
 167
 168             default:
 169                 unsupported = TRUE;
 170                 break;
 171             }
 172             break;
 173
 174         case SYSIA_ReferenceFont:
 175             if (tag->ti_Data) reffont = (struct TextFont *)tag->ti_Data;
 176             break;
 177
 178         case SYSIA_Size:
 179             size = tag->ti_Data;
 180             break;
 181
 182             /* private tags */
 183
 184         case SYSIA_WithBorder:
 185             if (!tag->ti_Data)
 186             {
 187                 data->flags |= SYSIFLG_NOBORDER;
 188             }
 189             break;
 190
 191         case SYSIA_Style:
 192             if (tag->ti_Data == SYSISTYLE_GADTOOLS)
 193             {
 194                 data->flags |= SYSIFLG_GADTOOLS;
 195             }
 196             break;
 197
 198         case IA_Window:
 199             if (tag->ti_Data)
 200             {
 201                 data->window = (struct Window *)tag->ti_Data;
 202                 data->flags |= SYSIFLG_WINDOWOK;
 203             }
 204             break;
 205
 206         } /* switch(tag->ti_Tag) */
 207
 208     } /* while ((tag = NextTagItem(&taglist))) */
 209
 210     D(bug("dri: %p, unsupported: %d\n", data->dri, unsupported));
 211
 212     if ((!data->dri) || (unsupported))
 213         return FALSE;
 214
 215     switch(data->type)
 216     {
 217     case LEFTIMAGE:
 218     case RIGHTIMAGE:
 219         def_low_width = 16;
 220         def_med_width = 16;
 221         def_high_width = 23;
 222         def_low_height = 11;
 223         def_med_height = 10;
 224         def_high_height = 22;
 225         break;
 226
 227     case UPIMAGE:
 228     case DOWNIMAGE:
 229         def_low_width = 13;
 230         def_med_width = 18;
 231         def_high_width = 23;
 232         def_low_height = 11;
 233         def_med_height = 11;
 234         def_high_height = 22;
 235         break;
 236
 237     case DEPTHIMAGE:
 238     case ZOOMIMAGE:
 239         def_low_width = 18;
 240         def_med_width = 24;
 241         def_high_width = 24;
 242         break;
 243
 244     case ICONIFYIMAGE:
 245     case LOCKIMAGE:
 246     case MUIIMAGE:
 247     case POPUPIMAGE:
 248     case SNAPSHOTIMAGE:
 249     case JUMPIMAGE:
 250         def_low_width = 18;
 251         def_med_width = 24;
 252         def_high_width = 24;
 253         break;
 254
 255     case SDEPTHIMAGE:
 256         def_low_width = 17;
 257         def_med_width = 23;
 258         def_high_width = 23;
 259         break;
 260
 261     case CLOSEIMAGE:
 262         def_low_width = 15;
 263         def_med_width = 20;
 264         def_high_width = 20;
 265
 266         break;
 267
 268     case SIZEIMAGE:
 269         def_low_width = 13;
 270         def_med_width = 18;
 271         def_high_width = 18;
 272         def_low_height = 11;
 273         def_med_height = 10;
 274         def_high_height = 10;
 275         break;
 276
 277     case MENUCHECK:
 278         //def_low_width  = reffont->tf_XSize * 3 / 2;
 279         //jDc: what's wrong with 1:1 ratio?? ;)
 280         def_low_width = reffont->tf_YSize;
 281         def_low_height = reffont->tf_YSize;
 282         size = SYSISIZE_LOWRES;
 283         break;
 284
 285     case AMIGAKEY:
 286 #if MENUS_AMIGALOOK
 287         def_low_width  = reffont->tf_XSize * 2;
 288         def_low_height = reffont->tf_YSize;
 289 #else
 290         def_low_width  = reffont->tf_XSize * 2;
 291         def_low_height = reffont->tf_YSize + 1;
 292 #endif
 293         size = SYSISIZE_LOWRES;
 294         break;
 295
 296     case MENUTOGGLEIMAGE:
 297     case SUBMENUIMAGE:
 298         def_low_width = reffont->tf_YSize;
 299         def_low_height = reffont->tf_YSize;
 300         size = SYSISIZE_LOWRES;
 301         break;
 302
 303     case MXIMAGE:
 304         /*
 305          * We really need some aspect ratio here..this sucks
 306          */
 307         def_low_width  = reffont->tf_XSize * 3 - 1;
 308         def_low_height = reffont->tf_YSize + 1;
 309         size = SYSISIZE_LOWRES;
 310         break;
 311
 312     case CHECKIMAGE:
 313         /*
 314          * We really need some aspect ratio here..this sucks
 315          */
 316         def_low_width  = 26;//reffont->tf_XSize * 2;
 317         def_low_height = reffont->tf_YSize + 3;
 318         size = SYSISIZE_LOWRES;
 319         break;
 320
 321     } /* switch(data->type) */
 322
 323     if (!set_width)
 324         IM(obj)->Width = size == SYSISIZE_LOWRES ? def_low_width :
 325                          (size == SYSISIZE_HIRES ? def_high_width : def_med_width);
 326     if (!set_height)
 327         IM(obj)->Height = size == SYSISIZE_LOWRES ? def_low_height :
 328                           (size == SYSISIZE_HIRES ? def_high_height : def_med_height);
 329
 330     sysi_skinnew(cl,obj,set_width,set_height,IntuitionBase);
 331
 332     return TRUE;
 333 }
 334
 335 /**************************************************************************************************/
 336
 337 Object *sysi_new(Class *cl, Class *rootcl, struct opSet *msg)
 338 {
 339     struct SysIData *data;
 340     Object *obj;
 341
 342     D(bug("sysi_new()\n"));
 343     obj = (Object *)DoSuperMethodA(cl, (Object *)rootcl, (Msg)msg);
 344     if (!obj)
 345         return NULL;
 346
 347     D(bug("sysi_new,: obj=%p\n", obj));
 348
 349     data = INST_DATA(cl, obj);
 350     data->type = 0;
 351     data->dri = NULL;
 352     data->frame = NULL;
 353     data->flags = 0;
 354     if (!sysi_setnew(cl, obj, (struct opSet *)msg))
 355     {
 356         ULONG method = OM_DISPOSE;
 357         CoerceMethodA(cl, obj, (Msg)&method);
 358         return NULL;
 359     }
 360
 361     D(bug("sysi_setnew called successfully\n"));
 362
 363     switch (data->type)
 364     {
 365     case CHECKIMAGE:
 366         {
 367             struct TagItem tags[] =
 368             {
 369                 {IA_FrameType, FRAME_BUTTON},
 370                 {IA_EdgesOnly, FALSE},
 371                 {TAG_MORE, 0L}
 372             };
 373
 374             tags[2].ti_Data = (IPTR)msg->ops_AttrList;
 375             data->frame = NewObjectA(NULL, FRAMEICLASS, tags);
 376             if (!data->frame)
 377             {
 378                 ULONG method = OM_DISPOSE;
 379                 CoerceMethodA(cl, obj, (Msg)&method);
 380                 return NULL;
 381             }
 382             break;
 383         }
 384
 385         /* Just to prevent it from reaching default: */
 386     case MXIMAGE:
 387     case LEFTIMAGE:
 388     case UPIMAGE:
 389     case RIGHTIMAGE:
 390     case DOWNIMAGE:
 391
 392     case SDEPTHIMAGE:
 393     case DEPTHIMAGE:
 394     case ZOOMIMAGE:
 395     case CLOSEIMAGE:
 396     case SIZEIMAGE:
 397
 398     case MENUCHECK:
 399     case AMIGAKEY:
 400
 401     case ICONIFYIMAGE:
 402     case LOCKIMAGE:
 403     case MUIIMAGE:
 404     case POPUPIMAGE:
 405     case SNAPSHOTIMAGE:
 406     case JUMPIMAGE:
 407     case MENUTOGGLEIMAGE:
 408     case SUBMENUIMAGE:
 409         break;
 410
 411     default:
 412         {
 413             ULONG method = OM_DISPOSE;
 414             CoerceMethodA(cl, obj, (Msg)&method);
 415         }
 416         return NULL;
 417     }
 418
 419     return obj;
 420 }
 421
 422 /**************************************************************************************************/
 423
 424 /* Georg Steger
 425  */
 426 #define HSPACING 3
 427 #define VSPACING 3
 428 /* Ralph Schmidt
 429  * heuristics for smaller arrows used in apps
 430  * like filer
 431  */
 432 #define HSPACING_MIDDLE 2
 433 #define VSPACING_MIDDLE 2
 434 #define HSPACING_SMALL 1
 435 #define VSPACING_SMALL 1
 436
 437 void sysi_draw(Class *cl, Object *obj, struct impDraw *msg)
 438 {
 439     struct SysIData *data = INST_DATA(cl, obj);
 440     struct RastPort *rport = msg->imp_RPort;
 441     WORD left = IM(obj)->LeftEdge + msg->imp_Offset.X;
 442     WORD top = IM(obj)->TopEdge + msg->imp_Offset.Y;
 443     UWORD width = IM(obj)->Width;
 444     UWORD height = IM(obj)->Height;
 445     WORD right = left + width - 1;
 446     WORD bottom = top + height - 1;
 447     struct sysiclassprefs *sysiclassprefs;
 448
 449     SANITY_CHECK(rport)
 450
 451     SetDrMd(rport, JAM1);
 452
 453     if (sysi_drawskin(cl,obj,msg,IntuitionBase)) return;
 454
 455     sysiclassprefs = (struct sysiclassprefs *)int_GetCustomPrefs(TYPE_SYSICLASS,data->dri,IntuitionBase);
 456
 457     switch(data->type)
 458     {
 459     case CHECKIMAGE:
 460         {
 461             WORD h_spacing = width / 4;
 462             WORD v_spacing = height / 4;
 463
 464             /* Draw frame */
 465             DrawImageState(rport, data->frame,
 466                            msg->imp_Offset.X, msg->imp_Offset.Y,
 467                            IDS_NORMAL, (struct DrawInfo *)data->dri);
 468
 469             /* Draw checkmark (only if image is in selected state) */
 470             if (msg->imp_State == IDS_SELECTED)
 471             {
 472                 left += h_spacing;
 473                 right -= h_spacing;
 474                 width -= h_spacing * 2;
 475                 top += v_spacing;
 476                 bottom -= v_spacing;
 477                 height -= v_spacing * 2;
 478
 479                 SetAPen(rport, data->dri->dri_Pens[SHADOWPEN]);
 480
 481 #if 0
 482                 draw_thick_line(cl, rport, left, top + height/2, left + width/3, bottom, 0);
 483                 draw_thick_line(cl, rport, left + width/3, bottom, right - 2, top, 0);
 484                 Move(rport, right -1 , top);
 485                 Draw(rport, right, top);
 486 #else
 487 draw_thick_line(cl, rport, left, top + height / 3 , left, bottom, 0);
 488                 draw_thick_line(cl, rport, left + 1, bottom, right - 1, top, 0);
 489 #endif
 490
 491             }
 492             break;
 493         }
 494     case MXIMAGE:
 495         {
 496             BOOL selected = FALSE;
 497             WORD col1 = SHINEPEN;
 498             WORD col2 = SHADOWPEN;
 499
 500             if ((msg->imp_State == IDS_SELECTED) || (msg->imp_State == IDS_INACTIVESELECTED))
 501             {
 502                 col1 = SHADOWPEN;
 503                 col2 = SHINEPEN;
 504                 selected = TRUE;
 505             }
 506
 507             SetAPen(rport, data->dri->dri_Pens[BACKGROUNDPEN]);
 508             RectFill(rport, left, top, right, bottom);
 509
 510 #if 0
 511             /* THICK MX IMAGE */
 512
 513             SetAPen(rport, data->dri->dri_Pens[col1]);
 514             RectFill(rport, left + 2, top, right - 3, top + 1);
 515             RectFill(rport, left + 1, top + 2, left + 2, top + 3);
 516             RectFill(rport, left, top + 4, left + 1, bottom - 4);
 517             RectFill(rport, left + 1, bottom - 3, left + 2, bottom - 2);
 518             RectFill(rport, left + 2, bottom - 1, left + 2, bottom);
 519
 520             SetAPen(rport, data->dri->dri_Pens[col2]);
 521             RectFill(rport, right - 2, top, right - 2, top + 1);
 522             RectFill(rport, right - 2, top + 2, right - 1, top + 3);
 523             RectFill(rport, right - 1, top + 4, right, bottom - 4);
 524             RectFill(rport, right - 2, bottom - 3, right - 1, bottom - 2);
 525             RectFill(rport, left + 3, bottom - 1, right - 2, bottom);
 526
 527             if (selected)
 528             {
 529                 left += 4;
 530                 right -= 4;
 531                 width -= 8;
 532                 top += 4;
 533                 bottom -= 4;
 534                 height -= 8;
 535
 536                 SetAPen(rport, data->dri->dri_Pens[FILLPEN]);
 537                 if ((width >= 3) && (height >= 3))
 538                 {
 539                     RectFill(rport, left + 1, top, right - 1, top);
 540                     RectFill(rport, left, top + 1, right, bottom - 1);
 541                     RectFill(rport, left + 1, bottom, right - 1, bottom);
 542                 }
 543                 else
 544                 {
 545                     RectFill(rport, left, top, right, bottom);
 546                 }
 547             }
 548 #else
 549             /* THIN MX IMAGE */
 550
 551             SetAPen(rport, data->dri->dri_Pens[col1]);
 552             RectFill(rport, left + 3, top, right - 3, top);
 553             WritePixel(rport, left + 2, top + 1);
 554             RectFill(rport, left + 1, top + 2, left + 1, top + 3);
 555             RectFill(rport, left, top + 4, left, bottom - 4);
 556             RectFill(rport, left + 1, bottom - 3, left + 1, bottom - 2);
 557             WritePixel(rport, left + 2, bottom - 1);
 558
 559             SetAPen(rport, data->dri->dri_Pens[col2]);
 560             WritePixel(rport, right - 2, top + 1);
 561             RectFill(rport, right - 1, top + 2, right - 1, top + 3);
 562             RectFill(rport, right, top + 4, right, bottom - 4);
 563             RectFill(rport, right - 1, bottom - 3, right - 1, bottom - 2);
 564             WritePixel(rport, right - 2, bottom - 1);
 565             RectFill(rport, left + 3, bottom, right - 3, bottom);
 566
 567             if (selected)
 568             {
 569                 left += 3;
 570                 right -= 3;
 571                 width -= 6;
 572                 top += 3;
 573                 bottom -= 3;
 574                 height -= 6;
 575
 576                 SetAPen(rport, data->dri->dri_Pens[FILLPEN]);
 577                 if ((width >= 5) && (height >= 5))
 578                 {
 579                     RectFill(rport, left, top + 2, left, bottom - 2);
 580                     RectFill(rport, left + 1, top + 1, left + 1, bottom - 1);
 581                     RectFill(rport, left + 2, top, right - 2, bottom);
 582                     RectFill(rport, right - 1, top + 1, right - 1, bottom - 1);
 583                     RectFill(rport, right, top + 2, right, bottom - 2);
 584                 }
 585                 else
 586                 {
 587                     RectFill(rport, left, top, right, bottom);
 588                 }
 589             }
 590
 591 #endif
 592             break;
 593         }
 594
 595     case MENUCHECK:
 596     case SUBMENUIMAGE:
 597     case MENUTOGGLEIMAGE:
 598         {
 599             UWORD *pens = data->dri->dri_Pens;
 600
 601 //#if MENUS_AMIGALOOK
 602 //            SetAPen(rport, pens[BARBLOCKPEN]);
 603 //#else
 604 //            SetAPen(rport, pens[(msg->imp_State == IDS_SELECTED) ? FILLPEN : BACKGROUNDPEN]);
 605 //#endif
 606
 607 //            if (hd.image)
 608 //            {
 609 //                /*EraseRect(rport,left,top,right,bottom);*/
 610 //                /*menutask will handle this!*/
 611 //            }
 612 //            else
 613 //            {
 614 //                RectFill(rport,left, top, right, bottom);
 615 //            }
 616
 617             SetAPen(rport, pens[BARDETAILPEN]);
 618
 619             switch (data->type)
 620             {
 621                 case MENUCHECK:
 622                     draw_thick_line(cl, rport, left + 1, top + height / 3 , left + 1, bottom, 0);
 623                     draw_thick_line(cl, rport, left + 2, bottom, right - 2, top, 0);
 624                     break;
 625
 626                 case MENUTOGGLEIMAGE:
 627                     RectFill(rport,left,top,left + width - 1,top);
 628                     RectFill(rport,left,top + height - 1,left + width - 1,top + height - 1);
 629                     RectFill(rport,left,top,left,top + height - 1);
 630                     RectFill(rport,left + width - 1, top, left + width - 1, top + height -1);
 631                     left++;top++;width -= 2; height -=2;
 632                     if (msg->imp_State == IDS_SELECTED)
 633                     {
 634                         draw_thick_line(cl, rport, left + 1, top + height / 3 , left + 1, bottom, 0);
 635                         draw_thick_line(cl, rport, left + 2, bottom, right - 2, top, 0);
 636                     }
 637                     break;
 638
 639                 case SUBMENUIMAGE:
 640                     Move(rport,left + width - 2, top + height/2);
 641                     Draw(rport,left + width - 6, top + height/2 - 2);
 642                     Move(rport,left + width - 2, top + height/2);
 643                     Draw(rport,left + width - 6, top + height/2 + 2);
 644                     break;
 645             }
 646
 647             break;
 648         }
 649
 650     case MUIIMAGE:
 651         {
 652             //UWORD *pens = data->dri->dri_Pens;
 653
 654             int_RenderWindowFrame(data->window,left,top,width,height,data->dri,IntuitionBase);
 655
 656             if (!(data->flags & SYSIFLG_NOBORDER))
 657             {
 658                 if (data->window)
 659                 {
 660                     int_RenderWindowFrameBorder(data->window,left,top,width,height,data->dri,IntuitionBase);
 661                 }
 662                 else
 663                 {
 664                     renderimageframe(rport, data->type, msg->imp_State, data->dri->dri_Pens,
 665                                      left, top, width, height, IntuitionBase);
 666                 }
 667                 left++;
 668                 top++;
 669                 right--;
 670                 bottom--;
 671                 width -= 2;
 672                 height -= 2;
 673             }
 674
 675             /* DRAW IMAGE :) */
 676
 677             DrawIB(rport,(BYTE*)muiimage[SIM_PREFS],left+(width/2),top+(height/2),IntuitionBase);
 678
 679             break;
 680         }
 681
 682     case SNAPSHOTIMAGE:
 683     case POPUPIMAGE:
 684     case ICONIFYIMAGE:
 685     case LOCKIMAGE:
 686         {
 687             //UWORD *pens = data->dri->dri_Pens;
 688
 689             int_RenderWindowFrame(data->window,left,top,width,height,data->dri,IntuitionBase);
 690
 691             if (!(data->flags & SYSIFLG_NOBORDER))
 692             {
 693                 if (data->window)
 694                 {
 695                     int_RenderWindowFrameBorder(data->window,left,top,width,height,data->dri,IntuitionBase);
 696                 }
 697                 else
 698                 {
 699                     renderimageframe(rport, data->type, msg->imp_State, data->dri->dri_Pens,
 700                                      left, top, width, height, IntuitionBase);
 701                 }
 702                 left++;
 703                 top++;
 704                 right--;
 705                 bottom--;
 706                 width -= 2;
 707                 height -= 2;
 708             }
 709
 710             /* DRAW IMAGE :) */
 711
 712             if (data->type == SNAPSHOTIMAGE)
 713             {
 714                 if (msg->imp_State == IDS_SELECTED)
 715                 {
 716                     DrawIB(rport,(BYTE*)muiimage[SIM_SNAPSHOTSEL],left+(width/2),top+(height/2),IntuitionBase);
 717                 }
 718                 else
 719                 {
 720                     DrawIB(rport,(BYTE*)muiimage[SIM_SNAPSHOT],left+(width/2),top+(height/2),IntuitionBase);
 721                 }
 722             }
 723
 724             if (data->type == POPUPIMAGE)
 725             {
 726                 if (msg->imp_State == IDS_SELECTED)
 727                 {
 728                     DrawIB(rport,(BYTE*)muiimage[SIM_POPUPSEL],left+(width/2),top+(height/2),IntuitionBase);
 729                 }
 730                 else
 731                 {
 732                     DrawIB(rport,(BYTE*)muiimage[SIM_POPUP],left+(width/2),top+(height/2),IntuitionBase);
 733                 }
 734             }
 735
 736             if (data->type == ICONIFYIMAGE)
 737             {
 738                 if (msg->imp_State == IDS_SELECTED)
 739                 {
 740                     DrawIB(rport,(BYTE*)muiimage[SIM_ICONIFYSEL],left+(width/2),top+(height/2),IntuitionBase);
 741                 }
 742                 else
 743                 {
 744                     DrawIB(rport,(BYTE*)muiimage[SIM_ICONIFY],left+(width/2),top+(height/2),IntuitionBase);
 745                 }
 746             }
 747
 748             if (data->type == LOCKIMAGE)
 749             {
 750                 if ((msg->imp_State == IDS_SELECTED) || (msg->imp_State == IDS_INACTIVESELECTED))
 751                 {
 752                     DrawIB(rport,(BYTE*)muiimage[SIM_LOCKSEL],left+(width/2),top+(height/2),IntuitionBase);
 753                 }
 754                 else
 755                 {
 756                     DrawIB(rport,(BYTE*)muiimage[SIM_LOCK],left+(width/2),top+(height/2),IntuitionBase);
 757                 }
 758             }
 759
 760             break;
 761         }
 762
 763     case JUMPIMAGE:
 764         {
 765             //UWORD *pens = data->dri->dri_Pens;
 766
 767             int_RenderWindowFrame(data->window,left,top,width,height,data->dri,IntuitionBase);
 768
 769             if (!(data->flags & SYSIFLG_NOBORDER))
 770             {
 771                 if (data->window)
 772                 {
 773                     int_RenderWindowFrameBorder(data->window,left,top,width,height,data->dri,IntuitionBase);
 774                 }
 775                 else
 776                 {
 777                     renderimageframe(rport, data->type, msg->imp_State, data->dri->dri_Pens,
 778                                      left, top, width, height, IntuitionBase);
 779                 }
 780                 left++;
 781                 top++;
 782                 right--;
 783                 bottom--;
 784                 width -= 2;
 785                 height -= 2;
 786             }
 787
 788             /* DRAW IMAGE :) */
 789
 790             DrawJUMP(rport,msg->imp_State,left+(width/2),top+(height/2),IntuitionBase);
 791
 792             break;
 793         }
 794
 795     } /* switch (image type) */
 796     int_FreeCustomPrefs(TYPE_SYSICLASS,data->dri,IntuitionBase);
 797     return;
 798 }
 799
 800 /**************************************************************************************************/
 801
 802 AROS_UFH3S(IPTR, dispatch_sysiclass,
 803            AROS_UFHA(Class *,  cl,  A0),
 804            AROS_UFHA(Object *, obj, A2),
 805            AROS_UFHA(Msg,      msg, A1)
 806           )
 807 {
 808     AROS_USERFUNC_INIT
 809
 810     IPTR retval = 0UL;
 811     struct SysIData *data;
 812
 813     D(bug(dprintf("dispatch_sysiclass: class 0x%lx object 0x%lx\n",cl,obj);))
 814
 815     switch (msg->MethodID)
 816     {
 817     case OM_NEW:
 818
 819         D(bug(dprintf("dispatch_sysiclass: OM_NEW\n");))
 820
 821         retval = (IPTR)sysi_new(cl, (Class *)obj, (struct opSet *)msg);
 822         break;
 823
 824     case OM_DISPOSE:
 825         D(bug(dprintf("dispatch_sysiclass: OM_DISPOSE\n");))
 826
 827         data = INST_DATA(cl, obj);
 828         DisposeObject(data->frame);
 829         retval = DoSuperMethodA(cl, obj, msg);
 830         break;
 831
 832     case OM_SET:
 833
 834         D(bug(dprintf("dispatch_sysiclass: OM_SET\n");))
 835
 836         data = INST_DATA(cl, obj);
 837         if (data->frame)
 838             DoMethodA((Object *)data->frame, msg);
 839         retval = DoSuperMethodA(cl, obj, msg);
 840         break;
 841
 842     case IM_DRAW:
 843
 844         D(bug(dprintf("dispatch_sysiclass: IM_DRAW\n");))
 845
 846         sysi_draw(cl, obj, (struct impDraw *)msg);
 847         break;
 848
 849     default:
 850         retval = DoSuperMethodA(cl, obj, msg);
 851         break;
 852     }
 853
 854     D(bug(dprintf("dispatch_sysiclass: done\n");))
 855
 856     return retval;
 857
 858     AROS_USERFUNC_EXIT
 859 }
 860
 861 /**************************************************************************************************/
 862
 863 #undef IntuitionBase
 864
 865 /**************************************************************************************************/
 866
 867 /* Initialize our class. */
 868 struct IClass *InitSysIClass (struct IntuitionBase * IntuitionBase)
 869 {
 870     struct IClass *cl = NULL;
 871
 872     cl = MakeClass(SYSICLASS, IMAGECLASS, NULL, sizeof(struct SysIData), 0);
 873     if (cl == NULL)
 874         return NULL;
 875
 876     cl->cl_Dispatcher.h_Entry    = (APTR)AROS_ASMSYMNAME(dispatch_sysiclass);
 877     cl->cl_Dispatcher.h_SubEntry = NULL;
 878     cl->cl_UserData              = (IPTR)IntuitionBase;
 879
 880     AddClass (cl);
 881
 882     return (cl);
 883 }
 884
 885 /**************************************************************************************************/
 886
 887 #if 0
 888 static UWORD getbgpen(ULONG state, UWORD *pens)
 889 {
 890     UWORD bg;
 891
 892     switch (state)
 893     {
 894
 895     case IDS_NORMAL:
 896     case IDS_SELECTED:
 897         bg = pens[FILLPEN];
 898         break;
 899
 900     case IDS_INACTIVENORMAL:
 901         bg = pens[BACKGROUNDPEN];
 902         break;
 903     default:
 904         bg = pens[BACKGROUNDPEN];
 905         break;
 906     }
 907     return bg;
 908 }
 909 #endif
 910
 911 /**************************************************************************************************/
 912
 913 void renderimageframe(struct RastPort *rp, ULONG which, ULONG state, UWORD *pens,
 914                              WORD left, WORD top, WORD width, WORD height,
 915                              struct IntuitionBase *IntuitionBase)
 916 {
 917     WORD right = left + width - 1;
 918     WORD bottom = top + height - 1;
 919     BOOL leftedgegodown = FALSE;
 920     BOOL topedgegoright = FALSE;
 921
 922     switch(which)
 923     {
 924     case CLOSEIMAGE:
 925         /* draw separator line at the right side */
 926         SetAPen(rp, pens[SHINEPEN]);
 927         RectFill(rp, right, top, right, bottom - 1);
 928         SetAPen(rp, pens[SHADOWPEN]);
 929         WritePixel(rp, right, bottom);
 930
 931         right--;
 932         break;
 933
 934     case ZOOMIMAGE:
 935     case DEPTHIMAGE:
 936     case SDEPTHIMAGE:
 937         /* draw separator line at the left side */
 938         SetAPen(rp, pens[SHINEPEN]);
 939         WritePixel(rp, left, top);
 940         SetAPen(rp, pens[SHADOWPEN]);
 941         RectFill(rp, left, top + 1, left, bottom);
 942
 943         left++;
 944         break;
 945
 946     case UPIMAGE:
 947     case DOWNIMAGE:
 948         leftedgegodown = TRUE;
 949         break;
 950
 951     case LEFTIMAGE:
 952     case RIGHTIMAGE:
 953         topedgegoright = TRUE;
 954         break;
 955     }
 956
 957     if (left == 0) leftedgegodown = TRUE;
 958     if (top == 0) topedgegoright = TRUE;
 959
 960     SetAPen(rp, pens[((state == IDS_SELECTED) || (state == IDS_INACTIVESELECTED)) ? SHADOWPEN : SHINEPEN]);
 961
 962     /* left edge */
 963     RectFill(rp, left,
 964              top,
 965              left,
 966              bottom - (leftedgegodown ? 0 : 1));
 967
 968     /* top edge */
 969     RectFill(rp, left + 1,
 970              top,
 971              right - (topedgegoright ? 0 : 1),
 972              top);
 973
 974     SetAPen(rp, pens[((state == IDS_SELECTED) || (state == IDS_INACTIVESELECTED)) ? SHINEPEN : SHADOWPEN]);
 975
 976     /* right edge */
 977     RectFill(rp, right,
 978              top + (topedgegoright ? 1 : 0),
 979              right,
 980              bottom);
 981
 982     /* bottom edge */
 983     RectFill(rp, left + (leftedgegodown ? 1 : 0),
 984              bottom,
 985              right - 1,
 986              bottom);
 987 }
 988
 989 /**************************************************************************************************/