workbench/classes/datatypes/gemimage/datatype.c

   1 /*
   2
   3 Author: Neil Cafferkey
   4 Copyright (C) 2002-2011 Neil Cafferkey
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19 MA 02111-1307, USA.
  20
  21 */
  22
  23
  24 #include <exec/types.h>
  25 #include <exec/resident.h>
  26 #include <utility/utility.h>
  27 #include <graphics/gfxbase.h>
  28 #include "initializers.h"
  29
  30 #include <proto/exec.h>
  31 #include <proto/intuition.h>
  32
  33 #include "datatype.h"
  34
  35 #include "datatype_protos.h"
  36 #include "gemimage_protos.h"
  37
  38 #define SUPERCLASS_VERSION 0
  39 #define INTUITION_VERSION 36
  40 #define UTILITY_VERSION 36
  41 #define DATATYPES_VERSION 0
  42 #define GRAPHICS_VERSION 39
  43 #define DOS_VERSION 36
  44
  45
  46 /* Private prototypes */
  47
  48 static VOID DeleteDataType(struct GemImgBase *base);
  49
  50
  51 /* Return an error immediately if someone tries to run the datatype */
  52
  53 LONG Main()
  54 {
  55    return -1;
  56 }
  57
  58
  59
  60 const TEXT datatype_name[] = DATATYPE_NAME;
  61 const TEXT version_string[] =
  62    DATATYPE_NAME " " STR(VERSION) "." STR(REVISION) " (" DATE ")\n";
  63 static const TEXT superclass_name[] = "datatypes/picture.datatype";
  64 static const TEXT intuition_name[] = "intuition.library";
  65 static const TEXT utility_name[] = UTILITYNAME;
  66 static const TEXT datatypes_name[] = "datatypes.library";
  67 static const TEXT graphics_name[] = GRAPHICSNAME;
  68 static const TEXT dos_name[] = DOSNAME;
  69
  70
  71 static const APTR vectors[] =
  72 {
  73    (APTR)LibOpen,
  74    (APTR)LibClose,
  75    (APTR)LibExpunge,
  76    (APTR)LibReserved,
  77    (APTR)ObtainClass,
  78    (APTR)-1
  79 };
  80
  81
  82 static const struct
  83 {
  84    SMALLINITBYTEDEF(type);
  85    SMALLINITPINTDEF(name);
  86    SMALLINITBYTEDEF(flags);
  87    SMALLINITWORDDEF(version);
  88    SMALLINITWORDDEF(revision);
  89    SMALLINITPINTDEF(id_string);
  90    INITENDDEF;
  91 }
  92 init_data =
  93 {
  94    SMALLINITBYTE(OFFSET(Node, ln_Type), NT_LIBRARY),
  95    SMALLINITPINT(OFFSET(Node, ln_Name), datatype_name),
  96    SMALLINITBYTE(OFFSET(Library, lib_Flags), LIBF_SUMUSED | LIBF_CHANGED),
  97    SMALLINITWORD(OFFSET(Library, lib_Version), VERSION),
  98    SMALLINITWORD(OFFSET(Library, lib_Revision), REVISION),
  99    SMALLINITPINT(OFFSET(Library, lib_IdString), version_string),
 100    INITEND
 101 };
 102
 103
 104 static const APTR init_table[] =
 105 {
 106    (APTR)sizeof(struct GemImgBase),
 107    (APTR)vectors,
 108    (APTR)&init_data,
 109    (APTR)LibInit
 110 };
 111
 112
 113 const struct Resident rom_tag =
 114 {
 115    RTC_MATCHWORD,
 116    (struct Resident *)&rom_tag,
 117    (APTR)(&rom_tag + 1),
 118    RTF_AUTOINIT,
 119    VERSION,
 120    NT_LIBRARY,
 121    0,
 122    (TEXT *)datatype_name,
 123    (TEXT *)version_string,
 124    (APTR)init_table
 125 };
 126
 127
 128
 129 /****i* gemimage.datatype/LibInit ******************************************
 130 *
 131 *   NAME
 132 *       LibInit
 133 *
 134 *   SYNOPSIS
 135 *       lib_base = LibInit(lib_base, seg_list)
 136 *
 137 *       struct GemImgBase *LibInit(struct GemImgBase *, APTR);
 138 *
 139 ****************************************************************************
 140 *
 141 */
 142
 143 struct GemImgBase *LibInit(struct GemImgBase *lib_base REG("d0"),
 144    APTR seg_list REG("a0"), struct GemImgBase *base REG(BASE_REG))
 145 {
 146    BOOL success = TRUE;
 147
 148    lib_base->sys_base = (APTR)base;
 149    base = lib_base;
 150    base->seg_list = seg_list;
 151
 152    base->superclass_base = OpenLibrary(superclass_name, SUPERCLASS_VERSION);
 153    base->intuition_base = (APTR)OpenLibrary(intuition_name,
 154       INTUITION_VERSION);
 155    base->utility_base = (APTR)OpenLibrary(utility_name, UTILITY_VERSION);
 156    base->datatypes_base = (APTR)OpenLibrary(datatypes_name,
 157       DATATYPES_VERSION);
 158    base->graphics_base = (APTR)OpenLibrary(graphics_name, GRAPHICS_VERSION);
 159    base->dos_base = (APTR)OpenLibrary(dos_name, DOS_VERSION);
 160    if(base->superclass_base == NULL || base->intuition_base == NULL
 161       || base->utility_base == NULL || base->datatypes_base == NULL
 162       || base->graphics_base == NULL || base->dos_base == NULL)
 163       success = FALSE;
 164
 165    if(success)
 166    {
 167       base->class = MakeGemImgClass(base);
 168       if(base->class == NULL)
 169          success = FALSE;
 170    }
 171
 172    if(!success)
 173    {
 174       DeleteDataType(base);
 175       base = NULL;
 176    }
 177
 178    return base;
 179 }
 180
 181
 182
 183 /****i* gemimage.datatype/LibOpen ******************************************
 184 *
 185 *   NAME
 186 *       LibOpen
 187 *
 188 *   SYNOPSIS
 189 *       datatype = LibOpen(version)
 190 *
 191 *       struct GemImgBase *LibOpen(ULONG);
 192 *
 193 ****************************************************************************
 194 *
 195 */
 196
 197 struct GemImgBase *LibOpen(ULONG version REG("d0"),
 198    struct GemImgBase *base REG(BASE_REG))
 199 {
 200    ((struct Library *)base)->lib_OpenCnt++;
 201    ((struct Library *)base)->lib_Flags &= ~LIBF_DELEXP;
 202
 203    return base;
 204 }
 205
 206
 207
 208 /****i* gemimage.datatype/LibClose *****************************************
 209 *
 210 *   NAME
 211 *       LibClose
 212 *
 213 *   SYNOPSIS
 214 *       seg_list = LibClose()
 215 *
 216 *       APTR LibClose(VOID);
 217 *
 218 ****************************************************************************
 219 *
 220 */
 221
 222 APTR LibClose(struct GemImgBase *base REG(BASE_REG))
 223 {
 224    APTR seg_list = NULL;
 225
 226    /* Expunge the datatype if a delayed expunge is pending */
 227
 228    if((--((struct Library *)base)->lib_OpenCnt) == 0)
 229    {
 230       if((((struct Library *)base)->lib_Flags & LIBF_DELEXP) != 0)
 231          seg_list = LibExpunge(base);
 232    }
 233
 234    return seg_list;
 235 }
 236
 237
 238
 239 /****i* gemimage.datatype/LibExpunge ***************************************
 240 *
 241 *   NAME
 242 *       LibExpunge
 243 *
 244 *   SYNOPSIS
 245 *       seg_list = LibExpunge()
 246 *
 247 *       APTR LibExpunge(VOID);
 248 *
 249 ****************************************************************************
 250 *
 251 */
 252
 253 APTR LibExpunge(struct GemImgBase *base REG(BASE_REG))
 254 {
 255    APTR seg_list;
 256
 257    if(((struct Library *)base)->lib_OpenCnt == 0)
 258    {
 259       seg_list = base->seg_list;
 260       Remove((APTR)base);
 261       DeleteDataType(base);
 262    }
 263    else
 264    {
 265       ((struct Library *)base)->lib_Flags |= LIBF_DELEXP;
 266       seg_list = NULL;
 267    }
 268    return seg_list;
 269 }
 270
 271
 272
 273 /****i* gemimage.datatype/LibReserved **************************************
 274 *
 275 *   NAME
 276 *       LibReserved
 277 *
 278 *   SYNOPSIS
 279 *       result = LibReserved()
 280 *
 281 *       APTR LibReserved(VOID);
 282 *
 283 ****************************************************************************
 284 *
 285 */
 286
 287 APTR LibReserved(VOID)
 288 {
 289    return NULL;
 290 }
 291
 292
 293
 294 /****i* gemimage.datatype/ObtainClass **************************************
 295 *
 296 *   NAME
 297 *       ObtainClass
 298 *
 299 *   SYNOPSIS
 300 *       class = ObtainClass()
 301 *
 302 *       struct IClass *ObtainClass(VOID);
 303 *
 304 ****************************************************************************
 305 *
 306 */
 307
 308 struct IClass *ObtainClass(struct GemImgBase *base REG(BASE_REG))
 309 {
 310    return base->class;
 311 }
 312
 313
 314
 315 /****i* gemimage.datatype/DeleteDataType ***********************************
 316 *
 317 *   NAME
 318 *       DeleteDataType
 319 *
 320 *   SYNOPSIS
 321 *       DeleteDataType()
 322 *
 323 *       VOID DeleteDataType(VOID);
 324 *
 325 ****************************************************************************
 326 *
 327 */
 328
 329 static VOID DeleteDataType(struct GemImgBase *base)
 330 {
 331    UWORD neg_size, pos_size;
 332
 333    if(base->class != NULL)
 334       FreeClass(base->class);
 335
 336    /* Close libraries */
 337
 338    if(base->dos_base != NULL)
 339       CloseLibrary((APTR)base->dos_base);
 340    if(base->graphics_base != NULL)
 341       CloseLibrary((APTR)base->graphics_base);
 342    if(base->datatypes_base != NULL)
 343       CloseLibrary(base->datatypes_base);
 344    if(base->utility_base != NULL)
 345       CloseLibrary((APTR)base->utility_base);
 346    if(base->intuition_base != NULL)
 347       CloseLibrary((APTR)base->intuition_base);
 348    if(base->superclass_base != NULL)
 349       CloseLibrary(base->superclass_base);
 350
 351    /* Free datatype's memory */
 352
 353    neg_size = ((struct Library *)base)->lib_NegSize;
 354    pos_size = ((struct Library *)base)->lib_PosSize;
 355    FreeMem((UBYTE *)base - neg_size, pos_size + neg_size);
 356
 357    return;
 358 }
 359
 360
 361