arch/.unmaintained/amiga/workbench/hidds/graphics/intuition/BM_Class.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Graphics-amiga-intui bitmap class implementation.
   6     Lang: english
   7 */
   8
   9 #include <string.h>
  10
  11 #include <proto/exec.h>
  12 #include <proto/utility.h>
  13 #include <proto/intuition.h>
  14 #include <proto/oop.h>
  15
  16 #include <exec/memory.h>
  17 #include <utility/tagitem.h>
  18 #include <intuition/screens.h>
  19
  20 #include <oop/oop.h>
  21
  22 #include <hidd/graphics.h>
  23 #include <hidd/graphics-amiga-intuition.h>
  24
  25 #include "graphics_intern.h"
  26
  27 #undef  SDEBUG
  28 #undef  DEBUG
  29 #define DEBUG 1
  30 #include <aros/debug.h>
  31
  32 #define IS_BM_ATTR(attr, idx) ( ( (idx) = (attr) - HiddBitMapAttrBase) < num_Hidd_BitMap_Attrs)
  33
  34 static AttrBase HiddBitMapAttrBase = 0;
  35
  36 /*** BitMap::New() ************************************************************/
  37
  38 static Object *bitmap_new(Class *cl, Object *obj, struct pRoot_New *msg)
  39 {
  40     struct TagItem tags[] = {
  41                              {aHidd_BitMap_AllocBuffer, FALSE      },
  42                              {TAG_MORE                , (IPTR) NULL}
  43                             };
  44
  45     struct HIDDBitMapAmigaIntuiData *data;
  46     struct TagItem *tag, *tstate, *newTagList;
  47     BOOL   ok = FALSE;
  48
  49     struct pRoot_New               new_msg;
  50     struct pHidd_BitMap_PrivateSet private_set_msg;
  51
  52     ULONG width, height, depth, format;
  53     BOOL  displayable;
  54
  55     EnterFunc(bug("BitMapAmigaIntui::New()\n"));
  56
  57     new_msg.mID         = GetMethodID(IID_Root, moRoot_New);
  58     private_set_msg.mID = GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PrivateSet);
  59
  60
  61     displayable = (BOOL) GetTagData(aHidd_BitMap_Displayable, 0, msg->attrList);
  62     if(!displayable)
  63     {
  64         /* let the superclass do all work */
  65
  66         obj = (Object *) DoSuperMethod(cl, obj, (Msg) msg);
  67         if(obj) ok = TRUE;
  68     }
  69     else
  70     {
  71         /*
  72             aHidd_BitMap_AllocBuffer and aHidd_BitMap_Displayable must be
  73             FALSE. To make this easy first a copy of the taglist is
  74             created. In the new list Hidd_BitMap_Displayable is set to
  75             FALSE. If the taglist contains a "aHidd_BitMap_AllocBuffer"
  76             tag then ti_Data is set to FALSE else tags(see above) is
  77             connected with the new list.
  78
  79             NOTE: If msg.attrList contains more than one
  80                   "aHidd_BitMap_AllocBuffer" we have a problem.
  81         */
  82
  83         newTagList = CloneTagItems(msg->attrList);
  84         if(newTagList)
  85         {
  86             tag = FindTagItem(aHidd_BitMap_Displayable, newTagList);
  87             if(tag)
  88             {
  89                 tag->ti_Data     = FALSE;
  90             }
  91
  92             tag = FindTagItem(aHidd_BitMap_AllocBuffer, newTagList);
  93             if(tag)
  94             {
  95                 tag->ti_Data     = FALSE;
  96                 new_msg.attrList = newTagList;
  97             }
  98             else
  99             {
 100                 tags[1].ti_Data  = (IPTR) newTagList;
 101                 new_msg.attrList = tags;
 102             }
 103
 104             obj  = (Object *) DoSuperMethod(cl, obj, (Msg) &new_msg);
 105
 106             FreeTagItems(newTagList);
 107         }
 108
 109         if(obj)
 110         {
 111             data = INST_DATA(cl, obj);
 112
 113             /* clear all data and set some default values */
 114             memset(data, 0, sizeof(struct HIDDBitMapAmigaIntuiData));
 115
 116             GetAttr(obj, aHidd_BitMap_Width,  &width);
 117             GetAttr(obj, aHidd_BitMap_Height, &height);
 118             GetAttr(obj, aHidd_BitMap_Depth,  &depth);
 119             GetAttr(obj, aHidd_BitMap_Format, &format);
 120
 121             if(format == vHIDD_BitMap_Format_Planar)
 122             {
 123                 /* only displayable support for planar format */
 124
 125                 struct TagItem tags[] =
 126                 {
 127                     {SA_Left     , 0},
 128                     {SA_Top      , 0},
 129                     {SA_Width    , width},
 130                     {SA_Height   , height},
 131                     {SA_Depth    , depth},
 132                     {TAG_SKIP    , 1},      /* Use SA_DisplayID only wenn a display mode */
 133                     {SA_DisplayID, 0},      /* is specified                              */
 134                     {SA_Title    , (ULONG) "AROS graphics hidd"},
 135                     {SA_Type     , CUSTOMSCREEN},
 136
 137                     /* Will be use later   */
 138                     /* SA_Quiet    , TRUE, */
 139                     /* SA_BitMap   , 0     On V37 double buffering could only
 140                                            implemented with a custom bitmap */
 141                     {TAG_DONE,   0}
 142                 };
 143
 144                 data->screen = OpenScreenTagList(NULL, tags);
 145                 if(data->screen)
 146                 {
 147                     struct TagItem set[] =
 148                     {
 149                         {aHidd_BitMap_BaseAddress, (IPTR) &data->screen->RastPort.BitMap->Planes[0]},
 150                         {aHidd_BitMap_Format     , vHIDD_BitMap_Format_Planar},
 151                         {aHidd_BitMap_Displayable, TRUE                      },
 152                         {aHidd_BitMap_BytesPerRow, data->screen->RastPort.BitMap->BytesPerRow},
 153                         {TAG_END                 , 0                         }
 154                     };
 155
 156                     private_set_msg.attrList = set;
 157                     DoSuperMethod(cl, obj, (Msg) &private_set_msg);
 158                     ok = TRUE;
 159                 } /* if(data->screen) */
 160             } /* if(format == vHIDD_BitMap_Format_Planar) */
 161         } /* if(obj) */
 162     } /* if(!displayable) */
 163
 164     /* free all on error */
 165     if(ok == FALSE)
 166     {
 167         if(obj) DisposeObject(obj);
 168         obj = NULL;
 169     }
 170
 171     ReturnPtr("BitMapAmigaIntui::New", Object *, obj);
 172 }
 173
 174
 175 /*** BitMap::Dispose() ********************************************************/
 176
 177 static void bitmap_dispose(Class *cl, Object *obj, Msg *msg)
 178 {
 179     struct HIDDBitMapAmigaIntuiData *data = INST_DATA(cl, obj);
 180
 181     struct pHidd_BitMap_PrivateSet private_set_msg;
 182
 183
 184     EnterFunc(bug("BitMapAmigaIntui::Dispose()\n"));
 185
 186     if(data->screen)
 187     {
 188         /*
 189            We use an own buffer so set the BaseAddress to NULL to prevent
 190            the superclass to free our own buffer.
 191         */
 192
 193         struct TagItem set[] =
 194         {
 195             {aHidd_BitMap_BaseAddress, NULL},
 196             {TAG_END                 , 0   }
 197         };
 198
 199         CloseScreen(data->screen);
 200
 201         private_set_msg.mID      = GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PrivateSet);
 202         private_set_msg.attrList = set;
 203         DoSuperMethod(cl, obj, (Msg) &private_set_msg);
 204     }
 205
 206     DoSuperMethod(cl, obj, (Msg) msg);
 207
 208     ReturnVoid("BitMapAmigaIntui::Dispose");
 209 }
 210
 211
 212 /*** init_bitmapclass *********************************************************/
 213
 214 #undef OOPBase
 215 #undef SysBase
 216
 217 #define OOPBase (csd->oopbase)
 218 #define SysBase (csd->sysbase)
 219
 220 #define NUM_ROOT_METHODS   2
 221 #define NUM_BITMAP_METHODS 0
 222
 223 Class *init_bitmapclass(struct class_static_data *csd)
 224 {
 225     struct MethodDescr root_descr[NUM_ROOT_METHODS + 1] =
 226     {
 227         {(IPTR (*)())bitmap_new    , moRoot_New    },
 228         {(IPTR (*)())bitmap_dispose, moRoot_Dispose},
 229         {NULL, 0UL}
 230     };
 231
 232     struct MethodDescr bitMap_descr[NUM_BITMAP_METHODS + 1] =
 233     {
 234         {NULL, 0UL}
 235     };
 236
 237     struct InterfaceDescr ifdescr[] =
 238     {
 239         {root_descr,    IID_Root       , NUM_ROOT_METHODS},
 240         {bitMap_descr,  IID_Hidd_BitMap, NUM_BITMAP_METHODS},
 241         {NULL, NULL, 0}
 242     };
 243
 244     AttrBase MetaAttrBase = GetAttrBase(IID_Meta);
 245
 246     struct TagItem tags[] =
 247     {
 248         {aMeta_SuperID,        (IPTR) CLID_Hidd_BitMap},
 249         {aMeta_InterfaceDescr, (IPTR) ifdescr},
 250         {aMeta_ID,             (IPTR) CLID_Hidd_BitMapAmigaIntui},
 251         {aMeta_InstSize,       (IPTR) sizeof(struct HIDDBitMapAmigaIntuiData)},
 252         {TAG_DONE, 0UL}
 253     };
 254
 255     Class *cl = NULL;
 256
 257     EnterFunc(bug("init_bitmapclassAmigaIntui(csd=%p)\n", csd));
 258
 259     if(MetaAttrBase)
 260     {
 261         cl = NewObject(NULL, CLID_HiddMeta, tags);
 262         if(cl)
 263         {
 264             D(bug("BitMap class ok\n"));
 265             csd->bitmapclass = cl;
 266             cl->UserData     = (APTR) csd;
 267
 268             /* Get attrbase for the BitMap interface */
 269             HiddBitMapAttrBase = ObtainAttrBase(IID_Hidd_BitMap);
 270             if(HiddBitMapAttrBase)
 271             {
 272                 AddClass(cl);
 273             }
 274             else
 275             {
 276                 free_bitmapclass(csd);
 277                 cl = NULL;
 278             }
 279         }
 280     } /* if(MetaAttrBase) */
 281
 282     ReturnPtr("init_bitmapclassAmigaIntui", Class *,  cl);
 283 }
 284
 285
 286 /*** free_bitmapclass *********************************************************/
 287
 288 void free_bitmapclass(struct class_static_data *csd)
 289 {
 290     EnterFunc(bug("free_bitmapclassAmigaIntui(csd=%p)\n", csd));
 291
 292     if(csd)
 293     {
 294         RemoveClass(csd->bitmapclass);
 295         DisposeObject((Object *) csd->bitmapclass);
 296         csd->bitmapclass = NULL;
 297         if(HiddBitMapAttrBase) ReleaseAttrBase(IID_Hidd_BitMap);
 298     }
 299
 300     ReturnVoid("free_bitmapclassAmigaIntui");
 301 }