workbench/libs/muimaster/classes/menuitem.c

   1 /*
   2     Copyright © 2002-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <exec/memory.h>
   7 #include <intuition/icclass.h>
   8 #include <intuition/gadgetclass.h>
   9 #include <libraries/gadtools.h>
  10 #include <clib/alib_protos.h>
  11 #include <proto/exec.h>
  12 #include <proto/intuition.h>
  13 #include <proto/utility.h>
  14 #include <proto/muimaster.h>
  15
  16 /*  #define MYDEBUG 1 */
  17 #include "debug.h"
  18 #include "mui.h"
  19 #include "muimaster_intern.h"
  20 #include "support.h"
  21
  22 extern struct Library *MUIMasterBase;
  23
  24 #define MENUF_CHECKED        (1<<0)
  25 #define MENUF_CHECKIT        (1<<1)
  26 #define MENUF_COMMANDSTRING  (1<<2)
  27 #define MENUF_ENABLED        (1<<3)
  28 #define MENUF_TOGGLE         (1<<4)
  29
  30 struct MUI_MenuitemData
  31 {
  32     ULONG flags;
  33     ULONG exclude;
  34
  35     char *shortcut;
  36     char *title;
  37
  38     struct NewMenu *newmenu;
  39
  40     struct MenuItem *trigger;
  41 };
  42
  43 static int Menuitem_GetTotalChildren(Object *obj)
  44 {
  45     Object *cstate;
  46     Object *child;
  47     struct MinList *ChildList = NULL;
  48     int num = 0;
  49
  50     get(obj, MUIA_Family_List, &ChildList);
  51     cstate = (Object *) ChildList->mlh_Head;
  52     while ((child = NextObject(&cstate)))
  53     {
  54         num++;
  55         num += Menuitem_GetTotalChildren(child);
  56     }
  57     return num;
  58 }
  59
  60 static int Menuitem_FillNewMenu(Object *obj, struct NewMenu *menu,
  61     int depth)
  62 {
  63     Object *cstate;
  64     Object *child;
  65     struct MinList *ChildList = NULL;
  66     int num = 0;
  67
  68     if (depth > 2)
  69         return 0;
  70
  71     get(obj, MUIA_Family_List, &ChildList);
  72     cstate = (Object *) ChildList->mlh_Head;
  73     while ((child = NextObject(&cstate)))
  74     {
  75         int entries;
  76         ULONG checkit = 0, checked = 0, toggle = 0, enabled = 0;
  77
  78         get(child, MUIA_Menuitem_Title, &menu->nm_Label);
  79         get(child, MUIA_Menuitem_Shortcut, &menu->nm_CommKey);
  80         get(child, MUIA_Menuitem_Checkit, &checkit);
  81         get(child, MUIA_Menuitem_Checked, &checked);
  82         get(child, MUIA_Menuitem_Toggle, &toggle);
  83         get(child, MUIA_Menuitem_Enabled, &enabled);
  84         if (checkit)
  85             menu->nm_Flags |= CHECKIT;
  86         if (checked)
  87             menu->nm_Flags |= CHECKED;
  88         if (toggle)
  89             menu->nm_Flags |= MENUTOGGLE;
  90         get(child, MUIA_Menuitem_Exclude, &menu->nm_MutualExclude);
  91
  92         if (depth == 0)
  93         {
  94             menu->nm_Type = NM_TITLE;
  95             if (!enabled)
  96                 menu->nm_Flags |= NM_MENUDISABLED;
  97         }
  98         else if (depth == 1)
  99         {
 100             menu->nm_Type = NM_ITEM;
 101             if (!enabled)
 102                 menu->nm_Flags |= NM_ITEMDISABLED;
 103         }
 104         else if (depth == 2)
 105         {
 106             menu->nm_Type = NM_SUB;
 107             if (!enabled)
 108                 menu->nm_Flags |= NM_ITEMDISABLED;
 109         }
 110
 111         menu->nm_UserData = child;
 112
 113         menu++;
 114         num++;
 115         entries = Menuitem_FillNewMenu(child, menu, depth + 1);
 116
 117         menu += entries;
 118         num += entries;
 119     }
 120     return num;
 121 }
 122
 123 /**************************************************************************
 124  ...
 125 **************************************************************************/
 126 static struct NewMenu *Menuitem_BuildNewMenu(struct MUI_MenuitemData *data,
 127     Object *obj)
 128 {
 129     int entries = Menuitem_GetTotalChildren(obj);
 130     if (data->newmenu)
 131         FreeVec(data->newmenu);
 132     data->newmenu = NULL;
 133     if (!entries)
 134         return NULL;
 135
 136     if ((data->newmenu =
 137             (struct NewMenu *)AllocVec((entries +
 138                     1) * sizeof(struct NewMenu), MEMF_CLEAR)))
 139     {
 140         Menuitem_FillNewMenu(obj, data->newmenu, 0);
 141     }
 142     return data->newmenu;
 143 }
 144
 145 /**************************************************************************
 146  OM_NEW
 147 **************************************************************************/
 148 IPTR Menuitem__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 149 {
 150     struct MUI_MenuitemData *data;
 151     struct TagItem *tags, *tag;
 152
 153     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
 154         /* We need no tags */
 155     if (!obj)
 156         return 0;
 157
 158     data = INST_DATA(cl, obj);
 159
 160     data->flags = MENUF_ENABLED;
 161
 162     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 163     {
 164         switch (tag->ti_Tag)
 165         {
 166         case MUIA_Menuitem_Checked:
 167             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_CHECKED);
 168             break;
 169
 170         case MUIA_Menuitem_Checkit:
 171             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_CHECKIT);
 172             break;
 173
 174         case MUIA_Menuitem_CommandString:
 175             _handle_bool_tag(data->flags, tag->ti_Data,
 176                 MENUF_COMMANDSTRING);
 177             break;
 178
 179         case MUIA_Menu_Enabled:
 180         case MUIA_Menuitem_Enabled:
 181             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_ENABLED);
 182             break;
 183
 184         case MUIA_Menuitem_Toggle:
 185             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_TOGGLE);
 186             break;
 187
 188         case MUIA_Menuitem_Exclude:
 189             data->exclude = tag->ti_Data;
 190             break;
 191
 192         case MUIA_Menuitem_Shortcut:
 193             data->shortcut = (char *)tag->ti_Data;
 194             break;
 195
 196         case MUIA_Menu_Title:
 197         case MUIA_Menuitem_Title:
 198             data->title = (char *)tag->ti_Data;
 199             break;
 200         }
 201     }
 202
 203     return (IPTR) obj;
 204 }
 205
 206 /**************************************************************************
 207  OM_SET
 208 **************************************************************************/
 209 IPTR Menuitem__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 210 {
 211     struct MUI_MenuitemData *data;
 212     struct TagItem *tags, *tag;
 213
 214     data = INST_DATA(cl, obj);
 215
 216     BOOL rebuild = FALSE;
 217
 218     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 219     {
 220         switch (tag->ti_Tag)
 221         {
 222         case MUIA_Menuitem_Checked:
 223             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_CHECKED);
 224             if (data->exclude && (data->flags & MENUF_CHECKED))
 225             {
 226                 Object *parent = NULL;
 227                 get(obj, MUIA_Parent, &parent);
 228
 229                 if (parent)
 230                 {
 231                     Object *child;
 232                     Object *cstate;
 233                     struct MinList *ChildList = NULL;
 234                     ULONG i = 1;
 235
 236                     get(parent, MUIA_Family_List, &ChildList);
 237                     cstate = (Object *) ChildList->mlh_Head;
 238                     while ((child = NextObject(&cstate)))
 239                     {
 240                         if ((i & data->exclude) && (child != obj))
 241                         {
 242                             IPTR checkit = 0, checked = 0;
 243
 244                             get(child, MUIA_Menuitem_Checkit, &checkit);
 245                             get(child, MUIA_Menuitem_Checked, &checked);
 246
 247                             if (checkit && checked)
 248                             {
 249                                 set(child, MUIA_Menuitem_Checked, FALSE);
 250                             }
 251                         }
 252
 253                         i <<= 1;
 254                     }
 255                 }
 256
 257             }
 258             rebuild = TRUE;
 259             break;
 260
 261         case MUIA_Menuitem_Checkit:
 262             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_CHECKIT);
 263             rebuild = TRUE;
 264             break;
 265
 266         case MUIA_Menuitem_CommandString:
 267             _handle_bool_tag(data->flags, tag->ti_Data,
 268                 MENUF_COMMANDSTRING);
 269             rebuild = TRUE;
 270             break;
 271
 272         case MUIA_Menu_Enabled:
 273         case MUIA_Menuitem_Enabled:
 274             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_ENABLED);
 275             tag->ti_Tag = TAG_IGNORE;
 276             rebuild = TRUE;
 277             break;
 278
 279         case MUIA_Menuitem_Toggle:
 280             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_TOGGLE);
 281             rebuild = TRUE;
 282             break;
 283
 284         case MUIA_Menuitem_Exclude:
 285             data->exclude = tag->ti_Data;
 286             rebuild = TRUE;
 287             break;
 288
 289         case MUIA_Menuitem_Shortcut:
 290             data->shortcut = (char *)tag->ti_Data;
 291             rebuild = TRUE;
 292             break;
 293
 294         case MUIA_Menu_Title:
 295         case MUIA_Menuitem_Title:
 296             data->title = (char *)tag->ti_Data;
 297             tag->ti_Tag = TAG_IGNORE;
 298             rebuild = TRUE;
 299             break;
 300
 301         case MUIA_Menuitem_Trigger:
 302             data->trigger = (struct MenuItem *)tag->ti_Data;
 303             rebuild = TRUE;
 304             break;
 305         }
 306     }
 307
 308     if (rebuild)
 309     {
 310         if (muiNotifyData(obj) &&
 311             muiNotifyData(obj)->mnd_GlobalInfo &&
 312             muiNotifyData(obj)->mnd_GlobalInfo->mgi_ApplicationObject)
 313         {
 314             DoMethod(_app(obj), MUIM_Application_UpdateMenus);
 315         }
 316     }
 317
 318     return DoSuperMethodA(cl, obj, (Msg) msg);
 319 }
 320
 321 /**************************************************************************
 322  OM_GET
 323 **************************************************************************/
 324 #define STORE *(msg->opg_Storage)
 325 IPTR Menuitem__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 326 {
 327     struct MUI_MenuitemData *data = INST_DATA(cl, obj);
 328
 329     switch (msg->opg_AttrID)
 330     {
 331     case MUIA_Menuitem_Checked:
 332         STORE = ((data->flags & MENUF_CHECKED) != 0);
 333         return 1;
 334
 335     case MUIA_Menuitem_Checkit:
 336         STORE = ((data->flags & MENUF_CHECKIT) != 0);
 337         return 1;
 338
 339     case MUIA_Menuitem_CommandString:
 340         STORE = ((data->flags & MENUF_COMMANDSTRING) != 0);
 341         return 1;
 342
 343     case MUIA_Menu_Enabled:
 344     case MUIA_Menuitem_Enabled:
 345         STORE = ((data->flags & MENUF_ENABLED) != 0);
 346         return 1;
 347
 348     case MUIA_Menuitem_Toggle:
 349         STORE = ((data->flags & MENUF_TOGGLE) != 0);
 350         return 1;
 351
 352     case MUIA_Menuitem_Exclude:
 353         STORE = data->exclude;
 354         return 1;
 355
 356     case MUIA_Menuitem_Shortcut:
 357         STORE = (IPTR) data->shortcut;
 358         return 1;
 359
 360     case MUIA_Menu_Title:
 361     case MUIA_Menuitem_Title:
 362         STORE = (IPTR) data->title;
 363         return 1;
 364
 365     case MUIA_Menuitem_NewMenu:
 366         Menuitem_BuildNewMenu(data, obj);
 367         STORE = (IPTR) data->newmenu;
 368         return 1;
 369
 370     case MUIA_Menuitem_Trigger:
 371         STORE = (IPTR) data->trigger;
 372         return 1;
 373     }
 374
 375     return DoSuperMethodA(cl, obj, (Msg) msg);
 376 }
 377 #undef STORE
 378
 379
 380 /**************************************************************************
 381  OM_DISPOSE
 382 **************************************************************************/
 383 IPTR Menuitem__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 384 {
 385     struct MUI_MenuitemData *data = INST_DATA(cl, obj);
 386
 387     FreeVec(data->newmenu);
 388
 389     return DoSuperMethodA(cl, obj, msg);
 390 }
 391
 392
 393 /**************************************************************************
 394  MUIM_ConnectParent
 395 **************************************************************************/
 396 IPTR Menuitem__MUIM_ConnectParent(struct IClass *cl, Object *obj,
 397     struct MUIP_ConnectParent *msg)
 398 {
 399     Object *cstate;
 400     Object *child;
 401     struct MinList *ChildList = NULL;
 402
 403     D(bug("Menuitem_ConnectParent(%p) %s\n", obj, OCLASS(obj)->cl_ID));
 404
 405     DoSuperMethodA(cl, obj, (Msg) msg);
 406
 407     muiNotifyData(obj)->mnd_ParentObject = msg->parent;
 408
 409     get(obj, MUIA_Family_List, &ChildList);
 410     cstate = (Object *) ChildList->mlh_Head;
 411     while ((child = NextObject(&cstate)))
 412     {
 413         DoMethod(child, MUIM_ConnectParent, (IPTR) obj);
 414     }
 415     return TRUE;
 416 }
 417
 418 /**************************************************************************
 419  MUIM_DisconnectParent
 420 **************************************************************************/
 421 IPTR Menuitem__MUIM_DisconnectParent(struct IClass *cl, Object *obj,
 422     struct MUIP_ConnectParent *msg)
 423 {
 424     Object *cstate;
 425     Object *child;
 426     struct MinList *ChildList = NULL;
 427
 428     D(bug("Menuitem_DisconnectParent(%p) %s\n", obj, OCLASS(obj)->cl_ID));
 429
 430     get(obj, MUIA_Family_List, &ChildList);
 431     cstate = (Object *) ChildList->mlh_Head;
 432     while ((child = NextObject(&cstate)))
 433     {
 434         DoMethodA(child, (Msg) msg);
 435     }
 436     muiNotifyData(obj)->mnd_ParentObject = NULL;
 437     DoSuperMethodA(cl, obj, (Msg) msg);
 438     return TRUE;
 439 }
 440
 441 /**************************************************************************
 442  MUIM_Family_Insert, MUIM_Family_Remove
 443 **************************************************************************/
 444 IPTR Menuitem__MUIM_Update(struct IClass *cl, Object *obj, Msg msg)
 445 {
 446     // struct MUI_MenuitemData *data = INST_DATA(cl, obj);
 447
 448     IPTR retval = DoSuperMethodA(cl, obj, msg);
 449
 450     if (muiNotifyData(obj) &&
 451         muiNotifyData(obj)->mnd_GlobalInfo &&
 452         muiNotifyData(obj)->mnd_GlobalInfo->mgi_ApplicationObject)
 453     {
 454         DoMethod(_app(obj), MUIM_Application_UpdateMenus);
 455     }
 456
 457     return retval;
 458 }
 459
 460
 461 BOOPSI_DISPATCHER(IPTR, Menuitem_Dispatcher, cl, obj, msg)
 462 {
 463     switch (msg->MethodID)
 464     {
 465     case OM_NEW:
 466         return Menuitem__OM_NEW(cl, obj, (struct opSet *)msg);
 467     case OM_DISPOSE:
 468         return Menuitem__OM_DISPOSE(cl, obj, msg);
 469     case OM_SET:
 470         return Menuitem__OM_SET(cl, obj, (struct opSet *)msg);
 471     case OM_GET:
 472         return Menuitem__OM_GET(cl, obj, (struct opGet *)msg);
 473     case MUIM_ConnectParent:
 474         return Menuitem__MUIM_ConnectParent(cl, obj, (APTR) msg);
 475     case MUIM_DisconnectParent:
 476         return Menuitem__MUIM_DisconnectParent(cl, obj, (APTR) msg);
 477     case MUIM_Family_Insert:
 478         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 479     case MUIM_Family_Remove:
 480         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 481     case MUIM_Family_AddTail:
 482         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 483     case MUIM_Family_AddHead:
 484         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 485     case OM_ADDMEMBER:
 486         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 487     case OM_REMMEMBER:
 488         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 489     }
 490     return DoSuperMethodA(cl, obj, msg);
 491 }
 492 BOOPSI_DISPATCHER_END
 493
 494 /*
 495  * Class descriptor.
 496  */
 497 const struct __MUIBuiltinClass _MUI_Menuitem_desc =
 498 {
 499     MUIC_Menuitem,
 500     MUIC_Family,
 501     sizeof(struct MUI_MenuitemData),
 502     (void *) Menuitem_Dispatcher
 503 };
 504
 505 /*
 506  * Class descriptor.- this class is the same like menuitem
 507  */
 508 const struct __MUIBuiltinClass _MUI_Menu_desc =
 509 {
 510     MUIC_Menu,
 511     MUIC_Family,
 512     sizeof(struct MUI_MenuitemData),
 513     (void *) Menuitem_Dispatcher
 514 };
 515
 516 /*
 517  * Class descriptor.- this class is the same like menuitem
 518  */
 519 const struct __MUIBuiltinClass _MUI_Menustrip_desc =
 520 {
 521     MUIC_Menustrip,
 522     MUIC_Family,
 523     sizeof(struct MUI_MenuitemData),
 524     (void *) Menuitem_Dispatcher
 525 };