workbench/libs/muimaster/classes/coloradjust.c

   1 /*
   2     Copyright © 2002-2018, 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 <intuition/gadgetclass.h>
  14 #include <gadgets/colorwheel.h>
  15 #include <gadgets/gradientslider.h>
  16 #include <intuition/icclass.h>
  17 #include <clib/alib_protos.h>
  18 #include <proto/exec.h>
  19 #include <proto/graphics.h>
  20 #include <proto/utility.h>
  21 #include <proto/intuition.h>
  22 #include <proto/colorwheel.h>
  23 #include <proto/muimaster.h>
  24
  25 #include <string.h>
  26
  27 #include "mui.h"
  28 #include "muimaster_intern.h"
  29 #include "support.h"
  30 #include "support_classes.h"
  31 #include "coloradjust_private.h"
  32
  33 /*  #define MYDEBUG 1 */
  34 #include "debug.h"
  35
  36 extern struct Library *MUIMasterBase;
  37
  38 #define FLAG_FIXED_PEN      1
  39 #define FLAG_PEN_ALLOCATED  2
  40 #define FLAG_NO_PEN         4
  41
  42 #define ColorWheelBase data->colorwheelbase
  43 #define IColorWheel data->icolorwheel
  44
  45 /* private msg structure's passed to the hook functions */
  46 struct MUIP_CANotifyMsg
  47 {
  48     STACKED struct Coloradjust_DATA *caData;
  49 };
  50
  51 struct MUIP_CASliderNotifyMsg
  52 {
  53     STACKED struct Coloradjust_DATA *caData;
  54     STACKED ULONG caGun;
  55 };
  56
  57 static void NotifyGun(Object *obj, struct Coloradjust_DATA *data, ULONG gun)
  58 {
  59     static Tag guntotag[3] = {
  60         MUIA_Coloradjust_Red,
  61         MUIA_Coloradjust_Green,
  62         MUIA_Coloradjust_Blue
  63     };
  64
  65     struct TagItem tags[] = {
  66         {0, 0},
  67         {MUIA_Coloradjust_RGB, 0},
  68         {TAG_DONE}
  69     };
  70
  71     tags[0].ti_Tag = guntotag[gun];
  72     tags[0].ti_Data = data->rgb[gun];
  73     tags[1].ti_Data = (IPTR) data->rgb;
  74
  75     CoerceMethod(OCLASS(obj), obj, OM_SET, (IPTR) tags, TAG_DONE);
  76 }
  77
  78 static void NotifyAll(Object *obj, struct Coloradjust_DATA *data)
  79 {
  80     struct TagItem tags[] = {
  81         {MUIA_Coloradjust_Red, 0},
  82         {MUIA_Coloradjust_Green, 0},
  83         {MUIA_Coloradjust_Blue, 0},
  84         {MUIA_Coloradjust_RGB, 0},
  85         {TAG_DONE}
  86     };
  87     tags[0].ti_Data = data->rgb[0];
  88     tags[1].ti_Data = data->rgb[1];
  89     tags[2].ti_Data = data->rgb[2];
  90     tags[3].ti_Data = (IPTR) data->rgb;
  91
  92     CoerceMethod(OCLASS(obj), obj, OM_SET, (IPTR) tags, TAG_DONE);
  93 }
  94
  95 static void SliderFunc(struct Hook *hook, Object *obj, struct MUIP_CASliderNotifyMsg *msg)
  96 {
  97     struct Coloradjust_DATA *data = msg->caData;
  98     ULONG gun = msg->caGun;
  99     struct ColorWheelRGB cw;
 100
 101     ULONG red = XGET(data->rslider, MUIA_Numeric_Value);
 102     ULONG green = XGET(data->gslider, MUIA_Numeric_Value);
 103     ULONG blue = XGET(data->bslider, MUIA_Numeric_Value);
 104
 105     cw.cw_Red = (red << 24) | (red << 16) | (red << 8) | red;
 106     cw.cw_Green = (green << 24) | (green << 16) | (green << 8) | green;
 107     cw.cw_Blue = (blue << 24) | (blue << 16) | (blue << 8) | blue;
 108
 109     data->rgb[0] = cw.cw_Red;
 110     data->rgb[1] = cw.cw_Green;
 111     data->rgb[2] = cw.cw_Blue;
 112
 113     nnset(data->colfield, MUIA_Colorfield_RGB, (IPTR) data->rgb);
 114
 115     if (data->wheel)
 116     {
 117         struct ColorWheelHSB hsb;
 118
 119         ConvertRGBToHSB(&cw, &hsb);
 120         nnset(data->wheel, WHEEL_HSB, (IPTR) & hsb);
 121         if (data->grad)
 122             nnset(data->grad, GRAD_CurVal, 0xFFFF - (hsb.cw_Brightness >> 16));
 123
 124         if (data->gradpen != -1)
 125         {
 126             hsb.cw_Brightness = 0xFFFFFFFF;
 127             ConvertHSBToRGB(&hsb, &cw);
 128
 129             SetRGB32(&_screen(obj)->ViewPort, data->gradpen, cw.cw_Red,
 130                 cw.cw_Green, cw.cw_Blue);
 131             if ((data->truecolor) && (data->grad))
 132                 MUI_Redraw(data->grad, MADF_DRAWUPDATE);
 133         }
 134     }
 135
 136     NotifyGun(obj, data, gun);
 137 }
 138
 139 static void WheelFunc(struct Hook *hook, Object *obj, struct MUIP_CANotifyMsg *msg)
 140 {
 141     struct Coloradjust_DATA *data = msg->caData;
 142     struct ColorWheelHSB hsb;
 143     struct ColorWheelRGB cw;
 144
 145     hsb.cw_Hue = XGET(data->wheel, WHEEL_Hue);
 146     hsb.cw_Saturation = XGET(data->wheel, WHEEL_Saturation);
 147     if (data->grad)
 148     {
 149         hsb.cw_Brightness = 0xFFFF - XGET(data->grad, GRAD_CurVal);
 150         hsb.cw_Brightness |= (hsb.cw_Brightness << 16);
 151     }
 152     ConvertHSBToRGB(&hsb, &cw);
 153
 154     data->rgb[0] = cw.cw_Red;
 155     data->rgb[1] = cw.cw_Green;
 156     data->rgb[2] = cw.cw_Blue;
 157
 158     nnset(data->rslider, MUIA_Numeric_Value, data->rgb[0] >> 24);
 159     nnset(data->gslider, MUIA_Numeric_Value, data->rgb[1] >> 24);
 160     nnset(data->bslider, MUIA_Numeric_Value, data->rgb[2] >> 24);
 161
 162     nnset(data->colfield, MUIA_Colorfield_RGB, (IPTR) data->rgb);
 163
 164     if (data->gradpen != -1)
 165     {
 166         hsb.cw_Brightness = 0xFFFFFFFF;
 167         ConvertHSBToRGB(&hsb, &cw);
 168
 169         SetRGB32(&_screen(obj)->ViewPort, data->gradpen, cw.cw_Red,
 170             cw.cw_Green, cw.cw_Blue);
 171         if ((data->truecolor) && (data->grad))
 172             MUI_Redraw(data->grad, MADF_DRAWUPDATE);
 173     }
 174
 175     NotifyAll(obj, data);
 176 }
 177
 178 static void GradFunc(struct Hook *hook, Object *obj, struct MUIP_CANotifyMsg *msg)
 179 {
 180     struct Coloradjust_DATA *data = msg->caData;
 181     struct ColorWheelHSB hsb;
 182     struct ColorWheelRGB cw;
 183
 184     ULONG bright = 0;
 185     if (data->grad)
 186         bright = XGET(data->grad, GRAD_CurVal);
 187
 188     bright = 0xFFFF - bright;
 189     bright |= (bright << 16);
 190
 191     hsb.cw_Hue = XGET(data->wheel, WHEEL_Hue);
 192     hsb.cw_Saturation = XGET(data->wheel, WHEEL_Saturation);
 193     hsb.cw_Brightness = bright;
 194
 195     ConvertHSBToRGB(&hsb, &cw);
 196
 197     data->rgb[0] = cw.cw_Red;
 198     data->rgb[1] = cw.cw_Green;
 199     data->rgb[2] = cw.cw_Blue;
 200
 201     nnset(data->rslider, MUIA_Numeric_Value, data->rgb[0] >> 24);
 202     nnset(data->gslider, MUIA_Numeric_Value, data->rgb[1] >> 24);
 203     nnset(data->bslider, MUIA_Numeric_Value, data->rgb[2] >> 24);
 204
 205     nnset(data->colfield, MUIA_Colorfield_RGB, (IPTR) data->rgb);
 206
 207     NotifyAll(obj, data);
 208 }
 209
 210 IPTR Coloradjust__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 211 {
 212     struct Coloradjust_DATA *data;
 213     struct TagItem *tags;
 214     struct TagItem *tag;
 215     struct Library *colorwheelbase, *gradientsliderbase;
 216     Object *rslider, *gslider, *bslider;
 217     Object *colfield, *wheel = NULL, *grad = NULL;
 218     ULONG *rgb;
 219
 220     colorwheelbase = OpenLibrary("gadgets/colorwheel.gadget", 0);
 221     gradientsliderbase = OpenLibrary("gadgets/gradientslider.gadget", 0);
 222
 223     obj = (Object *) DoSuperNewTags
 224         (cl, obj, NULL,
 225         MUIA_Group_Columns, 2,
 226         MUIA_Group_VertSpacing, 1,
 227         Child, (IPTR) Label1("Red:"),
 228         Child, (IPTR) (rslider = (Object *)SliderObject,
 229             MUIA_Group_Horiz, TRUE,
 230             MUIA_Numeric_Min, 0,
 231             MUIA_Numeric_Max, 255,
 232         End),
 233         Child, (IPTR) Label1("Green:"),
 234         Child, (IPTR) (gslider = (Object *)SliderObject,
 235             MUIA_Group_Horiz, TRUE,
 236             MUIA_Numeric_Min, 0,
 237             MUIA_Numeric_Max, 255,
 238         End),
 239         Child, (IPTR) Label1("Blue:"),
 240         Child, (IPTR) (bslider = (Object *)SliderObject,
 241             MUIA_Group_Horiz, TRUE,
 242             MUIA_Numeric_Min, 0,
 243             MUIA_Numeric_Max, 255,
 244         End),
 245         Child, (IPTR) VSpace(1),
 246         Child, (IPTR) VSpace(1),
 247         Child, (IPTR) (colfield = (Object *) ColorfieldObject,
 248             TextFrame,
 249             MUIA_Weight, 0,
 250         End),
 251         Child, (IPTR) (HGroup,
 252             MUIA_Group_HorizSpacing, 2,
 253             (!colorwheelbase) ? TAG_IGNORE : Child,
 254                 (IPTR) (wheel = (Object *) BoopsiObject,
 255                 MUIA_Boopsi_ClassID, (IPTR) "colorwheel.gadget",
 256                 MUIA_Boopsi_MinWidth, 16,
 257                 MUIA_Boopsi_MinHeight, 16,
 258                 MUIA_Boopsi_Remember, WHEEL_Saturation,
 259                 MUIA_Boopsi_Remember, WHEEL_Hue,
 260                 MUIA_Boopsi_TagScreen, WHEEL_Screen,
 261                 WHEEL_Screen, (IPTR) NULL,
 262                 GA_Left, 0,
 263                 GA_Top, 0,
 264                 GA_Width, 0,
 265                 GA_Height, 0,
 266                 ICA_TARGET, ICTARGET_IDCMP,
 267                 MUIA_FillArea, TRUE,
 268             End),
 269             (!gradientsliderbase) ? TAG_IGNORE : Child,
 270                 (IPTR) (grad = (Object *) BoopsiObject,
 271                 MUIA_Boopsi_ClassID, (IPTR) "gradientslider.gadget",
 272                 MUIA_Boopsi_MinWidth, 16,
 273                 MUIA_Boopsi_MinHeight, 16,
 274                 MUIA_Boopsi_MaxWidth, 16,
 275                 MUIA_Boopsi_Remember, GRAD_CurVal,
 276                 MUIA_Boopsi_Remember, GRAD_PenArray,
 277                 MUIA_Boopsi_Remember, GRAD_KnobPixels,
 278                 GA_Left, 0,
 279                 GA_Top, 0,
 280                 GA_Width, 0,
 281                 GA_Height, 0,
 282                 GRAD_KnobPixels, 8,
 283                 PGA_Freedom, LORIENT_VERT,
 284                 ICA_TARGET, ICTARGET_IDCMP,
 285                 MUIA_FillArea, TRUE,
 286             End),
 287             (!colorwheelbase && !gradientsliderbase) ? Child : TAG_IGNORE,
 288                 (IPTR)HVSpace,
 289         End),
 290         TAG_MORE, (IPTR) msg->ops_AttrList);
 291
 292     if (!obj)
 293     {
 294         if (gradientsliderbase)
 295             CloseLibrary(gradientsliderbase);
 296         if (colorwheelbase)
 297             CloseLibrary(colorwheelbase);
 298         return FALSE;
 299     }
 300
 301     data = INST_DATA(cl, obj);
 302
 303     data->colorwheelbase = colorwheelbase;
 304     data->gradientsliderbase = gradientsliderbase;
 305     if (!EXEC_INTERFACE_GET_MAIN(data->icolorwheel, data->colorwheelbase))
 306     {
 307         CoerceMethod(cl, obj, OM_DISPOSE);
 308         return (IPTR)NULL;
 309     }
 310
 311     data->sliderhook.h_Entry = HookEntry;
 312     data->sliderhook.h_SubEntry = (HOOKFUNC) SliderFunc;
 313
 314     data->wheelhook.h_Entry = HookEntry;
 315     data->wheelhook.h_SubEntry = (HOOKFUNC) WheelFunc;
 316
 317     data->gradhook.h_Entry = HookEntry;
 318     data->gradhook.h_SubEntry = (HOOKFUNC) GradFunc;
 319
 320     data->rslider = rslider;
 321     data->gslider = gslider;
 322     data->bslider = bslider;
 323     data->colfield = colfield;
 324     data->wheel = wheel;
 325     data->grad = grad;
 326
 327     data->rgb[0] = data->rgb[1] = data->rgb[2] = 0xFFFFFFFF;
 328
 329     /* parse initial taglist */
 330     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 331     {
 332         switch (tag->ti_Tag)
 333         {
 334         case MUIA_Coloradjust_Red:
 335             data->rgb[0] = (ULONG) tag->ti_Data;
 336             break;
 337
 338         case MUIA_Coloradjust_Green:
 339             data->rgb[1] = (ULONG) tag->ti_Data;
 340             break;
 341
 342         case MUIA_Coloradjust_Blue:
 343             data->rgb[2] = (ULONG) tag->ti_Data;
 344             break;
 345
 346         case MUIA_Coloradjust_RGB:
 347             rgb = (ULONG *) tag->ti_Data;
 348             data->rgb[0] = *rgb++;
 349             data->rgb[1] = *rgb++;
 350             data->rgb[2] = *rgb++;
 351             break;
 352
 353         }
 354     }
 355
 356     nnset(colfield, MUIA_Colorfield_RGB, (IPTR) data->rgb);
 357     nnset(rslider, MUIA_Numeric_Value, data->rgb[0] >> 24);
 358     nnset(gslider, MUIA_Numeric_Value, data->rgb[1] >> 24);
 359     nnset(bslider, MUIA_Numeric_Value, data->rgb[2] >> 24);
 360
 361     if (data->wheel )
 362     {
 363         struct ColorWheelRGB cw;
 364         struct ColorWheelHSB hsb;
 365
 366         cw.cw_Red = data->rgb[0];
 367         cw.cw_Green = data->rgb[1];
 368         cw.cw_Blue = data->rgb[2];
 369
 370         ConvertRGBToHSB(&cw, &hsb);
 371
 372         nnset(data->wheel, WHEEL_HSB, (IPTR) & hsb);
 373         /* just to be sure - colorwheel seems to have some problems */
 374         nnset(data->wheel, WHEEL_Saturation, hsb.cw_Saturation);
 375         nnset(data->wheel, WHEEL_Hue, hsb.cw_Hue);
 376         if (data->grad)
 377         {
 378             nnset(data->grad, GRAD_CurVal, 0xFFFF - (hsb.cw_Brightness >> 16));
 379             nnset(data->grad, GRAD_PenArray, (IPTR) data->gradpenarray);
 380         }
 381     }
 382
 383     DoMethod(rslider, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
 384         (IPTR) obj, 4, MUIM_CallHook, (IPTR) & data->sliderhook,
 385         (IPTR) data, 0);
 386     DoMethod(gslider, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
 387         (IPTR) obj, 4, MUIM_CallHook, (IPTR) & data->sliderhook,
 388         (IPTR) data, 1);
 389     DoMethod(bslider, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
 390         (IPTR) obj, 4, MUIM_CallHook, (IPTR) & data->sliderhook,
 391         (IPTR) data, 2);
 392
 393     if (data->wheel )
 394     {
 395         DoMethod(data->wheel , MUIM_Notify, WHEEL_Hue, MUIV_EveryTime,
 396             (IPTR) obj, 3, MUIM_CallHook, (IPTR) & data->wheelhook,
 397             (IPTR) data);
 398         DoMethod(data->wheel , MUIM_Notify, WHEEL_Saturation, MUIV_EveryTime,
 399             (IPTR) obj, 3, MUIM_CallHook, (IPTR) & data->wheelhook,
 400             (IPTR) data);
 401     }
 402     if (data->grad)
 403     {
 404         DoMethod(data->grad, MUIM_Notify, GRAD_CurVal, MUIV_EveryTime,
 405             (IPTR) obj, 3, MUIM_CallHook, (IPTR) & data->gradhook,
 406             (IPTR) data);
 407     }
 408     return (IPTR) obj;
 409 }
 410
 411 IPTR Coloradjust__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 412 {
 413     struct Coloradjust_DATA *data;
 414     struct Library *colorwheelbase;
 415     struct Library *gradientsliderbase;
 416     IPTR retval;
 417
 418     data = INST_DATA(cl, obj);
 419
 420     EXEC_INTERFACE_DROP(data->icolorwheel);
 421     colorwheelbase = data->colorwheelbase;
 422     gradientsliderbase = data->gradientsliderbase;
 423
 424     retval = DoSuperMethodA(cl, obj, msg);
 425
 426     if (colorwheelbase)
 427         CloseLibrary(colorwheelbase);
 428     if (gradientsliderbase)
 429         CloseLibrary(gradientsliderbase);
 430
 431     return retval;
 432 }
 433
 434 IPTR Coloradjust__OM_SET(struct IClass *cl, Object *obj,
 435     struct opSet *msg)
 436 {
 437     struct Coloradjust_DATA *data;
 438     struct TagItem *tags;
 439     struct TagItem *tag;
 440     ULONG *rgb;
 441     BOOL newcol = FALSE;
 442
 443     data = INST_DATA(cl, obj);
 444
 445     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 446     {
 447         switch (tag->ti_Tag)
 448         {
 449         case MUIA_Coloradjust_Red:
 450             data->rgb[0] = (ULONG) tag->ti_Data;
 451             newcol = TRUE;
 452             break;
 453
 454         case MUIA_Coloradjust_Green:
 455             data->rgb[1] = (ULONG) tag->ti_Data;
 456             newcol = TRUE;
 457             break;
 458
 459         case MUIA_Coloradjust_Blue:
 460             data->rgb[2] = (ULONG) tag->ti_Data;
 461             newcol = TRUE;
 462             break;
 463
 464         case MUIA_Coloradjust_RGB:
 465             rgb = (ULONG *) tag->ti_Data;
 466             data->rgb[0] = *rgb++;
 467             data->rgb[1] = *rgb++;
 468             data->rgb[2] = *rgb++;
 469             newcol = TRUE;
 470             break;
 471
 472         }
 473     }
 474
 475     if (newcol)
 476     {
 477         nnset(data->rslider, MUIA_Numeric_Value, data->rgb[0] >> 24);
 478         nnset(data->gslider, MUIA_Numeric_Value, data->rgb[1] >> 24);
 479         nnset(data->bslider, MUIA_Numeric_Value, data->rgb[2] >> 24);
 480         D(bug("coloradjust: sliders set to %ld, %ld, %ld\n",
 481                 data->rgb[0] >> 24, data->rgb[1] >> 24,
 482                 data->rgb[2] >> 24));
 483
 484         nnset(data->colfield, MUIA_Colorfield_RGB, (IPTR) data->rgb);
 485
 486         if (data->wheel)
 487         {
 488             struct ColorWheelRGB cw;
 489             struct ColorWheelHSB hsb;
 490
 491             cw.cw_Red = data->rgb[0];
 492             cw.cw_Green = data->rgb[1];
 493             cw.cw_Blue = data->rgb[2];
 494
 495             ConvertRGBToHSB(&cw, &hsb);
 496             nnset(data->wheel, WHEEL_HSB, (IPTR) & hsb);
 497             nnset(data->wheel, WHEEL_Saturation, hsb.cw_Saturation);
 498             nnset(data->wheel, WHEEL_Hue, hsb.cw_Hue);
 499             if (data->grad)
 500                 nnset(data->grad, GRAD_CurVal,
 501                     0xFFFF - (hsb.cw_Brightness >> 16));
 502
 503             if ((_flags(obj) & MADF_SETUP) && (data->gradpen != -1))
 504             {
 505                 hsb.cw_Brightness = 0xFFFFFFFF;
 506                 ConvertHSBToRGB(&hsb, &cw);
 507
 508                 SetRGB32(&_screen(obj)->ViewPort, data->gradpen, cw.cw_Red,
 509                     cw.cw_Green, cw.cw_Blue);
 510                 if ((data->truecolor) && (data->grad))
 511                 {
 512                     MUI_Redraw(data->grad, MADF_DRAWOBJECT);
 513                 }
 514             }
 515         }
 516     }
 517
 518     return DoSuperMethodA(cl, obj, (Msg) msg);
 519 }
 520
 521 IPTR Coloradjust__OM_GET(struct IClass *cl, Object *obj,
 522     struct opGet *msg)
 523 {
 524     struct Coloradjust_DATA *data = INST_DATA(cl, obj);
 525     IPTR *store = msg->opg_Storage;
 526
 527     switch (msg->opg_AttrID)
 528     {
 529     case MUIA_Coloradjust_Red:
 530         *store = data->rgb[0];
 531         return TRUE;
 532
 533     case MUIA_Coloradjust_Green:
 534         *store = data->rgb[1];
 535         return TRUE;
 536
 537     case MUIA_Coloradjust_Blue:
 538         *store = data->rgb[2];
 539         return TRUE;
 540
 541     case MUIA_Coloradjust_RGB:
 542         *(IPTR *) store = (IPTR) & data->rgb[0];
 543         return TRUE;
 544     }
 545
 546     return DoSuperMethodA(cl, obj, (Msg) msg);
 547 }
 548
 549 IPTR Coloradjust__MUIM_Setup(struct IClass *cl, Object *obj,
 550     struct MUIP_Setup *msg)
 551 {
 552     struct Coloradjust_DATA *data = INST_DATA(cl, obj);
 553
 554     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 555         return 0;
 556
 557     if (data->wheel)
 558     {
 559         struct ColorWheelHSB hsb;
 560         struct ColorWheelRGB rgb;
 561
 562         rgb.cw_Red = data->rgb[0];
 563         rgb.cw_Green = data->rgb[1];
 564         rgb.cw_Blue = data->rgb[2];
 565
 566         data->gradpenarray[0] = _pens(obj)[MPEN_SHINE];
 567         data->gradpenarray[1] = _pens(obj)[MPEN_SHADOW];
 568         data->gradpenarray[2] = (UWORD) ~ 0;
 569
 570         data->gradpen = ObtainPen(_screen(obj)->ViewPort.ColorMap,
 571             (ULONG) - 1,
 572             rgb.cw_Red, rgb.cw_Green, rgb.cw_Blue, PENF_EXCLUSIVE);
 573
 574         if (data->gradpen != -1)
 575         {
 576             data->gradpenarray[0] = data->gradpen;
 577         }
 578
 579         ConvertRGBToHSB(&rgb, &hsb);
 580         /* setting this will force wheel to properly set its display */
 581         nnset(data->wheel, WHEEL_Saturation, hsb.cw_Saturation);
 582         nnset(data->wheel, WHEEL_Hue, hsb.cw_Hue);
 583
 584         hsb.cw_Brightness = 0xFFFFFFFF;
 585         ConvertHSBToRGB(&hsb, &rgb);
 586
 587         if (data->gradpen != -1)
 588         {
 589             SetRGB32(&_screen(obj)->ViewPort, data->gradpen, rgb.cw_Red,
 590                 rgb.cw_Green, rgb.cw_Blue);
 591         }
 592
 593         data->truecolor =
 594             GetBitMapAttr(_screen(obj)->RastPort.BitMap, BMA_DEPTH) >= 15;
 595     }
 596
 597     return 1;
 598 }
 599
 600 IPTR Coloradjust__MUIM_Cleanup(struct IClass *cl, Object *obj,
 601     struct MUIP_Cleanup *msg)
 602 {
 603     struct Coloradjust_DATA *data = INST_DATA(cl, obj);
 604
 605     if (data->gradpen != -1)
 606     {
 607         ReleasePen(_screen(obj)->ViewPort.ColorMap, data->gradpen);
 608         data->gradpen = -1;
 609     }
 610
 611     return DoSuperMethodA(cl, obj, (Msg) msg);
 612 }
 613
 614 #if ZUNE_BUILTIN_COLORADJUST
 615 BOOPSI_DISPATCHER(IPTR, Coloradjust_Dispatcher, cl, obj, msg)
 616 {
 617     switch (msg->MethodID)
 618     {
 619     case OM_NEW:
 620         return Coloradjust__OM_NEW(cl, obj, (struct opSet *)msg);
 621     case OM_DISPOSE:
 622         return Coloradjust__OM_DISPOSE(cl, obj, msg);
 623     case OM_SET:
 624         return Coloradjust__OM_SET(cl, obj, (struct opSet *)msg);
 625     case OM_GET:
 626         return Coloradjust__OM_GET(cl, obj, (struct opGet *)msg);
 627     case MUIM_Setup:
 628         return Coloradjust__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 629     case MUIM_Cleanup:
 630         return Coloradjust__MUIM_Cleanup(cl, obj,
 631             (struct MUIP_Cleanup *)msg);
 632     default:
 633         return DoSuperMethodA(cl, obj, msg);
 634     }
 635 }
 636 BOOPSI_DISPATCHER_END
 637
 638 const struct __MUIBuiltinClass _MUI_Coloradjust_desc =
 639 {
 640     MUIC_Coloradjust,
 641     MUIC_Group,
 642     sizeof(struct Coloradjust_DATA),
 643     (void *) Coloradjust_Dispatcher
 644 };
 645 #endif /* ZUNE_BUILTIN_COLORADJUST */