workbench/libs/muimaster/classes/family.c

   1 /*
   2     Copyright © 1999, David Le Corfec.
   3     Copyright © 2002-2012, The AROS Development Team.
   4     All rights reserved.
   5
   6     $Id$
   7 */
   8
   9 #include <exec/types.h>
  10
  11 #include <clib/alib_protos.h>
  12 #include <proto/exec.h>
  13 #include <proto/intuition.h>
  14 #include <proto/utility.h>
  15 #include <proto/muimaster.h>
  16
  17 /*  #define MYDEBUG 1 */
  18 #include "debug.h"
  19 #include "muimaster_intern.h"
  20 #include "mui.h"
  21
  22 extern struct Library *MUIMasterBase;
  23
  24 struct MUI_FamilyData
  25 {
  26     struct List children;
  27 };
  28
  29 /*
  30  * Family class is the base class for objects that are able
  31  * to handle a list of children. This is e.g. the case for
  32  * MUIs Menustrip, Menu and Menuitem objects.
  33  * Group class and application class should also be a
  34  * subclass of Family class, but due to BOOPSI system
  35  * limitations, this is currently impossible.
  36  */
  37
  38 /*
  39 Family.mui/MUIA_Family_Child [I..]        done (note : == MUIA_Group_Child)
  40 Family.mui/MUIA_Family_List [..G]         done
  41
  42 Family.mui/MUIM_Family_AddHead            done
  43 Family.mui/MUIM_Family_AddTail            done
  44 Family.mui/MUIM_Family_Insert             done
  45 Family.mui/MUIM_Family_Remove             done
  46 Family.mui/MUIM_Family_Sort               done
  47 Family.mui/MUIM_Family_Transfer           done
  48 Notify.mui/MUIM_FindUData                 done
  49 Notify.mui/MUIM_GetUData                  done
  50 Notify.mui/MUIM_SetUData                  done
  51 Notify.mui/MUIM_SetUDataOnce              done
  52 */
  53
  54 static const int __version = 1;
  55 static const int __revision = 1;
  56
  57 /*  static void */
  58 /*  debuglist(struct List *list) */
  59 /*  { */
  60 /*      g_print("list %p:\nlh_Head@%p = %p\nlh_Tail@%p = %p\nlh_TailPred@%p = %p\n", */
  61 /*              list, &list->lh_Head, list->lh_Head, */
  62 /*              &list->lh_Tail, list->lh_Tail, */
  63 /*              &list->lh_TailPred, list->lh_TailPred); */
  64 /*  } */
  65
  66 /*  static void */
  67 /*  printlist (struct List *list) */
  68 /*  { */
  69 /*      struct Node *node; */
  70
  71 /*      debuglist(list); */
  72
  73 /*      for (node = list->lh_Head; node->ln_Succ; node = node->ln_Succ) */
  74 /*      { */
  75 /*          g_print("%s (ln_Succ@%p = %p | ln_Pred@%p = %p)\n", "node->ln_Name", */
  76 /*                  &node->ln_Succ, node->ln_Succ, &node->ln_Pred, node->ln_Pred); */
  77 /*      } */
  78 /*      g_print("\n"); */
  79 /*  } */
  80
  81 /*
  82  * OM_NEW
  83  */
  84 IPTR Family__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  85 {
  86     struct MUI_FamilyData *data;
  87     struct TagItem *tags;
  88     struct TagItem *tag;
  89     BOOL bad_children = FALSE;
  90
  91     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
  92     if (!obj)
  93         return FALSE;
  94     /*
  95      * Initial local instance data
  96      */
  97     data = INST_DATA(cl, obj);
  98     NewList(&(data->children));
  99
 100     /*
 101      * parse initial taglist
 102      */
 103     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 104     {
 105         if (tag->ti_Tag == MUIA_Family_Child
 106             || tag->ti_Tag == MUIA_Group_Child)
 107         {
 108             if (tag->ti_Data)   /* add child */
 109                 DoMethod(obj, MUIM_Family_AddTail, tag->ti_Data);
 110             else                /* fail and dispose children */
 111             {
 112                 bad_children = TRUE;
 113             }
 114         }
 115     }
 116
 117     if (bad_children)
 118     {
 119         CoerceMethod(cl, obj, OM_DISPOSE);
 120         return 0;
 121     }
 122
 123     return (IPTR) obj;
 124 }
 125
 126
 127 /*
 128  * OM_DISPOSE
 129  */
 130 IPTR Family__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 131 {
 132     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 133     Object *cstate = (Object *) data->children.lh_Head;
 134     Object *child;
 135
 136     while ((child = NextObject(&cstate)))
 137     {
 138 /*  g_print("Family_Dispose: dispose child %p\n", child); */
 139         MUI_DisposeObject(child);
 140     }
 141
 142     return DoSuperMethodA(cl, obj, msg);
 143 }
 144
 145
 146 /*
 147  * OM_GET
 148  */
 149 IPTR Family__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 150 {
 151     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 152     IPTR *store = msg->opg_Storage;
 153
 154     switch (msg->opg_AttrID)
 155     {
 156     case MUIA_Family_List:
 157         *store = (IPTR) & data->children;
 158         return TRUE;
 159
 160     case MUIA_Version:
 161         *store = __version;
 162         return TRUE;
 163
 164     case MUIA_Revision:
 165         *store = __revision;
 166         return TRUE;
 167
 168     case MUIA_Family_ChildCount:
 169         {
 170             Object *cstate = (Object *) data->children.lh_Head;
 171             *store = 0;
 172             while (NextObject(&cstate))
 173                 (*store)++;
 174             return TRUE;
 175         }
 176     }
 177
 178     return (DoSuperMethodA(cl, obj, (Msg) msg));
 179 }
 180
 181
 182 /*
 183  * MUIM_Family_AddHead : Add an object as first object to the family.
 184  */
 185 IPTR Family__MUIM_AddHead(struct IClass *cl, Object *obj,
 186     struct MUIP_Family_AddHead *msg)
 187 {
 188     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 189
 190     if (msg->obj)
 191     {
 192         AddHead(&(data->children), (struct Node *)_OBJECT(msg->obj));
 193         return TRUE;
 194     }
 195     else
 196         return FALSE;
 197 }
 198
 199
 200 /*
 201  * MUIM_Family_AddTail : Add an object as last object to the family.
 202  */
 203 IPTR Family__MUIM_AddTail(struct IClass *cl, Object *obj,
 204     struct MUIP_Family_AddTail *msg)
 205 {
 206     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 207
 208     if (msg->obj)
 209     {
 210         D(bug("Family_AddTail(%p): obj=%p node=%p\n", obj, msg->obj,
 211                 _OBJECT(msg->obj)));
 212         DoMethod(msg->obj, OM_ADDTAIL, (IPTR) & data->children);
 213         return TRUE;
 214     }
 215     else
 216         return FALSE;
 217 }
 218
 219
 220 /*
 221  * MUIM_Family_Insert : Add an object after another object to the family.
 222  */
 223 IPTR Family__MUIM_Insert(struct IClass *cl, Object *obj,
 224     struct MUIP_Family_Insert *msg)
 225 {
 226     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 227
 228     if (msg->obj)
 229     {
 230         Insert(&(data->children), (struct Node *)_OBJECT(msg->obj),
 231             (struct Node *)_OBJECT(msg->pred));
 232         return TRUE;
 233     }
 234     else
 235         return FALSE;
 236 }
 237
 238
 239 /*
 240  * MUIM_Family_Remove : Remove an object from a family.
 241  */
 242 IPTR Family__MUIM_Remove(struct IClass *cl, Object *obj,
 243     struct MUIP_Family_Remove *msg)
 244 {
 245     /* struct MUI_FamilyData *data = INST_DATA(cl, obj);
 246        struct Node *node; */
 247
 248     if (msg->obj)
 249     {
 250 /*          D(bug("Family_Remove(%p): obj=%p\n", obj, msg->obj)); */
 251         DoMethod(msg->obj, OM_REMOVE);
 252         return TRUE;
 253     }
 254     else
 255         return FALSE;
 256 }
 257
 258
 259 /*
 260  * MUIM_Family_Sort : Sort the children of a family.
 261  */
 262 IPTR Family__MUIM_Sort(struct IClass *cl, Object *obj,
 263     struct MUIP_Family_Sort *msg)
 264 {
 265     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 266     int i;
 267
 268     NewList(&(data->children));
 269     for (i = 0; msg->obj[i]; i++)
 270     {
 271         AddTail(&(data->children), (struct Node *)_OBJECT(msg->obj[i]));
 272     }
 273     return TRUE;
 274 }
 275
 276
 277 /*
 278  * MUIM_Family_Transfer : All the children of the family are removed and
 279  * added to another family in the same order.
 280  */
 281 IPTR Family__MUIM_Transfer(struct IClass *cl, Object *obj,
 282     struct MUIP_Family_Transfer *msg)
 283 {
 284     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 285     Object *cstate = (Object *) data->children.lh_Head;
 286     Object *child;
 287
 288     while ((child = NextObject(&cstate)))
 289     {
 290         DoMethod(obj, MUIM_Family_Remove, (IPTR) child);
 291         DoMethod(msg->family, MUIM_Family_AddTail, (IPTR) child);
 292     }
 293     return TRUE;
 294 }
 295
 296
 297 /**************************************************************************
 298  MUIM_FindUData : tests if the MUIA_UserData of the object
 299  contains the given <udata> and returns the object pointer in this case.
 300 **************************************************************************/
 301 IPTR Family__MUIM_FindUData(struct IClass *cl, Object *obj,
 302     struct MUIP_FindUData *msg)
 303 {
 304     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 305     Object *cstate = (Object *) data->children.lh_Head;
 306     Object *child;
 307
 308     if (muiNotifyData(obj)->mnd_UserData == msg->udata)
 309         return (IPTR) obj;
 310
 311     while ((child = NextObject(&cstate)))
 312     {
 313         Object *found = (Object *) DoMethodA(child, (Msg) msg);
 314         if (found)
 315             return (IPTR) found;
 316     }
 317     return 0;
 318 }
 319
 320
 321 /*
 322  * MUIM_GetUData : This method tests if the MUIA_UserData of the object
 323  * contains the given <udata> and gets <attr> to <storage> for itself
 324  * in this case.
 325  */
 326 IPTR Family__MUIM_GetUData(struct IClass *cl, Object *obj,
 327     struct MUIP_GetUData *msg)
 328 {
 329     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 330     Object *cstate = (Object *) data->children.lh_Head;
 331     Object *child;
 332
 333     if (muiNotifyData(obj)->mnd_UserData == msg->udata)
 334     {
 335         get(obj, msg->attr, msg->storage);
 336         return TRUE;
 337     }
 338     while ((child = NextObject(&cstate)))
 339         if (DoMethodA(child, (Msg) msg))
 340             return TRUE;
 341
 342     return FALSE;
 343 }
 344
 345
 346 /*
 347  * MUIM_SetUData : This method tests if the MUIA_UserData of the object
 348  * contains the given <udata> and sets <attr> to <val> for itself in this case.
 349  */
 350 IPTR Family__MUIM_SetUData(struct IClass *cl, Object *obj,
 351     struct MUIP_SetUData *msg)
 352 {
 353     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 354     Object *cstate = (Object *) data->children.lh_Head;
 355     Object *child;
 356
 357     if (muiNotifyData(obj)->mnd_UserData == msg->udata)
 358         set(obj, msg->attr, msg->val);
 359
 360     while ((child = NextObject(&cstate)))
 361         DoMethodA(child, (Msg) msg);
 362
 363     return TRUE;
 364 }
 365
 366
 367 /*
 368  * MUIM_SetUDataOnce : This method tests if the MUIA_UserData of the object
 369  * contains the given <udata> and sets <attr> to <val> for itself in this case.
 370  */
 371 IPTR Family__MUIM_SetUDataOnce(struct IClass *cl, Object *obj,
 372     struct MUIP_SetUDataOnce *msg)
 373 {
 374     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 375     Object *cstate = (Object *) data->children.lh_Head;
 376     Object *child;
 377
 378     if (muiNotifyData(obj)->mnd_UserData == msg->udata)
 379     {
 380         set(obj, msg->attr, msg->val);
 381         return TRUE;
 382     }
 383     while ((child = NextObject(&cstate)))
 384         if (DoMethodA(child, (Msg) msg))
 385             return TRUE;
 386
 387     return FALSE;
 388 }
 389
 390 IPTR Family__MUIM_GetChild(struct IClass *cl, Object *obj,
 391     struct MUIP_Family_GetChild *msg)
 392 {
 393     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 394     Object *cstate = (Object *) data->children.lh_Head;
 395     Object *child, *prev = NULL;
 396     LONG counter = 0;
 397
 398     while ((child = NextObject(&cstate)))
 399     {
 400         if ((msg->nr >= 0) && (msg->nr == counter))
 401             return (IPTR) child;
 402
 403         if ((msg->ref != NULL) && (msg->ref == child))
 404         {
 405             if (msg->nr == MUIV_Family_GetChild_Next)
 406                 return (IPTR) NextObject(&cstate);
 407             if (msg->nr == MUIV_Family_GetChild_Previous)
 408                 return (IPTR) prev;
 409         }
 410
 411         if (msg->nr == MUIV_Family_GetChild_First)
 412             return (IPTR) child;
 413
 414         prev = child;
 415         counter++;
 416     }
 417
 418     if (msg->nr == MUIV_Family_GetChild_Last)
 419         return (IPTR) prev;
 420
 421     return (IPTR) NULL;
 422 }
 423
 424 BOOPSI_DISPATCHER(IPTR, Family_Dispatcher, cl, obj, msg)
 425 {
 426     switch (msg->MethodID)
 427     {
 428     case OM_NEW:
 429         return Family__OM_NEW(cl, obj, (struct opSet *)msg);
 430
 431     case OM_DISPOSE:
 432         return Family__OM_DISPOSE(cl, obj, msg);
 433
 434     case OM_GET:
 435         return Family__OM_GET(cl, obj, (struct opGet *)msg);
 436
 437     case MUIM_Family_AddHead:
 438         return Family__MUIM_AddHead(cl, obj, (APTR) msg);
 439
 440     case OM_ADDMEMBER:
 441     case MUIM_Family_AddTail:
 442         return Family__MUIM_AddTail(cl, obj, (APTR) msg);
 443
 444     case MUIM_Family_Insert:
 445         return Family__MUIM_Insert(cl, obj, (APTR) msg);
 446
 447     case OM_REMMEMBER:
 448     case MUIM_Family_Remove:
 449         return Family__MUIM_Remove(cl, obj, (APTR) msg);
 450
 451     case MUIM_Family_Sort:
 452         return Family__MUIM_Sort(cl, obj, (APTR) msg);
 453
 454     case MUIM_Family_Transfer:
 455         return Family__MUIM_Transfer(cl, obj, (APTR) msg);
 456
 457     case MUIM_FindUData:
 458         return Family__MUIM_FindUData(cl, obj, (APTR) msg);
 459
 460     case MUIM_GetUData:
 461         return Family__MUIM_GetUData(cl, obj, (APTR) msg);
 462
 463     case MUIM_SetUData:
 464         return Family__MUIM_SetUData(cl, obj, (APTR) msg);
 465
 466     case MUIM_SetUDataOnce:
 467         return Family__MUIM_SetUDataOnce(cl, obj, (APTR) msg);
 468
 469     case MUIM_Family_GetChild:
 470         return Family__MUIM_GetChild(cl, obj, (APTR) msg);
 471     }
 472
 473     return (DoSuperMethodA(cl, obj, msg));
 474 }
 475 BOOPSI_DISPATCHER_END
 476
 477 /*
 478  * Class descriptor.
 479  */
 480 const struct __MUIBuiltinClass _MUI_Family_desc =
 481 {
 482     MUIC_Family,
 483     MUIC_Notify,
 484     sizeof(struct MUI_FamilyData),
 485     (void *) Family_Dispatcher
 486 };