workbench/libs/muimaster/classes/dtpic.c

   1 /*
   2     Copyright © 2002-2009, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /* Dtpic.mui. Source based on the one from MUIUndoc */
   7
   8 #define MUIMASTER_YES_INLINE_STDARG
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12
  13 #include <graphics/gfx.h>
  14 #include <graphics/view.h>
  15 #include <clib/alib_protos.h>
  16
  17 #include <datatypes/datatypesclass.h>
  18 #include <datatypes/pictureclass.h>
  19 #include <cybergraphx/cybergraphics.h>
  20
  21 #include <proto/exec.h>
  22 #include <proto/graphics.h>
  23 #include <proto/cybergraphics.h>
  24 #include <proto/utility.h>
  25 #include <proto/intuition.h>
  26 #include <proto/muimaster.h>
  27 #include <proto/datatypes.h>
  28
  29 #include <string.h>
  30
  31 /*  #define MYDEBUG 1 */
  32 #include "debug.h"
  33
  34 #include "mui.h"
  35 #include "muimaster_intern.h"
  36 #include "support.h"
  37 #include "support_classes.h"
  38 #include "dtpic_private.h"
  39
  40 extern struct Library *MUIMasterBase;
  41
  42 #ifdef DataTypesBase
  43 #undef DataTypesBase
  44 #endif
  45
  46 #define DataTypesBase data->datatypesbase
  47
  48 static void killdto(struct Dtpic_DATA *data)
  49 {
  50     data->bm = NULL;
  51     data->bmhd = NULL;
  52
  53     if (data->dto)
  54     {
  55         DisposeDTObject(data->dto);
  56         data->dto = NULL;
  57     }
  58
  59     if (data->datatypesbase)
  60     {
  61         CloseLibrary(data->datatypesbase);
  62     }
  63 };
  64
  65 /*
  66  * We copy the filename, as the file is opened later in setup and
  67  * not at once.
  68  */
  69 IPTR Dtpic__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  70 {
  71     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
  72
  73     if (obj)
  74     {
  75         struct Dtpic_DATA *data = INST_DATA(cl, obj);
  76         struct TagItem *tags = msg->ops_AttrList;
  77         struct TagItem *tag;
  78
  79         while ((tag = NextTagItem(&tags)) != NULL)
  80         {
  81             switch (tag->ti_Tag)
  82             {
  83             case MUIA_Dtpic_Name:
  84                 data->name =
  85                     AllocVec(strlen((char *)tag->ti_Data) + 1, MEMF_ANY);
  86                 strcpy((char *)data->name, (char *)tag->ti_Data);
  87                 break;
  88             }
  89         }
  90     }
  91
  92     return (IPTR) obj;
  93 }
  94
  95 IPTR setup_datatype(struct IClass *cl, Object *obj)
  96 {
  97     struct Dtpic_DATA *data = INST_DATA(cl, obj);
  98
  99     if (data->dto)
 100         killdto(data);          /* Object already existed */
 101
 102     if (data->name)
 103     {
 104         if ((data->datatypesbase = OpenLibrary("datatypes.library", 39)))
 105         {
 106             /* Prevent DOS Requesters from showing up */
 107
 108             struct Process *me = (struct Process *)FindTask(0);
 109             APTR oldwinptr = me->pr_WindowPtr;
 110
 111             me->pr_WindowPtr = (APTR) - 1;
 112
 113             data->dto = NewDTObject(data->name, DTA_GroupID, GID_PICTURE,
 114                 OBP_Precision, PRECISION_IMAGE,
 115                 PDTA_Screen, _screen(obj),
 116                 PDTA_DestMode, PMODE_V43,
 117                 PDTA_UseFriendBitMap, TRUE, TAG_DONE);
 118             me->pr_WindowPtr = oldwinptr;
 119
 120             if (data->dto)
 121             {
 122                 struct FrameInfo fri = { 0 };
 123
 124                 DoMethod(data->dto, DTM_FRAMEBOX, 0, &fri, &fri,
 125                     sizeof(struct FrameInfo), 0);
 126
 127                 if (fri.fri_Dimensions.Depth > 0)
 128                 {
 129                     if (DoMethod(data->dto, DTM_PROCLAYOUT, 0, 1))
 130                     {
 131                         get(data->dto, PDTA_BitMapHeader, &data->bmhd);
 132
 133                         if (data->bmhd)
 134                         {
 135                             if (data->bmhd->bmh_Masking != mskNone)
 136                                 set(obj, MUIA_FillArea, TRUE);
 137                             else
 138                                 set(obj, MUIA_FillArea, FALSE);
 139
 140                             GetDTAttrs(data->dto, PDTA_DestBitMap,
 141                                 &data->bm, TAG_DONE);
 142
 143                             if (!data->bm)
 144                             {
 145                                 GetDTAttrs(data->dto, PDTA_BitMap,
 146                                     &data->bm, TAG_DONE);
 147                             }
 148
 149                             if (data->bm)
 150                                 return TRUE;
 151                         }
 152                     }
 153                 }
 154             }
 155         }
 156     }
 157     killdto(data);
 158
 159     return TRUE;
 160 }
 161
 162 IPTR Dtpic__MUIM_Setup(struct IClass *cl, Object *obj,
 163     struct MUIP_Setup *msg)
 164 {
 165     if (!DoSuperMethodA(cl, obj, (Msg) msg))
 166         return FALSE;
 167
 168     return setup_datatype(cl, obj);
 169 }
 170
 171 IPTR Dtpic__MUIM_Cleanup(struct IClass *cl, Object *obj,
 172     struct MUIP_Cleanup *msg)
 173 {
 174     struct Dtpic_DATA *data = INST_DATA(cl, obj);
 175
 176     killdto(data);
 177
 178     return DoSuperMethodA(cl, obj, (Msg) msg);
 179 }
 180
 181 IPTR Dtpic__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 182     struct MUIP_AskMinMax *msg)
 183 {
 184     struct Dtpic_DATA *data = INST_DATA(cl, obj);
 185     IPTR retval;
 186
 187     retval = DoSuperMethodA(cl, obj, (Msg) msg);
 188
 189     if (data->bm)
 190     {
 191         msg->MinMaxInfo->MinWidth += data->bmhd->bmh_Width;
 192         msg->MinMaxInfo->MinHeight += data->bmhd->bmh_Height;
 193         msg->MinMaxInfo->DefWidth += data->bmhd->bmh_Width;
 194         msg->MinMaxInfo->DefHeight += data->bmhd->bmh_Height;
 195         msg->MinMaxInfo->MaxWidth += data->bmhd->bmh_Width;
 196         msg->MinMaxInfo->MaxHeight += data->bmhd->bmh_Height;
 197     }
 198
 199     return retval;
 200 }
 201
 202 IPTR Dtpic__MUIM_Draw(struct IClass *cl, Object *obj,
 203     struct MUIP_Draw *msg)
 204 {
 205     struct Dtpic_DATA *data = INST_DATA(cl, obj);
 206
 207     DoSuperMethodA(cl, obj, (Msg) msg);
 208
 209     if ((msg->flags & MADF_DRAWOBJECT) && data->bm)
 210     {
 211         /* Note: codes taken from picture.datatype GM_RENDER routine */
 212         ULONG depth = (ULONG) GetBitMapAttr(_rp(obj)->BitMap, BMA_DEPTH);
 213
 214         if ((depth >= 15) && (data->bmhd->bmh_Masking == mskHasAlpha))
 215         {
 216             /* Transparency on high color rast port with alpha channel in
 217              * picture */
 218             ULONG *img =
 219                 AllocVec(_mwidth(obj) * _mheight(obj) * 4, MEMF_ANY);
 220             if (img)
 221             {
 222                 struct pdtBlitPixelArray pa;
 223                 pa.MethodID = PDTM_READPIXELARRAY;
 224                 pa.pbpa_PixelData = (UBYTE *) img;
 225                 pa.pbpa_PixelFormat = PBPAFMT_ARGB;
 226                 pa.pbpa_PixelArrayMod = _mwidth(obj) * 4;
 227                 pa.pbpa_Left = 0;
 228                 pa.pbpa_Top = 0;
 229                 pa.pbpa_Width = _mwidth(obj);
 230                 pa.pbpa_Height = _mheight(obj);
 231                 if (DoMethodA(data->dto, (Msg) & pa))
 232                     WritePixelArrayAlpha(img, 0, 0, _mwidth(obj) * 4,
 233                         _rp(obj), _mleft(obj), _mtop(obj), _mwidth(obj),
 234                         _mheight(obj), 0xffffffff);
 235                 FreeVec((APTR) img);
 236             }
 237         }
 238         else
 239         {
 240             if (data->bmhd->bmh_Masking == mskHasMask)
 241             {
 242                 /* Transparency with mask */
 243                 APTR mask = NULL;
 244
 245                 GetDTAttrs(data->dto, PDTA_MaskPlane, (IPTR) & mask,
 246                     TAG_DONE);
 247
 248                 if (mask)
 249                     BltMaskBitMapRastPort(data->bm, 0, 0, _rp(obj),
 250                         _mleft(obj), _mtop(obj), _mwidth(obj),
 251                         _mheight(obj), 0xE0, (PLANEPTR) mask);
 252             }
 253             else
 254             {
 255                 /* All other cases */
 256                 BltBitMapRastPort(data->bm, 0, 0, _rp(obj), _mleft(obj),
 257                     _mtop(obj), _mwidth(obj), _mheight(obj), 0xC0);
 258             }
 259         }
 260     }
 261
 262     return 0;
 263 }
 264
 265 IPTR Dtpic__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 266 {
 267     struct Dtpic_DATA *data = INST_DATA(cl, obj);
 268
 269     if (data->name)
 270         FreeVec(data->name);
 271
 272     return DoSuperMethodA(cl, obj, msg);
 273 }
 274
 275 IPTR Dtpic__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 276 {
 277     struct Dtpic_DATA *data = INST_DATA(cl, obj);
 278     struct TagItem *tags = msg->ops_AttrList;
 279     struct TagItem *tag;
 280     ULONG needs_redraw = 0;
 281
 282     while ((tag = NextTagItem(&tags)) != NULL)
 283     {
 284         switch (tag->ti_Tag)
 285         {
 286         case MUIA_Dtpic_Name:
 287             /* If no filename or different filenames */
 288             if (!data->name || strcmp(data->name, (char *)tag->ti_Data))
 289             {
 290                 if (data->name)
 291                     FreeVec(data->name);
 292                 data->name =
 293                     AllocVec(strlen((char *)tag->ti_Data) + 1, MEMF_ANY);
 294                 strcpy((char *)data->name, (char *)tag->ti_Data);
 295
 296                 /* Run immediate setup only if base class is setup up */
 297                 if (_flags(obj) & MADF_SETUP)
 298                     setup_datatype(cl, obj);
 299                 needs_redraw = 1;
 300             }
 301             break;
 302         }
 303     }
 304
 305     if (needs_redraw)
 306     {
 307         MUI_Redraw(obj, MADF_DRAWOBJECT);
 308     }
 309
 310     return DoSuperMethodA(cl, obj, (Msg) msg);
 311 }
 312
 313 IPTR Dtpic__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 314 {
 315     struct Dtpic_DATA *data = INST_DATA(cl, obj);
 316
 317     switch (msg->opg_AttrID)
 318     {
 319     case MUIA_Dtpic_Name:
 320         *(msg->opg_Storage) = (IPTR) data->name;
 321         return TRUE;
 322     }
 323
 324     return DoSuperMethodA(cl, obj, (Msg) msg);
 325 }
 326
 327 #if ZUNE_BUILTIN_DTPIC
 328 BOOPSI_DISPATCHER(IPTR, Dtpic_Dispatcher, cl, obj, msg)
 329 {
 330     switch (msg->MethodID)
 331     {
 332     case OM_NEW:
 333         return Dtpic__OM_NEW(cl, obj, (struct opSet *)msg);
 334     case MUIM_Setup:
 335         return Dtpic__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 336     case MUIM_Cleanup:
 337         return Dtpic__MUIM_Cleanup(cl, obj, (struct MUIP_Clean *)msg);
 338     case MUIM_AskMinMax:
 339         return Dtpic__MUIM_AskMinMax(cl, obj, (struct MUIP_AskMinMax *)msg);
 340     case MUIM_Draw:
 341         return Dtpic__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
 342     case OM_DISPOSE:
 343         return Dtpic__OM_DISPOSE(cl, obj, msg);
 344     case OM_SET:
 345         return Dtpic__OM_SET(cl, obj, (struct opSet *)msg);
 346     case OM_GET:
 347         return Dtpic__OM_GET(cl, obj, (struct opGet *)msg);
 348     default:
 349         return DoSuperMethodA(cl, obj, msg);
 350     }
 351 }
 352 BOOPSI_DISPATCHER_END
 353
 354 const struct __MUIBuiltinClass _MUI_Dtpic_desc =
 355 {
 356     MUIC_Dtpic,
 357     MUIC_Area,
 358     sizeof(struct Dtpic_DATA),
 359     (void *) Dtpic_Dispatcher
 360 };
 361 #endif /* ZUNE_BUILTIN_DTPIC */