workbench/libs/muimaster/frame.c

   1 /*
   2     Copyright  1999, David Le Corfec.
   3     Copyright  2002, The AROS Development Team.
   4     All rights reserved.
   5
   6     $Id$
   7 */
   8
   9 #include <exec/types.h>
  10 #include <cybergraphx/cybergraphics.h>
  11
  12 #include <proto/graphics.h>
  13 #include <proto/cybergraphics.h>
  14 #include <proto/layers.h>
  15
  16 #include <stdio.h>
  17
  18 #include "muimaster_intern.h"
  19 #include "datatypescache.h"
  20 #include "mui.h"
  21 #include "frame.h"
  22 #define MYDEBUG 1
  23 #include "debug.h"
  24
  25 extern struct Library *MUIMasterBase;
  26
  27 /**************************************************************************
  28  custom frames
  29 **************************************************************************/
  30
  31 void DrawPartToImage(struct NewImage *src, struct NewImage *dest, UWORD sx,
  32     UWORD sy, UWORD sw, UWORD sh, UWORD dx, UWORD dy)
  33 {
  34     UWORD x, y;
  35
  36     ULONG *s, *d;
  37
  38
  39
  40     for (y = 0; y < sh; y++)
  41     {
  42         s = &src->data[sx + ((sy + y) * src->w)];
  43         d = &dest->data[dx + ((dy + y) * dest->w)];
  44
  45         for (x = 0; x < sw; x++)
  46         {
  47             *d++ = *s++;
  48         }
  49     }
  50 }
  51
  52
  53 static void DrawTileToImage(BOOL alpha, BOOL tc, struct RastPort *rp,
  54     struct NewImage *ni, struct NewImage *dest, UWORD _sx, UWORD _sy,
  55     UWORD _sw, UWORD _sh, UWORD _dx, UWORD _dy, UWORD _dw, UWORD _dh,
  56     UWORD posx, UWORD posy)
  57 {
  58
  59     ULONG dy, dx;
  60     LONG dh, height, dw, width;
  61
  62     if (ni == NULL)
  63         return;
  64
  65     if ((_sh == 0) || (_dh == 0) || (_sw == 0) || (_dw == 0))
  66         return;
  67
  68     dh = _sh;
  69     dy = _dy;
  70     height = _dh;
  71     while (height > 0)
  72     {
  73         if ((height - dh) < 0)
  74             dh = height;
  75         height -= dh;
  76
  77         dw = _sw;
  78         width = _dw;
  79         dx = _dx;
  80         while (width > 0)
  81         {
  82             if ((width - dw) < 0)
  83                 dw = width;
  84             width -= dw;
  85
  86             if (tc)
  87             {
  88                 if (dest != NULL)
  89                 {
  90                     DrawPartToImage(ni, dest, _sx, _sy, dw, dh, dx, dy);
  91                 }
  92                 else
  93                 {
  94                     if (alpha)
  95                         WritePixelArrayAlpha(ni->data, _sx, _sy, ni->w * 4,
  96                             rp, dx + posx, dy + posy, dw, dh, 0xffffffff);
  97                     else
  98                         WritePixelArray(ni->data, _sx, _sy, ni->w * 4, rp,
  99                             dx + posx, dy + posy, dw, dh, RECTFMT_ARGB);
 100                 }
 101             }
 102             else
 103             {
 104                 if (ni->bitmap != NULL)
 105                 {
 106                     if (alpha)
 107                     {
 108                         if (ni->mask)
 109                             BltMaskBitMapRastPort(ni->bitmap, _sx, _sy, rp,
 110                                 dx + posx, dy + posy, dw, dh, 0xe0,
 111                                 (PLANEPTR) ni->mask);
 112                         else
 113                             BltBitMapRastPort(ni->bitmap, _sx, _sy, rp,
 114                                 dx + posx, dy + posy, dw, dh, 0xc0);
 115                     }
 116                     else
 117                     {
 118                         BltBitMapRastPort(ni->bitmap, _sx, _sy, rp,
 119                             dx + posx, dy + posy, dw, dh, 0xc0);
 120                     }
 121                 }
 122             }
 123             dx += dw;
 124         }
 125         dy += dh;
 126     }
 127 }
 128
 129 static void draw_tile_frame(struct RastPort *rport, BOOL tc, BOOL direct,
 130     BOOL alpha, struct dt_frame_image *fi, struct NewImage *src,
 131     struct NewImage *dest, int gl, int gt, int gw, int gh, int left,
 132     int top, int width, int height)
 133 {
 134     int lw, rw, th, bh, right, bottom, gr, gb, lp, tp, rp, bp, mw, mh;
 135
 136
 137     right = left + width;
 138     bottom = top + height;
 139
 140     gr = gl + gw;
 141     gb = gt + gh;
 142
 143     /* calculate the left width of the frame */
 144
 145     lw = left - gl;
 146     if (lw > fi->tile_left)
 147         lw = fi->tile_left;
 148     lw = fi->tile_left - lw;
 149
 150     /* calculate the top height of the frame */
 151
 152     th = top - gt;
 153     if (th > fi->tile_top)
 154         th = fi->tile_top;
 155     th = fi->tile_top - th;
 156
 157     lp = fi->tile_left - lw;    // left position
 158     tp = fi->tile_top - th;
 159
 160     if (right < (fi->tile_left + gl))
 161         lw -= ((fi->tile_left + gl) - right);
 162     if (bottom < (fi->tile_top + gt))
 163         th -= ((fi->tile_top + gt) - bottom);
 164
 165     bp = src->h - fi->tile_bottom;
 166     bh = fi->tile_bottom;
 167
 168     if (top > (gb - fi->tile_bottom))
 169     {
 170         bp += (top - (gb - fi->tile_bottom));
 171         bh -= (top - (gb - fi->tile_bottom));
 172
 173         if (bottom < gb)
 174             bh -= (gb - bottom);
 175     }
 176     else
 177     {
 178         if (bottom < (gb - fi->tile_bottom))
 179             bh = 0;
 180         else
 181             bh -= (gb - bottom);
 182     }
 183
 184     rp = src->w - fi->tile_right;
 185     rw = fi->tile_right;
 186
 187     if (left > (gr - fi->tile_right))
 188     {
 189         rp += (left - (gr - fi->tile_right));
 190         rw -= (left - (gr - fi->tile_right));
 191
 192         if (right < gr)
 193             rw -= (gr - right);
 194     }
 195     else
 196     {
 197         if (right < (gr - fi->tile_right))
 198             rw = 0;
 199         else
 200             rw -= (gr - right);
 201     }
 202
 203     mw = width - lw - rw;
 204     mh = height - th - bh;
 205
 206     struct NewImage *d;
 207
 208     if (direct)
 209         d = NULL;
 210     else
 211         d = dest;
 212
 213     DrawTileToImage(alpha, tc, rport, src, d, lp, tp, lw, th, 0, 0, lw, th,
 214         left, top);
 215     DrawTileToImage(alpha, tc, rport, src, d, lp, bp, lw, bh, 0,
 216         height - bh, lw, bh, left, top);
 217     DrawTileToImage(alpha, tc, rport, src, d, rp, tp, rw, th, width - rw, 0,
 218         rw, th, left, top);
 219     DrawTileToImage(alpha, tc, rport, src, d, rp, bp, rw, bh, width - rw,
 220         height - bh, rw, bh, left, top);
 221
 222     DrawTileToImage(alpha, tc, rport, src, d, fi->tile_left, tp,
 223         src->w - fi->tile_left - fi->tile_right, th, lw, 0, mw, th, left,
 224         top);
 225     DrawTileToImage(alpha, tc, rport, src, d, fi->tile_left, bp,
 226         src->w - fi->tile_left - fi->tile_right, bh, lw, height - bh, mw,
 227         bh, left, top);
 228
 229     DrawTileToImage(alpha, tc, rport, src, d, lp, fi->tile_top, lw,
 230         src->h - fi->tile_bottom - fi->tile_top, 0, th, lw, mh, left, top);
 231
 232     DrawTileToImage(alpha, tc, rport, src, d, rp, fi->tile_top, rw,
 233         src->h - fi->tile_bottom - fi->tile_top, width - rw, th, rw, mh,
 234         left, top);
 235     DrawTileToImage(alpha, tc, rport, src, d, fi->tile_left, fi->tile_top,
 236         src->w - fi->tile_left - fi->tile_right,
 237         src->h - fi->tile_bottom - fi->tile_top, lw, th, mw, mh, left, top);
 238 }
 239
 240 struct FrameFillInfo
 241 {
 242     struct Hook Hook;
 243     struct dt_frame_image *fi;
 244     struct NewImage *ni;
 245     WORD gl, gt, gw, gh, left, top, width, height, ox, oy;
 246 };
 247
 248 struct BackFillMsg
 249 {
 250     STACKED struct Layer *Layer;
 251     STACKED struct Rectangle Bounds;
 252     STACKED LONG OffsetX;
 253     STACKED LONG OffsetY;
 254 };
 255
 256 AROS_UFH3S(void, WindowPatternBackFillFunc,
 257            AROS_UFHA(struct Hook *, Hook, A0),
 258            AROS_UFHA(struct RastPort *, RP, A2),
 259            AROS_UFHA(struct BackFillMsg *, BFM, A1))
 260 {
 261     AROS_USERFUNC_INIT
 262
 263     // get the data for our backfillhook
 264     struct FrameFillInfo *FFI = (struct FrameFillInfo *)Hook;
 265
 266     ULONG depth = (ULONG) GetBitMapAttr(RP->BitMap, BMA_DEPTH);
 267
 268     BOOL truecolor = TRUE;
 269
 270     if (depth < 15)
 271         truecolor = FALSE;
 272
 273     int left = BFM->Bounds.MinX;
 274     int top = BFM->Bounds.MinY;
 275     int width = BFM->Bounds.MaxX - left + 1;
 276     int height = BFM->Bounds.MaxY - top + 1;
 277
 278     left -= FFI->ox;
 279     top -= FFI->oy;
 280
 281     BOOL alpha = !FFI->fi->noalpha;
 282     BOOL direct = FALSE;
 283
 284     if (!truecolor)
 285         direct = TRUE;
 286
 287     if (!direct)
 288     {
 289         struct NewImage *dest = NewImageContainer(width, height);
 290         if (dest != NULL)
 291         {
 292             draw_tile_frame(NULL, truecolor, FALSE, alpha, FFI->fi, FFI->ni,
 293                 dest, FFI->gl, FFI->gt, FFI->gw, FFI->gh, left, top, width,
 294                 height);
 295             if (FFI->fi->noalpha)
 296                 WritePixelArray(dest->data, 0, 0, dest->w * 4, RP, left, top,
 297                     width, height, RECTFMT_ARGB);
 298             else
 299                 WritePixelArrayAlpha(dest->data, 0, 0, dest->w * 4, RP, left,
 300                     top, width, height, 0xffffffff);
 301
 302             DisposeImageContainer(dest);
 303         }
 304         else
 305             direct = TRUE;
 306     }
 307
 308     if (direct)
 309     {
 310         draw_tile_frame(RP, truecolor, FALSE, alpha, FFI->fi, FFI->ni, NULL,
 311             FFI->gl, FFI->gt, FFI->gw, FFI->gh, left, top, width, height);
 312     }
 313
 314     AROS_USERFUNC_EXIT
 315 }
 316
 317 void dt_do_frame_rects(struct RastPort *rp, struct dt_frame_image *fi,
 318     struct NewImage *ni, int gl, int gt, int gw, int gh, int left, int top,
 319     int width, int height)
 320 {
 321     struct Rectangle rect;
 322     struct FrameFillInfo ffi;
 323
 324     rect.MinX = left;
 325     rect.MinY = top;
 326     rect.MaxX = left + width - 1;
 327     rect.MaxY = top + height - 1;
 328
 329     ffi.left = left;
 330     ffi.top = top;
 331     ffi.width = width;
 332     ffi.height = height;
 333
 334     ffi.gl = gl;
 335     ffi.gt = gt;
 336     ffi.gw = gw;
 337     ffi.gh = gh;
 338
 339     ffi.ox = 0;
 340     ffi.oy = 0;
 341
 342     ffi.ni = ni;
 343
 344     ffi.fi = fi;
 345
 346     ffi.Hook.h_Entry = (HOOKFUNC) WindowPatternBackFillFunc;
 347
 348     if (rp->Layer)
 349     {
 350         LockLayer(0, rp->Layer);
 351         ffi.ox = rp->Layer->bounds.MinX;
 352         ffi.oy = rp->Layer->bounds.MinY;
 353     }
 354
 355     DoHookClipRects((struct Hook *)&ffi, rp, &rect);
 356
 357     if (rp->Layer)
 358     {
 359         UnlockLayer(rp->Layer);
 360     }
 361
 362 }
 363
 364
 365 static void frame_custom(struct dt_frame_image *fi, BOOL state,
 366     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 367     int top, int width, int height)
 368 {
 369     struct RastPort *rp = mri->mri_RastPort;
 370     struct NewImage *ni;
 371
 372     if (fi == NULL)
 373         return;
 374
 375     if (state)
 376         ni = fi->img_down;
 377     else
 378         ni = fi->img_up;
 379
 380     if ((fi->tile_left + fi->tile_right) > gw)
 381         return;
 382     if ((fi->tile_top + fi->tile_bottom) > gh)
 383         return;
 384
 385
 386     if (ni != NULL)
 387     {
 388         dt_do_frame_rects(rp, fi, ni, gl, gt, gw, gh, left, top, width,
 389             height);
 390     }
 391
 392 }
 393
 394 static void frame_custom_up(struct dt_frame_image *fi,
 395     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 396     int top, int width, int height)
 397 {
 398     frame_custom(fi, FALSE, mri, gl, gt, gw, gh, left, top, width, height);
 399 }
 400
 401 static void frame_custom_down(struct dt_frame_image *fi,
 402     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 403     int top, int width, int height)
 404 {
 405     frame_custom(fi, TRUE, mri, gl, gt, gw, gh, left, top, width, height);
 406 }
 407 /**************************************************************************
 408  no frame
 409 **************************************************************************/
 410 static void frame_none_draw(struct dt_frame_image *fi,
 411     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 412     int top, int width, int height)
 413 {
 414 }
 415
 416 /**************************************************************************
 417  1 : FST_RECT
 418 **************************************************************************/
 419 static void rect_draw(struct dt_frame_image *fi, struct MUI_RenderInfo *mri,
 420     int left, int top, int width, int height, MPen preset_color)
 421 {
 422     struct RastPort *rp = mri->mri_RastPort;
 423
 424     SetAPen(rp, mri->mri_Pens[preset_color]);
 425
 426     /* FIXME: usually RectFill() is faster */
 427     Move(rp, left, top);
 428     Draw(rp, left + width - 1, top);
 429     Draw(rp, left + width - 1, top + height - 1);
 430     Draw(rp, left, top + height - 1);
 431     Draw(rp, left, top);
 432 }
 433
 434
 435 /**************************************************************************
 436  simple white border
 437 **************************************************************************/
 438 static void frame_white_rect_draw(struct dt_frame_image *fi,
 439     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 440     int top, int width, int height)
 441 {
 442     rect_draw(fi, mri, left, top, width, height, MPEN_SHINE);
 443 }
 444
 445 /**************************************************************************
 446  simple black border
 447 **************************************************************************/
 448 static void frame_black_rect_draw(struct dt_frame_image *fi,
 449     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 450     int top, int width, int height)
 451 {
 452     rect_draw(fi, mri, left, top, width, height, MPEN_SHADOW);
 453 }
 454
 455 /**************************************************************************
 456  2 : FST_BEVEL
 457
 458  Draw a bicolor rectangle
 459 **************************************************************************/
 460 static void button_draw(struct dt_frame_image *fi,
 461     struct MUI_RenderInfo *mri, int left, int top, int width, int height,
 462     MPen ul_preset, MPen lr_preset)
 463 {
 464     struct RastPort *rp = mri->mri_RastPort;
 465
 466     SetAPen(rp, mri->mri_Pens[ul_preset]);
 467     Move(rp, left, top + height - 2);
 468     Draw(rp, left, top);
 469     Draw(rp, left + width - 2, top);
 470
 471     SetAPen(rp, mri->mri_Pens[lr_preset]);
 472     Move(rp, left + width - 1, top);
 473     Draw(rp, left + width - 1, top + height - 1);
 474     Draw(rp, left, top + height - 1);
 475
 476     SetAPen(rp, mri->mri_Pens[MPEN_BACKGROUND]);
 477     WritePixel(rp, left, top + height - 1);
 478     WritePixel(rp, left + width - 1, top);
 479 }
 480
 481 /**************************************************************************
 482  classic button
 483 **************************************************************************/
 484 static void frame_bevelled_draw(struct dt_frame_image *fi,
 485     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 486     int top, int width, int height)
 487 {
 488     button_draw(fi, mri, left, top, width, height, MPEN_SHINE, MPEN_SHADOW);
 489 }
 490
 491 /**************************************************************************
 492  classic pressed button
 493 **************************************************************************/
 494 static void frame_recessed_draw(struct dt_frame_image *fi,
 495     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 496     int top, int width, int height)
 497 {
 498     button_draw(fi, mri, left, top, width, height, MPEN_SHADOW, MPEN_SHINE);
 499 }
 500
 501 /**************************************************************************
 502  3 : FST_THIN_BORDER
 503  Draw a thin relief border
 504 **************************************************************************/
 505 static void thinborder_draw(struct dt_frame_image *fi,
 506     struct MUI_RenderInfo *mri, int left, int top, int width, int height,
 507     MPen ul_preset, MPen lr_preset)
 508 {
 509     struct RastPort *rp = mri->mri_RastPort;
 510
 511     SetAPen(rp, mri->mri_Pens[ul_preset]);
 512     Move(rp, left, top + height - 1);
 513     Draw(rp, left, top);
 514     Draw(rp, left + width - 1, top);
 515
 516     Move(rp, left + width - 2, top + 2);
 517     Draw(rp, left + width - 2, top + height - 2);
 518     Draw(rp, left + 2, top + height - 2);
 519
 520     rect_draw(fi, mri, left + 1, top + 1, width - 1, height - 1, lr_preset);
 521 }
 522
 523 /**************************************************************************
 524  draw border up
 525 **************************************************************************/
 526 static void frame_thin_border_up_draw(struct dt_frame_image *fi,
 527     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 528     int top, int width, int height)
 529 {
 530     thinborder_draw(fi, mri, left, top, width, height, MPEN_SHINE,
 531         MPEN_SHADOW);
 532 }
 533
 534 /**************************************************************************
 535  draw border down
 536 **************************************************************************/
 537 static void frame_thin_border_down_draw(struct dt_frame_image *fi,
 538     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 539     int top, int width, int height)
 540 {
 541     thinborder_draw(fi, mri, left, top, width, height, MPEN_SHADOW,
 542         MPEN_SHINE);
 543 }
 544
 545 /**************************************************************************
 546  4 : FST_THICK_BORDER
 547  Draw a thick relief border
 548 **************************************************************************/
 549 static void thickborder_draw(struct dt_frame_image *fi,
 550     struct MUI_RenderInfo *mri, int left, int top, int width, int height,
 551     BOOL bevelled)
 552 {
 553     if (bevelled)
 554     {
 555         button_draw(fi, mri, left, top, width, height, MPEN_SHINE,
 556             MPEN_SHADOW);
 557         button_draw(fi, mri, left + 2, top + 2, width - 4, height - 4,
 558             MPEN_SHADOW, MPEN_SHINE);
 559     }
 560     else
 561     {
 562         button_draw(fi, mri, left, top, width, height, MPEN_SHADOW,
 563             MPEN_SHINE);
 564         button_draw(fi, mri, left + 2, top + 2, width - 4, height - 4,
 565             MPEN_SHINE, MPEN_SHADOW);
 566     }
 567
 568     rect_draw(fi, mri, left + 1, top + 1, width - 2, height - 2,
 569         MPEN_BACKGROUND);
 570 }
 571
 572 /**************************************************************************
 573  draw thick border up
 574 **************************************************************************/
 575 static void frame_thick_border_up_draw(struct dt_frame_image *fi,
 576     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 577     int top, int width, int height)
 578 {
 579     thickborder_draw(fi, mri, left, top, width, height, TRUE);
 580 }
 581
 582 /**************************************************************************
 583  draw thick border down
 584 **************************************************************************/
 585 static void frame_thick_border_down_draw(struct dt_frame_image *fi,
 586     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 587     int top, int width, int height)
 588 {
 589     thickborder_draw(fi, mri, left, top, width, height, FALSE);
 590 }
 591
 592 /**************************************************************************
 593  5 : FST_ROUND_BEVEL
 594 **************************************************************************/
 595 static void round_bevel_draw(struct dt_frame_image *fi,
 596     struct MUI_RenderInfo *mri, int left, int top, int width, int height,
 597     MPen ul, MPen lr)
 598 {
 599     SetAPen(mri->mri_RastPort, mri->mri_Pens[MPEN_BACKGROUND]);
 600     RectFill(mri->mri_RastPort, left, top, left + 3, top + height - 1);
 601     RectFill(mri->mri_RastPort,
 602         left + width - 4, top, left + width - 1, top + height - 1);
 603     rect_draw(fi, mri, left, top + 2, 2, height - 4, ul);
 604     rect_draw(fi, mri, left + 1, top + 1, 2, 1, ul);
 605     rect_draw(fi, mri, left + 1, top + height - 2, 2, 1, ul);
 606     rect_draw(fi, mri, left + 2, top + height - 1, 1, 1, ul);
 607     rect_draw(fi, mri, left + 2, top, width - 5, 1, ul);
 608
 609     rect_draw(fi, mri, left + width - 2, top + 2, 2, height - 4, lr);
 610     rect_draw(fi, mri, left + width - 3, top + 1, 2, 1, lr);
 611     rect_draw(fi, mri, left + width - 3, top + height - 2, 2, 1, lr);
 612     rect_draw(fi, mri, left + 3, top + height - 1, width - 5, 1, lr);
 613     rect_draw(fi, mri, left + width - 3, top, 1, 1, lr);
 614 }
 615
 616 /**************************************************************************
 617
 618 **************************************************************************/
 619 static void frame_round_bevel_up_draw(struct dt_frame_image *fi,
 620     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 621     int top, int width, int height)
 622 {
 623     round_bevel_draw(fi, mri, left, top, width, height,
 624         MPEN_SHINE, MPEN_SHADOW);
 625 }
 626
 627 /**************************************************************************
 628
 629 **************************************************************************/
 630 static void frame_round_bevel_down_draw(struct dt_frame_image *fi,
 631     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 632     int top, int width, int height)
 633 {
 634     round_bevel_draw(fi, mri, left, top, width, height,
 635         MPEN_SHADOW, MPEN_SHINE);
 636 }
 637
 638 /**************************************************************************
 639  6 : FST_WIN_BEVEL
 640 **************************************************************************/
 641 static void frame_border_button_up_draw(struct dt_frame_image *fi,
 642     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 643     int top, int width, int height)
 644 {
 645     rect_draw(fi, mri, left, top, width, height, MPEN_SHADOW);
 646     button_draw(fi, mri, left + 1, top + 1, width - 2, height - 2,
 647         MPEN_SHINE, MPEN_HALFSHADOW);
 648 }
 649
 650 /**************************************************************************
 651
 652 **************************************************************************/
 653 static void frame_border_button_down_draw(struct dt_frame_image *fi,
 654     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 655     int top, int width, int height)
 656 {
 657     button_draw(fi, mri, left + 2, top + 2, width - 2, height - 2,
 658         MPEN_BACKGROUND, MPEN_SHADOW);
 659     button_draw(fi, mri, left + 1, top + 1, width - 1, height - 1,
 660         MPEN_HALFSHADOW, MPEN_SHADOW);
 661     rect_draw(fi, mri, left, top, width, height, MPEN_SHADOW);
 662 }
 663
 664 /**************************************************************************
 665  7 : FST_ROUND_THICK_BORDER
 666 **************************************************************************/
 667 static void round_thick_border_draw(struct dt_frame_image *fi,
 668     struct MUI_RenderInfo *mri, int left, int top, int width, int height,
 669     MPen pen1, MPen pen2, MPen pen3, MPen pen4, MPen pen5)
 670 {
 671     struct RastPort *rp = mri->mri_RastPort;
 672
 673     rect_draw(fi, mri, left, top, width - 2, height - 2, pen1);
 674     rect_draw(fi, mri, left + 2, top + 2, width - 2, height - 2, pen5);
 675
 676     rect_draw(fi, mri, left, top, 2, 2, pen2);
 677     rect_draw(fi, mri, left, top + height - 3, 2, 2, pen2);
 678     rect_draw(fi, mri, left + width - 3, top, 2, 2, pen2);
 679
 680     rect_draw(fi, mri, left + width - 2, top + height - 2, 2, 2, pen4);
 681     rect_draw(fi, mri, left + 1, top + height - 2, 2, 2, pen4);
 682     rect_draw(fi, mri, left + width - 2, top + 1, 2, 2, pen4);
 683
 684     rect_draw(fi, mri, left + 1, top + 1, width - 2, height - 2, pen3);
 685
 686     rect_draw(fi, mri, left + 2, top + 2, 2, 2, pen3);
 687     rect_draw(fi, mri, left + 2, top + height - 4, 2, 2, pen3);
 688     rect_draw(fi, mri, left + width - 4, top + height - 4, 2, 2, pen3);
 689     rect_draw(fi, mri, left + width - 4, top + 2, 2, 2, pen3);
 690
 691     /* these points were not in the original frame.  -dlc */
 692     SetAPen(rp, mri->mri_Pens[pen5]);
 693     WritePixel(rp, left + 3, top + 3);
 694
 695     SetAPen(rp, mri->mri_Pens[pen1]);
 696     WritePixel(rp, left + width - 4, top + height - 4);
 697 }
 698
 699 /**************************************************************************
 700
 701 **************************************************************************/
 702 static void frame_round_thick_border_up_draw(struct dt_frame_image *fi,
 703     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 704     int top, int width, int height)
 705 {
 706     round_thick_border_draw(fi, mri, left, top, width, height,
 707         MPEN_SHINE, MPEN_HALFSHINE, MPEN_BACKGROUND,
 708         MPEN_HALFSHADOW, MPEN_SHADOW);
 709 }
 710
 711 /**************************************************************************
 712
 713 **************************************************************************/
 714 static void frame_round_thick_border_down_draw(struct dt_frame_image *fi,
 715     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 716     int top, int width, int height)
 717 {
 718     round_thick_border_draw(fi, mri, left, top, width, height,
 719         MPEN_SHADOW, MPEN_HALFSHADOW, MPEN_BACKGROUND,
 720         MPEN_HALFSHINE, MPEN_SHINE);
 721 }
 722
 723 /**************************************************************************
 724  8 : FST_ROUND_THIN_BORDER
 725 **************************************************************************/
 726 static void round_thin_border_draw(struct dt_frame_image *fi,
 727     struct MUI_RenderInfo *mri, int left, int top, int width, int height,
 728     MPen pen1, MPen pen2, MPen pen3, MPen pen4, MPen pen5)
 729 {
 730     struct RastPort *rp = mri->mri_RastPort;
 731
 732     rect_draw(fi, mri, left, top, width - 1, height - 1, pen1);
 733     rect_draw(fi, mri, left + 1, top + 1, width - 1, height - 1, pen5);
 734
 735     rect_draw(fi, mri, left, top, 2, 2, pen2);
 736     rect_draw(fi, mri, left + width - 4, top + height - 4, 2, 2, pen2);
 737     rect_draw(fi, mri, left + 2, top + 2, 2, 2, pen4);
 738     rect_draw(fi, mri, left + width - 2, top + height - 2, 2, 2, pen4);
 739     rect_draw(fi, mri, left + 1, top + 1, 2, 2, pen3);
 740     rect_draw(fi, mri, left + width - 3, top + height - 3, 2, 2, pen3);
 741
 742     rect_draw(fi, mri, left + 1, top + height - 3, 1, 3, pen4);
 743     rect_draw(fi, mri, left + width - 3, top + 1, 3, 1, pen4);
 744
 745     WritePixel(rp, left + 2, top + height - 3);
 746     WritePixel(rp, left + width - 3, top + 2);
 747
 748     SetAPen(rp, mri->mri_Pens[pen2]);
 749     WritePixel(rp, left, top + height - 2);
 750     WritePixel(rp, left + 2, top + height - 2);
 751     WritePixel(rp, left + width - 2, top);
 752     WritePixel(rp, left + width - 2, top + 2);
 753 }
 754
 755 /**************************************************************************
 756
 757 **************************************************************************/
 758 static void frame_round_thin_border_up_draw(struct dt_frame_image *fi,
 759     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 760     int top, int width, int height)
 761 {
 762     round_thin_border_draw(fi, mri, left, top, width, height,
 763         MPEN_SHINE, MPEN_HALFSHINE, MPEN_BACKGROUND,
 764         MPEN_HALFSHADOW, MPEN_SHADOW);
 765 }
 766
 767 /**************************************************************************
 768
 769 **************************************************************************/
 770 static void frame_round_thin_border_down_draw(struct dt_frame_image *fi,
 771     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 772     int top, int width, int height)
 773 {
 774     round_thin_border_draw(fi, mri, left, top, width, height,
 775         MPEN_SHADOW, MPEN_HALFSHADOW, MPEN_BACKGROUND,
 776         MPEN_HALFSHINE, MPEN_SHINE);
 777 }
 778
 779 /**************************************************************************
 780  9 : FST_GRAY_BORDER
 781 **************************************************************************/
 782 static void frame_gray_border_up_draw(struct dt_frame_image *fi,
 783     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 784     int top, int width, int height)
 785 {
 786     thinborder_draw(fi, mri, left, top, width, height,
 787         MPEN_HALFSHINE, MPEN_HALFSHADOW);
 788 }
 789
 790 /**************************************************************************
 791
 792 **************************************************************************/
 793 static void frame_gray_border_down_draw(struct dt_frame_image *fi,
 794     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 795     int top, int width, int height)
 796 {
 797     thinborder_draw(fi, mri, left, top, width, height,
 798         MPEN_HALFSHADOW, MPEN_HALFSHINE);
 799 }
 800
 801 /**************************************************************************
 802  A : FST_SEMIROUND_BEVEL
 803 **************************************************************************/
 804 static void semiround_bevel_draw(struct dt_frame_image *fi,
 805     struct MUI_RenderInfo *mri, int left, int top, int width, int height,
 806     MPen pen1, MPen pen2, MPen pen3, MPen pen4, MPen pen5)
 807 {
 808     struct RastPort *rp = mri->mri_RastPort;
 809
 810     button_draw(fi, mri, left, top, width, height, pen1, pen5);
 811     button_draw(fi, mri, left + 1, top + 1, width - 2, height - 2, pen2,
 812         pen4);
 813
 814     SetAPen(rp, mri->mri_Pens[pen2]);
 815     WritePixel(rp, left, top);
 816
 817     SetAPen(rp, mri->mri_Pens[pen1]);
 818     WritePixel(rp, left + 1, top + 1);
 819
 820     SetAPen(mri->mri_RastPort, mri->mri_Pens[pen5]);
 821     WritePixel(rp, left + width - 2, top + height - 2);
 822
 823     SetAPen(mri->mri_RastPort, mri->mri_Pens[pen4]);
 824     WritePixel(rp, left + width - 1, top + height - 1);
 825
 826     SetAPen(mri->mri_RastPort, mri->mri_Pens[pen3]);
 827     WritePixel(rp, left, top + height - 2);
 828     WritePixel(rp, left + 1, top + height - 1);
 829     WritePixel(rp, left + width - 2, top);
 830     WritePixel(rp, left + width - 1, top + 1);
 831 }
 832
 833 /**************************************************************************
 834
 835 **************************************************************************/
 836 static void frame_semiround_bevel_up_draw(struct dt_frame_image *fi,
 837     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 838     int top, int width, int height)
 839 {
 840     semiround_bevel_draw(fi, mri, left, top, width, height,
 841         MPEN_SHINE, MPEN_HALFSHINE, MPEN_BACKGROUND,
 842         MPEN_HALFSHADOW, MPEN_SHADOW);
 843 }
 844
 845 /**************************************************************************
 846
 847 **************************************************************************/
 848 static void frame_semiround_bevel_down_draw(struct dt_frame_image *fi,
 849     struct MUI_RenderInfo *mri, int gl, int gt, int gw, int gh, int left,
 850     int top, int width, int height)
 851 {
 852     semiround_bevel_draw(fi, mri, left, top, width, height,
 853         MPEN_SHADOW, MPEN_HALFSHADOW, MPEN_BACKGROUND,
 854         MPEN_HALFSHINE, MPEN_SHINE);
 855 }
 856
 857 /**************************************************************************
 858  hold builtin frames.
 859 **************************************************************************/
 860 static const struct ZuneFrameGfx __builtinFrameGfx[] = {
 861     /* type 0 : FST_NONE */
 862     {frame_none_draw, 0, 0, 0, 0, 0},
 863     {frame_none_draw, 0, 0, 0, 0, 0},
 864
 865     /* monochrome border */
 866     /* 1 : FST_RECT */
 867     {frame_white_rect_draw, 0, 1, 1, 1, 1},
 868     {frame_black_rect_draw, 0, 1, 1, 1, 1},
 869
 870     /* clean 3D look */
 871     /* 2 : FST_BEVEL */
 872     {frame_bevelled_draw, 0, 1, 1, 1, 1},
 873     {frame_recessed_draw, 0, 1, 1, 1, 1},
 874
 875     /* thin relief border */
 876     /* 3 : FST_THIN_BORDER */
 877     {frame_thin_border_up_draw, 0, 2, 2, 2, 2},
 878     {frame_thin_border_down_draw, 0, 2, 2, 2, 2},
 879
 880     /* thick relief border */
 881     /* 4 : FST_THICK_BORDER */
 882     {frame_thick_border_up_draw, 0, 3, 3, 3, 3},
 883     {frame_thick_border_down_draw, 0, 3, 3, 3, 3},
 884
 885     /* rounded bevel */
 886     /* 5 : FST_ROUND_BEVEL */
 887     {frame_round_bevel_up_draw, 0, 4, 4, 1, 1},
 888     {frame_round_bevel_down_draw, 0, 4, 4, 1, 1},
 889
 890     /* zin31/xen look */
 891     /* 6 : FST_WIN_BEVEL */
 892     {frame_border_button_up_draw, 0, 2, 2, 2, 2},
 893     {frame_border_button_down_draw, 0, 3, 1, 3, 1},
 894
 895     /* rounded thick border */
 896     /* 7 : FST_ROUND_THICK_BORDER */
 897     {frame_round_thick_border_up_draw, 0, 4, 4, 4, 4},
 898     {frame_round_thick_border_down_draw, 0, 4, 4, 4, 4},
 899
 900     /* rounded thin border */
 901     /* 8 : FST_ROUND_THIN_BORDER */
 902     {frame_round_thin_border_up_draw, 0, 4, 4, 4, 4},
 903     {frame_round_thin_border_down_draw, 0, 4, 4, 4, 4},
 904
 905     /* strange gray border */
 906     /* 9 : FST_GRAY_BORDER */
 907     {frame_gray_border_up_draw, 0, 2, 2, 2, 2},
 908     {frame_gray_border_down_draw, 0, 2, 2, 2, 2},
 909
 910     /* semi rounded bevel */
 911     /* A : FST_SEMIROUND_BEVEL */
 912     {frame_semiround_bevel_up_draw, 0, 2, 2, 2, 2},
 913     {frame_semiround_bevel_down_draw, 0, 2, 2, 2, 2},
 914
 915     /* custom frames */
 916
 917     {frame_custom_up, 1, 0, 0, 0, 0},
 918     {frame_custom_down, 1, 0, 0, 0, 0},
 919
 920     {frame_custom_up, 2, 0, 0, 0, 0},
 921     {frame_custom_down, 2, 0, 0, 0, 0},
 922
 923     {frame_custom_up, 3, 0, 0, 0, 0},
 924     {frame_custom_down, 3, 0, 0, 0, 0},
 925
 926     {frame_custom_up, 4, 0, 0, 0, 0},
 927     {frame_custom_down, 4, 0, 0, 0, 0},
 928
 929     {frame_custom_up, 5, 0, 0, 0, 0},
 930     {frame_custom_down, 5, 0, 0, 0, 0},
 931
 932     {frame_custom_up, 6, 0, 0, 0, 0},
 933     {frame_custom_down, 6, 0, 0, 0, 0},
 934
 935     {frame_custom_up, 7, 0, 0, 0, 0},
 936     {frame_custom_down, 7, 0, 0, 0, 0},
 937
 938     {frame_custom_up, 8, 0, 0, 0, 0},
 939     {frame_custom_down, 8, 0, 0, 0, 0},
 940
 941     {frame_custom_up, 9, 0, 0, 0, 0},
 942     {frame_custom_down, 9, 0, 0, 0, 0},
 943
 944     {frame_custom_up, 10, 0, 0, 0, 0},
 945     {frame_custom_down, 10, 0, 0, 0, 0},
 946
 947     {frame_custom_up, 11, 0, 0, 0, 0},
 948     {frame_custom_down, 11, 0, 0, 0, 0},
 949
 950     {frame_custom_up, 12, 0, 0, 0, 0},
 951     {frame_custom_down, 12, 0, 0, 0, 0},
 952
 953     {frame_custom_up, 13, 0, 0, 0, 0},
 954     {frame_custom_down, 13, 0, 0, 0, 0},
 955
 956     {frame_custom_up, 14, 0, 0, 0, 0},
 957     {frame_custom_down, 14, 0, 0, 0, 0},
 958
 959     {frame_custom_up, 15, 0, 0, 0, 0},
 960     {frame_custom_down, 15, 0, 0, 0, 0},
 961
 962     {frame_custom_up, 16, 0, 0, 0, 0},
 963     {frame_custom_down, 16, 0, 0, 0, 0},
 964
 965 };
 966
 967
 968 /**************************************************************************
 969
 970 **************************************************************************/
 971 const struct ZuneFrameGfx *zune_zframe_get(Object *obj,
 972     const struct MUI_FrameSpec_intern *frameSpec)
 973 {
 974     struct dt_frame_image *fi = NULL;
 975
 976     if (frameSpec->type >= FST_CUSTOM1)
 977     {
 978         struct MUI_RenderInfo *mri = muiRenderInfo(obj);
 979         if (!(fi = mri->mri_FrameImage[frameSpec->type - FST_CUSTOM1]))
 980             return &__builtinFrameGfx[2 * FST_RECT];
 981     }
 982
 983     if (frameSpec->type >= FST_COUNT)
 984         return &__builtinFrameGfx[2 * FST_RECT];
 985
 986     return &__builtinFrameGfx[2 * frameSpec->type + frameSpec->state];
 987
 988 #if 0
 989     frame->customframe = NULL;
 990
 991     if ((fi != NULL) && (frame != NULL))
 992     {
 993         frame->customframe = fi;
 994         frame->ileft = fi->inner_left;
 995         frame->itop = fi->inner_top;
 996         frame->iright = fi->inner_right;
 997         frame->ibottom = fi->inner_bottom;
 998         frame->noalpha = fi->noalpha;
 999
1000     }
1001
1002     return frame;
1003 #endif
1004 }
1005
1006 const struct ZuneFrameGfx *zune_zframe_get_with_state(Object *obj,
1007     const struct MUI_FrameSpec_intern *frameSpec, UWORD state)
1008 {
1009     struct dt_frame_image *fi = NULL;
1010
1011     if (frameSpec->type >= FST_CUSTOM1)
1012     {
1013         struct MUI_RenderInfo *mri = muiRenderInfo(obj);
1014         if (!(fi = mri->mri_FrameImage[frameSpec->type - FST_CUSTOM1]))
1015             return &__builtinFrameGfx[2 * FST_RECT];
1016     }
1017
1018     if (frameSpec->type >= FST_COUNT)
1019         return &__builtinFrameGfx[2 * FST_RECT];
1020
1021     return &__builtinFrameGfx[2 * frameSpec->type + state];
1022 }
1023
1024 /*------------------------------------------------------------------------*/
1025
1026 BOOL zune_frame_intern_to_spec(const struct MUI_FrameSpec_intern *intern,
1027     STRPTR spec)
1028 {
1029     if (!intern || !spec)
1030         return FALSE;
1031
1032     char sp;
1033
1034     if (intern->type < 10)
1035         sp = ((char)intern->type) + '0';
1036     else
1037         sp = ((char)intern->type - 10) + 'a';
1038
1039     /* Must cast to LONG because on AmigaOS SNPrintf() is used which is like
1040      * RawDoFmt() 16 bit */
1041     snprintf(&spec[0], 2, "%c", sp);
1042     snprintf(&spec[1], 2, "%lx", (long)intern->state);
1043     snprintf(&spec[2], 2, "%lx", (long)intern->innerLeft);
1044     snprintf(&spec[3], 2, "%lx", (long)intern->innerRight);
1045     snprintf(&spec[4], 2, "%lx", (long)intern->innerTop);
1046     snprintf(&spec[5], 2, "%lx", (long)intern->innerBottom);
1047     /* 0 byte is ensured through snprintf */
1048     return TRUE;
1049 }
1050
1051 /*------------------------------------------------------------------------*/
1052
1053 static int xhexasciichar_to_int(char x)
1054 {
1055     if (x >= '0' && x <= '9')
1056         return x - '0';
1057     if (x >= 'a' && x <= 'z')
1058         return x - 'a' + 10;
1059     if (x >= 'A' && x <= 'Z')
1060         return x - 'A' + 10;
1061     return -1;
1062 }
1063
1064 BOOL zune_frame_spec_to_intern(CONST_STRPTR spec,
1065     struct MUI_FrameSpec_intern *intern)
1066 {
1067     int val;
1068
1069     if (!intern || !spec)
1070         return FALSE;
1071
1072     val = xhexasciichar_to_int(spec[0]);
1073     if (val == -1)
1074         return FALSE;
1075     intern->type = val;
1076
1077     val = xhexasciichar_to_int(spec[1]);
1078     if (val == -1)
1079         return FALSE;
1080     intern->state = val;
1081
1082     val = xhexasciichar_to_int(spec[2]);
1083     if (val == -1)
1084         return FALSE;
1085     intern->innerLeft = val;
1086
1087     val = xhexasciichar_to_int(spec[3]);
1088     if (val == -1)
1089         return FALSE;
1090     intern->innerRight = val;
1091
1092     val = xhexasciichar_to_int(spec[4]);
1093     if (val == -1)
1094         return FALSE;
1095     intern->innerTop = val;
1096
1097     val = xhexasciichar_to_int(spec[5]);
1098     if (val == -1)
1099         return FALSE;
1100     intern->innerBottom = val;
1101     return TRUE;
1102 }