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