workbench/libs/gadtools/createmenusa.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5 #include "gadtools_intern.h"
   6 #include <exec/memory.h>
   7 #include <exec/types.h>
   8 #define DEBUG 0
   9
  10 #include <intuition/intuition.h>
  11 #include <libraries/gadtools.h>
  12 #include <utility/tagitem.h>
  13
  14 #include <aros/debug.h>
  15
  16 #include <proto/gadtools.h>
  17
  18 /*********************************************************************
  19
  20     NAME */
  21
  22         AROS_LH2(struct Menu *, CreateMenusA,
  23
  24 /*  SYNOPSIS */
  25         AROS_LHA(struct NewMenu *, newmenu, A0),
  26         AROS_LHA(struct TagItem *, tagList, A1),
  27
  28 /*  LOCATION */
  29         struct Library *, GadToolsBase, 8, GadTools)
  30
  31 /*  FUNCTION
  32         CreateMenusA() creates a complete menu or parts of a menu.
  33
  34     INPUTS
  35         newmenu - pointer to struct NewMenu
  36         taglist - additional tags
  37
  38     RESULT
  39         A pointer to a menu structure.
  40
  41     NOTES
  42         CreateMenusA() stores no position information in the menu structure.
  43         You need to call LayoutMenusA() to retrieve them.
  44         The strings supplied for the menu are not copied into a private
  45         buffer. Therefore they must be preserved, until FreeMenus() was
  46         called.
  47
  48     EXAMPLE
  49
  50     BUGS
  51
  52     SEE ALSO
  53         FreeMenus(), LayoutMenusA()
  54
  55     INTERNALS
  56
  57     HISTORY
  58
  59 ***************************************************************************/
  60 #if NEWMENUCODE
  61 {
  62 /*
  63  * We need to allocate the whole menu in one block as we can't just
  64  * go through the menustructure in freemenus as programs may do dynamic
  65  * menu links which would be illegally freeed that way.
  66  * As barlabels are dynamic Boopsi image objects we need to store them
  67  * in a menu pregap so we can free them through DisposeObject() before
  68  * we free the whole menublock.
  69  *
  70  * Menu Memory structure:
  71  *  void *BarLabelTable[BarLabelCount];
  72  *  ULONG BarLabelCount;
  73  *  Menu(returned Ptr):
  74  *   MenuStructure
  75  *   .
  76  *   .
  77  */
  78
  79
  80     AROS_LIBFUNC_INIT
  81
  82     struct Menu         * firstmenu = NULL, * curmenu = NULL;
  83     struct MenuItem     * newitem, * firstitem = NULL, * curitem = NULL;
  84     struct MenuItem     * newsubitem, * firstsubitem = NULL, * cursubitem = NULL;
  85     struct TagItem      * ti;
  86     ULONG               menu_ctr = 0;
  87     ULONG               item_ctr = 0;
  88     ULONG               subitem_ctr = 0;
  89     BOOL                end;
  90     BOOL                fullmenu = GetTagData(GTMN_FullMenu, FALSE, tagList);
  91     UBYTE               prevtype = (UBYTE)-1;
  92     ULONG               BarLabels;
  93     ULONG               MenuMemSize;
  94     struct NewMenu      *menuentry;
  95     UBYTE               *MyMenuMemory;
  96     UBYTE               *MyMenuMemPtr;
  97     struct Image        **MyBarTablePtr;
  98     ULONG               err = 0;
  99
 100     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NewMenu %p TagList %p full %d\n",
 101                             newmenu, tagList, fullmenu));
 102
 103     D(bug("Entering %s\n",__FUNCTION__));
 104
 105     BarLabels   =       0;
 106     MenuMemSize =       0;
 107     menuentry   =       newmenu;
 108
 109     end = FALSE;
 110     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: count elements\n"));
 111     while (!end)
 112     {
 113         BOOL is_image = FALSE;
 114         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: Type %d\n", menuentry->nm_Type));
 115         switch (menuentry->nm_Type)
 116         {
 117             case NM_TITLE:
 118                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NW_TITLE\n"));
 119                 MenuMemSize += getmenutitlesize(newmenu,tagList);
 120                 break;
 121
 122             case IM_ITEM:
 123                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: IM_ITEM\n"));
 124                 is_image = TRUE;
 125                 /* Fall through */
 126
 127             case NM_ITEM: /* also the BARLABEL */
 128                 /*
 129                 ** There has to be a menu structure available
 130                 ** to create an item, unless GTMN_FullMenu is FALSE.
 131                 */
 132                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_ITEM\n"));
 133                 if (menuentry->nm_Label == NM_BARLABEL)
 134                 {
 135                         BarLabels++;
 136                 }
 137                 MenuMemSize += getmenuitemsize(newmenu,
 138                                                is_image,
 139                                                tagList,
 140                                                GTB(GadToolsBase));
 141
 142                 break;
 143
 144             case IM_SUB:
 145                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: IM_SUB\n"));
 146                 is_image = TRUE;
 147                 /* Fall through */
 148
 149             case NM_SUB:
 150                 /*
 151                 ** There has to be an item menu structure available
 152                 ** to create a sub item, unless GTMN_FullMenu == FALSE.
 153                 */
 154                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_SUB\n"));
 155                 if (menuentry->nm_Label == NM_BARLABEL)
 156                 {
 157                         BarLabels++;
 158                 }
 159                 MenuMemSize += getmenuitemsize(newmenu,
 160                                                is_image,
 161                                                tagList,
 162                                                GTB(GadToolsBase));
 163                 break;
 164
 165             case NM_IGNORE:
 166                 /*
 167                 ** Nothing to do in this case
 168                 */
 169                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_IGNORE\n"));
 170                 break;
 171
 172             case NM_END:
 173                 /*
 174                 ** The end.
 175                 */
 176                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_END\n"));
 177                 end = TRUE;
 178                 break;
 179
 180         } /* switch (menuentry->nm_Type) */
 181         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: Current MenuMemSize %ld\n",MenuMemSize));
 182         menuentry++;
 183     } /* while (!end) */
 184
 185     /*
 186      * Add space for barlabel count+area which must come at the beginning.
 187      */
 188     MenuMemSize += sizeof(ULONG) + (BarLabels * sizeof(void*));
 189
 190     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: MenuMemSize %ld BarLabels %ld\n",MenuMemSize,BarLabels));
 191
 192     if (!(MyMenuMemory=AllocVec(MenuMemSize,MEMF_ANY | MEMF_CLEAR)))
 193     {
 194         ULONG   *Ptr;
 195         /*
 196         ** Set the secondary error value if requested.
 197         */
 198         if ((Ptr =(ULONG*) GetTagData(GTMN_SecondaryError, (IPTR) NULL, tagList)))
 199         {
 200             *Ptr = GTMENU_NOMEM;
 201         }
 202         return(NULL);
 203     }
 204     MyBarTablePtr =(struct Image**) MyMenuMemory;
 205     MyMenuMemPtr =(UBYTE*) &MyBarTablePtr[BarLabels];
 206     *((ULONG*) MyMenuMemPtr) = BarLabels;
 207     MyMenuMemPtr += sizeof(ULONG);
 208
 209     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: MyMenuMemory 0x%lx MyBarTablePtr 0x%lx MyMenuMemPtr 0x%lx\n",MyMenuMemory,MyBarTablePtr,MyMenuMemPtr));
 210
 211     end = FALSE;
 212     while (!end)
 213     {
 214         BOOL is_image = FALSE;
 215
 216         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: Type %d\n", newmenu->nm_Type));
 217         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: Current MyMenuMemory 0x%lx MyBarTablePtr 0x%lx MyMenuMemPtr 0x%lx\n",MyMenuMemory,MyBarTablePtr,MyMenuMemPtr));
 218
 219         switch (newmenu->nm_Type)
 220         {
 221             case NM_TITLE:
 222                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NW_TITLE\n"));
 223                 curmenu = makemenutitle(newmenu,
 224                                         &MyMenuMemPtr,
 225                                         tagList);
 226
 227                 if (NULL == curmenu)
 228                 {
 229                     err = GTMENU_NOMEM;
 230                     goto failexit;
 231                 }
 232
 233                 /*
 234                 ** Append it to the list of menus or make it the
 235                 ** first entry.
 236                 */
 237                 if (NULL == firstmenu)
 238                     firstmenu = curmenu;
 239                 else
 240                     appendmenu(firstmenu, curmenu);
 241
 242                 menu_ctr ++;
 243                 item_ctr = 0;
 244                 curitem = firstitem = cursubitem = firstsubitem = NULL;
 245                 break;
 246
 247             case IM_ITEM:
 248                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: IM_ITEM\n"));
 249                 is_image = TRUE;
 250                 /* Fall through */
 251
 252             case NM_ITEM: /* also the BARLABEL */
 253                 /*
 254                 ** There has to be a menu structure available
 255                 ** to create an item, unless GTMN_FullMenu is FALSE.
 256                 */
 257                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_ITEM\n"));
 258
 259                 if (fullmenu && (NULL == curmenu))
 260                 {
 261                     err = GTMENU_INVALID;
 262                     goto failexit;
 263                 }
 264
 265                 if (item_ctr >= 64)
 266                 {
 267                     /* CreateMenusA must still return success here, only that the
 268                        menus will be trimmed */
 269                     err = GTMENU_TRIMMED;
 270                     break;
 271                 }
 272
 273                 newitem = makemenuitem(newmenu,
 274                                        &MyMenuMemPtr,
 275                                        &MyBarTablePtr,
 276                                        is_image,
 277                                        tagList,
 278                                        GTB(GadToolsBase));
 279
 280                 if (NULL == newitem)
 281                 {
 282                     err = GTMENU_NOMEM;
 283                     goto failexit;
 284                 }
 285
 286                 /*
 287                 ** Append this item to the current menu title
 288                 */
 289
 290                 if (curitem)
 291                 {
 292                     curitem->NextItem = newitem;
 293                 }
 294                 else
 295                 {
 296                     firstitem = newitem;
 297                     if (curmenu)
 298                     {
 299                         curmenu->FirstItem = newitem;
 300                         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: set FirstItem 0x%lx\n", newitem));
 301                     }
 302                 }
 303
 304                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NextItem 0x%lx\n", newitem));
 305
 306                 item_ctr ++;
 307                 subitem_ctr = 0;
 308                 cursubitem = firstsubitem = NULL;
 309
 310                 curitem = newitem;
 311                 break;
 312
 313             case IM_SUB:
 314                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: IM_SUB\n"));
 315                 is_image = TRUE;
 316                 /* Fall through */
 317
 318             case NM_SUB:
 319                 /*
 320                 ** There has to be an item menu structure available
 321                 ** to create a sub item, unless GTMN_FullMenu == FALSE.
 322                 */
 323                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_SUB\n"));
 324                 if ( (fullmenu && (NULL == curitem)) ||
 325                      (prevtype == NM_TITLE) )
 326                 {
 327                     err = GTMENU_INVALID;
 328                     goto failexit;
 329                 }
 330
 331                 if (subitem_ctr >= 32)
 332                 {
 333                     err = GTMENU_TRIMMED;
 334                     /* CreateMenusA must still return success here, only that the
 335                        menus will be trimmed */
 336                     break;
 337                 }
 338
 339                 newsubitem = makemenuitem(newmenu,
 340                                           &MyMenuMemPtr,
 341                                           &MyBarTablePtr,
 342                                           is_image,
 343                                           tagList,
 344                                           GTB(GadToolsBase));
 345
 346                 if (NULL == newsubitem)
 347                 {
 348                     err = GTMENU_NOMEM;
 349                     goto failexit;
 350                 }
 351
 352                 if (curitem)
 353                 {
 354                     if (!curitem->SubItem)
 355                     {
 356                     }
 357                 }
 358
 359                 /*
 360                 ** Append this item to the current sub menu item
 361                 */
 362
 363                 if (cursubitem)
 364                 {
 365                     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: CurSubItem 0x%lx NextItem 0x%lx\n", cursubitem,newsubitem));
 366                     cursubitem->NextItem = newsubitem;
 367                 }
 368                 else
 369                 {
 370                     firstsubitem = newsubitem;
 371                     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: FirstSubItem 0x%lx\n", firstsubitem));
 372                     if (curitem)
 373                     {
 374                         curitem->SubItem = newsubitem;
 375
 376                         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: CurItem 0x%lx SubItem 0x%lx\n", curitem,newsubitem));
 377
 378                         /* Add the ">>" mark. Hmm ... maybe if would be better if this
 379                            was done in LayoutMenus() ??? */
 380
 381                         curitem->Flags &= ~COMMSEQ;
 382                         if (curitem->Flags & ITEMTEXT)
 383                         {
 384                             struct IntuiText *it = (struct IntuiText *)curitem->ItemFill;
 385
 386                             if (!it->NextText)
 387                             {
 388                                 struct IntuiText *it2 = it + 1;
 389
 390                                 it->NextText = it2;
 391                                 it2->IText = "»";
 392                             }
 393                         }
 394
 395                     }
 396                 }
 397
 398                 cursubitem = newsubitem;
 399                 subitem_ctr ++;
 400                 break;
 401
 402             case NM_IGNORE:
 403                 /*
 404                 ** Nothing to do in this case
 405                 */
 406                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_IGNORE\n"));
 407                 break;
 408
 409             case NM_END:
 410                 /*
 411                 ** The end.
 412                 */
 413                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_END\n"));
 414                 end = TRUE;
 415                 break;
 416
 417         } /* switch (newmenu->nm_Type) */
 418
 419         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: firstmenu %p curmenu %p firstitem %p curitem %p firstsub %p cursub %p\n",
 420                                 firstmenu, curmenu, firstitem, curitem, firstsubitem, cursubitem));
 421
 422         prevtype = newmenu->nm_Type;
 423
 424         /*
 425         ** Advance to the next item in the array
 426         */
 427         newmenu = &newmenu[1];
 428
 429     } /* while (FALSE == end) */
 430
 431     /*
 432     ** Set the secondary error value if requested.
 433     */
 434     ti = FindTagItem(GTMN_SecondaryError, tagList);
 435
 436     if (NULL != ti)
 437         ti->ti_Data = err;
 438
 439     if (!firstmenu)
 440     {
 441         firstmenu = (struct Menu *)firstitem;
 442         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: No FirstMenu..use firstitem 0x%lx\n", firstitem));
 443     }
 444     if (!firstmenu)
 445     {
 446         firstmenu = (struct Menu *)firstsubitem;
 447         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: No FirstMenu..use firstsubitem 0x%lx\n", firstsubitem));
 448     }
 449
 450     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: return %p\n", firstmenu));
 451
 452 //    DumpMenu(firstmenu);
 453
 454     return firstmenu;
 455
 456
 457 failexit:
 458
 459     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: failed\n"));
 460
 461     /*
 462     ** Free all memory
 463     */
 464     FreeMenus(firstmenu);
 465
 466     /*
 467     ** Set the secondary error value if requested.
 468     */
 469     ti = FindTagItem(GTMN_SecondaryError, tagList);
 470
 471     if (NULL != ti)
 472         ti->ti_Data = err;
 473
 474     return NULL;
 475
 476     AROS_LIBFUNC_EXIT
 477
 478 } /* CreateMenusA */
 479
 480 #else
 481 {
 482     AROS_LIBFUNC_INIT
 483
 484     struct Menu         * firstmenu = NULL, * curmenu = NULL;
 485     struct MenuItem     * newitem, * firstitem = NULL, * curitem = NULL;
 486     struct MenuItem     * newsubitem, * firstsubitem = NULL, * cursubitem = NULL;
 487     struct TagItem      * ti;
 488     ULONG               menu_ctr = 0;
 489     ULONG               item_ctr = 0;
 490     ULONG               subitem_ctr = 0;
 491     BOOL                end = FALSE;
 492     BOOL                fullmenu = GetTagData(GTMN_FullMenu, FALSE, tagList);
 493     UBYTE               prevtype = (UBYTE)-1;
 494
 495     ULONG               err = 0;
 496
 497     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NewMenu %p TagList %p full %d\n",
 498                             newmenu, tagList, fullmenu));
 499
 500     D(bug("Entering %s\n",__FUNCTION__));
 501
 502     while (FALSE == end)
 503     {
 504         BOOL is_image = FALSE;
 505
 506         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: Type %d\n", newmenu->nm_Type));
 507
 508         switch (newmenu->nm_Type)
 509         {
 510             case NM_TITLE:
 511                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NW_TITLE\n"));
 512                 curmenu = makemenutitle(newmenu,
 513                                         tagList);
 514
 515                 if (NULL == curmenu)
 516                 {
 517                     err = GTMENU_NOMEM;
 518                     goto failexit;
 519                 }
 520
 521                 /*
 522                 ** Append it to the list of menus or make it the
 523                 ** first entry.
 524                 */
 525                 if (NULL == firstmenu)
 526                     firstmenu = curmenu;
 527                 else
 528                     appendmenu(firstmenu, curmenu);
 529
 530                 menu_ctr ++;
 531                 item_ctr = 0;
 532                 curitem = firstitem = cursubitem = firstsubitem = NULL;
 533                 break;
 534
 535             case IM_ITEM:
 536                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: IM_ITEM\n"));
 537                 is_image = TRUE;
 538                 /* Fall through */
 539
 540             case NM_ITEM: /* also the BARLABEL */
 541                 /*
 542                 ** There has to be a menu structure available
 543                 ** to create an item, unless GTMN_FullMenu is FALSE.
 544                 */
 545                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_ITEM\n"));
 546
 547                 if (fullmenu && (NULL == curmenu))
 548                 {
 549                     err = GTMENU_INVALID;
 550                     goto failexit;
 551                 }
 552
 553                 if (item_ctr >= 64)
 554                 {
 555                     /* CreateMenusA must still return success here, only that the
 556                        menus will be trimmed */
 557                     err = GTMENU_TRIMMED;
 558                     break;
 559                 }
 560
 561                 newitem = makemenuitem(newmenu,
 562                                        is_image,
 563                                        tagList,
 564                                        GTB(GadToolsBase));
 565
 566                 if (NULL == newitem)
 567                 {
 568                     err = GTMENU_NOMEM;
 569                     goto failexit;
 570                 }
 571
 572                 /*
 573                 ** Append this item to the current menu title
 574                 */
 575
 576                 if (curitem)
 577                 {
 578                     curitem->NextItem = newitem;
 579                 }
 580                 else
 581                 {
 582                     firstitem = newitem;
 583                     if (curmenu)
 584                     {
 585                         curmenu->FirstItem = newitem;
 586                         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: set FirstItem 0x%lx\n", newitem));
 587                     }
 588                 }
 589
 590                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NextItem 0x%lx\n", newitem));
 591
 592                 item_ctr ++;
 593                 subitem_ctr = 0;
 594                 cursubitem = firstsubitem = NULL;
 595
 596                 curitem = newitem;
 597                 break;
 598
 599             case IM_SUB:
 600                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: IM_SUB\n"));
 601                 is_image = TRUE;
 602                 /* Fall through */
 603
 604             case NM_SUB:
 605                 /*
 606                 ** There has to be an item menu structure available
 607                 ** to create a sub item, unless GTMN_FullMenu == FALSE.
 608                 */
 609                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_SUB\n"));
 610                 if ( (fullmenu && (NULL == curitem)) ||
 611                      (prevtype == NM_TITLE) )
 612                 {
 613                     err = GTMENU_INVALID;
 614                     goto failexit;
 615                 }
 616
 617                 if (subitem_ctr >= 32)
 618                 {
 619                     err = GTMENU_TRIMMED;
 620                     /* CreateMenusA must still return success here, only that the
 621                        menus will be trimmed */
 622                     break;
 623                 }
 624
 625                 newsubitem = makemenuitem(newmenu,
 626                                           is_image,
 627                                           tagList,
 628                                           GTB(GadToolsBase));
 629
 630                 if (NULL == newsubitem)
 631                 {
 632                     err = GTMENU_NOMEM;
 633                     goto failexit;
 634                 }
 635
 636                 if (curitem)
 637                 {
 638                     if (!curitem->SubItem)
 639                     {
 640                     }
 641                 }
 642
 643                 /*
 644                 ** Append this item to the current sub menu item
 645                 */
 646
 647                 if (cursubitem)
 648                 {
 649                     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: CurSubItem 0x%lx NextItem 0x%lx\n", cursubitem,newsubitem));
 650                     cursubitem->NextItem = newsubitem;
 651                 }
 652                 else
 653                 {
 654                     firstsubitem = newsubitem;
 655                     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: FirstSubItem 0x%lx\n", firstsubitem));
 656                     if (curitem)
 657                     {
 658                         curitem->SubItem = newsubitem;
 659
 660                         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: CurItem 0x%lx SubItem 0x%lx\n", curitem,newsubitem));
 661
 662                         /* Add the ">>" mark. Hmm ... maybe if would be better if this
 663                            was done in LayoutMenus() ??? */
 664
 665                         curitem->Flags &= ~COMMSEQ;
 666                         if (curitem->Flags & ITEMTEXT)
 667                         {
 668                             struct IntuiText *it = (struct IntuiText *)curitem->ItemFill;
 669
 670                             if (!it->NextText)
 671                             {
 672                                 struct IntuiText *it2 = it + 1;
 673
 674                                 it->NextText = it2;
 675                                 it2->IText = "»";
 676                             }
 677                         }
 678
 679                     }
 680                 }
 681
 682                 cursubitem = newsubitem;
 683                 subitem_ctr ++;
 684                 break;
 685
 686             case NM_IGNORE:
 687                 /*
 688                 ** Nothing to do in this case
 689                 */
 690                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_IGNORE\n"));
 691                 break;
 692
 693             case NM_END:
 694                 /*
 695                 ** The end.
 696                 */
 697                 DEBUG_CREATEMENUSA(dprintf("CreateMenusA: NM_END\n"));
 698                 end = TRUE;
 699                 break;
 700
 701         } /* switch (newmenu->nm_Type) */
 702
 703         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: firstmenu %p curmenu %p firstitem %p curitem %p firstsub %p cursub %p\n",
 704                                 firstmenu, curmenu, firstitem, curitem, firstsubitem, cursubitem));
 705
 706         prevtype = newmenu->nm_Type;
 707
 708         /*
 709         ** Advance to the next item in the array
 710         */
 711         newmenu = &newmenu[1];
 712
 713     } /* while (FALSE == end) */
 714
 715     /*
 716     ** Set the secondary error value if requested.
 717     */
 718     ti = FindTagItem(GTMN_SecondaryError, tagList);
 719
 720     if (NULL != ti)
 721         ti->ti_Data = err;
 722
 723     if (!firstmenu)
 724     {
 725         firstmenu = (struct Menu *)firstitem;
 726         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: No FirstMenu..use firstitem 0x%lx\n", firstitem));
 727     }
 728     if (!firstmenu)
 729     {
 730         firstmenu = (struct Menu *)firstsubitem;
 731         DEBUG_CREATEMENUSA(dprintf("CreateMenusA: No FirstMenu..use firstsubitem 0x%lx\n", firstsubitem));
 732     }
 733
 734     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: return %p\n", firstmenu));
 735
 736     DumpMenu(firstmenu);
 737
 738     return firstmenu;
 739
 740
 741 failexit:
 742
 743     DEBUG_CREATEMENUSA(dprintf("CreateMenusA: failed\n"));
 744
 745     /*
 746     ** Free all memory
 747     */
 748     FreeMenus(firstmenu);
 749
 750     /*
 751     ** Set the secondary error value if requested.
 752     */
 753     ti = FindTagItem(GTMN_SecondaryError, tagList);
 754
 755     if (NULL != ti)
 756         ti->ti_Data = err;
 757
 758     return NULL;
 759
 760     AROS_LIBFUNC_EXIT
 761
 762 } /* CreateMenusA */
 763 #endif
 764
 765 #if 0
 766 void    DumpMenuItem(struct MenuItem *item)
 767 {
 768         if (!item) return;
 769         while (item)
 770         {
 771                 DEBUG_DUMPMENUS(bug("DumpMenus: Item 0x%lx NextItem 0x%lx SubItem 0x%lx\n", item,item->NextItem,item->SubItem));
 772                 if (item->Flags & ITEMTEXT)
 773                 {
 774                         struct IntuiText *MyText=(struct IntuiText*) item->ItemFill;
 775                         DEBUG_DUMPMENUS(bug("DumpMenus: <%s>\n",MyText->IText));
 776                 }
 777                 else
 778                 {
 779                         DEBUG_DUMPMENUS(bug("DumpMenus: Image 0x%lx\n", item->ItemFill));
 780                 }
 781                 DumpMenuItem(item->SubItem);
 782                 item = item->NextItem;
 783         }
 784 }
 785
 786 void    DumpMenu(struct Menu *menu)
 787 {
 788 ULONG *p = (ULONG *)menu - 1;
 789
 790         if (!menu) return;
 791         if (*p)
 792         {
 793                 DumpMenuItem((struct MenuItem*) menu);
 794         }
 795         else
 796         {
 797                 while (menu)
 798                 {
 799                         DEBUG_DUMPMENUS(bug("DumpMenus: Menu 0x%lx <%s> NextMenu 0x%lx FirstItem 0x%lx\n", menu, menu->MenuName, menu->NextMenu, menu->FirstItem));
 800                         DumpMenuItem(menu->FirstItem);
 801                         menu = menu->NextMenu;
 802                 }
 803         }
 804 }
 805 #endif