workbench/libs/gadtools/menus.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: GadTools menu creation functions
   6     Lang: English
   7 */
   8
   9 /**************************************************************************************************/
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13
  14 #include <proto/exec.h>
  15 #include <exec/types.h>
  16 #include <exec/libraries.h>
  17 #include <exec/memory.h>
  18 #include <proto/intuition.h>
  19 #include <proto/utility.h>
  20 #include <intuition/intuition.h>
  21 #include <intuition/classusr.h>
  22 #include <intuition/imageclass.h>
  23 #include <intuition/screens.h>
  24 #include <intuition/icclass.h>
  25 #include <proto/utility.h>
  26 #include <utility/tagitem.h>
  27 #include <libraries/gadtools.h>
  28
  29 #define SDEBUG 1
  30 #define DEBUG 1
  31 #include <aros/debug.h>
  32
  33 #include "gadtools_intern.h"
  34
  35 /**************************************************************************************************/
  36
  37 #define CHECKMARK_TEXT_SPACING 2
  38 #define MENU_COLUMN_SPACING    8 /* when items must be arranged in 2 or more columns to fit on screen */
  39 #define AMIGAKEY_KEY_SPACING   4 /* we guess that Intuition uses the same value */
  40 #define TEXT_AMIGAKEY_SPACING  20
  41
  42 #define ITEXT_EXTRA_LEFT   2
  43 #define ITEXT_EXTRA_RIGHT  2
  44 #define ITEXT_EXTRA_TOP    1
  45 #define ITEXT_EXTRA_BOTTOM 1
  46
  47 #define IMAGE_EXTRA_LEFT   1
  48 #define IMAGE_EXTRA_RIGHT  1
  49 #define IMAGE_EXTRA_TOP    1
  50 #define IMAGE_EXTRA_BOTTOM 1
  51
  52 /**************************************************************************************************/
  53
  54 BOOL is_menubarlabelclass_image(struct Image *im, struct GadToolsBase_intern *GadToolsBase)
  55 {
  56     BOOL is_barlabel = FALSE;
  57
  58     DEBUG_FREEMENUS(bug("is_menubarlabelclass_image: im %p\n", im));
  59
  60     if (im)
  61     {
  62         DEBUG_FREEMENUS(bug("is_menubarlabelclass_image: depth %ld\n", im->Depth));
  63         if (im->Depth == CUSTOMIMAGEDEPTH)
  64         {
  65             Class *cl;
  66
  67             DEBUG_FREEMENUS(bug("is_menubarlabelclass_image: boopsi\n"));
  68
  69             cl = OCLASS(im);
  70
  71             DEBUG_FREEMENUS(bug("is_menubarlabelclass_image: cl %p\n",cl));
  72
  73             if (cl)
  74             {
  75                 DEBUG_FREEMENUS(bug("is_menubarlabelclass_image: ID %p\n",cl->cl_ID));
  76                 if (cl->cl_ID)
  77                 {
  78                     if (strcmp(cl->cl_ID, MENUBARLABELCLASS) == 0)
  79                     {
  80                         DEBUG_FREEMENUS(bug("is_menubarlabelclass_image: barlabel\n"));
  81                         is_barlabel = TRUE;
  82                     }
  83                 }
  84             }
  85         }
  86     }
  87
  88     return is_barlabel;
  89 }
  90
  91 /**************************************************************************************************/
  92
  93 void appendmenu(struct Menu * firstmenu,
  94                 struct Menu * lastmenu)
  95 {
  96     while (NULL != firstmenu->NextMenu)
  97         firstmenu = firstmenu->NextMenu;
  98
  99     firstmenu->NextMenu = lastmenu;
 100 }
 101
 102 /**************************************************************************************************/
 103
 104 void appenditem(struct Menu * curmenu,
 105                 struct MenuItem * item)
 106 {
 107     struct MenuItem * mi = curmenu->FirstItem;
 108
 109     if (NULL == mi)
 110         curmenu->FirstItem = item;
 111     else
 112     {
 113         while (NULL != mi->NextItem)
 114             mi = mi->NextItem;
 115
 116         mi->NextItem = item;
 117     }
 118 }
 119
 120 /**************************************************************************************************/
 121
 122 void appendsubitem(struct MenuItem * curitem,
 123                    struct MenuItem * cursubitem)
 124 {
 125     struct MenuItem *mi = curitem->SubItem;
 126
 127     if (NULL == mi)
 128         curitem->SubItem = cursubitem;
 129     else
 130     {
 131         while (NULL != mi->NextItem)
 132             mi = mi->NextItem;
 133
 134         mi->NextItem = cursubitem;
 135     }
 136 }
 137
 138 /**************************************************************************************************/
 139
 140 #if NEWMENUCODE
 141 struct Menu * makemenutitle(struct NewMenu * newmenu,
 142                             UBYTE               **MyMenuMemPtr,
 143                             struct TagItem * taglist)
 144 {
 145     struct Menu * menu = NULL;
 146     ULONG       * p;
 147
 148     p =(ULONG*) *MyMenuMemPtr;
 149     memset(p,0,sizeof(ULONG)+sizeof(struct Menu)+sizeof(APTR));
 150     *MyMenuMemPtr += sizeof(ULONG)+sizeof(struct Menu)+sizeof(APTR);
 151
 152     *p = 0;
 153     menu = (struct Menu *)(p + 1);
 154     menu->Flags               = (newmenu->nm_Flags & NM_MENUDISABLED) ^ MENUENABLED;
 155     menu->MenuName            = newmenu->nm_Label;
 156     GTMENU_USERDATA(menu) = newmenu->nm_UserData;
 157
 158     return menu;
 159 }
 160
 161 ULONG   getmenutitlesize(struct NewMenu * newmenu,
 162                          struct TagItem * taglist)
 163 {
 164     return(sizeof(ULONG)+sizeof(struct Menu)+sizeof(APTR));
 165 }
 166
 167 #else
 168 struct Menu * makemenutitle(struct NewMenu * newmenu,
 169                             struct TagItem * taglist)
 170 {
 171     struct Menu * menu = NULL;
 172     ULONG       * p;
 173
 174     p = (ULONG *)AllocMem(sizeof(ULONG)+sizeof(struct Menu)+sizeof(APTR), MEMF_CLEAR);
 175
 176     if (NULL != p)
 177     {
 178         *p = 0;
 179         menu = (struct Menu *)(p + 1);
 180         menu->Flags           = (newmenu->nm_Flags & NM_MENUDISABLED) ^ MENUENABLED;
 181         menu->MenuName        = newmenu->nm_Label;
 182         GTMENU_USERDATA(menu) = newmenu->nm_UserData;
 183     }
 184
 185     return menu;
 186 }
 187 #endif
 188
 189 /**************************************************************************************************/
 190 #if NEWMENUCODE
 191 struct MenuItem * makemenuitem(struct NewMenu * newmenu,
 192                                UBYTE            **MyMenuMemPtr,
 193                                struct Image     ***MyBarTablePtr,
 194                                BOOL is_image,
 195                                struct TagItem * taglist,
 196                                struct GadToolsBase_intern * GadToolsBase)
 197 {
 198     struct MenuItem     * menuitem = NULL;
 199     UWORD               allocsize;
 200     ULONG               * p;
 201
 202     /* Note: 2 IntuiTexts must be alloced, because CreateMenusA can depend on it
 203              if a subitem mark (">>") must be added */
 204
 205     if (newmenu->nm_Label == NM_BARLABEL) is_image = TRUE;
 206
 207     allocsize = sizeof(ULONG) + sizeof(struct MenuItem) + sizeof(APTR);
 208     if (!is_image) allocsize += sizeof(struct IntuiText) * 2; /* for text + (commandstring OR ">>") */
 209
 210     p =(ULONG*) *MyMenuMemPtr;
 211     memset(p,0,allocsize);
 212     *MyMenuMemPtr += allocsize;
 213
 214         *p = allocsize;
 215         menuitem = (struct MenuItem *)(p + 1);
 216
 217         DEBUG_ALLOCMENUS(bug("makemenuitem: MenuItem %p\n",menuitem));
 218         menuitem->Flags = (newmenu->nm_Flags & (NM_ITEMDISABLED | CHECKIT | MENUTOGGLE | CHECKED)) ^
 219                           ITEMENABLED;
 220
 221         menuitem->Flags |= HIGHCOMP;
 222
 223         if (newmenu->nm_CommKey)
 224         {
 225             if (!(newmenu->nm_Flags & NM_COMMANDSTRING))
 226             {
 227                 menuitem->Flags |= COMMSEQ;
 228                 menuitem->Command = newmenu->nm_CommKey[0];
 229             }
 230         }
 231
 232         menuitem->MutualExclude = newmenu->nm_MutualExclude;
 233         GTMENUITEM_USERDATA(menuitem) = newmenu->nm_UserData;
 234
 235         if (FALSE == is_image)
 236         {
 237             /*
 238             ** Text
 239             */
 240             struct IntuiText * it = (struct IntuiText *)(((UBYTE *)menuitem) +
 241                                                          sizeof(struct MenuItem) +
 242                                                          sizeof(APTR));
 243
 244             DEBUG_ALLOCMENUS(bug("makemenuitem: Text MenuItem\n"));
 245             menuitem->ItemFill = (APTR)it;
 246
 247             it->FrontPen = GetTagData(GTMN_FrontPen, 0, taglist);
 248             it->DrawMode = JAM1;
 249
 250             it->IText    = newmenu->nm_Label;
 251             DEBUG_ALLOCMENUS(bug("makemenuitem: FillName <%s>\n",it->IText));
 252
 253             menuitem->Flags |= ITEMTEXT;
 254
 255             if (newmenu->nm_CommKey && (newmenu->nm_Flags & NM_COMMANDSTRING))
 256             {
 257                 struct IntuiText *it2 = it + 1;
 258
 259                 *it2 = *it;
 260                 it2->IText = newmenu->nm_CommKey;
 261                 it->NextText = it2;
 262             }
 263
 264         } /* if (FALSE == is_image) */
 265         else
 266         {
 267             DEBUG_ALLOCMENUS(bug("makemenuitem: Image MenuItem\n"));
 268             menuitem->Flags &= ~ITEMTEXT;
 269
 270             if (newmenu->nm_Label != NM_BARLABEL)
 271             {
 272                 /*
 273                 ** An image.
 274                 */
 275                 menuitem->ItemFill = (APTR)newmenu->nm_Label;
 276                 DEBUG_ALLOCMENUS(bug("makemenuitem: FillImage 0x%lx\n",menuitem->ItemFill));
 277             }
 278             else
 279             {
 280                 /*
 281                 ** A barlabel image.
 282                 */
 283
 284                 struct TagItem barlabel_tags[] =
 285                 {
 286                     {IA_Left    , ITEXT_EXTRA_LEFT      },
 287                     {IA_Top     , 3                     },
 288                     {IA_Width   , 20                    },
 289                     {IA_Height  , 2                     },
 290                     {TAG_DONE                           }
 291                 };
 292
 293                 menuitem->Flags &= ~ITEMENABLED;
 294
 295                 menuitem->ItemFill = NewObjectA(NULL, MENUBARLABELCLASS, barlabel_tags);
 296
 297                 DEBUG_ALLOCMENUS(bug("makemenuitem: BarImage 0x%lx\n",menuitem->ItemFill));
 298
 299                 if (!menuitem->ItemFill)
 300                 {
 301                     DEBUG_ALLOCMENUS(bug("makemenuitem: barimage failed\n"));
 302                     menuitem = NULL;
 303                 }
 304                 DEBUG_ALLOCMENUS(bug("makemenuitem: BarTablePtr 0x%lx\n",*MyBarTablePtr));
 305                 /*
 306                  * Here we put the new Image to the array the BarTablePtr points to
 307                  * and then inc the BarTablePtr to the next empty Array slot
 308                  */
 309                 **MyBarTablePtr =       menuitem->ItemFill;
 310                 /*
 311                  * Attention..the () is *required*
 312                  */
 313                 (*MyBarTablePtr)++;
 314             }
 315
 316         } /* is_image */
 317
 318     return menuitem;
 319 }
 320
 321 ULONG getmenuitemsize(struct NewMenu * newmenu,
 322                       BOOL is_image,
 323                       struct TagItem * taglist,
 324                       struct GadToolsBase_intern * GadToolsBase)
 325 {
 326 ULONG   allocsize;
 327
 328     if (newmenu->nm_Label == NM_BARLABEL) is_image = TRUE;
 329
 330     allocsize = sizeof(ULONG) + sizeof(struct MenuItem) + sizeof(APTR);
 331     if (!is_image) allocsize += sizeof(struct IntuiText) * 2; /* for text + (commandstring OR ">>") */
 332
 333     DEBUG_ALLOCMENUS(bug("getmenuitemsize: allocsize %ld\n",allocsize));
 334     return(allocsize);
 335 }
 336
 337 #else
 338 struct MenuItem * makemenuitem(struct NewMenu * newmenu,
 339                                BOOL is_image,
 340                                struct TagItem * taglist,
 341                                struct GadToolsBase_intern * GadToolsBase)
 342 {
 343     struct MenuItem     * menuitem = NULL;
 344     ULONG               allocsize;
 345     ULONG               * p;
 346
 347     /* Note: 2 IntuiTexts must be alloced, because CreateMenusA can depend on it
 348              if a subitem mark (">>") must be added */
 349
 350     if (newmenu->nm_Label == NM_BARLABEL) is_image = TRUE;
 351
 352     allocsize = sizeof(ULONG) + sizeof(struct MenuItem) + sizeof(APTR);
 353     if (!is_image) allocsize += sizeof(struct IntuiText) * 2; /* for text + (commandstring OR ">>") */
 354
 355     p = (ULONG *)AllocMem(allocsize, MEMF_CLEAR);
 356
 357     if (NULL != p)
 358     {
 359         *p = allocsize;
 360         menuitem = (struct MenuItem *)(p + 1);
 361
 362         DEBUG_ALLOCMENUS(bug("makemenuitem: MenuItem %p\n",menuitem));
 363         menuitem->Flags = (newmenu->nm_Flags & (NM_ITEMDISABLED | CHECKIT | MENUTOGGLE | CHECKED)) ^
 364                           ITEMENABLED;
 365
 366         menuitem->Flags |= HIGHCOMP;
 367
 368         if (newmenu->nm_CommKey)
 369         {
 370             if (!(newmenu->nm_Flags & NM_COMMANDSTRING))
 371             {
 372                 menuitem->Flags |= COMMSEQ;
 373                 menuitem->Command = newmenu->nm_CommKey[0];
 374             }
 375         }
 376
 377         menuitem->MutualExclude = newmenu->nm_MutualExclude;
 378         GTMENUITEM_USERDATA(menuitem) = newmenu->nm_UserData;
 379
 380         if (FALSE == is_image)
 381         {
 382             /*
 383             ** Text
 384             */
 385             struct IntuiText * it = (struct IntuiText *)(((UBYTE *)menuitem) +
 386                                                          sizeof(struct MenuItem) +
 387                                                          sizeof(APTR));
 388
 389             DEBUG_ALLOCMENUS(bug("makemenuitem: Text MenuItem\n"));
 390             menuitem->ItemFill = (APTR)it;
 391
 392             it->FrontPen = GetTagData(GTMN_FrontPen, 0, taglist);
 393             it->DrawMode = JAM1;
 394
 395             it->IText    = newmenu->nm_Label;
 396             DEBUG_ALLOCMENUS(bug("makemenuitem: FillName <%s>\n",it->IText));
 397
 398             menuitem->Flags |= ITEMTEXT;
 399
 400             if (newmenu->nm_CommKey && (newmenu->nm_Flags & NM_COMMANDSTRING))
 401             {
 402                 struct IntuiText *it2 = it + 1;
 403
 404                 *it2 = *it;
 405                 it2->IText = newmenu->nm_CommKey;
 406                 it->NextText = it2;
 407             }
 408
 409         } /* if (FALSE == is_image) */
 410         else
 411         {
 412             DEBUG_ALLOCMENUS(bug("makemenuitem: Image MenuItem\n"));
 413             menuitem->Flags &= ~ITEMTEXT;
 414
 415             if (newmenu->nm_Label != NM_BARLABEL)
 416             {
 417                 /*
 418                 ** An image.
 419                 */
 420                 menuitem->ItemFill = (APTR)newmenu->nm_Label;
 421                 DEBUG_ALLOCMENUS(bug("makemenuitem: FillImage 0x%lx\n",menuitem->ItemFill));
 422             }
 423             else
 424             {
 425                 /*
 426                 ** A barlabel image.
 427                 */
 428
 429                 struct TagItem barlabel_tags[] =
 430                 {
 431                     {IA_Left    , ITEXT_EXTRA_LEFT      },
 432                     {IA_Top     , 3                     },
 433                     {IA_Width   , 20                    },
 434                     {IA_Height  , 2                     },
 435                     {TAG_DONE                           }
 436                 };
 437
 438                 menuitem->Flags &= ~ITEMENABLED;
 439
 440                 menuitem->ItemFill = NewObjectA(NULL, MENUBARLABELCLASS, barlabel_tags);
 441
 442                 DEBUG_ALLOCMENUS(bug("makemenuitem: BarImage 0x%lx\n",menuitem->ItemFill));
 443
 444                 if (!menuitem->ItemFill)
 445                 {
 446                     DEBUG_ALLOCMENUS(bug("makemenuitem: barimage failed\n"));
 447                     FreeVec(menuitem);
 448                     menuitem = NULL;
 449                 }
 450             }
 451
 452         } /* is_image */
 453
 454     } /* if (NULL != menuitem) */
 455
 456     return menuitem;
 457 }
 458 #endif
 459
 460 /**************************************************************************************************/
 461
 462 #if !NEWMENUCODE
 463 static void freeitem(struct MenuItem *item, struct GadToolsBase_intern * GadToolsBase)
 464 {
 465     ULONG * p = (ULONG *)item - 1;
 466
 467     DEBUG_FREEMENUS(bug("FreeItem: item %p\n", item));
 468
 469     DEBUG_FREEMENUS(bug("FreeItem: NextItem %p\n", item->NextItem));
 470     DEBUG_FREEMENUS(bug("FreeItem: Left %ld Top %ld Width %ld Height %ld\n", item->LeftEdge,item->TopEdge,item->Width,item->Height));
 471     DEBUG_FREEMENUS(bug("FreeItem: Flags 0x%lx ItemFill 0x%lx SelectFill 0x%lx\n", item->Flags,item->ItemFill,item->SelectFill));
 472     DEBUG_FREEMENUS(bug("FreeItem: Command %lc SubItem 0x%lx NextSelect 0x%lx\n", item->Command,item->SubItem,item->NextSelect));
 473
 474     if (!(item->Flags & ITEMTEXT))
 475     {
 476         struct Image *im = (struct Image *)item->ItemFill;
 477
 478         DEBUG_FREEMENUS(bug("FreeItem: free image\n"));
 479         if (is_menubarlabelclass_image(im, GadToolsBase))
 480         {
 481             DEBUG_FREEMENUS(bug("FreeItem: menubarimage %p\n",im));
 482             DisposeObject(im);
 483         }
 484     }
 485     else
 486     {
 487         struct IntuiText *MyText=(struct IntuiText*) item->ItemFill;
 488         struct IntuiText *MyText2=(struct IntuiText*) item->SelectFill;
 489         if (MyText)
 490         {
 491             DEBUG_FREEMENUS(bug("FreeItem: FillName <%s>\n",MyText->IText));
 492         }
 493         if (MyText2)
 494         {
 495             DEBUG_FREEMENUS(bug("FreeItem: SelectName <%s>\n",MyText2->IText));
 496         }
 497     }
 498
 499     DEBUG_FREEMENUS(bug("FreeItem: freeitem %p size %ld\n", p,*p));
 500
 501     FreeMem(p, *p);
 502     DEBUG_FREEMENUS(bug("FreeItem: done\n"));
 503 }
 504
 505 /**************************************************************************************************/
 506
 507 void freeitems(struct MenuItem * mi, struct GadToolsBase_intern * GadToolsBase)
 508 {
 509     DEBUG_FREEMENUS(bug("FreeItems: MenuItem %p\n",mi));
 510     while (mi)
 511     {
 512         struct MenuItem * _mi = mi->NextItem, *si = mi->SubItem;
 513
 514         DEBUG_FREEMENUS(bug("FreeItems: CurrentItem %p NextItem %p\n",mi,_mi));
 515
 516         DEBUG_FREEMENUS(bug("FreeItems: free SubItems\n"));
 517         while(si)
 518         {
 519             struct MenuItem * _si = si->NextItem;
 520
 521             DEBUG_FREEMENUS(bug("FreeItems: Current SubItem %p Next SubItem %p\n",si,_si));
 522
 523             freeitem(si, GadToolsBase);
 524             si = _si;
 525         }
 526
 527         DEBUG_FREEMENUS(bug("FreeItems: free MenuItem %p\n",mi));
 528
 529         freeitem(mi, GadToolsBase);
 530
 531         mi = _mi;
 532     }
 533     DEBUG_FREEMENUS(bug("FreeItems: done\n"));
 534 }
 535 #endif
 536 /**************************************************************************************************/
 537
 538 static WORD MyIntuiTextLength(struct VisualInfo *vi, struct IntuiText *it,
 539                               struct GadToolsBase_intern * GadToolsBase)
 540 {
 541     WORD width;
 542
 543     if (it->ITextFont)
 544     {
 545         struct IntuiText *it_next = it->NextText;
 546
 547         it->NextText = NULL;
 548         width = IntuiTextLength(it);
 549         it->NextText = it_next;
 550
 551     }
 552     else
 553     {
 554         width = TextLength(&vi->vi_screen->RastPort, it->IText, strlen(it->IText));
 555     }
 556
 557     return width;
 558 }
 559
 560 /**************************************************************************************************/
 561
 562 static ULONG EqualizeItems(struct MenuItem *firstitem, struct MenuItem *lastitem,
 563                            struct Image *amikeyimage, struct VisualInfo *vi,
 564                            struct GadToolsBase_intern * GadToolsBase)
 565 {
 566     struct MenuItem     *item;
 567     struct TextExtent    te;
 568     WORD                 minx = 0, maxwidth = 0, maxrightstuffwidth = 0;
 569
 570     if (!firstitem) return 0;
 571
 572     /* Calc. the max. width of item text/image (+ checkmark image)
 573        Calc. the min. item->LeftEdge */
 574
 575     for(item = firstitem; item && (item != lastitem); item = item->NextItem)
 576     {
 577         if (item->LeftEdge < minx) minx = item->LeftEdge;
 578         if (item->Width > maxwidth) maxwidth = item->Width;
 579     }
 580
 581     /* Calc. the max. width of AmigaKey/CommandString/">>" */
 582
 583     FontExtent(vi->vi_dri->dri_Font, &te);
 584
 585     for(item = firstitem; item && (item != lastitem); item = item->NextItem)
 586     {
 587         WORD width = 0;
 588
 589         if (item->Flags & COMMSEQ)
 590         {
 591             width = te.te_Width;
 592
 593             if (item->Flags & ITEMTEXT)
 594             {
 595                 struct TextFont  *font;
 596                 struct IntuiText *it = (struct IntuiText *)item->ItemFill;
 597
 598                 if (it->ITextFont)
 599                 {
 600                     if ((font = OpenFont(it->ITextFont)))
 601                     {
 602                         struct TextExtent e;
 603
 604                         FontExtent(font, &e);
 605
 606                         width = e.te_Width;
 607                         CloseFont(font);
 608                     }
 609                 }
 610             }
 611
 612             width += amikeyimage->Width +
 613                      AMIGAKEY_KEY_SPACING;
 614
 615         }
 616         else if (item->Flags & ITEMTEXT)
 617         {
 618             struct IntuiText *it = (struct IntuiText *)item->ItemFill;
 619             struct IntuiText *it2;
 620
 621             if ((it2 = it->NextText))
 622             {
 623                 it2->FrontPen = it->FrontPen;
 624                 it2->BackPen  = it->BackPen;
 625                 it2->DrawMode = it->DrawMode;
 626                 it2->TopEdge  = it->TopEdge;
 627
 628                 /* save width also in it->LeftEdge. Will be used below to
 629                    calc. x position */
 630
 631                 width = it2->LeftEdge = MyIntuiTextLength(vi, it2, GadToolsBase);
 632             }
 633         }
 634
 635         if (width > maxrightstuffwidth) maxrightstuffwidth = width;
 636
 637     } /* for(item = firstitem; item; item = item->NextItem) */
 638
 639     /* Calc. x coordinate of command strings and ">>"'s and submenu pos. */
 640
 641     if (maxrightstuffwidth)
 642     {
 643         maxwidth += maxrightstuffwidth + TEXT_AMIGAKEY_SPACING;
 644
 645         for(item = firstitem; item && (item != lastitem); item = item->NextItem)
 646         {
 647             struct MenuItem *subitem;
 648
 649             if (item->Flags & ITEMTEXT)
 650             {
 651                 struct IntuiText *it = (struct IntuiText *)item->ItemFill;
 652
 653                 if ((it = it->NextText))
 654                 {
 655                     /* it->LeftEdge contains the pixel width. see above */
 656
 657                     it->LeftEdge = minx + maxwidth - it->LeftEdge - ITEXT_EXTRA_RIGHT;
 658                 }
 659             }
 660
 661             for(subitem = item->SubItem; subitem; subitem = subitem->NextItem)
 662             {
 663                 subitem->LeftEdge += (maxwidth - maxrightstuffwidth);
 664             }
 665         }
 666
 667     } /* if (maxrightstuffwidth) */
 668
 669     /* Make all items have the same width and set also the width and the
 670        drawinfo of barlabel images */
 671
 672     for(item = firstitem; item && (item != lastitem); item = item->NextItem)
 673     {
 674         item->Width = maxwidth;
 675
 676         if(!(item->Flags & ITEMTEXT))
 677         {
 678             struct Image *im = (struct Image *)item->ItemFill;
 679
 680             if (is_menubarlabelclass_image(im, GadToolsBase))
 681             {
 682                 struct TagItem image_tags [] =
 683                 {
 684                     {IA_Width       , maxwidth - ITEXT_EXTRA_LEFT - ITEXT_EXTRA_RIGHT   },
 685                     {SYSIA_DrawInfo , (IPTR)vi->vi_dri                                  },
 686                     {TAG_DONE                                                           }
 687                 };
 688
 689                 SetAttrsA(im, image_tags);
 690
 691             }
 692         }
 693     }
 694
 695     return (ULONG)maxwidth;
 696 }
 697
 698 /**************************************************************************************************/
 699
 700 BOOL layoutmenuitems(struct MenuItem * firstitem,
 701                      struct VisualInfo * vi,
 702                      struct TagItem * taglist,
 703                      struct GadToolsBase_intern * GadToolsBase)
 704 {
 705     struct Menu         * menu;
 706     struct MenuItem     * menuitem = firstitem;
 707     struct MenuItem     * equalizeitem = firstitem;
 708     struct Image        * amikeyimage, * chkimage;
 709     struct TextExtent   te;
 710     ULONG               curX = 0;
 711     ULONG               curY = 0;
 712     WORD                numcolumns = 1;
 713
 714     amikeyimage = (struct Image *)GetTagData(GTMN_AmigaKey, 0, taglist);
 715     if (!amikeyimage) amikeyimage = vi->vi_dri->dri_AmigaKey;
 716
 717     chkimage = (struct Image *)GetTagData(GTMN_Checkmark, 0, taglist);
 718     if (!chkimage) chkimage = vi->vi_dri->dri_CheckMark;
 719
 720     FontExtent(vi->vi_dri->dri_Font, &te);
 721
 722     while (NULL != menuitem)
 723     {
 724         ULONG addwidth = 0;
 725         ULONG addleft = 0;
 726
 727         menuitem->LeftEdge = curX;
 728         menuitem->TopEdge  = curY;
 729
 730         if (0 != (menuitem->Flags & CHECKIT))
 731         {
 732             /*
 733             ** A checkmark will appear on the left.
 734             */
 735
 736             addleft  += chkimage->Width + CHECKMARK_TEXT_SPACING;
 737             addwidth += chkimage->Width + CHECKMARK_TEXT_SPACING;
 738         }
 739
 740         if (0 != (menuitem->Flags & ITEMTEXT))
 741         {
 742             /*
 743             ** Text
 744             */
 745             struct IntuiText * it = (struct IntuiText *)menuitem->ItemFill;
 746             struct TagItem   * ti;
 747
 748             if (NULL == it)
 749                 return FALSE;
 750
 751             if (NULL != (ti = FindTagItem(GTMN_FrontPen, taglist)))
 752             {
 753                 it->FrontPen = ti->ti_Data;
 754             }
 755             else
 756             {
 757                 it->FrontPen = vi->vi_dri->dri_Pens[BARDETAILPEN];
 758             }
 759
 760             it->ITextFont = (struct TextAttr *)GetTagData(GTMN_TextAttr,
 761                                                           0,
 762                                                           taglist);
 763
 764             it->LeftEdge = ITEXT_EXTRA_LEFT + addleft;
 765             it->TopEdge = ITEXT_EXTRA_TOP;
 766
 767             menuitem->Width = MyIntuiTextLength(vi, it, GadToolsBase) +
 768                               addwidth + ITEXT_EXTRA_LEFT + ITEXT_EXTRA_RIGHT;
 769
 770            /*
 771             ** Calculate the height menu item.
 772             */
 773             if (NULL == it->ITextFont)
 774             {
 775                 /*
 776                 ** No font is provided, so I will work with the screen font.
 777                 */
 778                 menuitem->Height = vi->vi_dri->dri_Font->tf_YSize + ITEXT_EXTRA_TOP + ITEXT_EXTRA_BOTTOM;
 779             }
 780             else
 781             {
 782                 struct TextFont * font;
 783
 784                 if (NULL != (font = OpenFont(it->ITextFont)))
 785                 {
 786                     menuitem->Height = font->tf_YSize + ITEXT_EXTRA_TOP + ITEXT_EXTRA_BOTTOM;
 787                     CloseFont(font);
 788                 }
 789                 else
 790                     return FALSE;
 791             }
 792
 793         } /* if (0 != (menuitem->Flags & ITEMTEXT)) */
 794         else
 795         {
 796             /*
 797             ** Image
 798             */
 799             struct Image * im = (struct Image *)menuitem->ItemFill;
 800
 801             if (NULL == im) return FALSE;
 802
 803             if (is_menubarlabelclass_image(im, GadToolsBase))
 804             {
 805                 menuitem->Width = 10;
 806                 menuitem->Height = 7;
 807
 808             }
 809             else
 810             {
 811
 812                 menuitem->Width  = im->Width + addwidth + IMAGE_EXTRA_LEFT + IMAGE_EXTRA_RIGHT;
 813                 menuitem->Height = im->Height + IMAGE_EXTRA_TOP + IMAGE_EXTRA_BOTTOM;
 814                 im->LeftEdge = IMAGE_EXTRA_LEFT + addleft;
 815                 im->TopEdge = IMAGE_EXTRA_TOP;
 816             }
 817
 818         } /* if (0 != (menuitem->Flags & ITEMTEXT)) else ... */
 819
 820         curY += menuitem->Height;
 821
 822         /*
 823         ** In case this menu becomes too high it will have more columns.
 824         */
 825
 826         if (curY > vi->vi_screen->Height)
 827         {
 828             ULONG width;
 829
 830             width = EqualizeItems(equalizeitem, menuitem, amikeyimage, vi, GadToolsBase);
 831             equalizeitem = menuitem;
 832
 833             curY = 0;
 834             curX += width + MENU_COLUMN_SPACING;
 835             menuitem->LeftEdge = curX;
 836             menuitem->TopEdge  = curY;
 837
 838             curY += menuitem->Height;
 839
 840             numcolumns++;
 841         }
 842
 843         /*
 844         ** Process the next menu item
 845         */
 846         menuitem = menuitem->NextItem;
 847
 848     } /* while (NULL != menuitem) */
 849
 850     EqualizeItems(equalizeitem, NULL, amikeyimage, vi, GadToolsBase);
 851
 852     menu = (struct Menu *)GetTagData(GTMN_Menu, 0, taglist);
 853     if (menu && (menu->FirstItem == firstitem))
 854     {
 855         /* Make sure the menu box is at least as large as the menu title,
 856            otherwise it looks ugly */
 857
 858         WORD menuwidth, minx, maxx, titlewidth, prevy = -1, col = 1;
 859
 860         minx = 32767;
 861         maxx = -32768;
 862
 863         for(menuitem = firstitem; menuitem; menuitem = menuitem->NextItem)
 864         {
 865             if (menuitem->LeftEdge < minx) minx = menuitem->LeftEdge;
 866             if (menuitem->LeftEdge + menuitem->Width - 1 > maxx) maxx = menuitem->LeftEdge + menuitem->Width - 1;
 867         }
 868
 869         menuwidth = maxx - minx + 1;
 870         titlewidth = TextLength(&vi->vi_screen->RastPort, menu->MenuName, strlen(menu->MenuName));
 871
 872         if (titlewidth > menuwidth)
 873         {
 874             WORD extrawidth = (titlewidth - menuwidth + numcolumns / 2) / numcolumns;
 875
 876             for(menuitem = firstitem; menuitem; menuitem = menuitem->NextItem)
 877             {
 878                 struct MenuItem *subitem;
 879
 880                 if (menuitem->TopEdge < prevy) col++;
 881                 prevy = menuitem->TopEdge;
 882
 883                 menuitem->LeftEdge += (col - 1) * extrawidth;
 884                 menuitem->Width += extrawidth;
 885
 886                 if (menuitem->Flags & ITEMTEXT)
 887                 {
 888                     struct IntuiText *it = (struct IntuiText *)menuitem->ItemFill;
 889
 890                     if ((it = it->NextText))
 891                     {
 892                         it->LeftEdge += extrawidth;
 893                     }
 894                 }
 895                 else
 896                 {
 897                     struct Image *im = (struct Image *)menuitem->ItemFill;
 898
 899                     if (is_menubarlabelclass_image(im, GadToolsBase))
 900                     {
 901                         im->Width += extrawidth;
 902                     }
 903                 }
 904
 905                 if ((subitem = menuitem->SubItem))
 906                 {
 907                     while(subitem)
 908                     {
 909                         subitem->LeftEdge += extrawidth;
 910                         subitem = subitem->NextItem;
 911                     }
 912                 }
 913
 914             } /* for(menuitem = firstitem; menuitem; menuitem = menuitem->NextItem) */
 915
 916         } /* if (titlewidth > menuwidth) */
 917
 918     } /* if (menu && (menu->FirstItem == firstitem)) */
 919
 920
 921     return TRUE;
 922 }
 923
 924 /**************************************************************************************************/
 925
 926 BOOL layoutsubitems(struct MenuItem * motheritem,
 927                     struct VisualInfo * vi,
 928                     struct TagItem * taglist,
 929                     struct GadToolsBase_intern * GadToolsBase)
 930 {
 931     struct MenuItem * menuitem = motheritem->SubItem;
 932
 933     layoutmenuitems(menuitem, vi, taglist, GadToolsBase);
 934
 935     return TRUE;
 936 }
 937
 938 /**************************************************************************************************/