workbench/libs/muimaster/classes/family.c

   1 /*
   2     Copyright © 1999, David Le Corfec.
   3     Copyright © 2002-2013, 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
 194         /* if we are in an application tree, propagate pointers */
 195         if (muiNotifyData(obj)->mnd_GlobalInfo)
 196         {
 197             muiNotifyData(msg->obj)->mnd_ParentObject = obj;
 198             DoMethod(msg->obj, MUIM_ConnectParent, (IPTR)obj);
 199         }
 200
 201         return TRUE;
 202     }
 203     else
 204         return FALSE;
 205 }
 206
 207
 208 /*
 209  * MUIM_Family_AddTail : Add an object as last object to the family.
 210  */
 211 IPTR Family__MUIM_AddTail(struct IClass *cl, Object *obj,
 212     struct MUIP_Family_AddTail *msg)
 213 {
 214     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 215
 216     if (msg->obj)
 217     {
 218         D(bug("Family_AddTail(%p): obj=%p node=%p\n", obj, msg->obj,
 219                 _OBJECT(msg->obj)));
 220         DoMethod(msg->obj, OM_ADDTAIL, (IPTR) & data->children);
 221
 222         /* if we are in an application tree, propagate pointers */
 223         if (muiNotifyData(obj)->mnd_GlobalInfo)
 224         {
 225             muiNotifyData(msg->obj)->mnd_ParentObject = obj;
 226             DoMethod(msg->obj, MUIM_ConnectParent, (IPTR)obj);
 227         }
 228
 229         return TRUE;
 230     }
 231     else
 232         return FALSE;
 233 }
 234
 235
 236 /*
 237  * MUIM_Family_Insert : Add an object after another object to the family.
 238  */
 239 IPTR Family__MUIM_Insert(struct IClass *cl, Object *obj,
 240     struct MUIP_Family_Insert *msg)
 241 {
 242     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 243
 244     if (msg->obj)
 245     {
 246         Insert(&(data->children), (struct Node *)_OBJECT(msg->obj),
 247             (struct Node *)_OBJECT(msg->pred));
 248
 249         /* if we are in an application tree, propagate pointers */
 250         if (muiNotifyData(obj)->mnd_GlobalInfo)
 251         {
 252             muiNotifyData(msg->obj)->mnd_ParentObject = obj;
 253             DoMethod(msg->obj, MUIM_ConnectParent, (IPTR)obj);
 254         }
 255
 256         return TRUE;
 257     }
 258     else
 259         return FALSE;
 260 }
 261
 262
 263 /*
 264  * MUIM_Family_Remove : Remove an object from a family.
 265  */
 266 IPTR Family__MUIM_Remove(struct IClass *cl, Object *obj,
 267     struct MUIP_Family_Remove *msg)
 268 {
 269     /* struct MUI_FamilyData *data = INST_DATA(cl, obj);
 270        struct Node *node; */
 271
 272     if (msg->obj)
 273     {
 274 /*          D(bug("Family_Remove(%p): obj=%p\n", obj, msg->obj)); */
 275         DoMethod(msg->obj, MUIM_DisconnectParent);
 276         muiNotifyData(msg->obj)->mnd_ParentObject = NULL;
 277         DoMethod(msg->obj, OM_REMOVE);
 278         return TRUE;
 279     }
 280     else
 281         return FALSE;
 282 }
 283
 284
 285 /*
 286  * MUIM_Family_Sort : Sort the children of a family.
 287  */
 288 IPTR Family__MUIM_Sort(struct IClass *cl, Object *obj,
 289     struct MUIP_Family_Sort *msg)
 290 {
 291     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 292     int i;
 293
 294     NewList(&(data->children));
 295     for (i = 0; msg->obj[i]; i++)
 296     {
 297         AddTail(&(data->children), (struct Node *)_OBJECT(msg->obj[i]));
 298     }
 299     return TRUE;
 300 }
 301
 302
 303 /*
 304  * MUIM_Family_Transfer : All the children of the family are removed and
 305  * added to another family in the same order.
 306  */
 307 IPTR Family__MUIM_Transfer(struct IClass *cl, Object *obj,
 308     struct MUIP_Family_Transfer *msg)
 309 {
 310     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 311     Object *cstate = (Object *) data->children.lh_Head;
 312     Object *child;
 313
 314     while ((child = NextObject(&cstate)))
 315     {
 316         DoMethod(obj, MUIM_Family_Remove, (IPTR) child);
 317         DoMethod(msg->family, MUIM_Family_AddTail, (IPTR) child);
 318     }
 319     return TRUE;
 320 }
 321
 322
 323 /**************************************************************************
 324  MUIM_FindUData : tests if the MUIA_UserData of the object
 325  contains the given <udata> and returns the object pointer in this case.
 326 **************************************************************************/
 327 IPTR Family__MUIM_FindUData(struct IClass *cl, Object *obj,
 328     struct MUIP_FindUData *msg)
 329 {
 330     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 331     Object *cstate = (Object *) data->children.lh_Head;
 332     Object *child;
 333
 334     if (muiNotifyData(obj)->mnd_UserData == msg->udata)
 335         return (IPTR) obj;
 336
 337     while ((child = NextObject(&cstate)))
 338     {
 339         Object *found = (Object *) DoMethodA(child, (Msg) msg);
 340         if (found)
 341             return (IPTR) found;
 342     }
 343     return 0;
 344 }
 345
 346
 347 /*
 348  * MUIM_GetUData : This method tests if the MUIA_UserData of the object
 349  * contains the given <udata> and gets <attr> to <storage> for itself
 350  * in this case.
 351  */
 352 IPTR Family__MUIM_GetUData(struct IClass *cl, Object *obj,
 353     struct MUIP_GetUData *msg)
 354 {
 355     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 356     Object *cstate = (Object *) data->children.lh_Head;
 357     Object *child;
 358
 359     if (muiNotifyData(obj)->mnd_UserData == msg->udata)
 360     {
 361         get(obj, msg->attr, msg->storage);
 362         return TRUE;
 363     }
 364     while ((child = NextObject(&cstate)))
 365         if (DoMethodA(child, (Msg) msg))
 366             return TRUE;
 367
 368     return FALSE;
 369 }
 370
 371
 372 /*
 373  * MUIM_SetUData : This method tests if the MUIA_UserData of the object
 374  * contains the given <udata> and sets <attr> to <val> for itself in this case.
 375  */
 376 IPTR Family__MUIM_SetUData(struct IClass *cl, Object *obj,
 377     struct MUIP_SetUData *msg)
 378 {
 379     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 380     Object *cstate = (Object *) data->children.lh_Head;
 381     Object *child;
 382
 383     if (muiNotifyData(obj)->mnd_UserData == msg->udata)
 384         set(obj, msg->attr, msg->val);
 385
 386     while ((child = NextObject(&cstate)))
 387         DoMethodA(child, (Msg) msg);
 388
 389     return TRUE;
 390 }
 391
 392
 393 /*
 394  * MUIM_SetUDataOnce : This method tests if the MUIA_UserData of the object
 395  * contains the given <udata> and sets <attr> to <val> for itself in this case.
 396  */
 397 IPTR Family__MUIM_SetUDataOnce(struct IClass *cl, Object *obj,
 398     struct MUIP_SetUDataOnce *msg)
 399 {
 400     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 401     Object *cstate = (Object *) data->children.lh_Head;
 402     Object *child;
 403
 404     if (muiNotifyData(obj)->mnd_UserData == msg->udata)
 405     {
 406         set(obj, msg->attr, msg->val);
 407         return TRUE;
 408     }
 409     while ((child = NextObject(&cstate)))
 410         if (DoMethodA(child, (Msg) msg))
 411             return TRUE;
 412
 413     return FALSE;
 414 }
 415
 416 IPTR Family__MUIM_GetChild(struct IClass *cl, Object *obj,
 417     struct MUIP_Family_GetChild *msg)
 418 {
 419     struct MUI_FamilyData *data = INST_DATA(cl, obj);
 420     Object *cstate = (Object *) data->children.lh_Head;
 421     Object *child, *prev = NULL;
 422     LONG counter = 0;
 423
 424     while ((child = NextObject(&cstate)))
 425     {
 426         if ((msg->nr >= 0) && (msg->nr == counter))
 427             return (IPTR) child;
 428
 429         if ((msg->ref != NULL) && (msg->ref == child))
 430         {
 431             if (msg->nr == MUIV_Family_GetChild_Next)
 432                 return (IPTR) NextObject(&cstate);
 433             if (msg->nr == MUIV_Family_GetChild_Previous)
 434                 return (IPTR) prev;
 435         }
 436
 437         if (msg->nr == MUIV_Family_GetChild_First)
 438             return (IPTR) child;
 439
 440         prev = child;
 441         counter++;
 442     }
 443
 444     if (msg->nr == MUIV_Family_GetChild_Last)
 445         return (IPTR) prev;
 446
 447     return (IPTR) NULL;
 448 }
 449
 450 BOOPSI_DISPATCHER(IPTR, Family_Dispatcher, cl, obj, msg)
 451 {
 452     switch (msg->MethodID)
 453     {
 454     case OM_NEW:
 455         return Family__OM_NEW(cl, obj, (struct opSet *)msg);
 456
 457     case OM_DISPOSE:
 458         return Family__OM_DISPOSE(cl, obj, msg);
 459
 460     case OM_GET:
 461         return Family__OM_GET(cl, obj, (struct opGet *)msg);
 462
 463     case MUIM_Family_AddHead:
 464         return Family__MUIM_AddHead(cl, obj, (APTR) msg);
 465
 466     case OM_ADDMEMBER:
 467     case MUIM_Family_AddTail:
 468         return Family__MUIM_AddTail(cl, obj, (APTR) msg);
 469
 470     case MUIM_Family_Insert:
 471         return Family__MUIM_Insert(cl, obj, (APTR) msg);
 472
 473     case OM_REMMEMBER:
 474     case MUIM_Family_Remove:
 475         return Family__MUIM_Remove(cl, obj, (APTR) msg);
 476
 477     case MUIM_Family_Sort:
 478         return Family__MUIM_Sort(cl, obj, (APTR) msg);
 479
 480     case MUIM_Family_Transfer:
 481         return Family__MUIM_Transfer(cl, obj, (APTR) msg);
 482
 483     case MUIM_FindUData:
 484         return Family__MUIM_FindUData(cl, obj, (APTR) msg);
 485
 486     case MUIM_GetUData:
 487         return Family__MUIM_GetUData(cl, obj, (APTR) msg);
 488
 489     case MUIM_SetUData:
 490         return Family__MUIM_SetUData(cl, obj, (APTR) msg);
 491
 492     case MUIM_SetUDataOnce:
 493         return Family__MUIM_SetUDataOnce(cl, obj, (APTR) msg);
 494
 495     case MUIM_Family_GetChild:
 496         return Family__MUIM_GetChild(cl, obj, (APTR) msg);
 497     }
 498
 499     return (DoSuperMethodA(cl, obj, msg));
 500 }
 501 BOOPSI_DISPATCHER_END
 502
 503 /*
 504  * Class descriptor.
 505  */
 506 const struct __MUIBuiltinClass _MUI_Family_desc =
 507 {
 508     MUIC_Family,
 509     MUIC_Notify,
 510     sizeof(struct MUI_FamilyData),
 511     (void *) Family_Dispatcher
 512 };