workbench/libs/muimaster/classes/pendisplay.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 "penspec.h"
  25 #include "textengine.h"
  26 #include "support.h"
  27 #include "support_classes.h"
  28 #include "pendisplay_private.h"
  29
  30 /*  #define MYDEBUG 1 */
  31 #include "debug.h"
  32
  33 extern struct Library *MUIMasterBase;
  34
  35
  36 IPTR Pendisplay__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  37 {
  38     struct Pendisplay_DATA *data;
  39     struct TagItem *tags;
  40     struct TagItem *tag;
  41
  42     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
  43     if (!obj)
  44         return FALSE;
  45
  46     data = INST_DATA(cl, obj);
  47     /* Format identifies need to be long enforced because of RawDoFmt()
  48      * limits */
  49     snprintf(data->penspec.ps_buf, sizeof(data->penspec.ps_buf), "%lc%d",
  50         (int)PST_MUI, (int)MPEN_TEXT);
  51     data->pen = -1;
  52
  53     /* parse initial taglist */
  54     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  55     {
  56         switch (tag->ti_Tag)
  57         {
  58         case MUIA_Pendisplay_Reference:
  59             data->refobj = (Object *) tag->ti_Data;
  60             DoMethod(data->refobj, MUIM_Notify, MUIA_Pendisplay_Spec,
  61                 MUIV_EveryTime, (IPTR) obj, 3, MUIM_Set,
  62                 MUIA_Pendisplay_Spec, MUIV_TriggerValue);
  63             break;
  64
  65         case MUIA_Pendisplay_RGBcolor:
  66             {
  67                 struct MUI_RGBcolor *rgb =
  68                     (struct MUI_RGBcolor *)tag->ti_Data;
  69                 snprintf(data->penspec.ps_buf, sizeof(data->penspec.ps_buf),
  70                     "%lc%08x,%08x,%08x", (int)PST_RGB,
  71                     (unsigned int)rgb->red, (unsigned int)rgb->green,
  72                     (unsigned int)rgb->blue);
  73             }
  74             break;
  75
  76         case MUIA_Pendisplay_Spec:
  77             data->penspec = *(struct MUI_PenSpec *)tag->ti_Data;
  78             break;
  79
  80         }
  81     }
  82
  83     return (IPTR) obj;
  84 }
  85
  86 IPTR Pendisplay__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
  87 {
  88     struct Pendisplay_DATA *data;
  89
  90     data = INST_DATA(cl, obj);
  91     if (data->refobj)
  92     {
  93         /* kill notify here? But refobj might already have been killed :-\ */
  94     }
  95
  96     return DoSuperMethodA(cl, obj, msg);
  97 }
  98
  99 IPTR Pendisplay__OM_SET(struct IClass *cl, Object *obj,
 100     struct opSet *msg)
 101 {
 102     struct Pendisplay_DATA *data;
 103     struct TagItem *tags;
 104     struct TagItem *tag;
 105     BOOL newcol = FALSE;
 106     IPTR retval;
 107
 108     data = INST_DATA(cl, obj);
 109
 110     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 111     {
 112         switch (tag->ti_Tag)
 113         {
 114         case MUIA_Pendisplay_Reference:
 115             if (data->refobj)
 116             {
 117                 DoMethod(data->refobj, MUIM_KillNotifyObj,
 118                     MUIA_Pendisplay_Spec, (IPTR) obj);
 119             }
 120
 121             data->refobj = (Object *) tag->ti_Data;
 122
 123             if (data->refobj)
 124             {
 125                 DoMethod(data->refobj, MUIM_Notify, MUIA_Pendisplay_Spec,
 126                     MUIV_EveryTime, (IPTR) obj, 3, MUIM_Set,
 127                     MUIA_Pendisplay_Spec, MUIV_TriggerValue);
 128             }
 129             newcol = TRUE;
 130             break;
 131
 132         case MUIA_Pendisplay_RGBcolor:
 133             {
 134                 struct MUI_RGBcolor *rgb =
 135                     (struct MUI_RGBcolor *)tag->ti_Data;
 136
 137                 snprintf(data->penspec.ps_buf, sizeof(data->penspec.ps_buf),
 138                     "%lc%08x,%08x,%08x", (int)PST_RGB,
 139                     (unsigned int)rgb->red, (unsigned int)rgb->green,
 140                     (unsigned int)rgb->blue);
 141             }
 142             newcol = TRUE;
 143             break;
 144
 145         case MUIA_Pendisplay_Spec:
 146             if (tag->ti_Data)
 147             {
 148                 data->penspec = *(struct MUI_PenSpec *)tag->ti_Data;
 149                 newcol = TRUE;
 150             }
 151             break;
 152
 153
 154         }
 155     }
 156
 157     retval = DoSuperMethodA(cl, obj, (Msg) msg);
 158
 159     if (newcol && (_flags(obj) & MADF_SETUP))
 160     {
 161         if (data->pen != -1)
 162         {
 163             MUI_ReleasePen(muiRenderInfo(obj), data->pen);
 164             data->pen = -1;
 165         }
 166
 167         if (!data->refobj)
 168         {
 169             data->pen =
 170                 MUI_ObtainPen(muiRenderInfo(obj), &data->penspec, 0);
 171         }
 172
 173         MUI_Redraw(obj, MADF_DRAWUPDATE);
 174     }
 175
 176     return retval;
 177 }
 178
 179 IPTR Pendisplay__OM_GET(struct IClass *cl, Object *obj,
 180     struct opGet *msg)
 181 {
 182     struct Pendisplay_DATA *data = INST_DATA(cl, obj);
 183     IPTR *store = msg->opg_Storage;
 184
 185     switch (msg->opg_AttrID)
 186     {
 187     case MUIA_Pendisplay_Pen:
 188         *store = (IPTR) data->pen;
 189         break;
 190
 191     case MUIA_Pendisplay_Reference:
 192         *store = (IPTR) data->refobj;
 193         break;
 194
 195     case MUIA_Pendisplay_RGBcolor:
 196         {
 197             // FIXME: MUIA_Pendisplay_RGBColor (only works for RGB pen specs)
 198             struct MUI_PenSpec_intern intpenspec;
 199             zune_pen_spec_to_intern(&data->penspec, &intpenspec);
 200
 201             switch (intpenspec.p_type)
 202             {
 203             case PST_MUI:
 204             case PST_CMAP:
 205             case PST_SYS:
 206                 break;
 207             case PST_RGB:
 208                 data->rgb = intpenspec.p_rgb;
 209                 break;
 210             }
 211
 212             *store = (IPTR) & data->rgb;
 213         }
 214         break;
 215
 216     case MUIA_Pendisplay_Spec:
 217         *store = (IPTR) & data->penspec;
 218         break;
 219
 220     default:
 221         return DoSuperMethodA(cl, obj, (Msg) msg);
 222     }
 223
 224     return TRUE;
 225 }
 226
 227 IPTR Pendisplay__MUIM_Setup(struct IClass *cl, Object *obj,
 228     struct MUIP_Setup *msg)
 229 {
 230     struct Pendisplay_DATA *data = INST_DATA(cl, obj);
 231
 232     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 233         return 0;
 234
 235     if (!data->refobj)
 236     {
 237         data->pen = MUI_ObtainPen(muiRenderInfo(obj), &data->penspec, 0);
 238     }
 239
 240     return 1;
 241 }
 242
 243 IPTR Pendisplay__MUIM_Cleanup(struct IClass *cl, Object *obj,
 244     struct MUIP_Cleanup *msg)
 245 {
 246     struct Pendisplay_DATA *data = INST_DATA(cl, obj);
 247
 248     if (data->pen != -1)
 249     {
 250         MUI_ReleasePen(muiRenderInfo(obj), data->pen);
 251         data->pen = -1;
 252     }
 253
 254     return DoSuperMethodA(cl, obj, (Msg) msg);
 255 }
 256
 257 IPTR Pendisplay__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 258     struct MUIP_AskMinMax *msg)
 259 {
 260     DoSuperMethodA(cl, obj, (Msg) msg);
 261
 262     msg->MinMaxInfo->MinWidth += 3;
 263     msg->MinMaxInfo->MinHeight += 3;
 264     msg->MinMaxInfo->DefWidth += 16;
 265     msg->MinMaxInfo->DefHeight += 16;
 266     msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
 267     msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
 268
 269     return 0;
 270 }
 271
 272 IPTR Pendisplay__MUIM_Draw(struct IClass *cl, Object *obj,
 273     struct MUIP_Draw *msg)
 274 {
 275     struct Pendisplay_DATA *data = INST_DATA(cl, obj);
 276     LONG color;
 277
 278     DoSuperMethodA(cl, obj, (Msg) msg);
 279
 280     if (!(msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE)))
 281         return FALSE;
 282
 283     if (data->refobj)
 284     {
 285         IPTR val = 0;
 286
 287         get(data->refobj, MUIA_Pendisplay_Pen, &val);
 288         color = (LONG) val;
 289     }
 290     else
 291     {
 292         color = data->pen;
 293     }
 294
 295     if (color == -1)
 296     {
 297         static UWORD pat[] = { 0x1111, 0x2222, 0x4444, 0x8888 };
 298
 299         SetAfPt(_rp(obj), pat, 2);
 300         SetABPenDrMd(_rp(obj), _pens(obj)[MPEN_SHADOW],
 301             _pens(obj)[MPEN_BACKGROUND], JAM2);
 302
 303     }
 304     else
 305     {
 306         SetABPenDrMd(_rp(obj), MUIPEN(color), 0, JAM1);
 307     }
 308
 309     RectFill(_rp(obj), _mleft(obj), _mtop(obj), _mright(obj),
 310         _mbottom(obj));
 311
 312     SetAfPt(_rp(obj), NULL, 0);
 313
 314     return 0;
 315 }
 316
 317 IPTR Pendisplay__MUIM_Pendisplay_SetColormap(struct IClass *cl,
 318     Object *obj, struct MUIP_Pendisplay_SetColormap *msg)
 319 {
 320     struct MUI_PenSpec penspec;
 321
 322     snprintf(penspec.ps_buf, sizeof(penspec.ps_buf), "%lc%d", (int)PST_CMAP,
 323         (int)msg->colormap);
 324     set(obj, MUIA_Pendisplay_Spec, (IPTR) & penspec);
 325
 326     return 0;
 327 }
 328
 329 IPTR Pendisplay__MUIM_Pendisplay_SetRGB(struct IClass *cl, Object *obj,
 330     struct MUIP_Pendisplay_SetRGB *msg)
 331 {
 332     struct MUI_PenSpec penspec;
 333
 334     snprintf(penspec.ps_buf, sizeof(penspec.ps_buf), "%lc%08x,%08x,%08x",
 335         (int)PST_RGB, (unsigned int)msg->r, (unsigned int)msg->g,
 336         (unsigned int)msg->b);
 337     set(obj, MUIA_Pendisplay_Spec, (IPTR) & penspec);
 338
 339     return 0;
 340 }
 341
 342 IPTR Pendisplay__MUIM_Pendisplay_SetMUIPen(struct IClass *cl, Object *obj,
 343     struct MUIP_Pendisplay_SetMUIPen *msg)
 344 {
 345     struct MUI_PenSpec penspec;
 346
 347     snprintf(penspec.ps_buf, sizeof(penspec.ps_buf), "%lc%d", (int)PST_MUI,
 348         (int)msg->muipen);
 349     set(obj, MUIA_Pendisplay_Spec, (IPTR) & penspec);
 350
 351     return 0;
 352 }
 353
 354 IPTR Pendisplay__MUIM_DragQuery(struct IClass *cl, Object *obj,
 355     struct MUIP_DragQuery *msg)
 356 {
 357     STRPTR spec = NULL;
 358
 359     if (msg->obj == obj)
 360         return MUIV_DragQuery_Refuse;
 361
 362     if (get(msg->obj, MUIA_Pendisplay_Spec, &spec))
 363         return MUIV_DragQuery_Accept;
 364
 365     if (get(msg->obj, MUIA_Imagedisplay_Spec, &spec))
 366     {
 367         if ((NULL != spec) && (strlen(spec) > 2) && (spec[0] == '2')
 368             && (spec[1] == ':'))
 369             return MUIV_DragQuery_Accept;
 370     }
 371
 372     return MUIV_DragQuery_Refuse;
 373 }
 374
 375 IPTR Pendisplay__MUIM_DragDrop(struct IClass *cl, Object *obj,
 376     struct MUIP_DragDrop *msg)
 377 {
 378     STRPTR spec = NULL;
 379
 380     if (get(msg->obj, MUIA_Pendisplay_Spec, &spec))
 381         set(obj, MUIA_Pendisplay_Spec, spec);
 382     else if (get(msg->obj, MUIA_Imagedisplay_Spec, &spec))
 383         set(obj, MUIA_Pendisplay_Spec, spec + 2);
 384     return 0;
 385 }
 386
 387 #if ZUNE_BUILTIN_PENDISPLAY
 388 BOOPSI_DISPATCHER(IPTR, Pendisplay_Dispatcher, cl, obj, msg)
 389 {
 390     switch (msg->MethodID)
 391     {
 392     case OM_NEW:
 393         return Pendisplay__OM_NEW(cl, obj, (struct opSet *)msg);
 394     case OM_DISPOSE:
 395         return Pendisplay__OM_DISPOSE(cl, obj, msg);
 396     case OM_SET:
 397         return Pendisplay__OM_SET(cl, obj, (struct opSet *)msg);
 398     case OM_GET:
 399         return Pendisplay__OM_GET(cl, obj, (struct opGet *)msg);
 400     case MUIM_Setup:
 401         return Pendisplay__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 402     case MUIM_Cleanup:
 403         return Pendisplay__MUIM_Cleanup(cl, obj,
 404             (struct MUIP_Cleanup *)msg);
 405     case MUIM_AskMinMax:
 406         return Pendisplay__MUIM_AskMinMax(cl, obj,
 407             (struct MUIP_AskMinMax *)msg);
 408     case MUIM_Draw:
 409         return Pendisplay__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
 410     case MUIM_Pendisplay_SetColormap:
 411         return Pendisplay__MUIM_Pendisplay_SetColormap(cl, obj,
 412             (struct MUIP_Pendisplay_SetColormap *)msg);
 413     case MUIM_Pendisplay_SetMUIPen:
 414         return Pendisplay__MUIM_Pendisplay_SetMUIPen(cl, obj,
 415             (struct MUIP_Pendisplay_SetMUIPen *)msg);
 416     case MUIM_Pendisplay_SetRGB:
 417         return Pendisplay__MUIM_Pendisplay_SetRGB(cl, obj,
 418             (struct MUIP_Pendisplay_SetRGB *)msg);
 419     case MUIM_DragQuery:
 420         return Pendisplay__MUIM_DragQuery(cl, obj,
 421             (struct MUIP_DragQuery *)msg);
 422     case MUIM_DragDrop:
 423         return Pendisplay__MUIM_DragDrop(cl, obj,
 424             (struct MUIP_DragDrop *)msg);
 425     default:
 426         return DoSuperMethodA(cl, obj, msg);
 427     }
 428 }
 429 BOOPSI_DISPATCHER_END
 430
 431 const struct __MUIBuiltinClass _MUI_Pendisplay_desc =
 432 {
 433     MUIC_Pendisplay,
 434     MUIC_Area,
 435     sizeof(struct Pendisplay_DATA),
 436     (void *) Pendisplay_Dispatcher
 437 };
 438 #endif /* ZUNE_BUILTIN_PENDISPLAY */