workbench/libs/muimaster/classes/imagedisplay.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 <intuition/imageclass.h>
  11 #include <graphics/gfx.h>
  12 #include <graphics/view.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 /*  #define MYDEBUG 1 */
  23 #include "debug.h"
  24 #include "mui.h"
  25 #include "muimaster_intern.h"
  26 #include "support.h"
  27 #include "support_classes.h"
  28 #include "imspec.h"
  29 #include "imagedisplay_private.h"
  30
  31 extern struct Library *MUIMasterBase;
  32
  33 #define MIF_FREEVERT         (1<<0)
  34 #define MIF_FREEHORIZ        (1<<1)
  35
  36
  37 IPTR Imagedisplay__OM_NEW(struct IClass *cl, Object *obj,
  38     struct opSet *msg)
  39 {
  40     struct Imagedisplay_DATA *data;
  41     struct TagItem *tag, *tags;
  42
  43     D(bug("Imagedisplay_New starts\n"));
  44
  45     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
  46     if (!obj)
  47         return FALSE;
  48
  49     data = INST_DATA(cl, obj);
  50     data->flags = MIF_FREEHORIZ | MIF_FREEVERT;
  51
  52     /* parse initial taglist */
  53
  54     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  55     {
  56         switch (tag->ti_Tag)
  57         {
  58         case MUIA_Imagedisplay_Spec:
  59             data->spec = zune_image_spec_duplicate(tag->ti_Data);
  60             break;
  61
  62         case MUIA_Imagedisplay_UseDefSize:
  63             _handle_bool_tag(data->flags, (!tag->ti_Data),
  64                 (MIF_FREEHORIZ | MIF_FREEVERT));
  65             break;
  66
  67         case MUIA_Imagedisplay_FreeHoriz:
  68             /* MUI implements some tag for optionnally prevent rescaling
  69              * of displayed image - without affecting imagedisplay resize -
  70              * see MUIPrefs/Buttons/Checkmarks/Look for nonrescaled image,
  71              * and try a popimage for yourself to see that by default they
  72              * get rescaled. It's not the same effect as MUI_Image_FreeHoriz.
  73              * -dlc 20030323
  74              */
  75             _handle_bool_tag(data->flags, tag->ti_Data, MIF_FREEHORIZ);
  76             break;
  77
  78         case MUIA_Imagedisplay_FreeVert:
  79             _handle_bool_tag(data->flags, tag->ti_Data, MIF_FREEVERT);
  80             break;
  81         }
  82     }
  83
  84     if (!data->spec)
  85     {
  86         data->spec = StrDup("0:128");
  87     }
  88
  89     if (!data->spec)
  90     {
  91         CoerceMethod(cl, obj, OM_DISPOSE);
  92         return 0;
  93     }
  94
  95     D(bug("Imagedisplay_New(%lx) spec=%lx\n", obj, data->img));
  96     return (IPTR) obj;
  97 }
  98
  99 IPTR Imagedisplay__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 100 {
 101     struct Imagedisplay_DATA *data = INST_DATA(cl, obj);
 102
 103     zune_image_spec_free(data->spec);
 104     DoSuperMethodA(cl, obj, (Msg) msg);
 105     return 0;
 106 }
 107
 108 IPTR Imagedisplay__OM_SET(struct IClass *cl, Object *obj,
 109     struct opSet *msg)
 110 {
 111     struct Imagedisplay_DATA *data = INST_DATA(cl, obj);
 112     struct TagItem *tag, *tags;
 113
 114     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 115     {
 116         switch (tag->ti_Tag)
 117         {
 118         case MUIA_Imagedisplay_Spec:
 119             if (data->spec)
 120                 zune_image_spec_free(data->spec);
 121             data->spec = zune_image_spec_duplicate(tag->ti_Data);
 122
 123             if (_flags(obj) & MADF_CANDRAW)
 124                 zune_imspec_hide(data->img);
 125
 126             if (_flags(obj) & MADF_SETUP)
 127             {
 128                 zune_imspec_cleanup(data->img);
 129                 data->img =
 130                     zune_imspec_setup((IPTR) data->spec,
 131                     muiRenderInfo(obj));
 132             }
 133
 134             if (_flags(obj) & MADF_CANDRAW)
 135                 zune_imspec_show(data->img, obj);
 136
 137             MUI_Redraw(obj, MADF_DRAWOBJECT);
 138             break;
 139         }
 140     }
 141
 142     return (IPTR) DoSuperMethodA(cl, obj, (Msg) msg);
 143 }
 144
 145 IPTR Imagedisplay__OM_GET(struct IClass *cl, Object *obj,
 146     struct opGet *msg)
 147 {
 148     struct Imagedisplay_DATA *data = INST_DATA(cl, obj);
 149     switch (msg->opg_AttrID)
 150     {
 151     case MUIA_Imagedisplay_Spec:
 152         *msg->opg_Storage = (IPTR) data->spec;
 153         return (TRUE);
 154     }
 155
 156     return (IPTR) DoSuperMethodA(cl, obj, (Msg) msg);
 157 }
 158
 159 IPTR Imagedisplay__MUIM_Setup(struct IClass *cl, Object *obj,
 160     struct MUIP_Setup *msg)
 161 {
 162     struct Imagedisplay_DATA *data = INST_DATA(cl, obj);
 163
 164     if (!DoSuperMethodA(cl, obj, (Msg) msg))
 165         return 0;
 166
 167     if (data->spec)
 168         data->img =
 169             zune_imspec_setup((IPTR) data->spec, muiRenderInfo(obj));
 170     return 1;
 171 }
 172
 173 IPTR Imagedisplay__MUIM_Cleanup(struct IClass *cl, Object *obj,
 174     struct MUIP_Cleanup *msg)
 175 {
 176     struct Imagedisplay_DATA *data = INST_DATA(cl, obj);
 177
 178     if (data->spec)
 179         zune_imspec_cleanup(data->img);
 180     return DoSuperMethodA(cl, obj, (Msg) msg);
 181 }
 182
 183 IPTR Imagedisplay__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 184     struct MUIP_AskMinMax *msg)
 185 {
 186     DoSuperMethodA(cl, obj, (Msg) msg);
 187
 188     msg->MinMaxInfo->MinWidth += 3;
 189     msg->MinMaxInfo->MinHeight += 3;
 190
 191     msg->MinMaxInfo->DefWidth += 16;
 192     msg->MinMaxInfo->DefHeight += 16;
 193
 194     msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
 195     msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
 196
 197     return 1;
 198 }
 199
 200 IPTR Imagedisplay__MUIM_Show(struct IClass *cl, Object *obj,
 201     struct MUIP_Show *msg)
 202 {
 203     struct Imagedisplay_DATA *data = INST_DATA(cl, obj);
 204
 205     DoSuperMethodA(cl, obj, (Msg) msg);
 206
 207     if (data->img)
 208         zune_imspec_show(data->img, obj);
 209     return 1;
 210 }
 211
 212 IPTR Imagedisplay__MUIM_Hide(struct IClass *cl, Object *obj,
 213     struct MUIP_Hide *msg)
 214 {
 215     struct Imagedisplay_DATA *data = INST_DATA(cl, obj);
 216
 217     if (data->img)
 218         zune_imspec_hide(data->img);
 219
 220     return DoSuperMethodA(cl, obj, (Msg) msg);
 221 }
 222
 223 IPTR Imagedisplay__MUIM_Draw(struct IClass *cl, Object *obj,
 224     struct MUIP_Draw *msg)
 225 {
 226     struct Imagedisplay_DATA *data = INST_DATA(cl, obj);
 227
 228     DoSuperMethodA(cl, obj, (Msg) msg);
 229
 230     if (!(msg->flags & MADF_DRAWOBJECT))
 231         return 0;
 232
 233     if (data->img)
 234     {
 235         WORD left, top, width, height;
 236         APTR clip;
 237
 238         left = _mleft(obj);
 239         top = _mtop(obj);
 240         width = _mwidth(obj);
 241         height = _mheight(obj);
 242
 243         /* if either horiz or vert is not rescalable, center it at def size */
 244         if (!(data->flags & MIF_FREEVERT) || !(data->flags & MIF_FREEHORIZ))
 245         {
 246             struct MUI_MinMax minmax;
 247
 248             zune_imspec_askminmax(data->img, &minmax);
 249             data->defwidth = minmax.DefWidth;
 250             data->defheight = minmax.DefHeight;
 251
 252             if (!(data->flags & MIF_FREEVERT) && (height > data->defheight))
 253             {
 254                 WORD freespace = height - data->defheight;
 255
 256                 top += freespace / 2;
 257                 height = data->defheight;
 258             }
 259
 260             if (!(data->flags & MIF_FREEHORIZ) && (width > data->defwidth))
 261             {
 262                 WORD freespace = width - data->defwidth;
 263
 264                 left += freespace / 2;
 265                 width = data->defwidth;
 266             }
 267         }
 268         else
 269         {
 270             struct MUI_MinMax minmax;
 271
 272             zune_imspec_askminmax(data->img, &minmax);
 273
 274             if (width > minmax.MaxWidth)
 275             {
 276                 width = minmax.MaxWidth;
 277                 left = _mleft(obj) + (_mwidth(obj) - width) / 2;
 278             }
 279
 280             if (height > minmax.MaxHeight)
 281             {
 282                 height = minmax.MaxHeight;
 283                 top = _mtop(obj) + (_mheight(obj) - height) / 2;
 284             }
 285         }
 286
 287         clip = MUI_AddClipping(muiRenderInfo(obj), _mleft(obj), _mtop(obj),
 288             _mwidth(obj), _mheight(obj));
 289         zune_imspec_draw(data->img, muiRenderInfo(obj),
 290             left, top, width, height, 0, 0, IDS_NORMAL);
 291         MUI_RemoveClipping(muiRenderInfo(obj), clip);
 292     }
 293
 294     return 1;
 295 }
 296
 297 IPTR Imagedisplay__MUIM_DragQuery(struct IClass *cl, Object *obj,
 298     struct MUIP_DragQuery *msg)
 299 {
 300     IPTR dummy = 0;
 301
 302     if (msg->obj == obj)
 303         return MUIV_DragQuery_Refuse;
 304     if (get(msg->obj, MUIA_Imagedisplay_Spec, &dummy)
 305         || get(msg->obj, MUIA_Pendisplay_Spec, &dummy))
 306         return MUIV_DragQuery_Accept;
 307     return MUIV_DragQuery_Refuse;
 308 }
 309
 310 IPTR Imagedisplay__MUIM_DragDrop(struct IClass *cl, Object *obj,
 311     struct MUIP_DragDrop *msg)
 312 {
 313     IPTR spec = 0;
 314
 315     if (get(msg->obj, MUIA_Imagedisplay_Spec, &spec))
 316     {
 317         set(obj, MUIA_Imagedisplay_Spec, spec);
 318     }
 319     else if (get(msg->obj, MUIA_Pendisplay_Spec, &spec))
 320     {
 321         char buf[67];
 322
 323         strcpy(buf, "2:");
 324         strncpy(buf + 2, (const char *)spec, 64);
 325         buf[66] = 0;
 326         set(obj, MUIA_Imagedisplay_Spec, (IPTR) buf);
 327     }
 328     return 0;
 329 }
 330
 331
 332 #if ZUNE_BUILTIN_IMAGEDISPLAY
 333 BOOPSI_DISPATCHER(IPTR, Imagedisplay_Dispatcher, cl, obj, msg)
 334 {
 335     switch (msg->MethodID)
 336     {
 337     case OM_NEW:
 338         return Imagedisplay__OM_NEW(cl, obj, (struct opSet *)msg);
 339     case OM_DISPOSE:
 340         return Imagedisplay__OM_DISPOSE(cl, obj, msg);
 341     case OM_SET:
 342         return Imagedisplay__OM_SET(cl, obj, (APTR) msg);
 343     case OM_GET:
 344         return Imagedisplay__OM_GET(cl, obj, (APTR) msg);
 345     case MUIM_AskMinMax:
 346         return Imagedisplay__MUIM_AskMinMax(cl, obj, (APTR) msg);
 347     case MUIM_Setup:
 348         return Imagedisplay__MUIM_Setup(cl, obj, (APTR) msg);
 349     case MUIM_Cleanup:
 350         return Imagedisplay__MUIM_Cleanup(cl, obj, (APTR) msg);
 351     case MUIM_Show:
 352         return Imagedisplay__MUIM_Show(cl, obj, (APTR) msg);
 353     case MUIM_Hide:
 354         return Imagedisplay__MUIM_Hide(cl, obj, (APTR) msg);
 355     case MUIM_Draw:
 356         return Imagedisplay__MUIM_Draw(cl, obj, (APTR) msg);
 357     case MUIM_DragQuery:
 358         return Imagedisplay__MUIM_DragQuery(cl, obj, (APTR) msg);
 359     case MUIM_DragDrop:
 360         return Imagedisplay__MUIM_DragDrop(cl, obj, (APTR) msg);
 361     default:
 362         return DoSuperMethodA(cl, obj, msg);
 363     }
 364 }
 365 BOOPSI_DISPATCHER_END
 366
 367 const struct __MUIBuiltinClass _MUI_Imagedisplay_desc =
 368 {
 369     MUIC_Imagedisplay,
 370     MUIC_Area,
 371     sizeof(struct Imagedisplay_DATA),
 372     (void *) Imagedisplay_Dispatcher
 373 };
 374 #endif /* ZUNE_BUILTIN_IMAGEDISPLAY */