workbench/libs/muimaster/classes/colorfield.c

   1 /*
   2     Copyright © 2002-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <stdio.h>
   9
  10 #include <graphics/gfx.h>
  11 #include <graphics/view.h>
  12 #include <graphics/gfxmacros.h>
  13 #include <clib/alib_protos.h>
  14 #include <proto/exec.h>
  15 #include <proto/graphics.h>
  16 #include <proto/utility.h>
  17 #include <proto/intuition.h>
  18 #include <proto/muimaster.h>
  19
  20 #include <string.h>
  21
  22 #include "mui.h"
  23 #include "muimaster_intern.h"
  24 #include "textengine.h"
  25 #include "support.h"
  26 #include "support_classes.h"
  27 #include "colorfield_private.h"
  28
  29 /*  #define MYDEBUG 1 */
  30 #include "debug.h"
  31
  32 extern struct Library *MUIMasterBase;
  33
  34 #define FLAG_FIXED_PEN      1
  35 #define FLAG_PEN_ALLOCATED  2
  36 #define FLAG_NO_PEN         4
  37
  38
  39 /****** Colorfield.mui/MUIA_Colorfield_Pen ***********************************
  40 *
  41 *   NAME
  42 *       MUIA_Colorfield_Pen -- (V4) [ISG], ULONG
  43 *
  44 *   FUNCTION
  45 *       The used pen. If not set explicitly, a new one is obtained
  46 *       automatically.
  47 *
  48 *       This attribute was incorrectly documented as gettable-only in the MUI
  49 *       documentation.
  50 *
  51 ******************************************************************************
  52 *
  53 */
  54
  55 /****** Colorfield.mui/MUIA_Colorfield_Red ***********************************
  56 *
  57 *   NAME
  58 *       MUIA_Colorfield_Red -- (V4) [ISG], ULONG
  59 *
  60 *   FUNCTION
  61 *       The red component of the color field as an unsigned 32-bit value
  62 *       (0 to 0xFFFFFFFF).
  63 *
  64 *   SEE ALSO
  65 *       MUIA_Colorfield_RGB, MUIA_Colorfield_Green, MUIA_Colorfield_Blue
  66 *
  67 ******************************************************************************
  68 *
  69 */
  70
  71 /****** Colorfield.mui/MUIA_Colorfield_Green *********************************
  72 *
  73 *   NAME
  74 *       MUIA_Colorfield_Green -- (V4) [ISG], ULONG
  75 *
  76 *   FUNCTION
  77 *       The green component of the color field as an unsigned 32-bit value
  78 *       (0 to 0xFFFFFFFF).
  79 *
  80 *   SEE ALSO
  81 *       MUIA_Colorfield_RGB, MUIA_Colorfield_Red, MUIA_Colorfield_Blue
  82 *
  83 ******************************************************************************
  84 *
  85 */
  86
  87 /****** Colorfield.mui/MUIA_Colorfield_Blue **********************************
  88 *
  89 *   NAME
  90 *       MUIA_Colorfield_Blue -- (V4) [ISG], ULONG
  91 *
  92 *   FUNCTION
  93 *       The blue component of the color field as an unsigned 32-bit value
  94 *       (0 to 0xFFFFFFFF).
  95 *
  96 *   SEE ALSO
  97 *       MUIA_Colorfield_RGB, MUIA_Colorfield_Red, MUIA_Colorfield_Green
  98 *
  99 ******************************************************************************
 100 *
 101 */
 102
 103 /****** Colorfield.mui/MUIA_Colorfield_RGB ***********************************
 104 *
 105 *   NAME
 106 *       MUIA_Colorfield_RGB -- (V4) [ISG], ULONG *
 107 *
 108 *   FUNCTION
 109 *       The red, green and blue components of the color field as an array of
 110 *       unsigned 32-bit values (0 to 0xFFFFFFFF).
 111 *
 112 *   SEE ALSO
 113 *       MUIA_Colorfield_Red, MUIA_Colorfield_Green, MUIA_Colorfield_Blue
 114 *
 115 ******************************************************************************
 116 *
 117 */
 118
 119 IPTR Colorfield__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 120 {
 121     struct Colorfield_DATA *data;
 122     struct TagItem *tags;
 123     struct TagItem *tag;
 124     ULONG *rgb;
 125
 126     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
 127     if (!obj)
 128         return FALSE;
 129
 130     data = INST_DATA(cl, obj);
 131
 132     /* parse initial taglist */
 133     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 134     {
 135         switch (tag->ti_Tag)
 136         {
 137         case MUIA_Colorfield_Red:
 138             data->rgb[0] = (ULONG) tag->ti_Data;
 139             break;
 140
 141         case MUIA_Colorfield_Green:
 142             data->rgb[1] = (ULONG) tag->ti_Data;
 143             break;
 144
 145         case MUIA_Colorfield_Blue:
 146             data->rgb[2] = (ULONG) tag->ti_Data;
 147             break;
 148
 149         case MUIA_Colorfield_RGB:
 150             rgb = (ULONG *) tag->ti_Data;
 151             data->rgb[0] = *rgb++;
 152             data->rgb[1] = *rgb++;
 153             data->rgb[2] = *rgb++;
 154             break;
 155
 156         case MUIA_Colorfield_Pen:
 157             data->pen = (UBYTE) tag->ti_Data;
 158             data->pen = FLAG_FIXED_PEN;
 159             break;
 160
 161         }
 162     }
 163
 164     return (IPTR) obj;
 165 }
 166
 167 IPTR Colorfield__OM_SET(struct IClass *cl, Object *obj,
 168     struct opSet *msg)
 169 {
 170     struct Colorfield_DATA *data;
 171     struct TagItem *tags;
 172     struct TagItem *tag;
 173     ULONG *rgb;
 174     BOOL newcol = FALSE;
 175     IPTR retval;
 176
 177     data = INST_DATA(cl, obj);
 178
 179     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 180     {
 181         switch (tag->ti_Tag)
 182         {
 183         case MUIA_Colorfield_Red:
 184             data->rgb[0] = (ULONG) tag->ti_Data;
 185             newcol = TRUE;
 186             break;
 187
 188         case MUIA_Colorfield_Green:
 189             data->rgb[1] = (ULONG) tag->ti_Data;
 190             newcol = TRUE;
 191             break;
 192
 193         case MUIA_Colorfield_Blue:
 194             data->rgb[2] = (ULONG) tag->ti_Data;
 195             newcol = TRUE;
 196             break;
 197
 198         case MUIA_Colorfield_RGB:
 199             rgb = (ULONG *) tag->ti_Data;
 200             data->rgb[0] = *rgb++;
 201             data->rgb[1] = *rgb++;
 202             data->rgb[2] = *rgb++;
 203             newcol = TRUE;
 204             break;
 205
 206         case MUIA_Colorfield_Pen:
 207             if (data->flags & FLAG_PEN_ALLOCATED)
 208             {
 209                 ReleasePen(_screen(obj)->ViewPort.ColorMap, data->pen);
 210                 data->flags &= ~(FLAG_PEN_ALLOCATED | FLAG_NO_PEN);
 211             }
 212             data->pen = (UBYTE) tag->ti_Data;
 213             data->flags |= FLAG_FIXED_PEN;
 214             break;
 215
 216         }
 217     }
 218
 219     retval = DoSuperMethodA(cl, obj, (Msg) msg);
 220
 221     if (newcol && (_flags(obj) & MADF_SETUP)
 222         && !(data->flags & FLAG_NO_PEN))
 223     {
 224         SetRGB32(&_screen(obj)->ViewPort, data->pen, data->rgb[0],
 225             data->rgb[1], data->rgb[2]);
 226
 227         if (GetBitMapAttr(_rp(obj)->BitMap, BMA_DEPTH) > 8)
 228         {
 229             MUI_Redraw(obj, MADF_DRAWUPDATE);
 230         }
 231     }
 232
 233     return retval;
 234 }
 235
 236 IPTR Colorfield__OM_GET(struct IClass *cl, Object *obj,
 237     struct opGet *msg)
 238 {
 239     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 240     IPTR *store = msg->opg_Storage;
 241
 242     switch (msg->opg_AttrID)
 243     {
 244     case MUIA_Colorfield_Red:
 245         *store = data->rgb[0];
 246         break;
 247
 248     case MUIA_Colorfield_Green:
 249         *store = data->rgb[1];
 250         break;
 251
 252     case MUIA_Colorfield_Blue:
 253         *store = data->rgb[2];
 254         break;
 255
 256     case MUIA_Colorfield_RGB:
 257         *(ULONG **) store = data->rgb;
 258         break;
 259
 260     case MUIA_Colorfield_Pen:
 261         *store = data->pen;
 262         break;
 263
 264     default:
 265         return DoSuperMethodA(cl, obj, (Msg) msg);
 266     }
 267
 268     return TRUE;
 269 }
 270
 271 IPTR Colorfield__MUIM_Setup(struct IClass *cl, Object *obj,
 272     struct MUIP_Setup *msg)
 273 {
 274     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 275
 276     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 277         return 0;
 278
 279     if (data->flags & FLAG_FIXED_PEN)
 280     {
 281         SetRGB32(&_screen(obj)->ViewPort,
 282             data->pen, data->rgb[0], data->rgb[1], data->rgb[2]);
 283     }
 284     else
 285     {
 286         LONG pen;
 287
 288         pen = ObtainPen(_screen(obj)->ViewPort.ColorMap,
 289             (ULONG) -1,
 290             data->rgb[0], data->rgb[1], data->rgb[2], PENF_EXCLUSIVE);
 291
 292         if (pen == -1)
 293         {
 294             data->flags |= FLAG_NO_PEN;
 295             data->pen = 0;
 296         }
 297         else
 298         {
 299             data->pen = (UBYTE) pen;
 300             data->flags |= FLAG_PEN_ALLOCATED;
 301         }
 302     }
 303
 304     return 1;
 305 }
 306
 307 IPTR Colorfield__MUIM_Cleanup(struct IClass *cl, Object *obj,
 308     struct MUIP_Cleanup *msg)
 309 {
 310     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 311
 312     if (data->flags & FLAG_PEN_ALLOCATED)
 313     {
 314         ReleasePen(_screen(obj)->ViewPort.ColorMap, data->pen);
 315         data->flags &= ~FLAG_PEN_ALLOCATED;
 316         data->pen = 0;
 317     }
 318     data->flags &= ~FLAG_NO_PEN;
 319
 320     return DoSuperMethodA(cl, obj, (Msg) msg);
 321 }
 322
 323 IPTR Colorfield__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 324     struct MUIP_AskMinMax *msg)
 325 {
 326     DoSuperMethodA(cl, obj, (Msg) msg);
 327
 328     msg->MinMaxInfo->MinWidth += 1;
 329     msg->MinMaxInfo->MinHeight += 1;
 330     msg->MinMaxInfo->DefWidth += 16;
 331     msg->MinMaxInfo->DefHeight += 16;
 332     msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
 333     msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
 334
 335     return 0;
 336 }
 337
 338 IPTR Colorfield__MUIM_Draw(struct IClass *cl, Object *obj,
 339     struct MUIP_Draw *msg)
 340 {
 341     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 342
 343     DoSuperMethodA(cl, obj, (Msg) msg);
 344
 345     if (!(msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE)))
 346         return FALSE;
 347
 348     if (data->flags & FLAG_NO_PEN)
 349     {
 350         static UWORD pat[] = { 0x1111, 0x2222, 0x4444, 0x8888 };
 351
 352         SetAfPt(_rp(obj), pat, 2);
 353         SetABPenDrMd(_rp(obj), _pens(obj)[MPEN_SHADOW],
 354             _pens(obj)[MPEN_BACKGROUND], JAM2);
 355
 356     }
 357     else
 358     {
 359         SetABPenDrMd(_rp(obj), data->pen, 0, JAM1);
 360     }
 361
 362     RectFill(_rp(obj), _mleft(obj), _mtop(obj), _mright(obj),
 363         _mbottom(obj));
 364
 365     SetAfPt(_rp(obj), NULL, 0);
 366
 367     return 0;
 368 }
 369
 370 #if ZUNE_BUILTIN_COLORFIELD
 371 BOOPSI_DISPATCHER(IPTR, Colorfield_Dispatcher, cl, obj, msg)
 372 {
 373     switch (msg->MethodID)
 374     {
 375     case OM_NEW:
 376         return Colorfield__OM_NEW(cl, obj, (struct opSet *)msg);
 377     case OM_SET:
 378         return Colorfield__OM_SET(cl, obj, (struct opSet *)msg);
 379     case OM_GET:
 380         return Colorfield__OM_GET(cl, obj, (struct opGet *)msg);
 381     case MUIM_Setup:
 382         return Colorfield__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 383     case MUIM_Cleanup:
 384         return Colorfield__MUIM_Cleanup(cl, obj,
 385             (struct MUIP_Cleanup *)msg);
 386     case MUIM_AskMinMax:
 387         return Colorfield__MUIM_AskMinMax(cl, obj,
 388             (struct MUIP_AskMinMax *)msg);
 389     case MUIM_Draw:
 390         return Colorfield__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
 391     default:
 392         return DoSuperMethodA(cl, obj, msg);
 393     }
 394 }
 395 BOOPSI_DISPATCHER_END
 396
 397 const struct __MUIBuiltinClass _MUI_Colorfield_desc =
 398 {
 399     MUIC_Colorfield,
 400     MUIC_Area,
 401     sizeof(struct Colorfield_DATA),
 402     (void *) Colorfield_Dispatcher
 403 };
 404 #endif /* ZUNE_BUILTIN_COLORFIELD */