workbench/libs/muimaster/classes/chunkyimage.c

   1 /*
   2     Copyright © 2002-2006, 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) ||
  40         (data->numcolors    > 256))
  41     {
  42         return FALSE;
  43     }
  44
  45     if (data->palette)
  46     {
  47         data->palette32 = AllocVec(data->numcolors * 3 * sizeof(ULONG), MEMF_ANY);
  48         if (!data->palette32) return FALSE;
  49
  50         if (data->palette32)
  51         {
  52             UBYTE *src = data->palette;
  53             ULONG *dest = data->palette32;
  54             WORD i;
  55
  56             for(i = 0; i < data->numcolors; i++)
  57             {
  58                 *dest++ = ((ULONG)(*src++)) * 0x01010101;
  59                 *dest++ = ((ULONG)(*src++)) * 0x01010101;
  60                 *dest++ = ((ULONG)(*src++)) * 0x01010101;
  61             }
  62         }
  63     }
  64
  65     for(depth = 1; (1L << depth) < data->numcolors; depth++)
  66     {
  67     }
  68
  69     data->bm = AllocBitMap(data->width, data->height, depth, BMF_CLEAR, NULL);
  70     if (!data->bm)
  71     {
  72         if (data->palette32)
  73         {
  74             FreeVec(data->palette32);
  75             data->palette32 = NULL;
  76         }
  77         return FALSE;
  78     }
  79
  80     InitRastPort(&temprp);
  81     temprp.BitMap = data->bm;
  82
  83     WriteChunkyPixels(&temprp,
  84                       0,
  85                       0,
  86                       data->width - 1,
  87                       data->height - 1,
  88                       data->pixels,
  89                       data->modulo);
  90
  91     DeinitRastPort(&temprp);
  92
  93     return TRUE;
  94 }
  95
  96 /**************************************************************************
  97  OM_NEW
  98 **************************************************************************/
  99 IPTR ChunkyImage__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 100 {
 101     struct MUI_ChunkyImageData    *data;
 102     struct TagItem              *tag, *tags;
 103
 104     obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
 105     if (!obj) return FALSE;
 106
 107     data = INST_DATA(cl, obj);
 108
 109     /* parse initial taglist */
 110
 111     data->modulo = 0xFFFF;
 112
 113     for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem**)&tags)); )
 114     {
 115         switch (tag->ti_Tag)
 116         {
 117             case MUIA_ChunkyImage_Pixels:
 118                 data->pixels = (UBYTE *)tag->ti_Data;
 119                 break;
 120
 121             case MUIA_ChunkyImage_Palette:
 122                 data->palette = (UBYTE *)tag->ti_Data;
 123                 break;
 124
 125             case MUIA_ChunkyImage_NumColors:
 126                 data->numcolors = (LONG)tag->ti_Data;
 127                 break;
 128
 129             case MUIA_ChunkyImage_Modulo:
 130                 data->modulo = (LONG)tag->ti_Data;
 131                 break;
 132
 133             case MUIA_Bitmap_Width:
 134                 data->width = (LONG)tag->ti_Data;
 135                 break;
 136
 137             case MUIA_Bitmap_Height:
 138                 data->height = (LONG)tag->ti_Data;
 139                 break;
 140
 141         }
 142     }
 143
 144     if (data->modulo == 0xFFFF) data->modulo = data->width;
 145
 146     return (IPTR)obj;
 147 }
 148
 149 /**************************************************************************
 150  OM_DISPOSE
 151 **************************************************************************/
 152 IPTR ChunkyImage__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 153 {
 154     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
 155
 156     if (data->bm)
 157     {
 158         WaitBlit();
 159         FreeBitMap(data->bm);
 160     }
 161
 162     return DoSuperMethodA(cl, obj, msg);
 163 }
 164
 165 /**************************************************************************
 166  OM_SET
 167 **************************************************************************/
 168 IPTR ChunkyImage__OM_SET(struct IClass *cl, Object *obj, 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((const struct TagItem**)&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, struct opGet *msg)
 212 {
 213 #define STORE *(msg->opg_Storage)
 214
 215     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
 216
 217     switch(msg->opg_AttrID)
 218     {
 219         case MUIA_ChunkyImage_Pixels:
 220             STORE = (IPTR)data->pixels;
 221             return TRUE;
 222
 223         case MUIA_ChunkyImage_Palette:
 224             STORE = (IPTR)data->palette;
 225             return TRUE;
 226
 227         case MUIA_ChunkyImage_NumColors:
 228             STORE = (IPTR)data->numcolors;
 229             return TRUE;
 230
 231         case MUIA_ChunkyImage_Modulo:
 232             STORE = (IPTR)data->modulo;
 233             return TRUE;
 234
 235     }
 236
 237     return DoSuperMethodA(cl, obj, (Msg)msg);
 238 #undef STORE
 239 }
 240
 241 /**************************************************************************
 242  MUIM_Setup
 243 **************************************************************************/
 244 IPTR ChunkyImage__MUIM_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
 245 {
 246     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
 247
 248     if (!make_bitmap(cl, obj)) return FALSE;
 249
 250     set(obj, MUIA_Bitmap_Bitmap, (IPTR)data->bm);
 251
 252     if (data->palette32)
 253     {
 254         set(obj, MUIA_Bitmap_SourceColors, (IPTR)data->palette32);
 255     }
 256
 257     if (!DoSuperMethodA(cl, obj, (Msg)msg))
 258     {
 259         set(obj, MUIA_Bitmap_Bitmap, NULL);
 260         WaitBlit();
 261         FreeBitMap(data->bm);
 262         data->bm = NULL;
 263         if (data->palette32)
 264         {
 265             set(obj, MUIA_Bitmap_SourceColors, NULL);
 266
 267             FreeVec(data->palette32);
 268             data->palette32 = NULL;
 269         }
 270         return FALSE;
 271     }
 272
 273     return TRUE;
 274 }
 275
 276 /**************************************************************************
 277  MUIM_Cleanup
 278 **************************************************************************/
 279 IPTR ChunkyImage__MUIM_Cleanup(struct IClass *cl, Object *obj, struct MUIP_Cleanup *msg)
 280 {
 281     struct MUI_ChunkyImageData *data = INST_DATA(cl, obj);
 282     IPTR                      retval;
 283
 284     retval = DoSuperMethodA(cl, obj, (Msg)msg);
 285     if (data->bm)
 286     {
 287         set(obj, MUIA_Bitmap_Bitmap, NULL);
 288
 289         WaitBlit();
 290
 291         FreeBitMap(data->bm);
 292         data->bm = NULL;
 293
 294         if (data->palette32)
 295         {
 296             set(obj, MUIA_Bitmap_SourceColors, NULL);
 297             FreeVec(data->palette32);
 298             data->palette32 = NULL;
 299         }
 300     }
 301
 302     return retval;
 303 }
 304
 305
 306 BOOPSI_DISPATCHER(IPTR, ChunkyImage_Dispatcher, cl, obj, msg)
 307 {
 308     switch (msg->MethodID)
 309     {
 310         case OM_NEW:       return ChunkyImage__OM_NEW(cl, obj, (struct opSet *)msg);
 311         case OM_DISPOSE:   return ChunkyImage__OM_DISPOSE(cl, obj, msg);
 312         case OM_SET:       return ChunkyImage__OM_SET(cl, obj, (struct opSet *)msg);
 313         case OM_GET:       return ChunkyImage__OM_GET(cl, obj, (struct opGet *)msg);
 314         case MUIM_Setup:   return ChunkyImage__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 315         case MUIM_Cleanup: return ChunkyImage__MUIM_Cleanup(cl, obj, (struct MUIP_Cleanup *)msg);
 316     }
 317
 318     return DoSuperMethodA(cl, obj, msg);
 319 }
 320 BOOPSI_DISPATCHER_END
 321
 322 /*
 323  * Class descriptor.
 324  */
 325 const struct __MUIBuiltinClass _MUI_ChunkyImage_desc = {
 326     MUIC_ChunkyImage,
 327     MUIC_Bitmap,
 328     sizeof(struct MUI_ChunkyImageData),
 329     (void*)ChunkyImage_Dispatcher
 330 };