workbench/libs/muimaster/classes/chunkyimage.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 <proto/exec.h>
  10 #include <proto/graphics.h>
  11 #include <proto/utility.h>
  12 #include <proto/intuition.h>
  13 #include <proto/muimaster.h>
  14
  15 #include "mui.h"
  16 #include "muimaster_intern.h"
  17 #include "support.h"
  18
  19 extern struct Library *MUIMasterBase;
  20
  21 struct MUI_ChunkyImageData
  22 {
  23     struct BitMap *bm;
  24     UBYTE *pixels;
  25     UBYTE *palette;
  26     ULONG *palette32;
  27     UWORD width, height, numcolors, modulo;
  28 };
  29
  30 static BOOL make_bitmap(struct IClass *cl, Object *obj)
  31 {
  32     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
  33     struct RastPort temprp;
  34     WORD depth;
  35
  36     if (!data->pixels ||
  37         (data->width < 1) ||
  38         (data->height < 1) ||
  39         (data->numcolors < 1) || (data->numcolors > 256))
  40     {
  41         return FALSE;
  42     }
  43
  44     if (data->palette)
  45     {
  46         data->palette32 =
  47             AllocVec(data->numcolors * 3 * sizeof(ULONG), MEMF_ANY);
  48         if (!data->palette32)
  49             return FALSE;
  50
  51         if (data->palette32)
  52         {
  53             UBYTE *src = data->palette;
  54             ULONG *dest = data->palette32;
  55             WORD i;
  56
  57             for (i = 0; i < data->numcolors; i++)
  58             {
  59                 *dest++ = ((ULONG) (*src++)) * 0x01010101;
  60                 *dest++ = ((ULONG) (*src++)) * 0x01010101;
  61                 *dest++ = ((ULONG) (*src++)) * 0x01010101;
  62             }
  63         }
  64     }
  65
  66     for (depth = 1; (1L << depth) < data->numcolors; depth++)
  67     {
  68     }
  69
  70     data->bm =
  71         AllocBitMap(data->width, data->height, depth, BMF_CLEAR, NULL);
  72     if (!data->bm)
  73     {
  74         if (data->palette32)
  75         {
  76             FreeVec(data->palette32);
  77             data->palette32 = NULL;
  78         }
  79         return FALSE;
  80     }
  81
  82     InitRastPort(&temprp);
  83     temprp.BitMap = data->bm;
  84
  85     WriteChunkyPixels(&temprp,
  86         0,
  87         0, data->width - 1, data->height - 1, data->pixels, data->modulo);
  88
  89     return TRUE;
  90 }
  91
  92 /**************************************************************************
  93  OM_NEW
  94 **************************************************************************/
  95 IPTR ChunkyImage__OM_NEW(struct IClass *cl, Object *obj,
  96     struct opSet *msg)
  97 {
  98     struct MUI_ChunkyImageData *data;
  99     struct TagItem *tag, *tags;
 100
 101     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
 102     if (!obj)
 103         return FALSE;
 104
 105     data = INST_DATA(cl, obj);
 106
 107     /* parse initial taglist */
 108
 109     data->modulo = 0xFFFF;
 110
 111     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 112     {
 113         switch (tag->ti_Tag)
 114         {
 115         case MUIA_ChunkyImage_Pixels:
 116             data->pixels = (UBYTE *) tag->ti_Data;
 117             break;
 118
 119         case MUIA_ChunkyImage_Palette:
 120             data->palette = (UBYTE *) tag->ti_Data;
 121             break;
 122
 123         case MUIA_ChunkyImage_NumColors:
 124             data->numcolors = (LONG) tag->ti_Data;
 125             break;
 126
 127         case MUIA_ChunkyImage_Modulo:
 128             data->modulo = (LONG) tag->ti_Data;
 129             break;
 130
 131         case MUIA_Bitmap_Width:
 132             data->width = (LONG) tag->ti_Data;
 133             break;
 134
 135         case MUIA_Bitmap_Height:
 136             data->height = (LONG) tag->ti_Data;
 137             break;
 138
 139         }
 140     }
 141
 142     if (data->modulo == 0xFFFF)
 143         data->modulo = data->width;
 144
 145     return (IPTR) obj;
 146 }
 147
 148 /**************************************************************************
 149  OM_DISPOSE
 150 **************************************************************************/
 151 IPTR ChunkyImage__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 152 {
 153     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
 154
 155     if (data->bm)
 156     {
 157         WaitBlit();
 158         FreeBitMap(data->bm);
 159     }
 160
 161     return DoSuperMethodA(cl, obj, msg);
 162 }
 163
 164 /**************************************************************************
 165  OM_SET
 166 **************************************************************************/
 167 IPTR ChunkyImage__OM_SET(struct IClass *cl, Object *obj,
 168     struct opSet *msg)
 169 {
 170     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
 171     struct TagItem *tags = msg->ops_AttrList;
 172     struct TagItem *tag;
 173
 174     while ((tag = NextTagItem(&tags)) != NULL)
 175     {
 176         switch (tag->ti_Tag)
 177         {
 178         case MUIA_ChunkyImage_Pixels:
 179             data->pixels = (UBYTE *) tag->ti_Data;
 180             break;
 181
 182         case MUIA_ChunkyImage_Palette:
 183             data->palette = (UBYTE *) tag->ti_Data;
 184             break;
 185
 186         case MUIA_ChunkyImage_NumColors:
 187             data->numcolors = (LONG) tag->ti_Data;
 188             break;
 189
 190         case MUIA_ChunkyImage_Modulo:
 191             data->modulo = (LONG) tag->ti_Data;
 192             break;
 193
 194         case MUIA_Bitmap_Width:
 195             data->width = (LONG) tag->ti_Data;
 196             break;
 197
 198         case MUIA_Bitmap_Height:
 199             data->height = (LONG) tag->ti_Data;
 200             break;
 201
 202         }
 203     }
 204
 205     return DoSuperMethodA(cl, obj, (Msg) msg);
 206 }
 207
 208 /**************************************************************************
 209  OM_GET
 210 **************************************************************************/
 211 IPTR ChunkyImage__OM_GET(struct IClass *cl, Object *obj,
 212     struct opGet *msg)
 213 {
 214 #define STORE *(msg->opg_Storage)
 215
 216     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
 217
 218     switch (msg->opg_AttrID)
 219     {
 220     case MUIA_ChunkyImage_Pixels:
 221         STORE = (IPTR) data->pixels;
 222         return TRUE;
 223
 224     case MUIA_ChunkyImage_Palette:
 225         STORE = (IPTR) data->palette;
 226         return TRUE;
 227
 228     case MUIA_ChunkyImage_NumColors:
 229         STORE = (IPTR) data->numcolors;
 230         return TRUE;
 231
 232     case MUIA_ChunkyImage_Modulo:
 233         STORE = (IPTR) data->modulo;
 234         return TRUE;
 235
 236     }
 237
 238     return DoSuperMethodA(cl, obj, (Msg) msg);
 239 #undef STORE
 240 }
 241
 242 /**************************************************************************
 243  MUIM_Setup
 244 **************************************************************************/
 245 IPTR ChunkyImage__MUIM_Setup(struct IClass *cl, Object *obj,
 246     struct MUIP_Setup *msg)
 247 {
 248     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
 249
 250     if (!make_bitmap(cl, obj))
 251         return FALSE;
 252
 253     set(obj, MUIA_Bitmap_Bitmap, (IPTR) data->bm);
 254
 255     if (data->palette32)
 256     {
 257         set(obj, MUIA_Bitmap_SourceColors, (IPTR) data->palette32);
 258     }
 259
 260     if (!DoSuperMethodA(cl, obj, (Msg) msg))
 261     {
 262         set(obj, MUIA_Bitmap_Bitmap, NULL);
 263         WaitBlit();
 264         FreeBitMap(data->bm);
 265         data->bm = NULL;
 266         if (data->palette32)
 267         {
 268             set(obj, MUIA_Bitmap_SourceColors, NULL);
 269
 270             FreeVec(data->palette32);
 271             data->palette32 = NULL;
 272         }
 273         return FALSE;
 274     }
 275
 276     return TRUE;
 277 }
 278
 279 /**************************************************************************
 280  MUIM_Cleanup
 281 **************************************************************************/
 282 IPTR ChunkyImage__MUIM_Cleanup(struct IClass *cl, Object *obj,
 283     struct MUIP_Cleanup *msg)
 284 {
 285     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
 286     IPTR retval;
 287
 288     retval = DoSuperMethodA(cl, obj, (Msg) msg);
 289     if (data->bm)
 290     {
 291         set(obj, MUIA_Bitmap_Bitmap, NULL);
 292
 293         WaitBlit();
 294
 295         FreeBitMap(data->bm);
 296         data->bm = NULL;
 297
 298         if (data->palette32)
 299         {
 300             set(obj, MUIA_Bitmap_SourceColors, NULL);
 301             FreeVec(data->palette32);
 302             data->palette32 = NULL;
 303         }
 304     }
 305
 306     return retval;
 307 }
 308
 309
 310 BOOPSI_DISPATCHER(IPTR, ChunkyImage_Dispatcher, cl, obj, msg)
 311 {
 312     switch (msg->MethodID)
 313     {
 314     case OM_NEW:
 315         return ChunkyImage__OM_NEW(cl, obj, (struct opSet *)msg);
 316     case OM_DISPOSE:
 317         return ChunkyImage__OM_DISPOSE(cl, obj, msg);
 318     case OM_SET:
 319         return ChunkyImage__OM_SET(cl, obj, (struct opSet *)msg);
 320     case OM_GET:
 321         return ChunkyImage__OM_GET(cl, obj, (struct opGet *)msg);
 322     case MUIM_Setup:
 323         return ChunkyImage__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 324     case MUIM_Cleanup:
 325         return ChunkyImage__MUIM_Cleanup(cl, obj,
 326             (struct MUIP_Cleanup *)msg);
 327     }
 328
 329     return DoSuperMethodA(cl, obj, msg);
 330 }
 331 BOOPSI_DISPATCHER_END
 332
 333 /*
 334  * Class descriptor.
 335  */
 336 const struct __MUIBuiltinClass _MUI_ChunkyImage_desc =
 337 {
 338     MUIC_ChunkyImage,
 339     MUIC_Bitmap,
 340     sizeof(struct MUI_ChunkyImageData),
 341     (void *) ChunkyImage_Dispatcher
 342 };