rom/hidds/graphics/CM_Class.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Graphics colormap class implementation.
   6     Lang: english
   7 */
   8
   9 /****************************************************************************************/
  10
  11 #include <string.h>
  12
  13 #include <proto/exec.h>
  14 #include <proto/utility.h>
  15 #include <proto/oop.h>
  16 #include <proto/arossupport.h>
  17
  18 #include <exec/memory.h>
  19 #include <utility/tagitem.h>
  20 #include <oop/oop.h>
  21 #include <graphics/text.h>
  22
  23 #include <hidd/graphics.h>
  24
  25 #include "graphics_intern.h"
  26
  27 #define DEBUG 0
  28 #include <aros/debug.h>
  29
  30 /*****************************************************************************************
  31
  32     NAME
  33         aoHidd_ColorMap_NumEntries
  34
  35     SYNOPSIS
  36         [I.G], ULONG
  37
  38     LOCATION
  39         CLID_Hidd_ColorMap
  40
  41     FUNCTION
  42         Number of colors in the colormap.
  43
  44     NOTES
  45
  46     EXAMPLE
  47
  48     BUGS
  49
  50     SEE ALSO
  51
  52     INTERNALS
  53
  54 *****************************************************************************************/
  55
  56 OOP_Object *CM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  57 {
  58     struct Library *UtilityBase = CSD(cl)->cs_UtilityBase;
  59     struct Library *OOPBase = CSD(cl)->cs_OOPBase;
  60     struct colormap_data    *data;
  61     ULONG                   numentries;
  62     struct TagItem          *tag, *tstate;
  63     BOOL                    ok = FALSE;
  64
  65     EnterFunc(bug("ColorMap::New()\n"));
  66     numentries = 256;
  67
  68     for (tstate = msg->attrList; (tag = NextTagItem(&tstate)); )
  69     {
  70         ULONG idx;
  71
  72         if (IS_COLORMAP_ATTR(tag->ti_Tag, idx))
  73         {
  74             switch (idx)
  75             {
  76                 case aoHidd_ColorMap_NumEntries:
  77                     numentries = tag->ti_Data;
  78                     if (numentries > 256 || numentries < 0)
  79                     {
  80                         D(bug("!!! ILLEGAL value for NumEntries in ColorMap::New()\n"));
  81                     }
  82                     break;
  83
  84             } /* switch */
  85
  86         }
  87     }
  88
  89     /* Create the object */
  90
  91     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
  92     if (NULL == o)
  93         return NULL;
  94
  95     data = OOP_INST_DATA(cl, o);
  96
  97     data->clut.entries = numentries;
  98
  99     data->clut.colors = AllocMem(sizeof (HIDDT_Color) * data->clut.entries, MEMF_CLEAR);
 100     if (NULL != data->clut.colors)
 101     {
 102         ok = TRUE;
 103     }
 104
 105     if (!ok)
 106     {
 107         ULONG dispose_mid;
 108
 109         dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 110         OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid);
 111         o = NULL;
 112     }
 113
 114     ReturnPtr("ColorMap::New", OOP_Object *, o);
 115 }
 116
 117 /****************************************************************************************/
 118
 119 VOID CM__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 120 {
 121     struct colormap_data *data;
 122
 123     data = OOP_INST_DATA(cl, o);
 124
 125     if (NULL != data->clut.colors)
 126     {
 127         FreeMem(data->clut.colors, data->clut.entries * sizeof (HIDDT_Color));
 128
 129         /* To detect use of already freed mem */
 130         data->clut.colors = (void *)0xDEADBEEF;
 131     }
 132
 133     OOP_DoSuperMethod(cl, o, msg);
 134
 135     return;
 136 }
 137
 138 /****************************************************************************************/
 139
 140 VOID CM__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 141 {
 142     struct colormap_data *data;
 143     ULONG               idx;
 144
 145     EnterFunc(bug("ColorMap::Get()\n"));
 146     data = OOP_INST_DATA(cl, o);
 147
 148     if (IS_COLORMAP_ATTR(msg->attrID, idx))
 149     {
 150         switch (idx)
 151         {
 152             case aoHidd_ColorMap_NumEntries:
 153                 *msg->storage = data->clut.entries;
 154                 break;
 155
 156             default:
 157                 D(bug("!!! Unknown colormap attr in ColorMap::Get()\n"));
 158                 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 159                 break;
 160         }
 161     }
 162     else
 163     {
 164         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 165     }
 166
 167     ReturnVoid("ColorMap::Get");
 168 }
 169
 170 /****************************************************************************************/
 171
 172 static inline HIDDT_Pixel int_map_truecolor(HIDDT_Color *color, HIDDT_PixelFormat *pf)
 173 {
 174     HIDDT_Pixel red     = color->red;
 175     HIDDT_Pixel green   = color->green;
 176     HIDDT_Pixel blue    = color->blue;
 177     HIDDT_Pixel alpha   = color->alpha;
 178
 179     /* This code assumes that sizeof(HIDDT_Pixel) is a multiple of sizeof(col->#?),
 180        which should be true for most (all?) systems. (I have never heard of any
 181        system with for example 3 byte types.)
 182     */
 183
 184     if (HIDD_PF_SWAPPIXELBYTES(pf))
 185     {
 186         /* FIXME: int_map_truecolor assuming that SwapPixelBytes flag only set for 2-byte/16-bit pixel formats */
 187
 188         HIDDT_Pixel pixel = MAP_RGBA(red, green, blue, alpha, pf);
 189
 190         color->pixval = SWAPBYTES_WORD(pixel);
 191     }
 192     else
 193     {
 194         color->pixval = MAP_RGBA(red, green, blue, alpha, pf);
 195     }
 196
 197     return color->pixval;
 198 }
 199
 200 /*****************************************************************************************
 201
 202     NAME
 203         moHidd_ColorMap_SetColors
 204
 205     SYNOPSIS
 206         BOOL OOP_DoMethod(OOP_Object *obj, struct pHidd_ColorMap_SetColors *msg);
 207
 208         BOOL HIDD_CM_SetColors(OOP_Object *obj, HIDDT_Color *colors, ULONG firstColor,
 209                                ULONG numColors, OOP_Object *pixFmt);
 210
 211     LOCATION
 212         CLID_Hidd_ColorMap
 213
 214     FUNCTION
 215
 216     INPUTS
 217         obj        -
 218         colors     -
 219         firstColor -
 220         numColors  -
 221         pixFmt     -
 222
 223     RESULT
 224
 225     NOTES
 226
 227     EXAMPLE
 228
 229     BUGS
 230
 231     SEE ALSO
 232
 233     INTERNALS
 234
 235 *****************************************************************************************/
 236
 237 BOOL CM__Hidd_ColorMap__SetColors(OOP_Class *cl, OOP_Object *o,
 238                                   struct pHidd_ColorMap_SetColors *msg)
 239 {
 240     struct colormap_data    *data;
 241     ULONG                   numnew;
 242     ULONG                   i, col_idx;
 243     HIDDT_Color             *col;
 244     HIDDT_PixelFormat       *pf;
 245
 246     data = OOP_INST_DATA(cl, o);
 247
 248     numnew = msg->firstColor + msg->numColors;
 249
 250     /* See if there is enough space in the array  */
 251
 252     if (numnew > data->clut.entries)
 253     {
 254         /* Reallocate and copy */
 255         HIDDT_Color *newmap;
 256
 257         newmap = AllocMem(sizeof (*newmap) * numnew, MEMF_ANY);
 258         if (NULL == newmap)
 259             return FALSE;
 260
 261         memcpy(newmap, data->clut.colors, sizeof (*newmap) * data->clut.entries);
 262
 263         FreeMem(data->clut.colors, sizeof (*newmap) * data->clut.entries);
 264
 265         data->clut.colors  = newmap;
 266         data->clut.entries = numnew;
 267     }
 268
 269     /* Insert the new colors */
 270     col_idx = msg->firstColor;
 271     col = &data->clut.colors[msg->firstColor];
 272     pf = (HIDDT_PixelFormat *)msg->pixFmt;
 273
 274     for (i = 0; i < msg->numColors; i ++)
 275     {
 276         /* Set the color */
 277         *col = msg->colors[i];
 278
 279         /* Set the pixval using the supplied pixel format */
 280         if (IS_TRUECOLOR(pf))
 281         {
 282             /* Map the color to a HIDDT_Pixel */
 283             msg->colors[i].pixval = col->pixval = int_map_truecolor(col, pf);
 284
 285         }
 286         else
 287         {
 288             msg->colors[i].pixval = col->pixval = (HIDDT_Pixel)col_idx;
 289         }
 290
 291 /*      bug("ColMap::SetColors: col %d (%x %x %x %x) mapped to %x\n"
 292                 , col_idx
 293                 , col->red, col->green, col->blue, col->alpha
 294                 , msg->colors[i].pixval);
 295
 296 */
 297
 298         col ++;
 299         col_idx ++;
 300     }
 301
 302     return TRUE;
 303 }
 304
 305 /*****************************************************************************************
 306
 307     NAME
 308         moHidd_ColorMap_GetPixel
 309
 310     SYNOPSIS
 311         HIDDT_Pixel OOP_DoMethod(OOP_Object *obj, struct pHidd_ColorMap_GetPixel *msg);
 312
 313         HIDDT_Pixel HIDD_CM_GetPixel(OOP_Object *obj, ULONG pixelNo);
 314
 315     LOCATION
 316         CLID_Hidd_ColorMap
 317
 318     FUNCTION
 319
 320     INPUTS
 321         obj     -
 322         pixelNo -
 323
 324     RESULT
 325
 326     NOTES
 327
 328     EXAMPLE
 329
 330     BUGS
 331
 332     SEE ALSO
 333
 334     INTERNALS
 335
 336 *****************************************************************************************/
 337
 338 HIDDT_Pixel CM__Hidd_ColorMap__GetPixel(OOP_Class *cl, OOP_Object *o,
 339                                         struct pHidd_ColorMap_GetPixel *msg)
 340 {
 341     struct colormap_data *data;
 342
 343     data = OOP_INST_DATA(cl, o);
 344
 345     if (msg->pixelNo < 0 || msg->pixelNo >= data->clut.entries)
 346     {
 347         D(bug("!!! Unvalid msg->pixelNo (%d) in ColorMap::GetPixel(). clutentries = %d\n",
 348                 msg->pixelNo,
 349                 data->clut.entries));
 350
 351         // *((ULONG *)0) = 0;
 352         return (HIDDT_Pixel)-1;
 353
 354     }
 355
 356     return data->clut.colors[msg->pixelNo].pixval;
 357 }
 358
 359 /*****************************************************************************************
 360
 361     NAME
 362         moHidd_ColorMap_GetColor
 363
 364     SYNOPSIS
 365         BOOL OOP_DoMethod(OOP_Object *o, struct pHidd_ColorMap_GetColor *msg);
 366
 367         BOOL HIDD_CM_GetColor(OOP_Object *obj, ULONG colorNo, HIDDT_Color *colorReturn);
 368
 369     LOCATION
 370         CLID_Hidd_ColorMap
 371
 372     FUNCTION
 373
 374     INPUTS
 375         obj         -
 376         colorNo     -
 377         colorReturn -
 378
 379     RESULT
 380
 381     NOTES
 382
 383     EXAMPLE
 384
 385     BUGS
 386
 387     SEE ALSO
 388
 389     INTERNALS
 390
 391 *****************************************************************************************/
 392
 393 BOOL CM__Hidd_ColorMap__GetColor(OOP_Class *cl, OOP_Object *o,
 394                                  struct pHidd_ColorMap_GetColor *msg)
 395 {
 396     struct colormap_data *data;
 397
 398     data = OOP_INST_DATA(cl, o);
 399
 400     if (msg->colorNo < 0 || msg->colorNo >= data->clut.entries)
 401     {
 402         D(bug("!!! Unvalid msg->colorNo (%d) in ColorMap::GetPixel(). clutentries = %d\n",
 403                 msg->colorNo,
 404                 data->clut.entries));
 405
 406         return FALSE;
 407     }
 408
 409     *msg->colorReturn = data->clut.colors[msg->colorNo];
 410
 411     return TRUE;
 412 }