rom/hidds/graphics/gfx_colormapclass.c

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