workbench/libs/muimaster/classes/menuitem.c

   1 /*
   2     Copyright © 2002-2015, 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 #define MENUF_MENUSTRIP      (1<<15)
  31 #define MENUF_MENU           (1<<16)
  32 #define MENUF_MENUITEM       (1<<17)
  33
  34 #define MUIA_Menuitem_Type   (MUIB_Menuitem | 0x00000001)
  35
  36 #define MUIV_Menuitem_Type_Menustrip    (-1)
  37 #define MUIV_Menuitem_Type_Menu         (-2)
  38 #define MUIV_Menuitem_Type_Menuitem     (-3)
  39
  40 struct MUI_MenuitemData
  41 {
  42     ULONG flags;
  43     ULONG exclude;
  44
  45     char *shortcut;
  46     char *title;
  47
  48     struct NewMenu *newmenu;
  49
  50     struct MenuItem *trigger;
  51 };
  52
  53 static int Menuitem_GetTotalChildren(Object *obj)
  54 {
  55     Object *cstate;
  56     Object *child;
  57     struct MinList *ChildList = NULL;
  58     int num = 0;
  59
  60     get(obj, MUIA_Family_List, &ChildList);
  61     cstate = (Object *) ChildList->mlh_Head;
  62     while ((child = NextObject(&cstate)))
  63     {
  64         num++;
  65         num += Menuitem_GetTotalChildren(child);
  66     }
  67     return num;
  68 }
  69
  70 static int Menuitem_FillNewMenu(Object *obj, struct NewMenu *menu,
  71     int depth)
  72 {
  73     Object *cstate;
  74     Object *child;
  75     struct MinList *ChildList = NULL;
  76     int num = 0;
  77
  78     if (depth > 2)
  79         return 0;
  80
  81     get(obj, MUIA_Family_List, &ChildList);
  82     cstate = (Object *) ChildList->mlh_Head;
  83     while ((child = NextObject(&cstate)))
  84     {
  85         int entries;
  86         ULONG checkit = 0, checked = 0, toggle = 0, enabled = 0, cmdstring = 0;
  87
  88         get(child, MUIA_Menuitem_Title, &menu->nm_Label);
  89         get(child, MUIA_Menuitem_Shortcut, &menu->nm_CommKey);
  90         get(child, MUIA_Menuitem_Checkit, &checkit);
  91         get(child, MUIA_Menuitem_Checked, &checked);
  92         get(child, MUIA_Menuitem_Toggle, &toggle);
  93         get(child, MUIA_Menuitem_Enabled, &enabled);
  94         get(child, MUIA_Menuitem_CommandString, &cmdstring);
  95         if (checkit)
  96             menu->nm_Flags |= CHECKIT;
  97         if (checked)
  98             menu->nm_Flags |= CHECKED;
  99         if (toggle)
 100             menu->nm_Flags |= MENUTOGGLE;
 101         if (cmdstring)
 102             menu->nm_Flags |= COMMSEQ;
 103         get(child, MUIA_Menuitem_Exclude, &menu->nm_MutualExclude);
 104
 105         if (depth == 0)
 106         {
 107             LONG type = 0;
 108             get(child, MUIA_Menuitem_Type, &type);
 109
 110             if (type == MUIV_Menuitem_Type_Menuitem)
 111                 /* Depth 0 Menuitems are to become items of current menu,
 112                  * not menus. MUI behavior */
 113                 menu->nm_Type = NM_ITEM;
 114             else
 115                 menu->nm_Type = NM_TITLE;
 116         }
 117         else if (depth == 1)
 118             menu->nm_Type = NM_ITEM;
 119         else if (depth == 2)
 120             menu->nm_Type = NM_SUB;
 121
 122         if (!enabled)
 123         {
 124             if (menu->nm_Type == NM_TITLE)
 125                 menu->nm_Flags |= NM_MENUDISABLED;
 126             else
 127                 menu->nm_Flags |= NM_ITEMDISABLED;
 128         }
 129
 130         menu->nm_UserData = child;
 131
 132         menu++;
 133         num++;
 134         entries = Menuitem_FillNewMenu(child, menu, depth + 1);
 135
 136         menu += entries;
 137         num += entries;
 138     }
 139     return num;
 140 }
 141
 142 /**************************************************************************
 143  ...
 144 **************************************************************************/
 145 static struct NewMenu *Menuitem_BuildNewMenu(struct MUI_MenuitemData *data,
 146     Object *obj)
 147 {
 148     int entries = Menuitem_GetTotalChildren(obj);
 149     if (data->newmenu)
 150         FreeVec(data->newmenu);
 151     data->newmenu = NULL;
 152     if (!entries)
 153         return NULL;
 154
 155     if ((data->newmenu =
 156             (struct NewMenu *)AllocVec((entries +
 157                     1) * sizeof(struct NewMenu), MEMF_CLEAR)))
 158     {
 159         Menuitem_FillNewMenu(obj, data->newmenu, 0);
 160     }
 161     return data->newmenu;
 162 }
 163
 164 /**************************************************************************
 165  OM_NEW
 166 **************************************************************************/
 167 IPTR Common__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 168 {
 169     struct MUI_MenuitemData *data;
 170     struct TagItem *tags, *tag;
 171
 172     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
 173         /* We need no tags */
 174     if (!obj)
 175         return 0;
 176
 177     data = INST_DATA(cl, obj);
 178
 179     data->flags = MENUF_ENABLED;
 180
 181     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 182     {
 183         switch (tag->ti_Tag)
 184         {
 185         case MUIA_Menuitem_Checked:
 186             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_CHECKED);
 187             break;
 188
 189         case MUIA_Menuitem_Checkit:
 190             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_CHECKIT);
 191             break;
 192
 193         case MUIA_Menuitem_CommandString:
 194             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_COMMANDSTRING);
 195             break;
 196
 197         case MUIA_Menu_Enabled:
 198         case MUIA_Menuitem_Enabled:
 199             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_ENABLED);
 200             break;
 201
 202         case MUIA_Menuitem_Toggle:
 203             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_TOGGLE);
 204             break;
 205
 206         case MUIA_Menuitem_Exclude:
 207             data->exclude = tag->ti_Data;
 208             break;
 209
 210         case MUIA_Menuitem_Shortcut:
 211             data->shortcut = (char *)tag->ti_Data;
 212             break;
 213
 214         case MUIA_Menu_Title:
 215         case MUIA_Menuitem_Title:
 216             data->title = (char *)tag->ti_Data;
 217             break;
 218         }
 219     }
 220
 221     return (IPTR) obj;
 222 }
 223
 224 IPTR Menuitem__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 225 {
 226     struct MUI_MenuitemData *data;
 227     obj = (Object *) Common__OM_NEW(cl, obj, msg);
 228     data = INST_DATA(cl, obj);
 229
 230     data->flags |= MENUF_MENUITEM;
 231
 232     return (IPTR) obj;
 233 }
 234
 235 IPTR Menu__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 236 {
 237     struct MUI_MenuitemData *data;
 238     obj = (Object *) Common__OM_NEW(cl, obj, msg);
 239     data = INST_DATA(cl, obj);
 240
 241     data->flags |= MENUF_MENU;
 242
 243     return (IPTR) obj;
 244 }
 245
 246 IPTR Menustrip__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 247 {
 248     struct MUI_MenuitemData *data;
 249     obj = (Object *) Common__OM_NEW(cl, obj, msg);
 250     data = INST_DATA(cl, obj);
 251
 252     data->flags |= MENUF_MENUSTRIP;
 253
 254     return (IPTR) obj;
 255 }
 256
 257 /**************************************************************************
 258  OM_SET
 259 **************************************************************************/
 260 IPTR Menuitem__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 261 {
 262     struct MUI_MenuitemData *data;
 263     struct TagItem *tags, *tag;
 264
 265     data = INST_DATA(cl, obj);
 266
 267     BOOL rebuild = FALSE;
 268
 269     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 270     {
 271         switch (tag->ti_Tag)
 272         {
 273         case MUIA_Menuitem_Checked:
 274             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_CHECKED);
 275             if (data->exclude && (data->flags & MENUF_CHECKED))
 276             {
 277                 Object *parent = NULL;
 278                 get(obj, MUIA_Parent, &parent);
 279
 280                 if (parent)
 281                 {
 282                     Object *child;
 283                     Object *cstate;
 284                     struct MinList *ChildList = NULL;
 285                     ULONG i = 1;
 286
 287                     get(parent, MUIA_Family_List, &ChildList);
 288                     cstate = (Object *) ChildList->mlh_Head;
 289                     while ((child = NextObject(&cstate)))
 290                     {
 291                         if ((i & data->exclude) && (child != obj))
 292                         {
 293                             IPTR checkit = 0, checked = 0;
 294
 295                             get(child, MUIA_Menuitem_Checkit, &checkit);
 296                             get(child, MUIA_Menuitem_Checked, &checked);
 297
 298                             if (checkit && checked)
 299                             {
 300                                 set(child, MUIA_Menuitem_Checked, FALSE);
 301                             }
 302                         }
 303
 304                         i <<= 1;
 305                     }
 306                 }
 307
 308             }
 309             rebuild = TRUE;
 310             break;
 311
 312         case MUIA_Menuitem_Checkit:
 313             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_CHECKIT);
 314             rebuild = TRUE;
 315             break;
 316
 317         case MUIA_Menuitem_CommandString:
 318             _handle_bool_tag(data->flags, tag->ti_Data,
 319                 MENUF_COMMANDSTRING);
 320             rebuild = TRUE;
 321             break;
 322
 323         case MUIA_Menu_Enabled:
 324         case MUIA_Menuitem_Enabled:
 325             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_ENABLED);
 326             tag->ti_Tag = TAG_IGNORE;
 327             rebuild = TRUE;
 328             break;
 329
 330         case MUIA_Menuitem_Toggle:
 331             _handle_bool_tag(data->flags, tag->ti_Data, MENUF_TOGGLE);
 332             rebuild = TRUE;
 333             break;
 334
 335         case MUIA_Menuitem_Exclude:
 336             data->exclude = tag->ti_Data;
 337             rebuild = TRUE;
 338             break;
 339
 340         case MUIA_Menuitem_Shortcut:
 341             data->shortcut = (char *)tag->ti_Data;
 342             rebuild = TRUE;
 343             break;
 344
 345         case MUIA_Menu_Title:
 346         case MUIA_Menuitem_Title:
 347             data->title = (char *)tag->ti_Data;
 348             tag->ti_Tag = TAG_IGNORE;
 349             rebuild = TRUE;
 350             break;
 351
 352         case MUIA_Menuitem_Trigger:
 353             data->trigger = (struct MenuItem *)tag->ti_Data;
 354             rebuild = TRUE;
 355             break;
 356         }
 357     }
 358
 359     if (rebuild)
 360     {
 361         if (muiNotifyData(obj) &&
 362             muiNotifyData(obj)->mnd_GlobalInfo &&
 363             muiNotifyData(obj)->mnd_GlobalInfo->mgi_ApplicationObject)
 364         {
 365             DoMethod(_app(obj), MUIM_Application_UpdateMenus);
 366         }
 367     }
 368
 369     return DoSuperMethodA(cl, obj, (Msg) msg);
 370 }
 371
 372 /**************************************************************************
 373  OM_GET
 374 **************************************************************************/
 375 #define STORE *(msg->opg_Storage)
 376 IPTR Menuitem__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 377 {
 378     struct MUI_MenuitemData *data = INST_DATA(cl, obj);
 379
 380     switch (msg->opg_AttrID)
 381     {
 382     case MUIA_Menuitem_Checked:
 383         STORE = ((data->flags & MENUF_CHECKED) != 0);
 384         return 1;
 385
 386     case MUIA_Menuitem_Checkit:
 387         STORE = ((data->flags & MENUF_CHECKIT) != 0);
 388         return 1;
 389
 390     case MUIA_Menuitem_CommandString:
 391         STORE = ((data->flags & MENUF_COMMANDSTRING) != 0);
 392         return 1;
 393
 394     case MUIA_Menu_Enabled:
 395     case MUIA_Menuitem_Enabled:
 396         STORE = ((data->flags & MENUF_ENABLED) != 0);
 397         return 1;
 398
 399     case MUIA_Menuitem_Toggle:
 400         STORE = ((data->flags & MENUF_TOGGLE) != 0);
 401         return 1;
 402
 403     case MUIA_Menuitem_Exclude:
 404         STORE = data->exclude;
 405         return 1;
 406
 407     case MUIA_Menuitem_Shortcut:
 408         STORE = (IPTR) data->shortcut;
 409         return 1;
 410
 411     case MUIA_Menu_Title:
 412     case MUIA_Menuitem_Title:
 413         STORE = (IPTR) data->title;
 414         return 1;
 415
 416     case MUIA_Menuitem_NewMenu:
 417         Menuitem_BuildNewMenu(data, obj);
 418         STORE = (IPTR) data->newmenu;
 419         return 1;
 420
 421     case MUIA_Menuitem_Trigger:
 422         STORE = (IPTR) data->trigger;
 423         return 1;
 424
 425     case MUIA_Menuitem_Type:
 426         if (data->flags & MENUF_MENUSTRIP)
 427             STORE = (IPTR) MUIV_Menuitem_Type_Menustrip;
 428         else if(data->flags & MENUF_MENU)
 429             STORE = (IPTR) MUIV_Menuitem_Type_Menu;
 430         else
 431             STORE = (IPTR) MUIV_Menuitem_Type_Menuitem;
 432         return 1;
 433
 434     }
 435
 436     return DoSuperMethodA(cl, obj, (Msg) msg);
 437 }
 438 #undef STORE
 439
 440
 441 /**************************************************************************
 442  OM_DISPOSE
 443 **************************************************************************/
 444 IPTR Menuitem__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 445 {
 446     struct MUI_MenuitemData *data = INST_DATA(cl, obj);
 447
 448     FreeVec(data->newmenu);
 449
 450     return DoSuperMethodA(cl, obj, msg);
 451 }
 452
 453
 454 /**************************************************************************
 455  MUIM_ConnectParent
 456 **************************************************************************/
 457 IPTR Menuitem__MUIM_ConnectParent(struct IClass *cl, Object *obj,
 458     struct MUIP_ConnectParent *msg)
 459 {
 460     Object *cstate;
 461     Object *child;
 462     struct MinList *ChildList = NULL;
 463
 464     D(bug("Menuitem_ConnectParent(%p) %s\n", obj, OCLASS(obj)->cl_ID));
 465
 466     DoSuperMethodA(cl, obj, (Msg) msg);
 467
 468     muiNotifyData(obj)->mnd_ParentObject = msg->parent;
 469
 470     get(obj, MUIA_Family_List, &ChildList);
 471     cstate = (Object *) ChildList->mlh_Head;
 472     while ((child = NextObject(&cstate)))
 473     {
 474         DoMethod(child, MUIM_ConnectParent, (IPTR) obj);
 475     }
 476     return TRUE;
 477 }
 478
 479 /**************************************************************************
 480  MUIM_DisconnectParent
 481 **************************************************************************/
 482 IPTR Menuitem__MUIM_DisconnectParent(struct IClass *cl, Object *obj,
 483     struct MUIP_ConnectParent *msg)
 484 {
 485     Object *cstate;
 486     Object *child;
 487     struct MinList *ChildList = NULL;
 488
 489     D(bug("Menuitem_DisconnectParent(%p) %s\n", obj, OCLASS(obj)->cl_ID));
 490
 491     get(obj, MUIA_Family_List, &ChildList);
 492     cstate = (Object *) ChildList->mlh_Head;
 493     while ((child = NextObject(&cstate)))
 494     {
 495         DoMethodA(child, (Msg) msg);
 496     }
 497     muiNotifyData(obj)->mnd_ParentObject = NULL;
 498     DoSuperMethodA(cl, obj, (Msg) msg);
 499     return TRUE;
 500 }
 501
 502 /**************************************************************************
 503  MUIM_Family_Insert, MUIM_Family_Remove
 504 **************************************************************************/
 505 IPTR Menuitem__MUIM_Update(struct IClass *cl, Object *obj, Msg msg)
 506 {
 507     // struct MUI_MenuitemData *data = INST_DATA(cl, obj);
 508
 509     IPTR retval = DoSuperMethodA(cl, obj, msg);
 510
 511     if (muiNotifyData(obj) &&
 512         muiNotifyData(obj)->mnd_GlobalInfo &&
 513         muiNotifyData(obj)->mnd_GlobalInfo->mgi_ApplicationObject)
 514     {
 515         DoMethod(_app(obj), MUIM_Application_UpdateMenus);
 516     }
 517
 518     return retval;
 519 }
 520
 521 IPTR Common_Dispatcher(Class *cl, Object *obj, Msg msg)
 522 {
 523     switch (msg->MethodID)
 524     {
 525     case OM_DISPOSE:
 526         return Menuitem__OM_DISPOSE(cl, obj, msg);
 527     case OM_SET:
 528         return Menuitem__OM_SET(cl, obj, (struct opSet *)msg);
 529     case OM_GET:
 530         return Menuitem__OM_GET(cl, obj, (struct opGet *)msg);
 531     case MUIM_ConnectParent:
 532         return Menuitem__MUIM_ConnectParent(cl, obj, (APTR) msg);
 533     case MUIM_DisconnectParent:
 534         return Menuitem__MUIM_DisconnectParent(cl, obj, (APTR) msg);
 535     case MUIM_Family_Insert:
 536         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 537     case MUIM_Family_Remove:
 538         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 539     case MUIM_Family_AddTail:
 540         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 541     case MUIM_Family_AddHead:
 542         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 543     case OM_ADDMEMBER:
 544         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 545     case OM_REMMEMBER:
 546         return Menuitem__MUIM_Update(cl, obj, (APTR) msg);
 547     }
 548     return DoSuperMethodA(cl, obj, msg);
 549 }
 550
 551 BOOPSI_DISPATCHER(IPTR, Menuitem_Dispatcher, cl, obj, msg)
 552 {
 553     switch (msg->MethodID)
 554     {
 555     case OM_NEW:
 556         return Menuitem__OM_NEW(cl, obj, (struct opSet *)msg);
 557     }
 558
 559     return Common_Dispatcher(cl, obj, msg);
 560 }
 561 BOOPSI_DISPATCHER_END
 562
 563 BOOPSI_DISPATCHER(IPTR, Menu_Dispatcher, cl, obj, msg)
 564 {
 565     switch (msg->MethodID)
 566     {
 567     case OM_NEW:
 568         return Menu__OM_NEW(cl, obj, (struct opSet *)msg);
 569     }
 570
 571     return Common_Dispatcher(cl, obj, msg);
 572 }
 573 BOOPSI_DISPATCHER_END
 574
 575 BOOPSI_DISPATCHER(IPTR, Menustrip_Dispatcher, cl, obj, msg)
 576 {
 577     switch (msg->MethodID)
 578     {
 579     case OM_NEW:
 580         return Menustrip__OM_NEW(cl, obj, (struct opSet *)msg);
 581     }
 582
 583     return Common_Dispatcher(cl, obj, msg);
 584 }
 585 BOOPSI_DISPATCHER_END
 586 /*
 587  * Class descriptor.
 588  */
 589 const struct __MUIBuiltinClass _MUI_Menuitem_desc =
 590 {
 591     MUIC_Menuitem,
 592     MUIC_Family,
 593     sizeof(struct MUI_MenuitemData),
 594     (void *) Menuitem_Dispatcher
 595 };
 596
 597 /*
 598  * Class descriptor.- this class is the same like menuitem
 599  */
 600 const struct __MUIBuiltinClass _MUI_Menu_desc =
 601 {
 602     MUIC_Menu,
 603     MUIC_Family,
 604     sizeof(struct MUI_MenuitemData),
 605     (void *) Menu_Dispatcher
 606 };
 607
 608 /*
 609  * Class descriptor.- this class is the same like menuitem
 610  */
 611 const struct __MUIBuiltinClass _MUI_Menustrip_desc =
 612 {
 613     MUIC_Menustrip,
 614     MUIC_Family,
 615     sizeof(struct MUI_MenuitemData),
 616     (void *) Menustrip_Dispatcher
 617 };