workbench/c/Decoration/drawfuncs.c

   1 /*
   2     Copyright © 2011, The AROS Development Team.
   3     $Id$
   4 */
   5
   6 #include <intuition/imageclass.h>
   7 #include <graphics/rpattr.h>
   8 #include <libraries/cybergraphics.h>
   9 #include <proto/arossupport.h>
  10 #include <proto/graphics.h>
  11 #include <proto/cybergraphics.h>
  12 #include <proto/exec.h>
  13 #include <aros/debug.h>
  14
  15 #include <math.h>
  16
  17 #include "drawfuncs.h"
  18
  19 #if AROS_BIG_ENDIAN
  20 #define GET_A(rgb) ((rgb >> 24) & 0xff)
  21 #define GET_R(rgb) ((rgb >> 16) & 0xff)
  22 #define GET_G(rgb) ((rgb >> 8) & 0xff)
  23 #define GET_B(rgb) (rgb & 0xff)
  24 #define SET_ARGB(a, r, g, b) a << 24 | r << 16 | g << 8 | b
  25 #else
  26 #define GET_A(rgb) (rgb & 0xff)
  27 #define GET_R(rgb) ((rgb >> 8) & 0xff)
  28 #define GET_G(rgb) ((rgb >> 16) & 0xff)
  29 #define GET_B(rgb) ((rgb >> 24) & 0xff)
  30 #define SET_ARGB(a, r, g, b) b << 24 | g << 16 | r << 8 | a
  31 #endif
  32
  33 /* This function provides a number of ways to blit a NewImage onto RastPort. Please take great care when modifying it.
  34  *
  35  * The number of combinations of arguments is quite high. Please take time to understand it.
  36  *
  37  * Arguments:
  38  * ni - a NewImage that is to be blitted
  39  * subimageCol, subimageRow - define the initial read offset in source image based on assumption that image contains
  40  *                            a number of subimages drawn in rows or columns
  41  * xSrc, ySrc - define additional read offset in the source image subimage
  42  * destRP - destination RastPort to blit the image to
  43  * xDest, yDest - coordinates on the destination RastPort to where the imatge will be blitted
  44  * widthSrc, heightSrc - width/height of region to be read from, if -1 then use the width/height of subimage
  45  * widthDest, heightDest - width/height of blit on destination RastPort, if -1 then use widthSrc/heightSrc
  46  *
  47  */
  48 static void BltScaleNewImageSubImageRastPort(struct NewImage * ni, ULONG subimageCol, ULONG subimageRow,
  49         LONG xSrc, LONG ySrc, struct RastPort * destRP, LONG xDest, LONG yDest,
  50         LONG widthSrc, LONG heightSrc, LONG widthDest, LONG heightDest)
  51 {
  52     ULONG subimagewidth     = ni->w / ni->subimagescols;
  53     ULONG subimageheight    = ni->h / ni->subimagesrows;
  54
  55     if (subimageCol >= ni->subimagescols) return;
  56     if (subimageRow >= ni->subimagesrows) return;
  57
  58     /* If source size not provided, use subimage size */
  59     if (widthSrc < 0) widthSrc = (LONG)subimagewidth;
  60     if (heightSrc < 0) heightSrc = (LONG)subimageheight;
  61
  62     /* If destination size not provided, use source */
  63     if (widthDest < 0) widthDest = widthSrc;
  64     if (heightDest < 0) heightDest = heightSrc;
  65
  66     /* If source and destination sizes do not match, scale */
  67     if ((widthSrc != widthDest) || (heightSrc != heightDest))
  68     {
  69         /* FIXME: The scaled blitting needs similar optimized code paths as non-scaled */
  70         ULONG * srcptr = (ni->data) + (((subimageheight * subimageRow) + ySrc) * ni->w) +
  71                 ((subimagewidth * subimageCol) + xSrc); /* Go to (0,0) of source rect */
  72
  73         ULONG * scaleddata = ScaleBuffer(srcptr, ni->w, widthSrc, heightSrc, widthDest, heightDest);
  74
  75         D(bug("[Decoration] SCALED %d,%d -> %d,%d!\n", widthSrc, heightSrc, widthDest, heightDest));
  76
  77         WritePixelArrayAlpha(scaleddata, 0, 0, widthDest * 4, destRP, xDest, yDest, widthDest, heightDest, 0xffffffff);
  78
  79         FreeVec(scaleddata);
  80     }
  81     else /* ((widthSrc != widthDest) || (heightSrc != heightDest)) */
  82     {
  83         /* Detect if image can be drawn using blitting instead of alpha draw */
  84         if ((!ni->subimageinbm) || (!(ni->subimageinbm[subimageCol + (subimageRow * ni->subimagescols)])))
  85         {
  86             WritePixelArrayAlpha(ni->data, (subimagewidth * subimageCol) + xSrc ,
  87                 (subimageheight * subimageRow) + ySrc, ni->w * 4, destRP,
  88                 xDest, yDest, widthSrc, heightSrc, 0xffffffff);
  89         }
  90         else
  91         {
  92             /* LUT */
  93             if (ni->bitmap != NULL)
  94             {
  95                 if (ni->mask)
  96                 {
  97                     BltMaskBitMapRastPort(ni->bitmap, (subimagewidth * subimageCol) + xSrc ,
  98                         (subimageheight * subimageRow) + ySrc, destRP, xDest, yDest,
  99                         widthSrc, heightSrc, 0xe0, (PLANEPTR) ni->mask);
 100                 }
 101                 else
 102                 {
 103                     BltBitMapRastPort(ni->bitmap, (subimagewidth * subimageCol) + xSrc ,
 104                         (subimageheight * subimageRow) + ySrc, destRP, xDest, yDest,
 105                         widthSrc, heightSrc, 0xc0);
 106                 }
 107             }
 108
 109             /* Truecolor */
 110             if (ni->bitmap2 != NULL)
 111             {
 112                 BltBitMapRastPort(ni->bitmap2, (subimagewidth * subimageCol) + xSrc ,
 113                     (subimageheight * subimageRow) + ySrc, destRP, xDest, yDest,
 114                     widthSrc, heightSrc, 0xc0);
 115             }
 116         }
 117     }
 118 }
 119
 120 /* HELPER WRAPPERS */
 121 static inline void BltNewImageSubImageRastPort(struct NewImage * ni, ULONG subimageCol, ULONG subimageRow,
 122         LONG xSrc, LONG ySrc, struct RastPort * destRP, LONG xDest, LONG yDest, LONG widthSrc, LONG heightSrc)
 123 {
 124     BltScaleNewImageSubImageRastPort(ni, subimageCol, subimageRow, xSrc, ySrc, destRP,
 125             xDest, yDest, widthSrc, heightSrc, -1, -1);
 126 }
 127
 128 static inline void BltNewImageSubImageRastPortSimple(struct NewImage * ni, ULONG subimageCol, ULONG subimageRow,
 129     struct RastPort * destRP, LONG xDest, LONG yDest)
 130 {
 131     BltNewImageSubImageRastPort(ni, subimageCol, subimageRow, 0, 0, destRP,
 132             xDest, yDest, -1, -1);
 133 }
 134
 135 static inline void BltScaleNewImageSubImageRastPortSimple(struct NewImage * ni, ULONG subimageCol, ULONG subimageRow,
 136     struct RastPort * destRP, LONG xDest, LONG yDest, LONG widthDest, LONG heightDest)
 137 {
 138     BltScaleNewImageSubImageRastPort(ni, subimageCol, subimageRow, 0, 0, destRP,
 139             xDest, yDest, -1, -1, widthDest, heightDest);
 140 }
 141 /* HELPER WRAPPERS */
 142
 143 static void DrawTileToImage(struct NewImage *src, struct NewImage *dest, UWORD _sx, UWORD _sy, UWORD _sw, UWORD _sh, UWORD _dx, UWORD _dy, UWORD _dw, UWORD _dh)
 144 {
 145
 146     ULONG   dy, dx;
 147     LONG    dh, height, dw, width;
 148
 149     if (src == NULL) return;
 150     if (dest == NULL) return;
 151
 152     dh = _sh;
 153     dy = _dy;
 154     height = _dh;
 155
 156     while (height > 0)
 157     {
 158         if ((height-dh)<0) dh = height;
 159         height -= dh;
 160         dw = _sw;
 161         width = _dw;
 162         dx = _dx;
 163         while (width > 0)
 164         {
 165             if ((width-dw)<0) dw = width;
 166             width -= dw;
 167             DrawPartToImage(src, dest, _sx, _sy, dw, dh, dx, dy);
 168             dx += dw;
 169         }
 170         dy += dh;
 171     }
 172 }
 173
 174 static void TileImageToImageMenuBar(struct NewImage *src, struct TileInfo * srcti, struct NewImage *dest)
 175 {
 176     UWORD   y, h;
 177
 178     if (dest == NULL) return;
 179     if (src == NULL) return;
 180     if (srcti == NULL) return;
 181     y = 0;
 182
 183     h = src->h;
 184
 185     if ((srcti->TileTop + srcti->TileBottom) > dest->h) return;
 186     if (srcti->TileRight > dest->w) return;
 187
 188     DrawTileToImage(src, dest, srcti->TileLeft, y, src->w - srcti->TileLeft - srcti->TileRight, srcti->TileTop, 0, 0, dest->w - srcti->TileRight, srcti->TileTop);
 189     DrawTileToImage(src, dest, srcti->TileLeft, y + h - srcti->TileBottom, src->w - srcti->TileLeft - srcti->TileRight, srcti->TileBottom, 0, dest->h - srcti->TileBottom, dest->w - srcti->TileRight, srcti->TileBottom);
 190     DrawTileToImage(src, dest, srcti->TileLeft, y + srcti->TileTop, src->w - srcti->TileLeft - srcti->TileRight, h - srcti->TileBottom - srcti->TileTop, 0, srcti->TileTop + 0, dest->w - srcti->TileRight, dest->h - srcti->TileTop - srcti->TileBottom - 0);
 191
 192
 193     DrawTileToImage(src, dest, src->w - srcti->TileRight, y, srcti->TileRight, srcti->TileTop, dest->w - srcti->TileRight, 0, srcti->TileRight, srcti->TileTop);
 194     DrawTileToImage(src, dest, src->w - srcti->TileRight, y + h - srcti->TileBottom, srcti->TileRight, srcti->TileBottom, dest->w - srcti->TileRight , dest->h - srcti->TileBottom, srcti->TileRight, srcti->TileBottom);
 195     DrawTileToImage(src, dest, src->w - srcti->TileRight, y + srcti->TileTop, srcti->TileRight,  h - srcti->TileBottom - srcti->TileTop, dest->w - srcti->TileRight, srcti->TileTop + 0, srcti->TileRight, dest->h - srcti->TileTop - srcti->TileBottom - 0);
 196
 197 }
 198
 199 static void TileImageToImage(struct NewImage *src, struct TileInfo * srcti, struct NewImage *dest)
 200 {
 201     UWORD   y, h;
 202
 203     if (dest == NULL) return;
 204     if (src == NULL) return;
 205     if (srcti == NULL) return;
 206     y = 0;
 207
 208     h = src->h;
 209
 210     if ((srcti->TileTop + srcti->TileBottom) > dest->h) return;
 211     if ((srcti->TileLeft + srcti->TileRight) > dest->w) return;
 212
 213     DrawTileToImage(src, dest, 0, y, srcti->TileLeft, srcti->TileTop, 0 , 0, srcti->TileLeft, srcti->TileTop);
 214     DrawTileToImage(src, dest, 0, y + h - srcti->TileBottom, srcti->TileLeft, srcti->TileBottom, 0 , dest->h - srcti->TileBottom, srcti->TileLeft, srcti->TileBottom);
 215     DrawTileToImage(src, dest, src->w - srcti->TileRight, y, srcti->TileRight, srcti->TileTop, dest->w - srcti->TileRight, 0, srcti->TileRight, srcti->TileTop);
 216     DrawTileToImage(src, dest, src->w - srcti->TileRight, y + h - srcti->TileBottom, srcti->TileRight, srcti->TileBottom, dest->w - srcti->TileRight , dest->h - srcti->TileBottom, srcti->TileRight, srcti->TileBottom);
 217
 218     DrawTileToImage(src, dest, srcti->TileLeft, y, src->w - srcti->TileLeft - srcti->TileRight, srcti->TileTop, srcti->TileLeft, 0, dest->w - srcti->TileLeft - srcti->TileRight, srcti->TileTop);
 219     DrawTileToImage(src, dest, srcti->TileLeft, y + h - srcti->TileBottom, src->w - srcti->TileLeft - srcti->TileRight, srcti->TileBottom, srcti->TileLeft, dest->h - srcti->TileBottom, dest->w - srcti->TileLeft - srcti->TileRight, srcti->TileBottom);
 220     DrawTileToImage(src, dest, 0, y + srcti->TileTop, srcti->TileLeft, h - srcti->TileBottom - srcti->TileTop, 0 , srcti->TileTop + 0, srcti->TileLeft, dest->h - srcti->TileTop - srcti->TileBottom - 0);
 221     DrawTileToImage(src, dest, src->w - srcti->TileRight, y + srcti->TileTop, srcti->TileRight,  h - srcti->TileBottom - srcti->TileTop, dest->w - srcti->TileRight, srcti->TileTop + 0, srcti->TileRight, dest->h - srcti->TileTop - srcti->TileBottom - 0);
 222     DrawTileToImage(src, dest, srcti->TileLeft, y + srcti->TileTop, src->w - srcti->TileLeft - srcti->TileRight, h - srcti->TileBottom - srcti->TileTop, srcti->TileLeft, srcti->TileTop + 0, dest->w - srcti->TileLeft - srcti->TileRight, dest->h - srcti->TileTop - srcti->TileBottom - 0);
 223 }
 224
 225 static void  MixImage(struct NewImage *dst, struct NewImage *src, struct TileInfo *srcti, UWORD ratio, UWORD w, UWORD h, UWORD dx, UWORD dy)
 226 {
 227     ULONG  *s, *d;
 228     ULONG   rgba, rgb;
 229     UWORD   r, g, b;
 230     UBYTE   as, rs, gs, bs, rd, gd, bd;
 231     BOOL    tiled = FALSE;
 232     int     x, y;
 233
 234     if (src == NULL) return;
 235     if (dst == NULL) return;
 236
 237     s = src->data;
 238     d = dst->data;
 239
 240     if (srcti) tiled = TRUE;
 241
 242     for (y = 0; y < h; y++)
 243     {
 244         for (x = 0; x < w; x++)
 245         {
 246             rgba = s[x+y*src->w];
 247             as = GET_A(rgba);
 248             rs = GET_R(rgba);
 249             gs = GET_G(rgba);
 250             bs = GET_B(rgba);
 251             rgb = d[x+dx + (y+dy) * dst->w];
 252
 253             rd = GET_R(rgb);
 254             gd = GET_G(rgb);
 255             bd = GET_B(rgb);
 256
 257             r = ((rs * ratio) >> 8) + ((rd * (255 - ratio)) >> 8);
 258             g = ((gs * ratio) >> 8) + ((gd * (255 - ratio)) >> 8);
 259             b = ((bs * ratio) >> 8) + ((bd * (255 - ratio)) >> 8);
 260
 261             if (tiled) {
 262                 r = ((r * as) >> 8) + ((rd * (255 - as)) >> 8);
 263                 g = ((g * as) >> 8) + ((gd * (255 - as)) >> 8);
 264                 b = ((b * as) >> 8) + ((bd * (255 - as)) >> 8);
 265             }
 266
 267             r = r & 0xff;
 268             g = g & 0xff;
 269             b = b & 0xff;
 270
 271             d[x+dx + (y+dy) * dst->w] = SET_ARGB(as, r, g, b);
 272         }
 273     }
 274 }
 275
 276
 277 static void BlurSourceAndMixTexture(struct NewImage *pic, struct NewImage *texture, struct TileInfo * textureti, UWORD ratio)
 278 {
 279     int     x, y, ytw, t1, t2, b1, b2, l1, l2, r1, r2;
 280     UWORD   red, green, blue, alpha= 0, rs, gs, bs, as;
 281     ULONG   rgb, argb;
 282     int     width, w, height, ah, aw, xpos, ypos;
 283     BOOL    tiled = FALSE;
 284     ULONG  *raw, tw, th;
 285
 286     if (pic == NULL) return;
 287     if (pic->data == NULL) return;
 288
 289     tw = pic->w;
 290     if (textureti) tiled = TRUE;
 291     th = pic->h;
 292     raw = pic->data;
 293     height = th;
 294     width = tw;
 295
 296     if (raw)
 297     {
 298         for (y = 0; y < th; y++)
 299         {
 300             t1 = tw;
 301             t2 = tw+tw;
 302             b1 = tw;
 303             b2 = tw+tw;
 304             if (y == 0) t1 = t2 = 0;
 305             else if (y == 1) t2 = t1;
 306
 307             if (y == (th-1)) b1 = b2 = 0;
 308             else if (y == (th-2)) b2 = b1;
 309
 310             ytw = y*tw;
 311
 312             for (x = 0; x < tw; x++)
 313             {
 314                 r1 = 1;
 315                 r2 = 2;
 316                 l1 = 1;
 317                 l2 = 2;
 318
 319                 if (x == 0) l1 = r1 = 0;
 320                 else if (x == 1) l2 = l1;
 321
 322                 if (x == (tw-1)) r1 = r2 = 0;
 323                 else if (x == (tw-2)) r2 = r1;
 324
 325                 rgb = raw[x+ytw];
 326                 red = GET_R(rgb);
 327                 green = GET_G(rgb);
 328                 blue = GET_B(rgb);
 329
 330                 rgb = raw[x+ytw-t2];
 331                 red += GET_R(rgb);
 332                 green += GET_G(rgb);
 333                 blue += GET_B(rgb);
 334
 335                 rgb = raw[x+ytw-l1-t1];
 336                 red += GET_R(rgb);
 337                 green += GET_G(rgb);
 338                 blue += GET_B(rgb);
 339
 340                 rgb = raw[x+ytw-t1];
 341                 red += GET_R(rgb);
 342                 green += GET_G(rgb);
 343                 blue += GET_B(rgb);
 344
 345                 rgb = raw[x+ytw-t1];
 346                 red += GET_R(rgb);
 347                 green += GET_G(rgb);
 348                 blue += GET_B(rgb);
 349
 350                 rgb = raw[x+ytw-t1+r1];
 351                 red += GET_R(rgb);
 352                 green += GET_G(rgb);
 353                 blue += GET_B(rgb);
 354
 355                 rgb = raw[x+ytw-l2];
 356                 red += GET_R(rgb);
 357                 green += GET_G(rgb);
 358                 blue += GET_B(rgb);
 359
 360                 rgb = raw[x+ytw-l1];
 361                 red += GET_R(rgb);
 362                 green += GET_G(rgb);
 363                 blue += GET_B(rgb);
 364
 365                 rgb = raw[x+ytw+r1];
 366                 red += GET_R(rgb);
 367                 green += GET_G(rgb);
 368                 blue += GET_B(rgb);
 369
 370                 rgb = raw[x+ytw+r2];
 371                 red += GET_R(rgb);
 372                 green += GET_G(rgb);
 373                 blue += GET_B(rgb);
 374
 375                 rgb = raw[x+ytw+b1-l1];
 376                 red += GET_R(rgb);
 377                 green += GET_G(rgb);
 378                 blue += GET_B(rgb);
 379
 380                 rgb = raw[x+ytw+b1];
 381                 red += GET_R(rgb);
 382                 green += GET_G(rgb);
 383                 blue += GET_B(rgb);
 384
 385                 rgb = raw[x+ytw+b1+r1];
 386                 red += GET_R(rgb);
 387                 green += GET_G(rgb);
 388                 blue += GET_B(rgb);
 389
 390                 rgb = raw[x+ytw+b2];
 391                 red += GET_R(rgb);
 392                 green += GET_G(rgb);
 393                 blue += GET_B(rgb);
 394
 395                 red = red/14;
 396                 green = green/14;
 397                 blue = blue/14;
 398                 alpha = 255;
 399
 400                 if (tiled)
 401                 {
 402                     argb = raw[x+ytw];
 403                     as = 255 - GET_A(texture->data[x + y * texture->w]);
 404                     rs = GET_R(argb);
 405                     gs = GET_G(argb);
 406                     bs = GET_B(argb);
 407
 408                     red = ((rs * as) >> 8) + ((red * (255 - as)) >> 8);
 409                     green = ((gs * as) >> 8) + ((green * (255 - as)) >> 8);
 410                     blue = ((bs * as) >> 8) + ((blue * (255 - as)) >> 8);
 411
 412                     raw[x+ytw] = SET_ARGB(as, red, green, blue);
 413
 414                 }
 415                 else
 416                 {
 417                     raw[x+ytw] = SET_ARGB(alpha, red, green, blue);
 418                 }
 419             }
 420         }
 421     }
 422     if (ratio < 100)
 423     {
 424         if (texture)
 425         {
 426             ypos = 0;
 427             while (height>0)
 428             {
 429                 ah = texture->h;
 430                 if (ah > height) ah = height;
 431                 xpos = 0;
 432                 w = width;
 433                 while (w>0)
 434                 {
 435                     aw = texture->w;
 436                     if (aw > w) aw = w;
 437                     MixImage(pic, texture, textureti, 255 - (2.55 * ratio), aw, ah, xpos, ypos);
 438                     w -= aw;
 439                     xpos += aw;
 440                 }
 441                 height -= ah;
 442                 ypos += ah;
 443             }
 444         }
 445     }
 446 }
 447
 448 static void RenderBackgroundTiled(struct NewImage *pic, struct NewImage *texture, struct TileInfo *textureti,
 449         UWORD ratio, VOID (*TileImageToImageFunc)(struct NewImage *src, struct TileInfo * srcti, struct NewImage *dest))
 450 {
 451     struct NewImage *ni;
 452
 453     if (texture)
 454     {
 455         ni = NewImageContainer(pic->w, pic->h);
 456         if (ni)
 457         {
 458             if (textureti)
 459             {
 460                 TileImageToImageFunc(texture, textureti, ni);
 461                 BlurSourceAndMixTexture(pic, ni, textureti, ratio);
 462             }
 463             else BlurSourceAndMixTexture(pic, texture, textureti, ratio);
 464
 465             DisposeImageContainer(ni);
 466         }
 467         else BlurSourceAndMixTexture(pic, texture, textureti, ratio);
 468     }
 469     else BlurSourceAndMixTexture(pic, NULL, NULL, ratio);
 470 }
 471
 472 static void DrawMapTileToRP(struct NewImage *src, struct RastPort *rp, UWORD _sx, UWORD _sy, UWORD _sw, UWORD _sh, UWORD _dx, UWORD _dy, UWORD _dw, UWORD _dh)
 473 {
 474
 475     ULONG   dy, dx;
 476     LONG    dh, height, dw, width;
 477
 478     if (src == NULL) return;
 479     if (rp == NULL) return;
 480
 481     dh = _sh;
 482     dy = _dy;
 483     height = _dh;
 484
 485     if (!src->ok) return;
 486
 487     while (height > 0)
 488     {
 489         if ((height-dh)<0) dh = height;
 490         height -= dh;
 491         dw = _sw;
 492         width = _dw;
 493         dx = _dx;
 494         while (width > 0)
 495         {
 496             if ((width-dw)<0) dw = width;
 497             width -= dw;
 498
 499             if (src->mask)
 500             {
 501                 BltMaskBitMapRastPort(src->bitmap, _sx, _sy, rp, dx, dy, dw, dh, 0xe0, (PLANEPTR) src->mask);
 502             }
 503             else BltBitMapRastPort(src->bitmap, _sx, _sy, rp, dx, dy, dw, dh, 0xc0);
 504
 505             dx += dw;
 506         }
 507         dy += dh;
 508     }
 509 }
 510
 511 /******************************************************************************/
 512 /******************************************************************************/
 513 /******************************************************************************/
 514 /******************************************************************************/
 515 /******************************************************************************/
 516
 517 void DrawPartImageToRP(struct RastPort *rp, struct NewImage *ni, UWORD x, UWORD y, UWORD sx, UWORD sy, UWORD sw, UWORD sh)
 518 {
 519     if (ni->ok)
 520     {
 521         if (ni->bitmap == NULL)
 522         {
 523             WritePixelArray(ni->data, sx, sy, ni->w*4, rp, x, y, sw, sh, RECTFMT_ARGB);
 524         }
 525         else
 526         {
 527             BltBitMapRastPort(ni->bitmap, sx, sy, rp, x, y, sw, sh, 0xc0);
 528         }
 529     }
 530 }
 531
 532 void DrawPartToImage(struct NewImage *src, struct NewImage *dest, UWORD sx, UWORD sy, UWORD sw, UWORD sh, UWORD dx, UWORD dy)
 533 {
 534     UWORD   x, y;
 535
 536     for (y = 0; y < sh; y++)
 537     {
 538         for (x = 0; x < sw; x++)
 539         {
 540             dest->data[dx  + x + (dy + y) * dest->w] = src->data[sx + x + (sy + y) * src->w];
 541         }
 542     }
 543 }
 544
 545 void RenderMenuBackground(struct NewImage *pic, struct NewImage *texture, struct TileInfo *textureti, UWORD ratio)
 546 {
 547     if (texture)
 548     {
 549         if (textureti) RenderBackgroundTiled(pic, texture, textureti, ratio, TileImageToImage);
 550         else BlurSourceAndMixTexture(pic, texture, textureti, ratio);
 551     }
 552     else BlurSourceAndMixTexture(pic, NULL, NULL, ratio);
 553 }
 554
 555 void RenderMenuBarBackground(struct NewImage *pic, struct NewImage *texture, struct TileInfo *textureti, UWORD ratio)
 556 {
 557     if (texture && textureti)
 558     {
 559
 560         /* Fill the image with the center tile */
 561         DrawTileToImage(texture, pic,
 562                 textureti->TileLeft, textureti->TileTop,
 563                 texture->w - textureti->TileLeft - textureti->TileRight, texture->h - textureti->TileBottom - textureti->TileTop,
 564                 0, 0, pic->w, pic->h);
 565
 566         RenderBackgroundTiled(pic, texture, textureti, ratio, TileImageToImageMenuBar);
 567     }
 568 }
 569
 570 void WriteAlphaPixelArray(struct NewImage *src, struct NewLUT8Image *dst, LONG sx, LONG sy, LONG dx, LONG dy, LONG w, LONG h)
 571 {
 572     ULONG  *s = src->data;
 573     ULONG   argb;
 574     UBYTE  *d = dst->data;
 575     int     x, y;
 576
 577     for (y = 0; y < h; y++)
 578     {
 579         for (x = 0; x < w; x++)
 580         {
 581             argb = s[sx + x + (sy + y) * src->w];
 582             d[dx + x + (dy + y) * dst->w] = GET_A(argb);
 583         }
 584     }
 585 }
 586
 587 void  SetImageTint(struct NewImage *dst, UWORD ratio, ULONG argb)
 588 {
 589
 590     ULONG  *d;
 591     ULONG   rgb;
 592     UWORD   r, g, b, w, h;
 593     UBYTE   rs, gs, bs, rd, gd, bd;
 594     int     x, y;
 595
 596     if (dst == NULL) return;
 597
 598     d = dst->data;
 599
 600     w = dst->w;
 601     h = dst->h;
 602
 603     rs = (argb >> 16) & 0xff;
 604     gs = (argb >> 8) & 0xff;
 605     bs = argb & 0xff;
 606
 607     for (y = 0; y < h; y++)
 608     {
 609         for (x = 0; x < w; x++)
 610         {
 611             rgb = d[x + y * w];
 612             rd = GET_R(rgb);
 613             gd = GET_G(rgb);
 614             bd = GET_B(rgb);
 615             r = ((rs * ratio) >> 8) + ((rd * (255 - ratio)) >> 8);
 616             g = ((gs * ratio) >> 8) + ((gd * (255 - ratio)) >> 8);
 617             b = ((bs * ratio) >> 8) + ((bd * (255 - ratio)) >> 8);
 618
 619             r = r & 0xff;
 620             g = g & 0xff;
 621             b = b & 0xff;
 622
 623             d[x + y * w] = SET_ARGB(255, r, g, b);
 624         }
 625     }
 626 }
 627
 628 /*
 629  * offx - offset between start of ni and place where image should be sample from
 630  * offy - offset between start of ni and place where image should be sample from
 631  * x, y, w, h - coords in rastport rp
 632  */
 633 void HorizVertRepeatNewImage(struct NewImage *ni, ULONG color, UWORD offx, UWORD offy, struct RastPort *rp, UWORD x, UWORD y, WORD w, WORD h)
 634 {
 635     ULONG   ow, oh, sy, sx, dy, dx;
 636     LONG    dh, height, dw, width;
 637
 638     if ((w <= 0) || (h <= 0)) return;
 639
 640     if (!ni->ok)
 641     {
 642         FillPixelArray(rp, x, y, w, h, color);
 643         return;
 644     }
 645
 646     ow = ni->w;
 647     oh = ni->h;
 648
 649     sy = offy % oh;
 650     dh = oh - sy;
 651     height = h;
 652     dy = y;
 653     while (height > 0)
 654     {
 655         if ((height-dh)<0) dh = height;
 656         height -= dh;
 657
 658         sx = offx % ow;
 659         dw = ow - sx;
 660         width = w;
 661         dx = x;
 662         while (width > 0)
 663         {
 664             if ((width-dw)<0) dw = width;
 665             width -= dw;
 666
 667             BltNewImageSubImageRastPort(ni, 0, 0, sx, sy, rp, dx, dy, dw, dh);
 668
 669             dx += dw;
 670             sx = 0;
 671             dw = ow;
 672         }
 673         dy += dh;
 674         sy = 0;
 675         dh = oh;
 676     }
 677 }
 678
 679 /* NOTE: fill parameter is ignored, previously it was forcing a no-alpha blit, but
 680    this is already handled in BltNewImageSubImageRastPort */
 681 /* dh - destination height to which subimage will be scaled to */
 682 LONG WriteTiledImageTitle(BOOL fill, struct Window *win,
 683     struct RastPort *rp, struct NewImage *ni, LONG sx, LONG sy, LONG sw,
 684     LONG sh, LONG xp, LONG yp, LONG dw, LONG dh)
 685 {
 686     int     w = dw;
 687     int     x = xp;
 688     int     ddw;
 689
 690     if (!ni->ok) return x;
 691
 692     if ((sw == 0) || (dw == 0)) return xp;
 693
 694     if (win)
 695     {
 696         if (x > win->Width) return xp;
 697         if ((x + w) > win->Width) w = win->Width - x;
 698     }
 699
 700     while (w > 0)
 701     {
 702         ddw = sw;
 703         if (w < ddw) ddw = w;
 704
 705         BltScaleNewImageSubImageRastPort(ni, 0, 0, sx, sy, rp, x, yp, ddw, -1, -1, dh);
 706
 707         w -= ddw;
 708         x += ddw;
 709     }
 710     return x;
 711 }
 712
 713 /*
 714  * dh - destination height to scale to, -1 to use subimage height
 715  */
 716 LONG WriteVerticalScaledTiledImageHorizontal(struct RastPort *rp, struct NewImage *ni, ULONG subimage,
 717         LONG sx, LONG sw, LONG xp, LONG yp, LONG sh, LONG dw, LONG dh)
 718 {
 719     LONG w = dw;
 720     LONG x = xp;
 721     LONG ddw;
 722
 723     if (!ni->ok) return xp;
 724
 725     if ((sw == 0) || (dw == 0)) return xp;
 726
 727     while (w > 0)
 728     {
 729         ddw = sw;
 730         if (w < ddw) ddw = w;
 731
 732         BltScaleNewImageSubImageRastPort(ni, 0, subimage, sx, 0, rp, x, yp, ddw, sh, -1, dh);
 733
 734         w -= ddw;
 735         x += ddw;
 736     }
 737
 738     return x;
 739 }
 740
 741 LONG WriteTiledImageHorizontal(struct RastPort *rp, struct NewImage *ni, ULONG subimage, LONG sx, LONG sw, LONG xp, LONG yp, LONG dw)
 742 {
 743     return WriteVerticalScaledTiledImageHorizontal(rp, ni, subimage, sx, sw, xp, yp, -1, dw, -1);
 744 }
 745
 746 LONG WriteTiledImageVertical(struct RastPort *rp, struct NewImage *ni, ULONG subimage, LONG sy, LONG sh, LONG xp, LONG yp, LONG dh)
 747 {
 748     int     h = dh;
 749     int     y = yp;
 750     int     ddh;
 751
 752     if (!ni->ok) return y;
 753
 754     if ((sh == 0) || (dh == 0)) return yp;
 755
 756     while (h > 0)
 757     {
 758         ddh = sh;
 759         if (h < ddh) ddh = h;
 760
 761         BltNewImageSubImageRastPort(ni, subimage, 0, 0, sy, rp, xp, y, -1, ddh);
 762
 763         h -= ddh;
 764         y += ddh;
 765     }
 766     return y;
 767 }
 768
 769 struct myrgb
 770 {
 771     int red,green,blue;
 772 };
 773
 774 void FillMemoryBufferRGBGradient(UBYTE * buf, LONG pen, LONG xt, LONG yt, LONG xb, LONG yb, LONG xp, LONG yp, LONG w, LONG h, ULONG start_rgb, ULONG end_rgb, LONG angle)
 775 {
 776     /* The basic idea of this algorithm is to calc the intersection between the
 777     * diagonal of the rectangle (xs,ys) with dimension (xw,yw) a with the line starting
 778     * at (x,y) (every pixel inside the rectangle) and angle angle with direction vector (vx,vy).
 779     *
 780     * Having the intersection point we then know the color of the pixel.
 781     *
 782     * TODO: Turn the algorithm into a incremental one
 783     *       Remove the use of floating point variables
 784     */
 785     double rad = angle*M_PI/180;
 786     double cosarc = cos(rad);
 787     double sinarc = sin(rad);
 788
 789     struct myrgb startRGB,endRGB;
 790
 791     int diffR, diffG, diffB;
 792
 793     int r,t; /* some helper variables to short the code */
 794     int l,y,c,x;
 795     int y1; /* The intersection point */
 796     int incr_y1; /* increment of y1 */
 797     int xs,ys,xw,yw;
 798     int xadd,ystart,yadd;
 799 //    double vx = -cosarc;
 800 //    double vy = sinarc;
 801     int vx = (int)(-cosarc*0xff);
 802     int vy = (int)(sinarc*0xff);
 803
 804     int width = xb - xt + 1;
 805     int height = yb - yt + 1;
 806
 807     if (buf == NULL) return;
 808
 809     startRGB.red = (start_rgb >> 16) & 0xff;
 810     startRGB.green = (start_rgb >> 8) & 0xff;
 811     startRGB.blue = start_rgb & 0xff;
 812
 813     endRGB.red = (end_rgb >> 16) & 0xff;
 814     endRGB.green = (end_rgb >> 8) & 0xff;
 815     endRGB.blue = end_rgb & 0xff;
 816
 817     diffR = endRGB.red - startRGB.red;
 818     diffG = endRGB.green - startRGB.green;
 819     diffB = endRGB.blue - startRGB.blue;
 820
 821     /* Normalize the angle */
 822     if (angle < 0) angle = 360 - ((-angle)%360);
 823     if (angle >= 0) angle = angle % 360;
 824
 825     if (angle <= 90 || (angle > 180 && angle <= 270))
 826     {
 827         /* The to be intersected diagonal goes from the top left edge to the bottom right edge */
 828         xs = 0;
 829         ys = 0;
 830         xw = width;
 831         yw = height;
 832     } else
 833     {
 834         /* The to be intersected diagonal goes from the bottom left edge to the top right edge */
 835         xs = 0;
 836         ys = height;
 837         xw = width;
 838         yw = -height;
 839     }
 840
 841     if (angle > 90 && angle <= 270)
 842     {
 843         /* for these angle we have y1 = height - y1. Instead of
 844         *
 845         *  y1 = height - (-vy*(yw*  xs -xw*  ys)         + yw*(vy*  x -vx*  y))        /(-yw*vx + xw*vy);
 846         *
 847         * we can write
 848         *
 849         *  y1 =          (-vy*(yw*(-xs)-xw*(-ys+height)) + yw*(vy*(-x)-vx*(-y+height)))/(-yw*vx + xw*vy);
 850         *
 851         * so height - y1 can be expressed with the normal formular adapting some parameters.
 852         *
 853         * Note that if one would exchanging startRGB/endRGB the values would only work
 854         * for linear color gradients
 855  */
 856         xadd = -1;
 857         yadd = -1;
 858         ystart = height;
 859
 860         xs = -xs;
 861         ys = -ys + height;
 862     }
 863     else
 864     {
 865         xadd = 1;
 866         yadd = 1;
 867         ystart = 0;
 868     }
 869
 870     r = -vy*(yw*xs-xw*ys);
 871     t = -yw*vx + xw*vy;
 872
 873     /* The formular as shown above is
 874     *
 875     *    y1 = ((-vy*(yw*xs-xw*ys) + yw*(vy*x-vx*y)) /(-yw*vx + xw*vy));
 876     *
 877     * We see that only yw*(vy*x-vx*y) changes during the loop.
 878     *
 879     * We write
 880     *
 881     *   Current Pixel: y1(x,y) = (r + yw*(vy*x-vx*y))/t = r/t + yw*(vy*x-vx*y)/t
 882     *   Next Pixel:    y1(x+xadd,y) = (r + vw*(vy*(x+xadd)-vx*y))/t
 883     *
 884     *   t*(y1(x+xadd,y) - y1(x,y)) = yw*(vy*(x+xadd)-vx*y) - yw*(vy*x-vx*y) = yw*vy*xadd;
 885     *
 886     */
 887
 888     incr_y1 = yw*vy*xadd;
 889     UBYTE *bufptr = buf;
 890     for (l = 0, y = ystart + ((yp - yt)* yadd); l < h; l++, y+=yadd)
 891     {
 892
 893         /* Calculate initial y1 accu, can be brought out of the loop as well (x=0). It's probably a
 894         * a good idea to add here also a value of (t-1)/2 to ensure the correct rounding
 895         * This (and for r) is also a place were actually a overflow can happen |yw|=16 |y|=16. So for
 896  * vx nothing is left, currently 9 bits are used for vx or vy */
 897         int y1_mul_t_accu = r - yw*vx*y;
 898
 899
 900
 901         for (c = 0, x = ((xp - xt) * xadd); c < w; c++, x+=xadd)
 902         {
 903             int red,green,blue;
 904
 905             /* Calculate the intersection of two lines, this is not the fastet way to do but
 906             * it is intuitive. Note: very slow! Will be optimzed later (remove FFP usage
 907             * and making it incremental)...update: it's now incremental and no FFP is used
 908             * but it probably can be optimized more by removing some more of the divisions and
 909      * further specialize the stuff here (use of three accus). */
 910             /*      y1 = (int)((-vy*(yw*xs-xw*ys) + yw*(vy*x-vx*y)) /(-yw*vx + xw*vy));*/
 911             y1 = y1_mul_t_accu / t;
 912
 913             red = startRGB.red + (int)(diffR*y1/height);
 914             green = startRGB.green + (int)(diffG*y1/height);
 915             blue = startRGB.blue + (int)(diffB*y1/height);
 916             /* By using full 32 bits this can be made faster as well */
 917             *bufptr++ = red;
 918             *bufptr++ = green;
 919             *bufptr++ = blue;
 920
 921             y1_mul_t_accu += incr_y1;
 922         }
 923     }
 924
 925 }
 926
 927 void FillPixelArrayGradient(LONG pen, BOOL tc, struct RastPort *rp, LONG xt, LONG yt, LONG xb, LONG yb, LONG xp, LONG yp, LONG w, LONG h, ULONG start_rgb, ULONG end_rgb, LONG angle, LONG dx, LONG dy)
 928 {
 929     UBYTE * buf = NULL;
 930
 931     if ((w <= 0) || (h <= 0)) return;
 932
 933         /* By bringing building the gradient array in the same format as the RastPort BitMap a call
 934         to WritePixelArray() can be made also faster */
 935     buf = AllocVec(1 * yb * 3, 0);
 936
 937     FillMemoryBufferRGBGradient(buf, pen, xt, yt, xb, yb, xp, yp, 1, yb, start_rgb, end_rgb, angle);
 938
 939     HorizRepeatBuffer(buf, dy, pen, tc, rp, xp, yp, w, h);
 940
 941     FreeVec(buf);
 942 }
 943
 944 void HorizRepeatBuffer(UBYTE * buf, LONG offy, LONG pen, BOOL tc, struct RastPort *rp, LONG x, LONG y, LONG w, LONG h)
 945 {
 946     UBYTE * bufblit = NULL;
 947     ULONG xi, yi;
 948     ULONG idxd;
 949     ULONG idxs;
 950
 951     if ((w <= 0) || (h <= 0)) return;
 952     if (!tc)
 953     {
 954         if (pen != -1) SetAPen(rp, pen); else SetAPen(rp, 2);
 955         RectFill(rp, x, y, x + w - 1, y + h - 1);
 956         return;
 957     }
 958
 959     /* By bringing building the gradient array in the same format as the RastPort BitMap a call
 960        to WritePixelArray() can be made also faster */
 961     bufblit = AllocVec(w * h * 3, MEMF_ANY);
 962
 963     /* Copy one column buffer into blit buffer */
 964     for (yi = 0; yi < h; yi++)
 965     {
 966         idxs = (offy + yi) * 3; /* source index */
 967         idxd = yi * 3 * w; /* dest index */
 968         for (xi = 0; xi < w; xi++)
 969         {
 970             /* Copy RGB pixel */
 971             bufblit[idxd++] = buf[idxs + 0];
 972             bufblit[idxd++] = buf[idxs + 1];
 973             bufblit[idxd++] = buf[idxs + 2];
 974         }
 975     }
 976
 977     WritePixelArray(bufblit, 0, 0, w * 3, rp, x, y, w, h, RECTFMT_RGB);
 978
 979     FreeVec(bufblit);
 980 }
 981
 982 void TileMapToBitmap(struct NewImage *src, struct TileInfo *srcti, struct BitMap *map, UWORD dw, UWORD dh)
 983 {
 984     UWORD   y, h;
 985
 986     if (map == NULL) return;
 987     if (src == NULL) return;
 988     if (srcti == NULL) return;
 989     y = 0;
 990
 991     h = src->h;
 992
 993     if ((srcti->TileTop + srcti->TileBottom) > dh) return;
 994     if ((srcti->TileLeft + srcti->TileRight) > dw) return;
 995
 996     struct RastPort *dest = CreateRastPort();
 997
 998     if (dest != NULL)
 999     {
1000         dest->BitMap = map;
1001
1002         DrawMapTileToRP(src, dest, 0, y, srcti->TileLeft, srcti->TileTop, 0 , 0, srcti->TileLeft, srcti->TileTop);
1003         DrawMapTileToRP(src, dest, 0, y + h - srcti->TileBottom, srcti->TileLeft, srcti->TileBottom, 0 , dh - srcti->TileBottom, srcti->TileLeft, srcti->TileBottom);
1004         DrawMapTileToRP(src, dest, src->w - srcti->TileRight, y, srcti->TileRight, srcti->TileTop, dw - srcti->TileRight, 0, srcti->TileRight, srcti->TileTop);
1005         DrawMapTileToRP(src, dest, src->w - srcti->TileRight, y + h - srcti->TileBottom, srcti->TileRight, srcti->TileBottom, dw - srcti->TileRight , dh - srcti->TileBottom, srcti->TileRight, srcti->TileBottom);
1006
1007         DrawMapTileToRP(src, dest, srcti->TileLeft, y, src->w - srcti->TileLeft - srcti->TileRight, srcti->TileTop, srcti->TileLeft, 0, dw - srcti->TileLeft - srcti->TileRight, srcti->TileTop);
1008         DrawMapTileToRP(src, dest, srcti->TileLeft, y + h - srcti->TileBottom, src->w - srcti->TileLeft - srcti->TileRight, srcti->TileBottom, srcti->TileLeft, dh - srcti->TileBottom, dw - srcti->TileLeft - srcti->TileRight, srcti->TileBottom);
1009         DrawMapTileToRP(src, dest, 0, y + srcti->TileTop, srcti->TileLeft, h - srcti->TileBottom - srcti->TileTop, 0 , srcti->TileTop + 0, srcti->TileLeft, dh - srcti->TileTop - srcti->TileBottom - 0);
1010         DrawMapTileToRP(src, dest, src->w - srcti->TileRight, y + srcti->TileTop, srcti->TileRight,  h - srcti->TileBottom - srcti->TileTop, dw - srcti->TileRight, srcti->TileTop + 0, srcti->TileRight, dh - srcti->TileTop - srcti->TileBottom - 0);
1011         DrawMapTileToRP(src, dest, srcti->TileLeft, y + srcti->TileTop, src->w - srcti->TileLeft - srcti->TileRight, h - srcti->TileBottom - srcti->TileTop, srcti->TileLeft, srcti->TileTop + 0, dw - srcti->TileLeft - srcti->TileRight, dh - srcti->TileTop - srcti->TileBottom - 0);
1012         FreeRastPort(dest);
1013     }
1014 }
1015
1016 struct NewImage *GetImageFromRP(struct RastPort *rp, UWORD x, UWORD y, UWORD w, UWORD h)
1017 {
1018     struct NewImage *ni;
1019
1020     ni = NewImageContainer(w, h);
1021     if (ni)
1022     {
1023         ReadPixelArray(ni->data, 0, 0, w*4, rp, x, y, w, h, RECTFMT_ARGB);
1024     }
1025     return ni;
1026 }
1027
1028 void PutImageToRP(struct RastPort *rp, struct NewImage *ni, UWORD x, UWORD y) {
1029
1030     if (ni)
1031     {
1032         if (ni->data) WritePixelArray(ni->data, 0, 0, ni->w*4, rp, x, y, ni->w, ni->h, RECTFMT_ARGB);
1033         DisposeImageContainer(ni);
1034     }
1035 }
1036
1037 void ShadeLine(LONG pen, BOOL tc, BOOL usegradients, struct RastPort *rp, struct NewImage *ni, ULONG basecolor, UWORD fact, UWORD _offy, UWORD x0, UWORD y0, UWORD x1, UWORD y1)
1038 {
1039     int px, py, x, y;
1040     ULONG   c;
1041     int     c0, c1, c2, c3;
1042     UWORD   offy = 0;
1043
1044     if ((x1 < x0) || (y1 < y0)) return;
1045     if (!tc)
1046     {
1047         SetAPen(rp, pen);
1048         Move(rp, x0, y0);
1049         Draw(rp, x1, y1);
1050         return;
1051     }
1052     if (usegradients)
1053     {
1054         c = basecolor;
1055         c3 = (c >> 24) & 0xff;
1056         c2 = (c >> 16) & 0xff;
1057         c1 = (c >> 8) & 0xff;
1058         c0 = c & 0xff;
1059         c0 *= fact;
1060         c1 *= fact;
1061         c2 *= fact;
1062         c3 *= fact;
1063         c0 = c0 >> 8;
1064         c1 = c1 >> 8;
1065         c2 = c2 >> 8;
1066         c3 = c3 >> 8;
1067         if (c0 > 255) c0 = 255;
1068         if (c1 > 255) c1 = 255;
1069         if (c2 > 255) c2 = 255;
1070         if (c3 > 255) c3 = 255;
1071         c = (c3 << 24) | (c2 << 16) | (c1 << 8) | c0;
1072         SetRPAttrs(rp, RPTAG_PenMode, FALSE, RPTAG_FgColor, c, TAG_DONE);
1073         Move(rp, x0, y0);
1074         Draw(rp, x1, y1);
1075     }
1076     else if (ni->ok)
1077     {
1078         if (x0 == x1)
1079         {
1080             x = x0 % ni->w;
1081             for (py = y0; py < y1; py++)
1082             {
1083                 y = (py - offy) % ni->h;
1084                 c = ni->data[x + y * ni->w];
1085                 c0 = (c >> 24) & 0xff;
1086                 c1 = (c >> 16) & 0xff;
1087                 c2 = (c >> 8) & 0xff;
1088                 c3 = c & 0xff;
1089                 c0 *= fact;
1090                 c1 *= fact;
1091                 c2 *= fact;
1092                 c3 *= fact;
1093                 c0 = c0 >> 8;
1094                 c1 = c1 >> 8;
1095                 c2 = c2 >> 8;
1096                 c3 = c3 >> 8;
1097                 if (c0 > 255) c0 = 255;
1098                 if (c1 > 255) c1 = 255;
1099                 if (c2 > 255) c2 = 255;
1100                 if (c3 > 255) c3 = 255;
1101                 c = (c3 << 24) | (c2 << 16) | (c1 << 8) | c0;
1102                 WriteRGBPixel(rp, x0, py, c);
1103             }
1104         } else {
1105             y = (y0 - offy) % ni->h;
1106             for (px = x0; px < x1; px++) {
1107                 x = px % ni->h;
1108                 c = ni->data[x + y * ni->w];
1109                 c0 = (c >> 24) & 0xff;
1110                 c1 = (c >> 16) & 0xff;
1111                 c2 = (c >> 8) & 0xff;
1112                 c3 = c & 0xff;
1113                 c0 *= fact;
1114                 c1 *= fact;
1115                 c2 *= fact;
1116                 c3 *= fact;
1117                 c0 = c0 >> 8;
1118                 c1 = c1 >> 8;
1119                 c2 = c2 >> 8;
1120                 c3 = c3 >> 8;
1121                 if (c0 > 255) c0 = 255;
1122                 if (c1 > 255) c1 = 255;
1123                 if (c2 > 255) c2 = 255;
1124                 if (c3 > 255) c3 = 255;
1125                 c = (c3 << 24) | (c2 << 16) | (c1 << 8) | c0;
1126                 WriteRGBPixel(rp, px, y0, c);
1127             }
1128         }
1129     }
1130     else
1131     {
1132         Move(rp, x0, y0);
1133         Draw(rp, x1, y1);
1134     }
1135 }
1136
1137 void DrawScaledStatefulGadgetImageToRP(struct RastPort *rp, struct NewImage *ni, ULONG state, UWORD xp, UWORD yp,
1138         WORD scaledwidth, WORD scaledheight)
1139 {
1140
1141     UWORD subimagecol = 0;
1142     UWORD subimagerow = 0;
1143
1144     if (ni->ok)
1145     {
1146         switch(state)
1147         {
1148             case IDS_NORMAL:
1149                 break;
1150             case IDS_SELECTED:
1151                 subimagecol = 1;
1152                 break;
1153             case IDS_INACTIVENORMAL:
1154                 subimagecol = 2;
1155                 break;
1156         }
1157
1158         BltScaleNewImageSubImageRastPortSimple(ni, subimagecol, subimagerow, rp, xp, yp, scaledwidth, scaledheight);
1159     }
1160 }
1161
1162 void DrawStatefulGadgetImageToRP(struct RastPort *rp, struct NewImage *ni, ULONG state, UWORD xp, UWORD yp)
1163 {
1164     DrawScaledStatefulGadgetImageToRP(rp, ni, state, xp, yp, -1, -1);
1165 }