workbench/libs/datatypes/newdtobjecta.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8 #include <proto/intuition.h>
   9 #include <proto/utility.h>
  10 #include <proto/iffparse.h>
  11 #include <proto/dos.h>
  12 #include <utility/tagitem.h>
  13 #include <intuition/intuition.h>
  14 #include "datatypes_intern.h"   /* Must be after <intuition/intuition.h> */
  15
  16 #include <aros/debug.h>
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21 #include <proto/datatypes.h>
  22
  23         AROS_LH2(Object *, NewDTObjectA,
  24
  25 /*  SYNOPSIS */
  26         AROS_LHA(APTR            , name , D0),
  27         AROS_LHA(struct TagItem *, attrs, A0),
  28
  29 /*  LOCATION */
  30         struct Library *, DataTypesBase, 8, DataTypes)
  31
  32 /*  FUNCTION
  33
  34     Create a data type object from a BOOPSI class.
  35
  36     INPUTS
  37
  38     name   --  name of the data source; generally an existing file name
  39     attrs  --  pointer to a TagList specifying additional arguments
  40
  41     TAGS
  42
  43     DTA_SourceType  --  The type of source data (defaults to DTST_FILE).
  44                         If the source is the clipboard the name field
  45                         contains the numeric clipboard unit.
  46
  47     DTA_Handle      --  Can be used instead of the 'name' field. If the
  48                         source is DTST_FILE, ths must be a valid FileHandle;
  49                         must be a valid IFFHandle if source is DTST_CLIPBOARD.
  50
  51     DTA_DataType    --  The class of the data. Data is a pointer to a valid
  52                         DataType; only used when creating a new object that
  53                         doens't have any source data.
  54
  55     DTA_GroupID     --  If the object isn't of this type, fail with an IoErr()
  56                         of ERROR_OBJECT_WRONG_TYPE.
  57
  58     GA_Left
  59     GA_RelRight
  60     GA_Top
  61     GA_RelBottom
  62     GA_Width
  63     GA_RelWidth
  64     GA_Height
  65     GA_RelHeight    --  Specify the position of the object relative to the
  66                         window.
  67
  68     GA_ID           --  ID of the object.
  69
  70     GA_UserData     --  Application specific data for the object.
  71
  72     GA_Previous     --  Previous object / gadget in the list.
  73
  74     RESULT
  75
  76     A BOOPSI object. This may be used in different contexts such as a gadget
  77     or image. NULL indicates failure -- in that case IoErr() gives more
  78     information:
  79
  80     ERROR_REQUIRED_ARG_MISSING  --  A required attribute wasn't specified.
  81
  82     ERROR_BAD_NUMBER            --  The group ID specified was invalid.
  83
  84     ERROR_OBJECT_WRONG_TYPE     --  Object data type doesn't match DTA_GroupID.
  85
  86     NOTES
  87
  88     This function invokes the method OM_NEW for the specified class.
  89
  90     The object should (eventually) be freed by DisposeDTObject() when no
  91     longer needed.
  92
  93     EXAMPLE
  94
  95     BUGS
  96
  97     SEE ALSO
  98
  99     AddDTObject(), DisposeDTObject(), RemoveDTObject(),
 100     intuition.library/NewObjectA()
 101
 102     INTERNALS
 103
 104     HISTORY
 105
 106 *****************************************************************************/
 107 {
 108     AROS_LIBFUNC_INIT
 109
 110     ULONG             SourceType;
 111     struct DataType  *DataType;
 112     APTR              Handle;
 113     ULONG             GroupID;
 114     BPTR              lock = BNULL;
 115     struct IFFHandle *iff = NULL;
 116     Object           *dtobj = NULL;
 117     UBYTE            *BaseName = NULL;
 118
 119     D(bug("datatypes.library/NewDTObjectA\n"));
 120
 121     if(!(SourceType = GetTagData(DTA_SourceType, DTST_FILE, attrs)))
 122     {
 123         D(bug("datatypes.library/NewDTObjectA: Bad DTA_SourceType (or no such tag)\n"));
 124         SetIoErr(ERROR_REQUIRED_ARG_MISSING);
 125     }
 126     else
 127     {
 128         D(bug("datatypes.library/NewDTObjectA: DTA_SourceType okay\n"));
 129
 130         DataType = (struct DataType *)GetTagData(DTA_DataType, (IPTR) NULL, attrs);
 131         Handle   =              (APTR)GetTagData(DTA_Handle,   (IPTR) NULL, attrs);
 132         GroupID  =                    GetTagData(DTA_GroupID,         0,    attrs);
 133         BaseName =           (UBYTE *)GetTagData(DTA_BaseName, (IPTR) NULL, attrs);
 134
 135         D(bug("datatypes.library/NewDTObjectA: Got attrs DTA_DataType, DTA_Handle and DTA_GroupID\n"));
 136
 137         if((SourceType == DTST_RAM) && GroupID)
 138         {
 139             D(bug("datatypes.library/NewDTObjectA: SourceType is DTST_RAM and GroupID is != 0\n"));
 140             switch (GroupID)
 141             {
 142             case GID_ANIMATION:  BaseName="animation";         break;
 143             case GID_DOCUMENT:   BaseName="document";          break;
 144             case GID_INSTRUMENT: BaseName="instrument";        break;
 145             case GID_MOVIE:      BaseName="movie";             break;
 146             case GID_MUSIC:      BaseName="music";             break;
 147             case GID_PICTURE:    BaseName="picture";           break;
 148             case GID_SOUND:      BaseName="sound";             break;
 149             case GID_TEXT:       BaseName="ascii";             break;
 150
 151             default:             SetIoErr(ERROR_BAD_NUMBER);   break;
 152             }
 153         }
 154         else
 155         {
 156             D(bug("datatypes.library/NewDTObjectA: SourceType is *not* DTST_RAM or GroupID is 0\n"));
 157
 158             if(Handle != NULL)
 159             {
 160                 D(bug("datatypes.library/NewDTObjectA: We have a DTA_Handle. Calling ObtainDataTypeA\n"));
 161
 162                 DataType = ObtainDataTypeA(SourceType, Handle, attrs);
 163
 164                 D(bug("datatypes.library/NewDTObjectA: ObtainDataTypeA() returned %x\n", DataType));
 165
 166             }
 167             else
 168             {
 169                 D(bug("datatypes.library/NewDTObjectA: DTA_Handle is NULL\n"));
 170                 if(DataType == NULL)
 171                 {
 172                     D(bug("datatypes.library/NewDTObjectA: DataType is NULL\n"));
 173
 174                     switch(SourceType)
 175                     {
 176                     case DTST_FILE:
 177                         D(bug("datatypes.library/NewDTObjectA: SourceType is DTST_FILE\n"));
 178
 179                         if((lock = Lock(name, ACCESS_READ)))
 180                         {
 181                             D(bug("datatypes.library/NewDTObjectA: Lock(\"%s\") okay\n", name));
 182                             if((DataType = ObtainDataTypeA(SourceType,
 183                                                            (APTR)lock, attrs)))
 184                             {
 185                                 D(bug("datatypes.library/NewDTObjectA: ObtainDataType returned %x\n", DataType));
 186                                 if (GroupID && (DataType->dtn_Header->dth_GroupID != GroupID))
 187                                 {
 188                                     D(bug("datatypes.library/NewDTObjectA: Bad GroupID\n"));
 189
 190                                     ReleaseDataType(DataType);
 191                                     DataType = NULL;
 192                                     SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 193                                 }
 194                                 else
 195                                     Handle = (APTR)lock;
 196                             }
 197
 198                             if(Handle == NULL)
 199                             {
 200                                 UnLock(lock);
 201                                 lock = BNULL;
 202                             }
 203
 204                         } /* if lock aquired */
 205                         break;
 206
 207                     case DTST_CLIPBOARD:
 208                         D(bug("datatypes.library/NewDTObjectA: SourceType = DTST_CLIPBOARD\n"));
 209
 210                         if(!(iff = AllocIFF()))
 211                             SetIoErr(ERROR_NO_FREE_STORE);
 212                         else
 213                         {
 214                             D(bug("datatypes.library/NewDTObjectA: AllocIFF okay\n"));
 215                             if((iff->iff_Stream = (IPTR)OpenClipboard((IPTR)name)))
 216                             {
 217                                 D(bug("datatypes.library/NewDTObjectA: OpenClipBoard okay\n"));
 218
 219                                 InitIFFasClip(iff);
 220
 221                                 if(!OpenIFF(iff, IFFF_READ))
 222                                 {
 223                                     D(bug("datatypes.library/NewDTObjectA: OpenIFF okay\n"));
 224
 225                                     if((DataType = ObtainDataTypeA(SourceType,
 226                                                                   iff, attrs)))
 227                                     {
 228                                         D(bug("datatypes.library/NewDTObjectA: ObtainDataType returned %x\n", DataType));
 229
 230                                         if (GroupID && (DataType->dtn_Header->dth_GroupID != GroupID))
 231                                         {
 232                                             D(bug("datatypes.library/NewDTObjectA: Bad GroupID\n"));
 233
 234                                             ReleaseDataType(DataType);
 235                                             DataType = NULL;
 236                                             SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 237                                         }
 238                                         else
 239                                             Handle = iff;
 240
 241                                     } /* ObtainDataType okay */
 242                                     if(Handle == NULL)
 243                                         CloseIFF(iff);
 244
 245                                 } /* OpenIFF okay */
 246
 247                                 if(Handle == NULL)
 248                                     CloseClipboard((struct ClipboardHandle*)iff->iff_Stream);
 249
 250                             } /* OpenClipBoard okay */
 251
 252                             if(Handle == NULL)
 253                             {
 254                                 FreeIFF(iff);
 255                                 iff = NULL;
 256                             }
 257
 258                         } /* AllocIFF okay */
 259
 260                         break;
 261
 262                     } /* switch(SourceType) */
 263
 264                 } /* if (DataType == NULL */
 265
 266             } /* DTA_Handle == NULL */
 267
 268         } /* SourceType != DTST_RAM or GroupID == 0 */
 269
 270         if(DataType != NULL)
 271             BaseName = DataType->dtn_Header->dth_BaseName;
 272
 273         if(BaseName != NULL)
 274         {
 275             UBYTE libname[120];
 276             struct Library *DTClassBase;
 277
 278             D(bug("datatypes.library/NewDTObjectA: Trying OpenLibrary(datatypes/%s.datatype)\n", BaseName));
 279             strcpy(libname, "datatypes/");
 280             strcat(libname, BaseName);
 281             strcat(libname, ".datatype");
 282
 283             if(!(DTClassBase = OpenLibrary(libname, 0)))
 284                 SetIoErr(DTERROR_UNKNOWN_DATATYPE);
 285             else
 286             {
 287                 struct IClass *DTClass;
 288
 289                 D(bug("datatypes.library/NewDTObjectA: OpenLibrary okay. Now calling ObtainEngine\n"));
 290
 291                 /* Call ObtainEngine() */
 292                 if((DTClass = AROS_LVO_CALL0(Class *, struct Library *,
 293                                              DTClassBase, 5,)))
 294
 295                 {
 296                     struct TagItem Tags[4];
 297
 298                     D(bug("datatypes.library/NewDTObjectA: ObtainEngine returned %x\n", DTClass));
 299
 300                     Tags[0].ti_Tag  = DTA_Name;
 301                     Tags[0].ti_Data = (IPTR)name;
 302                     Tags[1].ti_Tag  = DTA_DataType;
 303                     Tags[1].ti_Data = (IPTR)DataType;
 304                     Tags[2].ti_Tag  = DTA_Handle;
 305                     Tags[2].ti_Data = (IPTR)Handle;
 306                     Tags[3].ti_Tag  = TAG_MORE;
 307                     Tags[3].ti_Data = (IPTR)attrs;
 308
 309                     D(bug("datatypes.library/NewDTObjectA: Calling NewObjectA on obtained engine\n"));
 310
 311                     dtobj = NewObjectA(DTClass, NULL, Tags);
 312
 313                     D(bug("datatypes.library/NewDTObjectA: NewObjectA returned %x\n", dtobj));
 314
 315                     lock = BNULL;
 316                     iff = NULL;
 317
 318                 } /* ObtainEngine okay */
 319
 320                 if(dtobj == NULL)
 321                     CloseLibrary(DTClassBase);
 322
 323             } /* datatype class library could be opened */
 324
 325         } /* if (BaseName != NULL) */
 326
 327         if(dtobj == NULL)
 328         {
 329             D(bug("datatypes.library/NewDTObjectA: dtobj is NULL. Cleaning up\n"));
 330
 331             if(lock != BNULL)
 332                 UnLock(lock);
 333
 334             if(iff != NULL)
 335             {
 336                 D(bug("datatypes.library/NewDTObjectA: Calling CloseIFF\n"));
 337                 CloseIFF(iff);
 338                 D(bug("datatypes.library/NewDTObjectA: Calling CloseClipboard\n"));
 339                 CloseClipboard((struct ClipboardHandle *)iff->iff_Stream);
 340                 D(bug("datatypes.library/NewDTObjectA: Calling FreeIFF\n"));
 341                 FreeIFF(iff);
 342                 D(bug("datatypes.library/NewDTObjectA: IFF cleanup done\n"));
 343
 344             } /* if (iff != NULL) */
 345
 346         } /* if (dtobj == NULL) */
 347
 348     } /* SourceType okay */
 349
 350     if(IoErr() == ERROR_OBJECT_NOT_FOUND)
 351         SetIoErr(DTERROR_COULDNT_OPEN);
 352
 353     D(bug("datatypes.library/NewDTObjectA: Done. Returning %x\n", dtobj));
 354
 355     return dtobj;
 356
 357     AROS_LIBFUNC_EXIT
 358
 359 } /* NewDTObjectA */
 360