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->flags |= 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 opSet supMsg;
 172     struct TagItem *tags;
 173     struct TagItem *tag;
 174     ULONG *rgb;
 175     BOOL newcol = FALSE;
 176     IPTR retval;
 177     struct TagItem extra_tags[] = {{TAG_IGNORE, 0}, {TAG_IGNORE, 0},
 178         {TAG_IGNORE, 0}, {TAG_IGNORE, 0},
 179         {TAG_MORE, (IPTR)msg->ops_AttrList}};
 180
 181     data = INST_DATA(cl, obj);
 182
 183     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 184     {
 185         switch (tag->ti_Tag)
 186         {
 187         case MUIA_Colorfield_Red:
 188             data->rgb[0] = (ULONG) tag->ti_Data;
 189             newcol = TRUE;
 190             extra_tags[3].ti_Tag = MUIA_Colorfield_RGB;
 191             break;
 192
 193         case MUIA_Colorfield_Green:
 194             data->rgb[1] = (ULONG) tag->ti_Data;
 195             newcol = TRUE;
 196             extra_tags[3].ti_Tag = MUIA_Colorfield_RGB;
 197             break;
 198
 199         case MUIA_Colorfield_Blue:
 200             data->rgb[2] = (ULONG) tag->ti_Data;
 201             newcol = TRUE;
 202             extra_tags[3].ti_Tag = MUIA_Colorfield_RGB;
 203             break;
 204
 205         case MUIA_Colorfield_RGB:
 206             rgb = (ULONG *) tag->ti_Data;
 207             data->rgb[0] = *rgb++;
 208             data->rgb[1] = *rgb++;
 209             data->rgb[2] = *rgb++;
 210             newcol = TRUE;
 211             extra_tags[0].ti_Tag = MUIA_Colorfield_Red;
 212             extra_tags[1].ti_Tag = MUIA_Colorfield_Green;
 213             extra_tags[2].ti_Tag = MUIA_Colorfield_Blue;
 214             break;
 215
 216         case MUIA_Colorfield_Pen:
 217             if (data->flags & FLAG_PEN_ALLOCATED)
 218             {
 219                 ReleasePen(_screen(obj)->ViewPort.ColorMap, data->pen);
 220                 data->flags &= ~(FLAG_PEN_ALLOCATED | FLAG_NO_PEN);
 221             }
 222             data->pen = (UBYTE) tag->ti_Data;
 223             data->flags |= FLAG_FIXED_PEN;
 224             newcol = TRUE;
 225             break;
 226
 227         }
 228     }
 229
 230     /* Prepare notification values for inter-dependent attributes */
 231     extra_tags[0].ti_Data = data->rgb[0];
 232     extra_tags[1].ti_Data = data->rgb[1];
 233     extra_tags[2].ti_Data = data->rgb[2];
 234     extra_tags[3].ti_Data = (IPTR) data->rgb;
 235     supMsg.MethodID = msg->MethodID;
 236     supMsg.ops_AttrList = extra_tags;
 237     supMsg.ops_GInfo = msg->ops_GInfo;
 238
 239     retval = DoSuperMethodA(cl, obj, (Msg) &supMsg);
 240
 241     if (newcol && (_flags(obj) & MADF_SETUP)
 242         && !(data->flags & FLAG_NO_PEN))
 243     {
 244         SetRGB32(&_screen(obj)->ViewPort, data->pen, data->rgb[0],
 245             data->rgb[1], data->rgb[2]);
 246
 247         if (GetBitMapAttr(_rp(obj)->BitMap, BMA_DEPTH) > 8)
 248         {
 249             MUI_Redraw(obj, MADF_DRAWUPDATE);
 250         }
 251     }
 252
 253     return retval;
 254 }
 255
 256 IPTR Colorfield__OM_GET(struct IClass *cl, Object *obj,
 257     struct opGet *msg)
 258 {
 259     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 260     IPTR *store = msg->opg_Storage;
 261
 262     switch (msg->opg_AttrID)
 263     {
 264     case MUIA_Colorfield_Red:
 265         *store = data->rgb[0];
 266         break;
 267
 268     case MUIA_Colorfield_Green:
 269         *store = data->rgb[1];
 270         break;
 271
 272     case MUIA_Colorfield_Blue:
 273         *store = data->rgb[2];
 274         break;
 275
 276     case MUIA_Colorfield_RGB:
 277         *(ULONG **) store = data->rgb;
 278         break;
 279
 280     case MUIA_Colorfield_Pen:
 281         *store = data->pen;
 282         break;
 283
 284     default:
 285         return DoSuperMethodA(cl, obj, (Msg) msg);
 286     }
 287
 288     return TRUE;
 289 }
 290
 291 IPTR Colorfield__MUIM_Setup(struct IClass *cl, Object *obj,
 292     struct MUIP_Setup *msg)
 293 {
 294     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 295
 296     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 297         return 0;
 298
 299     if (data->flags & FLAG_FIXED_PEN)
 300     {
 301         SetRGB32(&_screen(obj)->ViewPort,
 302             data->pen, data->rgb[0], data->rgb[1], data->rgb[2]);
 303     }
 304     else
 305     {
 306         LONG pen;
 307
 308         pen = ObtainPen(_screen(obj)->ViewPort.ColorMap,
 309             (ULONG) -1,
 310             data->rgb[0], data->rgb[1], data->rgb[2], PENF_EXCLUSIVE);
 311
 312         if (pen == -1)
 313         {
 314             data->flags |= FLAG_NO_PEN;
 315             data->pen = 0;
 316         }
 317         else
 318         {
 319             data->pen = (UBYTE) pen;
 320             data->flags |= FLAG_PEN_ALLOCATED;
 321         }
 322     }
 323
 324     return 1;
 325 }
 326
 327 IPTR Colorfield__MUIM_Cleanup(struct IClass *cl, Object *obj,
 328     struct MUIP_Cleanup *msg)
 329 {
 330     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 331
 332     if (data->flags & FLAG_PEN_ALLOCATED)
 333     {
 334         ReleasePen(_screen(obj)->ViewPort.ColorMap, data->pen);
 335         data->flags &= ~FLAG_PEN_ALLOCATED;
 336         data->pen = 0;
 337     }
 338     data->flags &= ~FLAG_NO_PEN;
 339
 340     return DoSuperMethodA(cl, obj, (Msg) msg);
 341 }
 342
 343 IPTR Colorfield__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 344     struct MUIP_AskMinMax *msg)
 345 {
 346     DoSuperMethodA(cl, obj, (Msg) msg);
 347
 348     msg->MinMaxInfo->MinWidth += 1;
 349     msg->MinMaxInfo->MinHeight += 1;
 350     msg->MinMaxInfo->DefWidth += 16;
 351     msg->MinMaxInfo->DefHeight += 16;
 352     msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
 353     msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
 354
 355     return 0;
 356 }
 357
 358 IPTR Colorfield__MUIM_Draw(struct IClass *cl, Object *obj,
 359     struct MUIP_Draw *msg)
 360 {
 361     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 362
 363     DoSuperMethodA(cl, obj, (Msg) msg);
 364
 365     if (!(msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE)))
 366         return FALSE;
 367
 368     if (data->flags & FLAG_NO_PEN)
 369     {
 370         static UWORD pat[] = { 0x1111, 0x2222, 0x4444, 0x8888 };
 371
 372         SetAfPt(_rp(obj), pat, 2);
 373         SetABPenDrMd(_rp(obj), _pens(obj)[MPEN_SHADOW],
 374             _pens(obj)[MPEN_BACKGROUND], JAM2);
 375
 376     }
 377     else
 378     {
 379         SetABPenDrMd(_rp(obj), data->pen, 0, JAM1);
 380     }
 381
 382     RectFill(_rp(obj), _mleft(obj), _mtop(obj), _mright(obj),
 383         _mbottom(obj));
 384
 385     SetAfPt(_rp(obj), NULL, 0);
 386
 387     return 0;
 388 }
 389
 390 #if ZUNE_BUILTIN_COLORFIELD
 391 BOOPSI_DISPATCHER(IPTR, Colorfield_Dispatcher, cl, obj, msg)
 392 {
 393     switch (msg->MethodID)
 394     {
 395     case OM_NEW:
 396         return Colorfield__OM_NEW(cl, obj, (struct opSet *)msg);
 397     case OM_SET:
 398         return Colorfield__OM_SET(cl, obj, (struct opSet *)msg);
 399     case OM_GET:
 400         return Colorfield__OM_GET(cl, obj, (struct opGet *)msg);
 401     case MUIM_Setup:
 402         return Colorfield__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 403     case MUIM_Cleanup:
 404         return Colorfield__MUIM_Cleanup(cl, obj,
 405             (struct MUIP_Cleanup *)msg);
 406     case MUIM_AskMinMax:
 407         return Colorfield__MUIM_AskMinMax(cl, obj,
 408             (struct MUIP_AskMinMax *)msg);
 409     case MUIM_Draw:
 410         return Colorfield__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
 411     default:
 412         return DoSuperMethodA(cl, obj, msg);
 413     }
 414 }
 415 BOOPSI_DISPATCHER_END
 416
 417 const struct __MUIBuiltinClass _MUI_Colorfield_desc =
 418 {
 419     MUIC_Colorfield,
 420     MUIC_Area,
 421     sizeof(struct Colorfield_DATA),
 422     (void *) Colorfield_Dispatcher
 423 };
 424 #endif /* ZUNE_BUILTIN_COLORFIELD */