workbench/libs/muimaster/classes/bitmap.c

   1 /*
   2     Copyright © 2002-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <graphics/gfx.h>
   7 #include <graphics/view.h>
   8 #include <clib/alib_protos.h>
   9 #include <cybergraphx/cybergraphics.h>
  10 #include <proto/exec.h>
  11 #include <proto/graphics.h>
  12 #include <proto/utility.h>
  13 #include <proto/cybergraphics.h>
  14 #include <proto/intuition.h>
  15 #include <proto/muimaster.h>
  16
  17 #include "mui.h"
  18 #include "muimaster_intern.h"
  19 #include "support.h"
  20
  21 #include <string.h>
  22
  23 extern struct Library *MUIMasterBase;
  24
  25 struct MUI_BitmapData
  26 {
  27     struct BitMap *bm, *remapped_bm;
  28     ULONG *sourcecolors;
  29     LONG width, height, precision, transparent;
  30     UBYTE *mappingtable;
  31     PLANEPTR mask;
  32     WORD *remaptable;
  33     BYTE usefriend;
  34 };
  35
  36 static void remap_bitmap(struct IClass *cl, Object *obj)
  37 {
  38     struct MUI_BitmapData *data = INST_DATA(cl, obj);
  39     struct BitMap *friendbm = NULL;
  40     struct RastPort temprp, bmrp, *scrrp;
  41     UBYTE *linebuffer;
  42     ULONG *cgfxcoltab = NULL;
  43     LONG bmflags = 0;
  44     WORD bmdepth, bmwidth, bmheight, bmcols, x, y;
  45
  46     if (!data->mappingtable && !data->sourcecolors)
  47         return;
  48     if (!data->bm || (data->width < 1) || (data->height < 1))
  49         return;
  50
  51     /* Don't remap if bitmap is hicolor/truecolor */
  52     if (GetBitMapAttr(data->bm, BMA_DEPTH) > 8)
  53         return;
  54
  55     if (!data->mappingtable && !data->remaptable)
  56     {
  57         data->remaptable =
  58             AllocVec(256 * sizeof(WORD), MEMF_PUBLIC | MEMF_CLEAR);
  59         if (!data->remaptable)
  60             return;
  61     }
  62
  63     scrrp = &_screen(obj)->RastPort;
  64
  65     if (data->usefriend)
  66     {
  67         friendbm = scrrp->BitMap;
  68         bmflags |= BMF_MINPLANES;
  69     }
  70
  71     linebuffer = AllocVec(data->width + 16, MEMF_PUBLIC);
  72     if (!linebuffer)
  73         return;
  74
  75     bmdepth = GetBitMapAttr(scrrp->BitMap, BMA_DEPTH);
  76     if (bmdepth > 8)
  77         bmdepth = 8;
  78
  79     bmcols = 1L << bmdepth;
  80
  81     data->remapped_bm =
  82         AllocBitMap(data->width, data->height, bmdepth, bmflags, friendbm);
  83
  84     if (!data->remapped_bm)
  85     {
  86         FreeVec(linebuffer);
  87         return;
  88     }
  89
  90     bmwidth = GetBitMapAttr(data->remapped_bm, BMA_WIDTH);
  91     bmheight = GetBitMapAttr(data->remapped_bm, BMA_HEIGHT);
  92
  93     if (data->transparent != -1)
  94     {
  95         data->mask = AllocRaster(bmwidth, bmheight);
  96         memset(data->mask, 0xff, RASSIZE(bmwidth, bmheight));
  97     }
  98
  99     if (CyberGfxBase &&
 100         !data->mappingtable &&
 101         (GetBitMapAttr(data->remapped_bm, BMA_DEPTH) >= 15))
 102     {
 103         cgfxcoltab = AllocVec(bmcols * sizeof(ULONG), MEMF_ANY);
 104
 105         if (cgfxcoltab)
 106         {
 107             for (y = 0; y < bmcols; y++)
 108             {
 109                 ULONG red = data->sourcecolors[y * 3] & 0xFF000000;
 110                 ULONG green = data->sourcecolors[y * 3 + 1] & 0xFF000000;
 111                 ULONG blue = data->sourcecolors[y * 3 + 2] & 0xFF000000;
 112
 113                 cgfxcoltab[y] = (red >> 8) | (green >> 16) | (blue >> 24);
 114             }
 115         }
 116
 117     }
 118
 119     InitRastPort(&temprp);
 120     temprp.BitMap = AllocBitMap(data->width, 1, 1, 0, NULL);
 121
 122     InitRastPort(&bmrp);
 123
 124     for (y = 0; y < data->height; y++)
 125     {
 126         /* Read a line from source bitmap */
 127
 128         bmrp.BitMap = data->bm;
 129         if (temprp.BitMap)
 130         {
 131             ReadPixelLine8(&bmrp, 0, y, data->width, linebuffer, &temprp);
 132         }
 133         else
 134         {
 135             for (x = 0; x < data->width; x++)
 136             {
 137                 linebuffer[x] = ReadPixel(&bmrp, x, y);
 138             }
 139         }
 140
 141         /* Build the mask, totaly slow but works */
 142         if (data->mask)
 143         {
 144             UBYTE *mask = data->mask + y * bmwidth / 8;
 145             UBYTE xmask = 0x80;
 146
 147             for (x = 0; x < data->width; x++)
 148             {
 149                 if (linebuffer[x] == data->transparent)
 150                 {
 151                     *mask &= ~xmask;
 152                 }
 153
 154                 xmask >>= 1;
 155                 if (!xmask)
 156                 {
 157                     xmask = 0x80;
 158                     mask++;
 159                 }
 160             }
 161         }
 162
 163         /* Remap the line */
 164         if (data->mappingtable)
 165         {
 166             for (x = 0; x < data->width; x++)
 167             {
 168                 linebuffer[x] = data->mappingtable[linebuffer[x]];
 169             }
 170         }
 171         else if (!cgfxcoltab)
 172         {
 173             for (x = 0; x < data->width; x++)
 174             {
 175                 UBYTE pixel = linebuffer[x];
 176                 UBYTE remappixel = data->remaptable[pixel];
 177
 178                 if (!remappixel)
 179                 {
 180                     struct TagItem tags[3];
 181                     tags[0].ti_Tag = OBP_Precision;
 182                     tags[0].ti_Data = data->precision;
 183                     tags[1].ti_Tag = OBP_FailIfBad;
 184                     tags[1].ti_Data = FALSE;
 185                     tags[2].ti_Tag = 0;
 186
 187                     data->remaptable[pixel] = remappixel =
 188                         ObtainBestPenA(_screen(obj)->ViewPort.ColorMap,
 189                         data->sourcecolors[pixel * 3],
 190                         data->sourcecolors[pixel * 3 + 1],
 191                         data->sourcecolors[pixel * 3 + 2], tags) | 0x100;
 192                 }
 193
 194                 linebuffer[x] = (remappixel & 0xFF);
 195             }
 196
 197         }
 198
 199         /* Write line into destination bitmap */
 200
 201         bmrp.BitMap = data->remapped_bm;
 202
 203         if (cgfxcoltab)
 204         {
 205             WriteLUTPixelArray(linebuffer,
 206                 0,
 207                 0,
 208                 data->width,
 209                 &bmrp, cgfxcoltab, 0, y, data->width, 1, CTABFMT_XRGB8);
 210         }
 211         else
 212         {
 213             bmrp.BitMap = data->remapped_bm;
 214             if (temprp.BitMap)
 215             {
 216                 WritePixelLine8(&bmrp, 0, y, data->width, linebuffer,
 217                     &temprp);
 218             }
 219             else
 220             {
 221                 for (x = 0; x < data->width; x++)
 222                 {
 223                     SetAPen(&bmrp, linebuffer[x]);
 224                     WritePixel(&bmrp, x, y);
 225                 }
 226             }
 227
 228         }
 229
 230     }
 231
 232     if (temprp.BitMap)
 233     {
 234         WaitBlit();
 235         FreeBitMap(temprp.BitMap);
 236     }
 237
 238     FreeVec(cgfxcoltab);
 239     FreeVec(linebuffer);
 240 }
 241
 242 /**************************************************************************
 243  OM_NEW
 244 **************************************************************************/
 245 IPTR Bitmap__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 246 {
 247     struct MUI_BitmapData *data;
 248     struct TagItem *tag, *tags;
 249
 250     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
 251     if (!obj)
 252         return FALSE;
 253
 254     data = INST_DATA(cl, obj);
 255
 256     data->precision = PRECISION_GUI;
 257     data->transparent = -1;
 258
 259     /* parse initial taglist */
 260
 261     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 262     {
 263         switch (tag->ti_Tag)
 264         {
 265         case MUIA_Bitmap_Bitmap:
 266             data->bm = (struct BitMap *)tag->ti_Data;
 267             break;
 268
 269         case MUIA_Bitmap_Height:
 270             data->height = (LONG) tag->ti_Data;
 271             break;
 272
 273         case MUIA_Bitmap_MappingTable:
 274             data->mappingtable = (UBYTE *) tag->ti_Data;
 275             break;
 276
 277         case MUIA_Bitmap_Precision:
 278             data->precision = (LONG) tag->ti_Data;
 279             break;
 280
 281         case MUIA_Bitmap_SourceColors:
 282             data->sourcecolors = (ULONG *) tag->ti_Data;
 283             break;
 284
 285         case MUIA_Bitmap_Transparent:
 286             data->transparent = (LONG) tag->ti_Data;
 287             break;
 288
 289         case MUIA_Bitmap_UseFriend:
 290             data->usefriend = (tag->ti_Data != 0);
 291             break;
 292
 293         case MUIA_Bitmap_Width:
 294             data->width = (LONG) tag->ti_Data;
 295             break;
 296
 297         }
 298     }
 299
 300     return (IPTR) obj;
 301 }
 302
 303 /**************************************************************************
 304  OM_DISPOSE
 305 **************************************************************************/
 306 IPTR Bitmap__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 307 {
 308     struct MUI_BitmapData *data = INST_DATA(cl, obj);
 309
 310     if (data->remapped_bm)
 311     {
 312         WaitBlit();
 313         FreeBitMap(data->remapped_bm);
 314     }
 315     if (data->remaptable)
 316         FreeVec(data->remaptable);
 317
 318     return DoSuperMethodA(cl, obj, msg);
 319 }
 320
 321 /**************************************************************************
 322  OM_SET
 323 **************************************************************************/
 324 IPTR Bitmap__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 325 {
 326     struct MUI_BitmapData *data = INST_DATA(cl, obj);
 327     struct TagItem *tags = msg->ops_AttrList;
 328     struct TagItem *tag;
 329
 330     while ((tag = NextTagItem(&tags)) != NULL)
 331     {
 332         switch (tag->ti_Tag)
 333         {
 334         case MUIA_Bitmap_Bitmap:
 335             if (!data->remapped_bm)
 336             {
 337                 data->bm = (struct BitMap *)tag->ti_Data;
 338             }
 339             break;
 340
 341         case MUIA_Bitmap_Height:
 342             data->height = (LONG) tag->ti_Data;
 343             break;
 344
 345         case MUIA_Bitmap_MappingTable:
 346             data->mappingtable = (UBYTE *) tag->ti_Data;
 347             break;
 348
 349         case MUIA_Bitmap_Precision:
 350             data->precision = (LONG) tag->ti_Data;
 351             break;
 352
 353         case MUIA_Bitmap_SourceColors:
 354             data->sourcecolors = (ULONG *) tag->ti_Data;
 355             break;
 356
 357         case MUIA_Bitmap_Transparent:
 358             data->transparent = (LONG) tag->ti_Data;
 359             break;
 360
 361         case MUIA_Bitmap_Width:
 362             data->width = (LONG) tag->ti_Data;
 363             break;
 364
 365         }
 366     }
 367
 368     return DoSuperMethodA(cl, obj, (Msg) msg);
 369 }
 370
 371 /**************************************************************************
 372  OM_GET
 373 **************************************************************************/
 374 IPTR Bitmap__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 375 {
 376 #define STORE *(msg->opg_Storage)
 377
 378     struct MUI_BitmapData *data = INST_DATA(cl, obj);
 379
 380     switch (msg->opg_AttrID)
 381     {
 382     case MUIA_Bitmap_Bitmap:
 383         STORE = (IPTR) data->bm;
 384         return TRUE;
 385
 386     case MUIA_Bitmap_Height:
 387         STORE = (IPTR) data->height;
 388         return TRUE;
 389
 390     case MUIA_Bitmap_MappingTable:
 391         STORE = (IPTR) data->mappingtable;
 392         return TRUE;
 393
 394     case MUIA_Bitmap_Precision:
 395         STORE = (IPTR) data->precision;
 396         return TRUE;
 397
 398     case MUIA_Bitmap_RemappedBitmap:
 399         STORE = (IPTR) data->remapped_bm;
 400         return TRUE;
 401
 402     case MUIA_Bitmap_SourceColors:
 403         STORE = (IPTR) data->sourcecolors;
 404         return TRUE;
 405
 406     case MUIA_Bitmap_Transparent:
 407         STORE = (IPTR) data->transparent;
 408         return TRUE;
 409
 410     case MUIA_Bitmap_Width:
 411         STORE = (IPTR) data->width;
 412         return TRUE;
 413     }
 414
 415     return DoSuperMethodA(cl, obj, (Msg) msg);
 416 #undef STORE
 417 }
 418
 419 /**************************************************************************
 420  MUIM_Setup
 421 **************************************************************************/
 422 IPTR Bitmap__MUIM_Setup(struct IClass *cl, Object *obj, Msg msg)
 423 {
 424     //struct MUI_BitmapData *data = INST_DATA(cl, obj);
 425
 426     if (!DoSuperMethodA(cl, obj, (Msg) msg))
 427         return FALSE;
 428
 429     remap_bitmap(cl, obj);
 430
 431     return TRUE;
 432 }
 433
 434 /**************************************************************************
 435  MUIM_Cleanup
 436 **************************************************************************/
 437 IPTR Bitmap__MUIM_Cleanup(struct IClass *cl, Object *obj, Msg msg)
 438 {
 439     struct MUI_BitmapData *data = INST_DATA(cl, obj);
 440
 441     if (data->mask)
 442     {
 443         LONG bmwidth = GetBitMapAttr(data->remapped_bm, BMA_WIDTH);
 444         LONG bmheight = GetBitMapAttr(data->remapped_bm, BMA_HEIGHT);
 445         FreeRaster(data->mask, bmwidth, bmheight);
 446
 447         data->mask = NULL;
 448     }
 449
 450     if (data->remapped_bm)
 451     {
 452         WaitBlit();
 453         FreeBitMap(data->remapped_bm);
 454         data->remapped_bm = NULL;
 455
 456         if (data->remaptable)
 457         {
 458             WORD i;
 459
 460             for (i = 0; i < 256; i++)
 461             {
 462                 if (data->remaptable[i])
 463                 {
 464                     ReleasePen(_screen(obj)->ViewPort.ColorMap,
 465                         data->remaptable[i] & 0xFF);
 466                     data->remaptable[i] = 0;
 467                 }
 468             }
 469         }
 470     }
 471
 472     return DoSuperMethodA(cl, obj, (Msg) msg);
 473 }
 474
 475 /**************************************************************************
 476  MUIM_AskMinMax
 477 **************************************************************************/
 478 IPTR Bitmap__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 479     struct MUIP_AskMinMax *msg)
 480 {
 481     DoSuperMethodA(cl, obj, (Msg) msg);
 482
 483     msg->MinMaxInfo->MinWidth += 1;
 484     msg->MinMaxInfo->MinHeight += 1;
 485
 486     msg->MinMaxInfo->DefWidth += 1;
 487     msg->MinMaxInfo->DefHeight += 1;
 488
 489     msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
 490     msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
 491
 492     return TRUE;
 493 }
 494
 495 /**************************************************************************
 496  MUIM_Draw
 497 **************************************************************************/
 498 IPTR Bitmap__MUIM_Draw(struct IClass *cl, Object *obj,
 499     struct MUIP_Draw *msg)
 500 {
 501     struct MUI_BitmapData *data = INST_DATA(cl, obj);
 502     struct BitMap *bm;
 503
 504     DoSuperMethodA(cl, obj, (Msg) msg);
 505
 506     bm = data->remapped_bm ? data->remapped_bm : data->bm;
 507     if (bm)
 508     {
 509         LONG width, height;
 510
 511         width = data->width;
 512         height = data->height;
 513
 514         if (width > _mwidth(obj))
 515             width = _mwidth(obj);
 516         if (height > _mheight(obj))
 517             height = _mheight(obj);
 518
 519         if ((width > 0) && (height > 0))
 520         {
 521             if (data->mask)
 522             {
 523                 BltMaskBitMapRastPort(bm, 0, 0, _rp(obj), _mleft(obj),
 524                     _mtop(obj), width, height, 0xE0, data->mask);
 525             }
 526             else
 527             {
 528                 BltBitMapRastPort(bm, 0, 0, _rp(obj), _mleft(obj),
 529                     _mtop(obj), width, height, 0xC0);
 530             }
 531         }
 532     }
 533
 534     return TRUE;
 535 }
 536
 537
 538 BOOPSI_DISPATCHER(IPTR, Bitmap_Dispatcher, cl, obj, msg)
 539 {
 540     switch (msg->MethodID)
 541     {
 542     case OM_NEW:
 543         return Bitmap__OM_NEW(cl, obj, (struct opSet *)msg);
 544     case OM_DISPOSE:
 545         return Bitmap__OM_DISPOSE(cl, obj, msg);
 546     case OM_SET:
 547         return Bitmap__OM_SET(cl, obj, (struct opSet *)msg);
 548     case OM_GET:
 549         return Bitmap__OM_GET(cl, obj, (struct opGet *)msg);
 550     case MUIM_Setup:
 551         return Bitmap__MUIM_Setup(cl, obj, msg);
 552     case MUIM_Cleanup:
 553         return Bitmap__MUIM_Cleanup(cl, obj, msg);
 554     case MUIM_AskMinMax:
 555         return Bitmap__MUIM_AskMinMax(cl, obj,
 556             (struct MUIP_AskMinMax *)msg);
 557     case MUIM_Draw:
 558         return Bitmap__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
 559     }
 560
 561     return DoSuperMethodA(cl, obj, msg);
 562 }
 563 BOOPSI_DISPATCHER_END
 564
 565 /*
 566  * Class descriptor.
 567  */
 568 const struct __MUIBuiltinClass _MUI_Bitmap_desc =
 569 {
 570     MUIC_Bitmap,
 571     MUIC_Area,
 572     sizeof(struct MUI_BitmapData),
 573     (void *) Bitmap_Dispatcher
 574 };