workbench/libs/muimaster/classes/colorfield.c

   1 /*
   2     Copyright © 2002-2003, 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 IPTR Colorfield__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  40 {
  41     struct Colorfield_DATA *data;
  42     struct TagItem *tags;
  43     struct TagItem *tag;
  44     ULONG *rgb;
  45
  46     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
  47     if (!obj)
  48         return FALSE;
  49
  50     data = INST_DATA(cl, obj);
  51
  52     /* parse initial taglist */
  53     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  54     {
  55         switch (tag->ti_Tag)
  56         {
  57         case MUIA_Colorfield_Red:
  58             data->rgb[0] = (ULONG) tag->ti_Data;
  59             break;
  60
  61         case MUIA_Colorfield_Green:
  62             data->rgb[1] = (ULONG) tag->ti_Data;
  63             break;
  64
  65         case MUIA_Colorfield_Blue:
  66             data->rgb[2] = (ULONG) tag->ti_Data;
  67             break;
  68
  69         case MUIA_Colorfield_RGB:
  70             rgb = (ULONG *) tag->ti_Data;
  71             data->rgb[0] = *rgb++;
  72             data->rgb[1] = *rgb++;
  73             data->rgb[2] = *rgb++;
  74             break;
  75
  76         case MUIA_Colorfield_Pen:
  77             data->pen = (UBYTE) tag->ti_Data;
  78             data->pen = FLAG_FIXED_PEN;
  79             break;
  80
  81         }
  82     }
  83
  84     return (IPTR) obj;
  85 }
  86
  87 IPTR Colorfield__OM_SET(struct IClass *cl, Object *obj,
  88     struct opSet *msg)
  89 {
  90     struct Colorfield_DATA *data;
  91     struct TagItem *tags;
  92     struct TagItem *tag;
  93     ULONG *rgb;
  94     BOOL newcol = FALSE;
  95     IPTR retval;
  96
  97     data = INST_DATA(cl, obj);
  98
  99     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 100     {
 101         switch (tag->ti_Tag)
 102         {
 103         case MUIA_Colorfield_Red:
 104             data->rgb[0] = (ULONG) tag->ti_Data;
 105             newcol = TRUE;
 106             break;
 107
 108         case MUIA_Colorfield_Green:
 109             data->rgb[1] = (ULONG) tag->ti_Data;
 110             newcol = TRUE;
 111             break;
 112
 113         case MUIA_Colorfield_Blue:
 114             data->rgb[2] = (ULONG) tag->ti_Data;
 115             newcol = TRUE;
 116             break;
 117
 118         case MUIA_Colorfield_RGB:
 119             rgb = (ULONG *) tag->ti_Data;
 120             data->rgb[0] = *rgb++;
 121             data->rgb[1] = *rgb++;
 122             data->rgb[2] = *rgb++;
 123             newcol = TRUE;
 124             break;
 125
 126         case MUIA_Colorfield_Pen:
 127             if (data->flags & FLAG_PEN_ALLOCATED)
 128             {
 129                 ReleasePen(_screen(obj)->ViewPort.ColorMap, data->pen);
 130                 data->flags &= ~(FLAG_PEN_ALLOCATED | FLAG_NO_PEN);
 131             }
 132             data->pen = (UBYTE) data->pen;
 133             data->flags |= FLAG_FIXED_PEN;
 134             break;
 135
 136         }
 137     }
 138
 139     retval = DoSuperMethodA(cl, obj, (Msg) msg);
 140
 141     if (newcol && (_flags(obj) & MADF_SETUP)
 142         && !(data->flags & FLAG_NO_PEN))
 143     {
 144         SetRGB32(&_screen(obj)->ViewPort, data->pen, data->rgb[0],
 145             data->rgb[1], data->rgb[2]);
 146
 147         if (GetBitMapAttr(_rp(obj)->BitMap, BMA_DEPTH) > 8)
 148         {
 149             MUI_Redraw(obj, MADF_DRAWUPDATE);
 150         }
 151     }
 152
 153     return retval;
 154 }
 155
 156 IPTR Colorfield__OM_GET(struct IClass *cl, Object *obj,
 157     struct opGet *msg)
 158 {
 159     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 160     IPTR *store = msg->opg_Storage;
 161
 162     switch (msg->opg_AttrID)
 163     {
 164     case MUIA_Colorfield_Red:
 165         *store = data->rgb[0];
 166         break;
 167
 168     case MUIA_Colorfield_Green:
 169         *store = data->rgb[1];
 170         break;
 171
 172     case MUIA_Colorfield_Blue:
 173         *store = data->rgb[2];
 174         break;
 175
 176     case MUIA_Colorfield_RGB:
 177         *(ULONG **) store = data->rgb;
 178         break;
 179
 180     case MUIA_Colorfield_Pen:
 181         *store = data->pen;
 182         break;
 183
 184     default:
 185         return DoSuperMethodA(cl, obj, (Msg) msg);
 186     }
 187
 188     return TRUE;
 189 }
 190
 191 IPTR Colorfield__MUIM_Setup(struct IClass *cl, Object *obj,
 192     struct MUIP_Setup *msg)
 193 {
 194     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 195
 196     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 197         return 0;
 198
 199     if (data->flags & FLAG_FIXED_PEN)
 200     {
 201         SetRGB32(&_screen(obj)->ViewPort,
 202             data->pen, data->rgb[0], data->rgb[1], data->rgb[2]);
 203     }
 204     else
 205     {
 206         LONG pen;
 207
 208         pen = ObtainPen(_screen(obj)->ViewPort.ColorMap,
 209             (ULONG) - 1,
 210             data->rgb[0], data->rgb[1], data->rgb[2], PENF_EXCLUSIVE);
 211
 212         if (pen == -1)
 213         {
 214             data->flags |= FLAG_NO_PEN;
 215             data->pen = 0;
 216         }
 217         else
 218         {
 219             data->pen = (UBYTE) pen;
 220             data->flags |= FLAG_PEN_ALLOCATED;
 221         }
 222     }
 223
 224     return 1;
 225 }
 226
 227 IPTR Colorfield__MUIM_Cleanup(struct IClass *cl, Object *obj,
 228     struct MUIP_Cleanup *msg)
 229 {
 230     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 231
 232     if (data->flags & FLAG_PEN_ALLOCATED)
 233     {
 234         ReleasePen(_screen(obj)->ViewPort.ColorMap, data->pen);
 235         data->flags &= ~FLAG_PEN_ALLOCATED;
 236         data->pen = 0;
 237     }
 238     data->flags &= ~FLAG_NO_PEN;
 239
 240     return DoSuperMethodA(cl, obj, (Msg) msg);
 241 }
 242
 243 IPTR Colorfield__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 244     struct MUIP_AskMinMax *msg)
 245 {
 246     DoSuperMethodA(cl, obj, (Msg) msg);
 247
 248     msg->MinMaxInfo->MinWidth += 1;
 249     msg->MinMaxInfo->MinHeight += 1;
 250     msg->MinMaxInfo->DefWidth += 16;
 251     msg->MinMaxInfo->DefHeight += 16;
 252     msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
 253     msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
 254
 255     return 0;
 256 }
 257
 258 IPTR Colorfield__MUIM_Draw(struct IClass *cl, Object *obj,
 259     struct MUIP_Draw *msg)
 260 {
 261     struct Colorfield_DATA *data = INST_DATA(cl, obj);
 262
 263     DoSuperMethodA(cl, obj, (Msg) msg);
 264
 265     if (!(msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE)))
 266         return FALSE;
 267
 268     if (data->flags & FLAG_NO_PEN)
 269     {
 270         static UWORD pat[] = { 0x1111, 0x2222, 0x4444, 0x8888 };
 271
 272         SetAfPt(_rp(obj), pat, 2);
 273         SetABPenDrMd(_rp(obj), _pens(obj)[MPEN_SHADOW],
 274             _pens(obj)[MPEN_BACKGROUND], JAM2);
 275
 276     }
 277     else
 278     {
 279         SetABPenDrMd(_rp(obj), data->pen, 0, JAM1);
 280     }
 281
 282     RectFill(_rp(obj), _mleft(obj), _mtop(obj), _mright(obj),
 283         _mbottom(obj));
 284
 285     SetAfPt(_rp(obj), NULL, 0);
 286
 287     return 0;
 288 }
 289
 290 #if ZUNE_BUILTIN_COLORFIELD
 291 BOOPSI_DISPATCHER(IPTR, Colorfield_Dispatcher, cl, obj, msg)
 292 {
 293     switch (msg->MethodID)
 294     {
 295     case OM_NEW:
 296         return Colorfield__OM_NEW(cl, obj, (struct opSet *)msg);
 297     case OM_SET:
 298         return Colorfield__OM_SET(cl, obj, (struct opSet *)msg);
 299     case OM_GET:
 300         return Colorfield__OM_GET(cl, obj, (struct opGet *)msg);
 301     case MUIM_Setup:
 302         return Colorfield__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 303     case MUIM_Cleanup:
 304         return Colorfield__MUIM_Cleanup(cl, obj,
 305             (struct MUIP_Cleanup *)msg);
 306     case MUIM_AskMinMax:
 307         return Colorfield__MUIM_AskMinMax(cl, obj,
 308             (struct MUIP_AskMinMax *)msg);
 309     case MUIM_Draw:
 310         return Colorfield__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
 311     default:
 312         return DoSuperMethodA(cl, obj, msg);
 313     }
 314 }
 315 BOOPSI_DISPATCHER_END
 316
 317 const struct __MUIBuiltinClass _MUI_Colorfield_desc =
 318 {
 319     MUIC_Colorfield,
 320     MUIC_Area,
 321     sizeof(struct Colorfield_DATA),
 322     (void *) Colorfield_Dispatcher
 323 };
 324 #endif /* ZUNE_BUILTIN_COLORFIELD */