bgui/aslreqclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * aslreqclass.c
   6  *
   7  * (C) Copyright 1998 Manuel Lemos.
   8  * (C) Copyright 1996-1997 Ian J. Einman.
   9  * (C) Copyright 1993-1996 Jaba Development.
  10  * (C) Copyright 1993-1996 Jan van den Baard.
  11  * All Rights Reserved.
  12  *
  13  */
  14
  15 #include "include/classdefs.h"
  16
  17 #ifdef __AROS__
  18 extern struct Library * AslBase;
  19 #endif
  20
  21 /// Class definitions.
  22 /*
  23  * Object instance data.
  24  */
  25 typedef struct ad_ {
  26    APTR            ad_Requester; /* Requester         */
  27    ULONG           ad_Type;      /* Requester type    */
  28    WORD            ad_Left;      /* Requester left    */
  29    WORD            ad_Top;       /* Requester top     */
  30    UWORD           ad_Width;     /* Requester width   */
  31    UWORD           ad_Height;    /* Requester height  */
  32    struct TagItem *ad_ASLTags;   /* Copy of ASL tags  */
  33 }  AD;
  34
  35 #define AD_ENTRY(tag, offset, flags) PACK_ENTRY(ASLREQ_TAGSTART, tag, ad_, offset, flags)
  36 #define AD_FLAG(tag, flag) PACK_LONGBIT(ASLREQ_TAGSTART, tag, ad_, ad_Flags, PKCTRL_BIT, flag)
  37
  38 static ULONG AslPackTable[] =
  39 {
  40    PACK_STARTTABLE(ASLREQ_TAGSTART),
  41
  42    AD_ENTRY(ASLREQ_Type,         ad_Type,       PKCTRL_ULONG),
  43    AD_ENTRY(ASLREQ_Left,         ad_Left,       PKCTRL_WORD),
  44    AD_ENTRY(ASLREQ_Top,          ad_Top,        PKCTRL_WORD),
  45    AD_ENTRY(ASLREQ_Width,        ad_Width,      PKCTRL_UWORD),
  46    AD_ENTRY(ASLREQ_Height,       ad_Height,     PKCTRL_UWORD),
  47
  48    PACK_ENDTABLE
  49 };
  50 ///
  51
  52 /// OM_NEW
  53 /*
  54  * Create a shiny new object.
  55  */
  56 METHOD(AslReqClassNew, struct opSet *, ops)
  57 {
  58    AD          *ad;
  59    IPTR         rc;
  60
  61    /*
  62     * First we let the superclass
  63     * create the object.
  64     */
  65    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)ops)))
  66    {
  67       /*
  68        * Get us the instance data.
  69        */
  70       ad = INST_DATA(cl, rc);
  71
  72       /*
  73        * Setup the defaults.
  74        */
  75       ad->ad_Left          = 30;
  76       ad->ad_Top           = 20;
  77       ad->ad_Width         = 320;
  78       ad->ad_Height        = 180;
  79       ad->ad_ASLTags       = CloneTagItems(NULL);
  80
  81       /*
  82        * Setup user attributes.
  83        */
  84       if (AsmCoerceMethod(cl, (Object *)rc, OM_SET, ops, NULL) != ASLREQ_OK)
  85       {
  86          /*
  87           * Failure.
  88           */
  89          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
  90          rc = 0;
  91       }
  92    }
  93    return rc;
  94 }
  95 METHOD_END
  96 ///
  97 /// OM_DISPOSE
  98 /*
  99  * They want us gone.
 100  */
 101 METHOD(AslReqClassDispose, Msg, msg)
 102 {
 103    AD       *ad = INST_DATA(cl, obj);
 104
 105    /*
 106     * Free requester, if it still exists somehow.
 107     */
 108    FreeAslRequest(ad->ad_Requester);
 109
 110    /*
 111     * Free tag copy.
 112     */
 113    FreeTagItems(ad->ad_ASLTags);
 114
 115    /*
 116     * The superclass does the rest.
 117     */
 118    return AsmDoSuperMethodA(cl, obj, msg);
 119 }
 120 METHOD_END
 121 ///
 122 /// OM_SET, OM_UPDATE
 123 /*
 124  * Change one or more of the object
 125  * it's attributes.
 126  */
 127 METHOD(AslReqClassSetUpdate, struct opSet *, ops)
 128 {
 129    AD             *ad = INST_DATA(cl, obj);
 130    Tag             attr;
 131    IPTR            data;
 132    struct TagItem *tstate;
 133    struct TagItem *tags, *tag;
 134    BOOL            asl = FALSE;
 135
 136    /*
 137     * Filter out values in old taglist that will be replaced,
 138     * and values in new taglist that are not ASL tags.
 139     * Process the non-ASL tags before disposal.
 140     */
 141    tstate = tags = CloneTagItems(ops->ops_AttrList);
 142
 143    while ((tag = NextTagItem(&tstate)))
 144    {
 145       attr = tag->ti_Tag;
 146       data = tag->ti_Data;
 147
 148       if ((attr >= ASL_TB) && (attr < ASL_TB + 0x10000))
 149       {
 150          asl = TRUE;
 151       }
 152       else
 153       {
 154          switch (attr)
 155          {
 156          case ASLREQ_Bounds:
 157             *((struct IBox *)&ad->ad_Left) = *((struct IBox *)data);
 158             break;
 159          case ASLREQ_Requester:
 160             ad->ad_Requester = (APTR)data;
 161             break;
 162          default:
 163             /*
 164              * Try to process it.
 165              */
 166             BGUI_PackStructureTag((UBYTE *)ad, AslPackTable, attr, data);
 167             break;
 168          };
 169          /*
 170           * Kill it.
 171           */
 172          tag->ti_Tag = TAG_IGNORE;
 173       };
 174    };
 175
 176    /*
 177     * Merge the old with the new.
 178     */
 179    if (asl)
 180    {
 181       tag = BGUI_MergeTagItems(ad->ad_ASLTags, tags);
 182       FreeTagItems(ad->ad_ASLTags);
 183       ad->ad_ASLTags = BGUI_CleanTagItems(tag, 1);
 184    };
 185
 186    FreeTagItems(tags);
 187
 188    return ASLREQ_OK;
 189 }
 190 METHOD_END
 191 ///
 192 /// OM_GET
 193 /*
 194  * Give one of the attributes.
 195  */
 196 METHOD(AslReqClassGet, struct opGet *, opg)
 197 {
 198    AD                *ad = INST_DATA(cl, obj);
 199    struct TagItem    *tag;
 200    ULONG              rc;
 201    Tag                attr = opg->opg_AttrID;
 202    IPTR              *store = opg->opg_Storage;
 203
 204    if ((tag = FindTagItem(attr, ad->ad_ASLTags)))
 205    {
 206       *store = tag->ti_Data;
 207       rc = 1;
 208    }
 209    else if (attr == ASLREQ_Requester)
 210    {
 211       *store = (IPTR)ad->ad_Requester;
 212       rc = 1;
 213    }
 214    else
 215    {
 216       rc = BGUI_UnpackStructureTag((UBYTE *)ad, AslPackTable, attr, store);
 217       if (!rc) rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 218    };
 219    return rc;
 220 }
 221 METHOD_END
 222 ///
 223 /// ASLM_ALLOCREQUEST
 224 /*
 225  * Allocate requester.
 226  */
 227 METHOD(AslReqClassAllocRequest, Msg, msg)
 228 {
 229    AD          *ad = INST_DATA(cl, obj);
 230
 231    ad->ad_Requester = AllocAslRequestTags(ad->ad_Type,
 232       ASL_LeftEdge,     ad->ad_Left,      ASL_TopEdge,   ad->ad_Top,
 233       ASL_Width,        ad->ad_Width,     ASL_Height,    ad->ad_Height,
 234       TAG_DONE);
 235
 236    return (IPTR)ad->ad_Requester;
 237 }
 238 METHOD_END
 239 ///
 240 /// ASLM_REQUEST
 241 /*
 242  * Show requester.
 243  */
 244 METHOD(AslReqClassRequest, Msg, msg)
 245 {
 246    AD          *ad = INST_DATA(cl, obj);
 247    ULONG        rc = 0;
 248
 249    if (ad->ad_Requester)
 250    {
 251       rc = AslRequest(ad->ad_Requester, ad->ad_ASLTags);
 252    };
 253    return rc;
 254 }
 255 METHOD_END
 256 ///
 257 /// ASLM_FREEREQUEST
 258 /*
 259  * Free requester.
 260  */
 261 METHOD(AslReqClassFreeRequest, Msg, msg)
 262 {
 263    AD          *ad = INST_DATA(cl, obj);
 264
 265    FreeAslRequest(ad->ad_Requester);
 266    ad->ad_Requester = NULL;
 267
 268    return 1;
 269 }
 270 METHOD_END
 271 ///
 272
 273 /// Class initialization.
 274 /*
 275  * Function table.
 276  */
 277 STATIC DPFUNC ClassFunc[] = {
 278    { OM_NEW,              AslReqClassNew, },
 279    { OM_SET,              AslReqClassSetUpdate, },
 280    { OM_UPDATE,           AslReqClassSetUpdate, },
 281    { OM_GET,              AslReqClassGet, },
 282    { OM_DISPOSE,          AslReqClassDispose, },
 283    { ASLM_ALLOCREQUEST,   AslReqClassAllocRequest, },
 284    { ASLM_REQUEST,        AslReqClassRequest, },
 285    { ASLM_FREEREQUEST,    AslReqClassFreeRequest, },
 286    { DF_END,              NULL },
 287 };
 288
 289 /*
 290  * Simple class initialization.
 291  */
 292 makeproto Class *InitAslReqClass(void)
 293 {
 294    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_ROOT_OBJECT,
 295                          CLASS_ObjectSize,     sizeof(AD),
 296                          CLASS_DFTable,        ClassFunc,
 297                          TAG_DONE);
 298 }
 299 ///