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