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_Requester,    ad_Requester,  PKCTRL_ULONG),
  43    AD_ENTRY(ASLREQ_Type,         ad_Type,       PKCTRL_ULONG),
  44    AD_ENTRY(ASLREQ_Left,         ad_Left,       PKCTRL_WORD),
  45    AD_ENTRY(ASLREQ_Top,          ad_Top,        PKCTRL_WORD),
  46    AD_ENTRY(ASLREQ_Width,        ad_Width,      PKCTRL_UWORD),
  47    AD_ENTRY(ASLREQ_Height,       ad_Height,     PKCTRL_UWORD),
  48
  49    PACK_ENDTABLE
  50 };
  51 ///
  52
  53 /// OM_NEW
  54 /*
  55  * Create a shiny new object.
  56  */
  57 METHOD(AslReqClassNew, struct opSet *, ops)
  58 {
  59    AD          *ad;
  60    ULONG        rc;
  61
  62    /*
  63     * First we let the superclass
  64     * create the object.
  65     */
  66    if (rc = AsmDoSuperMethodA(cl, obj, (Msg)ops))
  67    {
  68       /*
  69        * Get us the instance data.
  70        */
  71       ad = INST_DATA(cl, rc);
  72
  73       /*
  74        * Setup the defaults.
  75        */
  76       ad->ad_Left          = 30;
  77       ad->ad_Top           = 20;
  78       ad->ad_Width         = 320;
  79       ad->ad_Height        = 180;
  80       ad->ad_ASLTags       = CloneTagItems(NULL);
  81
  82       /*
  83        * Setup user attributes.
  84        */
  85       if (AsmCoerceMethod(cl, (Object *)rc, OM_SET, ops, NULL) != ASLREQ_OK)
  86       {
  87          /*
  88           * Failure.
  89           */
  90          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
  91          rc = 0;
  92       }
  93    }
  94    return rc;
  95 }
  96 METHOD_END
  97 ///
  98 /// OM_DISPOSE
  99 /*
 100  * They want us gone.
 101  */
 102 METHOD(AslReqClassDispose, Msg, msg)
 103 {
 104    AD       *ad = INST_DATA(cl, obj);
 105
 106    /*
 107     * Free requester, if it still exists somehow.
 108     */
 109    FreeAslRequest(ad->ad_Requester);
 110
 111    /*
 112     * Free tag copy.
 113     */
 114    FreeTagItems(ad->ad_ASLTags);
 115
 116    /*
 117     * The superclass does the rest.
 118     */
 119    return AsmDoSuperMethodA(cl, obj, msg);
 120 }
 121 METHOD_END
 122 ///
 123 /// OM_SET, OM_UPDATE
 124 /*
 125  * Change one or more of the object
 126  * it's attributes.
 127  */
 128 METHOD(AslReqClassSetUpdate, struct opSet *, ops)
 129 {
 130    AD             *ad = INST_DATA(cl, obj);
 131    struct TagItem *tstate, *tags, *tag;
 132    ULONG           attr, data;
 133    BOOL            asl = FALSE;
 134
 135    /*
 136     * Filter out values in old taglist that will be replaced,
 137     * and values in new taglist that are not ASL tags.
 138     * Process the non-ASL tags before disposal.
 139     */
 140    tstate = tags = CloneTagItems(ops->ops_AttrList);
 141
 142    while (tag = NextTagItem(&tstate))
 143    {
 144       attr = tag->ti_Tag;
 145       data = tag->ti_Data;
 146
 147       if ((attr >= ASL_TB) && (attr < ASL_TB + 0x10000))
 148       {
 149          asl = TRUE;
 150       }
 151       else
 152       {
 153          switch (attr)
 154          {
 155          case ASLREQ_Bounds:
 156             *((struct IBox *)&ad->ad_Left) = *((struct IBox *)data);
 157             break;
 158          default:
 159             /*
 160              * Try to process it.
 161              */
 162             BGUI_PackStructureTag((UBYTE *)ad, AslPackTable, attr, data);
 163             break;
 164          };
 165          /*
 166           * Kill it.
 167           */
 168          tag->ti_Tag = TAG_IGNORE;
 169       };
 170    };
 171
 172    /*
 173     * Merge the old with the new.
 174     */
 175    if (asl)
 176    {
 177       tag = BGUI_MergeTagItems(ad->ad_ASLTags, tags);
 178       FreeTagItems(ad->ad_ASLTags);
 179       ad->ad_ASLTags = BGUI_CleanTagItems(tag, 1);
 180    };
 181
 182    FreeTagItems(tags);
 183
 184    return ASLREQ_OK;
 185 }
 186 METHOD_END
 187 ///
 188 /// OM_GET
 189 /*
 190  * Give one of the attributes.
 191  */
 192 METHOD(AslReqClassGet, struct opGet *, opg)
 193 {
 194    AD                *ad = INST_DATA(cl, obj);
 195    struct TagItem    *tag;
 196    ULONG              rc, attr = opg->opg_AttrID, *store = opg->opg_Storage;
 197
 198    if (tag = FindTagItem(attr, ad->ad_ASLTags))
 199    {
 200       *store = tag->ti_Data;
 201       rc = 1;
 202    }
 203    else
 204    {
 205       rc = BGUI_UnpackStructureTag((UBYTE *)ad, AslPackTable, attr, store);
 206       if (!rc) rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 207    };
 208    return rc;
 209 }
 210 METHOD_END
 211 ///
 212 /// ASLM_ALLOCREQUEST
 213 /*
 214  * Allocate requester.
 215  */
 216 METHOD(AslReqClassAllocRequest, Msg, msg)
 217 {
 218    AD          *ad = INST_DATA(cl, obj);
 219
 220    ad->ad_Requester = AllocAslRequestTags(ad->ad_Type,
 221       ASL_LeftEdge,     ad->ad_Left,      ASL_TopEdge,   ad->ad_Top,
 222       ASL_Width,        ad->ad_Width,     ASL_Height,    ad->ad_Height,
 223       TAG_DONE);
 224
 225    return (ULONG)ad->ad_Requester;
 226 }
 227 METHOD_END
 228 ///
 229 /// ASLM_REQUEST
 230 /*
 231  * Show requester.
 232  */
 233 METHOD(AslReqClassRequest, Msg, msg)
 234 {
 235    AD          *ad = INST_DATA(cl, obj);
 236    ULONG        rc = 0;
 237
 238    if (ad->ad_Requester)
 239    {
 240       rc = AslRequest(ad->ad_Requester, ad->ad_ASLTags);
 241    };
 242    return rc;
 243 }
 244 METHOD_END
 245 ///
 246 /// ASLM_FREEREQUEST
 247 /*
 248  * Free requester.
 249  */
 250 METHOD(AslReqClassFreeRequest, Msg, msg)
 251 {
 252    AD          *ad = INST_DATA(cl, obj);
 253
 254    FreeAslRequest(ad->ad_Requester);
 255    ad->ad_Requester = NULL;
 256
 257    return 1;
 258 }
 259 METHOD_END
 260 ///
 261
 262 /// Class initialization.
 263 /*
 264  * Function table.
 265  */
 266 STATIC DPFUNC ClassFunc[] = {
 267    OM_NEW,              (FUNCPTR)AslReqClassNew,
 268    OM_SET,              (FUNCPTR)AslReqClassSetUpdate,
 269    OM_UPDATE,           (FUNCPTR)AslReqClassSetUpdate,
 270    OM_GET,              (FUNCPTR)AslReqClassGet,
 271    OM_DISPOSE,          (FUNCPTR)AslReqClassDispose,
 272    ASLM_ALLOCREQUEST,   (FUNCPTR)AslReqClassAllocRequest,
 273    ASLM_REQUEST,        (FUNCPTR)AslReqClassRequest,
 274    ASLM_FREEREQUEST,    (FUNCPTR)AslReqClassFreeRequest,
 275    DF_END,              NULL
 276 };
 277
 278 /*
 279  * Simple class initialization.
 280  */
 281 makeproto Class *InitAslReqClass(void)
 282 {
 283    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_ROOT_OBJECT,
 284                          CLASS_ObjectSize,     sizeof(AD),
 285                          CLASS_DFTable,        ClassFunc,
 286                          TAG_DONE);
 287 }
 288 ///