workbench/libs/muimaster/menu.c

   1 /*
   2     Copyright © 2002-2011, The AROS Development Team.
   3     All rights reserved.
   4
   5     $Id$
   6 */
   7
   8 #include <string.h>
   9
  10 #include <graphics/gfxmacros.h>
  11 #include <intuition/imageclass.h>
  12 #include <clib/alib_protos.h>
  13 #include <proto/exec.h>
  14 #include <proto/intuition.h>
  15 #include <proto/gadtools.h>
  16 #include <proto/graphics.h>
  17 #include <proto/layers.h>
  18
  19 #include "muimaster_intern.h"
  20
  21 extern struct Library *MUIMasterBase;
  22
  23 /**************************************************************************
  24  The following stuff is taken from AROS's intuition. Maybe if this go to
  25  the public somewhere we don't need this in the AROS version
  26 **************************************************************************/
  27
  28 #define min(a,b) (((a) < (b)) ? (a) : (b))
  29 #define max(a,b) (((a) > (b)) ? (a) : (b))
  30
  31 void GetMenuBox(struct Window *win, struct MenuItem *item,
  32     WORD *xmin, WORD *ymin, WORD *xmax, WORD *ymax)
  33 {
  34
  35     WORD left, right, top, bottom;
  36
  37     left = top = 0x7fff;
  38     right = bottom = -0x7fff;
  39
  40     while (item != NULL)
  41     {
  42         left = min(left, item->LeftEdge);
  43         top = min(top, item->TopEdge);
  44         right = max(right, item->LeftEdge + item->Width - 1);
  45         bottom = max(bottom, item->TopEdge + item->Height - 1);
  46
  47         item = item->NextItem;
  48     }
  49
  50     if (xmin)
  51         *xmin = left - win->WScreen->MenuHBorder;
  52     if (ymin)
  53         *ymin = top - win->WScreen->MenuVBorder;
  54     if (xmax)
  55         *xmax = right + win->WScreen->MenuHBorder;
  56     if (ymax)
  57         *ymax = bottom + win->WScreen->MenuVBorder;
  58
  59 }
  60
  61 void CalculateDims(struct Window *win, struct Menu *menu)
  62 {
  63     struct MenuItem *item;
  64
  65     while (menu != NULL)
  66     {
  67         item = menu->FirstItem;
  68
  69         GetMenuBox(win, item, &menu->JazzX, &menu->JazzY, &menu->BeatX,
  70             &menu->BeatY);
  71
  72         menu = menu->NextMenu;
  73     }
  74 }
  75
  76 /* Mark items that has subitems. This is necessary for the input handler
  77    code. It's not possible to check item->SubItem within it as we save
  78    the layer coordinates there. */
  79 void Characterize(struct Menu *menu)
  80 {
  81     while (menu != NULL)
  82     {
  83         struct MenuItem *item;
  84
  85         item = menu->FirstItem;
  86
  87         while (item != NULL)
  88         {
  89 //          if(item->SubItem != NULL)
  90 //              item->Flags |= HASSUBITEM;
  91
  92             item = item->NextItem;
  93         }
  94
  95         menu = menu->NextMenu;
  96     }
  97 }
  98
  99 #define MENUS_UNDERMOUSE 1
 100 #define MENUS_AMIGALOOK 1
 101
 102 /** BEGIN AROS **/
 103
 104 #define ITEM_ITEM    1
 105 #define ITEM_SUBITEM 2
 106
 107 #define AMIGAKEY_KEY_SPACING     4      /* GadTools assumes this, too */
 108 #define AMIGAKEY_BORDER_SPACING  2
 109
 110 struct MenuHandlerData
 111 {
 112     struct Window *win;
 113     struct Screen *scr;
 114     struct DrawInfo *dri;
 115     struct Window *menubarwin;
 116     struct Window *menuwin;
 117     struct Window *submenuwin;
 118     struct Menu *menu;
 119     struct Menu *activemenu;
 120     struct MenuItem *activeitem;
 121     struct MenuItem *activesubitem;
 122     struct Rectangle submenubox;
 123     struct Image *checkmark;
 124     struct Image *amigakey;
 125     WORD menubarwidth;
 126     WORD menubarheight;
 127     WORD menubaritemwidth;
 128     WORD menubaritemheight;
 129     WORD nummenubaritems;
 130     WORD activemenunum;
 131     WORD activeitemnum;
 132     WORD activesubitemnum;
 133     WORD maxcommkeywidth_menu;
 134     WORD maxcommkeywidth_submenu;
 135     WORD scrmousex;
 136     WORD scrmousey;
 137     UWORD firstmenupick;
 138     UWORD lastmenupick;
 139     BOOL active;
 140 };
 141
 142 /* this #defines are taken from workbench/libs/gadtools/menus.c!! */
 143
 144 #define TEXT_AMIGAKEY_SPACING  6
 145
 146 #define ITEXT_EXTRA_LEFT   2
 147 #define ITEXT_EXTRA_RIGHT  2
 148 #define ITEXT_EXTRA_TOP    1
 149 #define ITEXT_EXTRA_BOTTOM 1
 150
 151 static const char subitemindicator[] = "»";
 152
 153
 154 static void HandleMouseMove(struct MenuHandlerData *mhd);
 155 static void HandleMouseClick(struct MenuHandlerData *mhd, int menuup);
 156 static void HandleCheckItem(struct Window *win, struct MenuItem *item,
 157     WORD itemnum, struct MenuHandlerData *mhd);
 158
 159 static void HighlightMenuTitle(struct Menu *menu,
 160     struct MenuHandlerData *mhd);
 161
 162 static struct Menu *FindMenu(WORD *var, struct MenuHandlerData *mhd);
 163 static struct MenuItem *FindItem(WORD *var, struct MenuHandlerData *mhd);
 164 static struct MenuItem *FindSubItem(WORD *var,
 165     struct MenuHandlerData *mhd);
 166
 167 static void MakeMenuBarWin(struct MenuHandlerData *mhd);
 168 static void KillMenuBarWin(struct MenuHandlerData *mhd);
 169 static void RenderMenuBar(struct MenuHandlerData *mhd);
 170
 171 static void MakeMenuWin(struct MenuHandlerData *mhd);
 172 static void KillMenuWin(struct MenuHandlerData *mhd);
 173 static void RenderMenu(struct MenuHandlerData *mhd);
 174 static void RenderMenuTitle(struct Menu *menu, struct MenuHandlerData *mhd);
 175
 176 static void MakeSubMenuWin(struct MenuHandlerData *mhd);
 177 static void KillSubMenuWin(struct MenuHandlerData *mhd);
 178 static void RenderSubMenu(struct MenuHandlerData *mhd);
 179
 180 static void RenderItem(struct MenuItem *item, WORD itemtype,
 181     struct Rectangle *box, struct MenuHandlerData *mhd);
 182
 183 static void RenderMenuBG(struct Window *win, struct MenuHandlerData *mhd);
 184 static void RenderCheckMark(struct MenuItem *item, WORD itemtype,
 185     struct MenuHandlerData *mhd);
 186 static void RenderAmigaKey(struct MenuItem *item, WORD itemtype,
 187     struct MenuHandlerData *mhd);
 188 static void RenderDisabledPattern(struct RastPort *rp, WORD x1, WORD y1,
 189     WORD x2, WORD y2, struct MenuHandlerData *mhd);
 190 #if 0
 191 static void RenderFrame(struct RastPort *rp, WORD x1, WORD y1, WORD x2,
 192     WORD y2, WORD state, struct MenuHandlerData *mhd);
 193 #endif
 194 static void HighlightItem(struct MenuItem *item, WORD itemtype,
 195     struct MenuHandlerData *mhd);
 196 static WORD CalcMaxCommKeyWidth(struct Window *win,
 197     struct MenuHandlerData *mhd);
 198 static void AddToSelection(struct MenuHandlerData *mhd);
 199
 200
 201
 202 static void HandleMouseMove(struct MenuHandlerData *mhd)
 203 {
 204     struct Layer *lay;
 205     struct Window *win = NULL;
 206     struct Menu *menu;
 207     struct MenuItem *item;
 208
 209     WORD new_activemenunum = mhd->activemenunum;
 210     WORD new_activeitemnum = mhd->activeitemnum;
 211     WORD new_activesubitemnum = mhd->activesubitemnum;
 212
 213     mhd->scrmousex = mhd->scr->MouseX;
 214     mhd->scrmousey = mhd->scr->MouseY;
 215
 216     LockLayerInfo(&mhd->scr->LayerInfo);
 217     lay = WhichLayer(&mhd->scr->LayerInfo, mhd->scrmousex, mhd->scrmousey);
 218     UnlockLayerInfo(&mhd->scr->LayerInfo);
 219
 220     if (lay)
 221     {
 222         win = (struct Window *)lay->Window;
 223
 224         if (win && (win == mhd->submenuwin))
 225         {
 226             /* Mouse over submenu box */
 227             item = FindSubItem(&new_activesubitemnum, mhd);
 228
 229             if (new_activesubitemnum != mhd->activesubitemnum)
 230             {
 231                 if (mhd->activesubitemnum != -1)
 232                 {
 233                     HighlightItem(mhd->activesubitem, ITEM_SUBITEM, mhd);
 234                 }
 235
 236                 mhd->activesubitemnum = new_activesubitemnum;
 237                 mhd->activesubitem = item;
 238
 239                 if (item)
 240                 {
 241                     HighlightItem(mhd->activesubitem, ITEM_SUBITEM, mhd);
 242                 }
 243             }
 244
 245         }
 246         else if (win && (win == mhd->menuwin))
 247         {
 248             item = FindItem(&new_activeitemnum, mhd);
 249
 250             if (new_activeitemnum != mhd->activeitemnum)
 251             {
 252                 if (mhd->activeitemnum != -1)
 253                 {
 254                     HighlightItem(mhd->activeitem, ITEM_ITEM, mhd);
 255                     KillSubMenuWin(mhd);
 256                 }
 257
 258                 mhd->activeitemnum = new_activeitemnum;
 259                 mhd->activeitem = item;
 260
 261                 if (item)
 262                 {
 263                     HighlightItem(mhd->activeitem, ITEM_ITEM, mhd);
 264
 265                     if (item->SubItem)
 266                     {
 267                         MakeSubMenuWin(mhd);
 268                     }
 269                 }
 270             }
 271         }
 272         else if (win && (win == mhd->menubarwin))
 273         {
 274             /* Mouse over menu box */
 275
 276             menu = FindMenu(&new_activemenunum, mhd);
 277
 278             if (new_activemenunum != mhd->activemenunum)
 279             {
 280                 if (mhd->activemenunum != -1)
 281                 {
 282                     HighlightMenuTitle(mhd->activemenu, mhd);
 283                     KillMenuWin(mhd);
 284                     KillSubMenuWin(mhd);
 285                 }
 286
 287                 mhd->activemenunum = new_activemenunum;
 288                 mhd->activemenu = menu;
 289
 290                 if (menu)
 291                 {
 292                     HighlightMenuTitle(mhd->activemenu, mhd);
 293                     MakeMenuWin(mhd);
 294                 }
 295             }
 296
 297             if ((mhd->activeitemnum != -1) && (!mhd->submenuwin))
 298             {
 299                 HighlightItem(mhd->activeitem, ITEM_ITEM, mhd);
 300                 mhd->activeitemnum = -1;
 301                 mhd->activeitem = NULL;
 302             }
 303         }
 304         else
 305         {
 306             win = NULL;
 307         }
 308     }
 309
 310     if (!win)
 311     {
 312         /* mouse outside any menu window */
 313
 314         if ((mhd->activeitemnum != -1) && (!mhd->submenuwin))
 315         {
 316             HighlightItem(mhd->activeitem, ITEM_ITEM, mhd);
 317             mhd->activeitemnum = -1;
 318             mhd->activeitem = NULL;
 319         }
 320         else if (mhd->activesubitemnum != -1)
 321         {
 322             HighlightItem(mhd->activesubitem, ITEM_SUBITEM, mhd);
 323             mhd->activesubitemnum = -1;
 324             mhd->activesubitem = NULL;
 325         }
 326     }
 327
 328 }
 329
 330
 331 static void HandleMouseClick(struct MenuHandlerData *mhd, int menuup)
 332 {
 333     struct Layer *lay;
 334
 335     LockLayerInfo(&mhd->scr->LayerInfo);
 336     lay = WhichLayer(&mhd->scr->LayerInfo, mhd->scrmousex, mhd->scrmousey);
 337     UnlockLayerInfo(&mhd->scr->LayerInfo);
 338
 339     if (lay)
 340     {
 341         struct Window *win = (struct Window *)lay->Window;
 342         struct MenuItem *item = NULL;
 343         WORD itemnum = 0;
 344
 345         win = (struct Window *)lay->Window;
 346
 347         if (win && (win == mhd->submenuwin)
 348             && (mhd->activesubitemnum != -1))
 349         {
 350             item = mhd->activesubitem;
 351         }
 352         else if (win && (win == mhd->menuwin) && (mhd->activeitemnum != -1))
 353         {
 354             item = mhd->activeitem;
 355         }
 356
 357         if (item)
 358             if (item->Flags & CHECKIT)
 359             {
 360                 HandleCheckItem(win, item, itemnum, mhd);
 361             }
 362
 363         AddToSelection(mhd);
 364     }
 365 }
 366
 367
 368 static void HandleCheckItem(struct Window *win, struct MenuItem *item,
 369     WORD itemnum, struct MenuHandlerData *mhd)
 370 {
 371     /* Note: If you change something here, you probably must also change
 372        menus.c/CheckMenuItemWasClicked() which is used when the
 373        user uses the menu key shortcuts! */
 374
 375     WORD itemtype = ((win == mhd->menuwin) ? ITEM_ITEM : ITEM_SUBITEM);
 376
 377     BOOL re_render = FALSE;
 378
 379     if (item->Flags & MENUTOGGLE)
 380     {
 381         item->Flags ^= CHECKED;
 382         re_render = TRUE;
 383     }
 384     else
 385     {
 386         if (!(item->Flags & CHECKED))
 387         {
 388             item->Flags |= CHECKED;
 389             re_render = TRUE;
 390         }
 391     }
 392
 393     if (re_render)
 394     {
 395         BOOL toggle_hi = FALSE;
 396
 397         if ((item->Flags & HIGHITEM) &&
 398             ((item->Flags & HIGHFLAGS) == HIGHCOMP))
 399             toggle_hi = TRUE;
 400
 401         if (toggle_hi)
 402             HighlightItem(item, itemtype, mhd);
 403         RenderCheckMark(item, itemtype, mhd);
 404         if (toggle_hi)
 405             HighlightItem(item, itemtype, mhd);
 406
 407     }
 408
 409     if (item->MutualExclude)
 410     {
 411         struct MenuItem *checkitem =
 412             (itemtype ==
 413             ITEM_ITEM) ? mhd->activemenu->FirstItem : mhd->activeitem->
 414             SubItem;
 415         BOOL toggle_hi = FALSE;
 416         WORD i;
 417
 418         if ((item->Flags & HIGHITEM) &&
 419             ((item->Flags & HIGHFLAGS) == HIGHBOX))
 420             toggle_hi = TRUE;
 421
 422         if (toggle_hi)
 423             HighlightItem(item, itemtype, mhd);
 424
 425         for (i = 0; (i < 32) && checkitem;
 426             i++, checkitem = checkitem->NextItem)
 427         {
 428             if ((i != itemnum) && (item->MutualExclude & (1L << i)) &&
 429                 ((checkitem->Flags & (CHECKED | CHECKIT)) ==
 430                     (CHECKIT | CHECKED)))
 431             {
 432                 checkitem->Flags &= ~CHECKED;
 433                 RenderCheckMark(checkitem, itemtype, mhd);
 434             }
 435         }
 436
 437         if (toggle_hi)
 438             HighlightItem(item, itemtype, mhd);
 439     }
 440 }
 441
 442
 443 static void HighlightMenuTitle(struct Menu *menu,
 444     struct MenuHandlerData *mhd)
 445 {
 446     if (menu->Flags & MENUENABLED)
 447     {
 448         struct RastPort *rp = mhd->menubarwin->RPort;
 449
 450 #if MENUS_UNDERMOUSE
 451         struct Menu *m = mhd->menu;
 452         WORD x1 = mhd->scr->MenuHBorder;
 453         WORD x2 = x1 + mhd->menubaritemwidth - 1;
 454         WORD y1, y2, i;
 455
 456         for (i = 0; m != menu; m = m->NextMenu)
 457             i++;
 458
 459         y1 = mhd->scr->MenuVBorder + i * mhd->menubaritemheight;
 460         y2 = y1 + mhd->menubaritemheight - 1;
 461
 462 #else
 463         WORD x1 =
 464             menu->LeftEdge + mhd->scr->BarHBorder - mhd->scr->MenuHBorder;
 465         WORD y1 = 0;
 466         WORD x2 = x1 + menu->Width - 1;
 467         WORD y2 = mhd->scr->BarHeight - 1;
 468 #endif
 469
 470 #if MENUS_AMIGALOOK
 471         SetDrMd(rp, COMPLEMENT);
 472         RectFill(rp, x1, y1, x2, y2);
 473 #else
 474         menu->Flags ^= HIGHITEM;
 475
 476 #if !MENUS_UNDERMOUSE
 477         y1++;
 478 #endif
 479
 480         SetDrMd(rp, JAM1);
 481         SetAPen(rp,
 482             mhd->dri->dri_Pens[(menu->
 483                     Flags & HIGHITEM) ? FILLPEN : BACKGROUNDPEN]);
 484         RectFill(rp, x1, y1, x2, y2);
 485
 486         RenderMenuTitle(menu, mhd);
 487
 488         if (menu->Flags & HIGHITEM)
 489         {
 490 #if MENUS_UNDERMOUSE
 491             RenderFrame(rp, x1, y1, x2, y2, IDS_SELECTED, mhd);
 492 #else
 493             SetAPen(rp, mhd->dri->dri_Pens[SHINEPEN]);
 494             RectFill(rp, x1, y1, x1, y2);
 495             SetAPen(rp, mhd->dri->dri_Pens[SHADOWPEN]);
 496             RectFill(rp, x2, y1, x2, y2);
 497 #endif
 498         }
 499
 500
 501 #endif /* MENUS_AMIGALOOK */
 502     }
 503 }
 504
 505
 506 static struct Menu *FindMenu(WORD *var, struct MenuHandlerData *mhd)
 507 {
 508     struct Menu *menu;
 509     WORD mouse_x, mouse_y, i;
 510
 511     mouse_x = mhd->scrmousex - mhd->menubarwin->LeftEdge;
 512     mouse_y = mhd->scrmousey - mhd->menubarwin->TopEdge;
 513
 514 #if MENUS_UNDERMOUSE
 515     menu = NULL;
 516
 517     mouse_x -= mhd->scr->MenuHBorder;
 518     mouse_y -= mhd->scr->MenuVBorder;
 519
 520     if ((mouse_x >= 0) && (mouse_x < mhd->menubaritemwidth)
 521         && (mouse_y >= 0))
 522     {
 523         i = mouse_y / mhd->menubaritemheight;
 524
 525         if ((i >= 0) && (i < mhd->nummenubaritems))
 526         {
 527             WORD i2 = i;
 528
 529             menu = mhd->menu;
 530             while (i && menu)
 531             {
 532                 i--;
 533                 menu = menu->NextMenu;
 534             }
 535
 536             if (menu && (i == 0))
 537             {
 538                 *var = i2;
 539             }
 540         }
 541     }
 542 #else
 543     for (menu = mhd->menu, i = 0; menu; menu = menu->NextMenu, i++)
 544     {
 545         if ((mouse_x >= menu->LeftEdge) &&
 546             (mouse_x < menu->LeftEdge + menu->Width) &&
 547             (mouse_y >= 0) && (mouse_y <= mhd->scr->BarHeight))
 548         {
 549             *var = i;
 550             break;
 551         }
 552     }
 553 #endif
 554
 555     return menu;
 556 }
 557
 558
 559 static struct MenuItem *FindItem(WORD *var, struct MenuHandlerData *mhd)
 560 {
 561     struct MenuItem *item = NULL;
 562     WORD mouse_x, mouse_y, i;
 563
 564     if (mhd->menuwin)
 565     {
 566         mouse_x =
 567             mhd->scrmousex - mhd->menuwin->LeftEdge +
 568             mhd->activemenu->JazzX;
 569         mouse_y =
 570             mhd->scrmousey - mhd->menuwin->TopEdge + mhd->activemenu->JazzY;
 571
 572         for (item = mhd->activemenu->FirstItem, i = 0; item;
 573             item = item->NextItem, i++)
 574         {
 575             if ((mouse_x >= item->LeftEdge) &&
 576                 (mouse_x < item->LeftEdge + item->Width) &&
 577                 (mouse_y >= item->TopEdge) &&
 578                 (mouse_y < item->TopEdge + item->Height))
 579             {
 580                 *var = i;
 581                 break;
 582             }
 583         }
 584     }
 585
 586     if ((item == NULL) && !mhd->submenuwin)
 587         *var = -1;
 588
 589     return item;
 590 }
 591
 592
 593 static struct MenuItem *FindSubItem(WORD *var, struct MenuHandlerData *mhd)
 594 {
 595     struct MenuItem *item = NULL;
 596     WORD mouse_x, mouse_y, i;
 597
 598     if (mhd->submenuwin)
 599     {
 600         mouse_x =
 601             mhd->scrmousex - mhd->submenuwin->LeftEdge +
 602             mhd->submenubox.MinX;
 603         mouse_y =
 604             mhd->scrmousey - mhd->submenuwin->TopEdge +
 605             mhd->submenubox.MinY;
 606
 607         *var = -1;
 608
 609         for (item = mhd->activeitem->SubItem, i = 0; item;
 610             item = item->NextItem, i++)
 611         {
 612             if ((mouse_x >= item->LeftEdge) &&
 613                 (mouse_x < item->LeftEdge + item->Width) &&
 614                 (mouse_y >= item->TopEdge) &&
 615                 (mouse_y < item->TopEdge + item->Height))
 616             {
 617                 *var = i;
 618                 break;
 619             }
 620         }
 621
 622     }
 623
 624     return item;
 625 }
 626
 627
 628 static void MakeMenuBarWin(struct MenuHandlerData *mhd)
 629 {
 630     struct TagItem win_tags[9];
 631     struct Menu *menu;
 632
 633 #if MENUS_UNDERMOUSE
 634     WORD w, maxw = 0;
 635 #endif
 636
 637     win_tags[0].ti_Tag = WA_Left;
 638     win_tags[0].ti_Data = 0;
 639     win_tags[1].ti_Tag = WA_Top;
 640     win_tags[1].ti_Data = 0;
 641     win_tags[2].ti_Tag = WA_Width;
 642     win_tags[2].ti_Data = mhd->scr->Width;
 643     win_tags[3].ti_Tag = WA_Height;
 644     win_tags[3].ti_Data = mhd->scr->BarHeight + 1;
 645     win_tags[4].ti_Tag = WA_AutoAdjust;
 646     win_tags[4].ti_Data = TRUE;
 647     win_tags[5].ti_Tag = WA_Borderless;
 648     win_tags[5].ti_Data = TRUE;
 649     win_tags[6].ti_Tag = WA_CustomScreen;
 650     win_tags[6].ti_Data = (IPTR) mhd->scr;
 651     win_tags[7].ti_Tag = WA_BackFill;
 652     win_tags[7].ti_Tag = (IPTR) LAYERS_NOBACKFILL;
 653     win_tags[8].ti_Tag = TAG_DONE;
 654
 655 #if MENUS_UNDERMOUSE
 656
 657     mhd->nummenubaritems = 0;
 658     for (menu = mhd->menu; menu; menu = menu->NextMenu)
 659     {
 660         w = TextLength(&mhd->scr->RastPort, menu->MenuName,
 661             strlen(menu->MenuName));
 662         if (w > maxw)
 663             maxw = w;
 664         mhd->nummenubaritems++;
 665     }
 666
 667     mhd->menubaritemwidth =
 668         maxw + TextLength(&mhd->scr->RastPort, subitemindicator,
 669         1) + TEXT_AMIGAKEY_SPACING + ITEXT_EXTRA_LEFT + ITEXT_EXTRA_RIGHT;
 670
 671     mhd->menubaritemheight =
 672         mhd->scr->RastPort.TxHeight + ITEXT_EXTRA_TOP + ITEXT_EXTRA_BOTTOM;
 673
 674     win_tags[2].ti_Data = mhd->menubaritemwidth + mhd->scr->MenuHBorder * 2;
 675     win_tags[3].ti_Data =
 676         mhd->menubaritemheight * mhd->nummenubaritems +
 677         mhd->scr->MenuVBorder * 2;
 678     win_tags[0].ti_Data = mhd->scr->MouseX - win_tags[2].ti_Data / 2;
 679     win_tags[1].ti_Data = mhd->scr->MouseY;
 680
 681 #endif
 682
 683     mhd->menubarwin = OpenWindowTagList(0, win_tags);
 684
 685     for (menu = mhd->menu; menu; menu = menu->NextMenu)
 686     {
 687         menu->Flags &= ~HIGHITEM;
 688     }
 689
 690     RenderMenuBar(mhd);
 691 }
 692
 693
 694 static void KillMenuBarWin(struct MenuHandlerData *mhd)
 695 {
 696     if (mhd->menubarwin)
 697     {
 698         CloseWindow(mhd->menubarwin);
 699         mhd->menubarwin = NULL;
 700     }
 701 }
 702
 703
 704 static void RenderMenuBar(struct MenuHandlerData *mhd)
 705 {
 706     if (mhd->menubarwin)
 707     {
 708         struct Menu *menu = mhd->menu;
 709         struct RastPort *rp = mhd->menubarwin->RPort;
 710
 711         SetFont(rp, mhd->dri->dri_Font);
 712
 713 #if MENUS_UNDERMOUSE
 714
 715         RenderMenuBG(mhd->menubarwin, mhd);
 716
 717 #else
 718
 719 #if MENUS_AMIGALOOK
 720         SetABPenDrMd(rp, mhd->dri->dri_Pens[BARBLOCKPEN], 0, JAM1);
 721 #else
 722         SetABPenDrMd(rp, mhd->dri->dri_Pens[BACKGROUNDPEN], 0, JAM1);
 723 #endif
 724         RectFill(rp, 0, 0, mhd->menubarwin->Width - 1,
 725             mhd->menubarwin->Height - 2);
 726         SetAPen(rp, mhd->dri->dri_Pens[BARTRIMPEN]);
 727         RectFill(rp, 0, mhd->menubarwin->Height - 1,
 728             mhd->menubarwin->Width - 1, mhd->menubarwin->Height - 1);
 729
 730 #if !MENUS_AMIGALOOK
 731         SetAPen(rp, mhd->dri->dri_Pens[SHINEPEN]);
 732         RectFill(rp, 0, 0, 0, mhd->menubarwin->Height - 2);
 733         RectFill(rp, 1, 0, mhd->menubarwin->Width - 1, 0);
 734         SetAPen(rp, mhd->dri->dri_Pens[SHADOWPEN]);
 735         RectFill(rp, mhd->menubarwin->Width - 1, 1,
 736             mhd->menubarwin->Width - 1, mhd->menubarwin->Height - 2);
 737
 738 #endif
 739
 740 #endif
 741
 742         for (; menu; menu = menu->NextMenu)
 743         {
 744             RenderMenuTitle(menu, mhd);
 745         }
 746     }
 747 }
 748
 749
 750 static void RenderMenuTitle(struct Menu *menu, struct MenuHandlerData *mhd)
 751 {
 752     struct RastPort *rp = mhd->menubarwin->RPort;
 753     WORD len = strlen(menu->MenuName);
 754
 755 #if MENUS_UNDERMOUSE
 756     struct Menu *m;
 757     WORD x, y, yoff;
 758
 759     yoff = 0;
 760     for (m = mhd->menu; m && (m != menu); m = m->NextMenu)
 761     {
 762         yoff++;
 763     }
 764
 765     x = mhd->scr->MenuHBorder + ITEXT_EXTRA_LEFT;
 766     y = mhd->scr->MenuVBorder + ITEXT_EXTRA_TOP +
 767         yoff * mhd->menubaritemheight;
 768 #else
 769     WORD x = mhd->scr->BarHBorder + menu->LeftEdge;
 770     WORD y = mhd->scr->BarVBorder;
 771 #endif
 772
 773 #if MENUS_AMIGALOOK
 774     SetAPen(rp, mhd->dri->dri_Pens[BARDETAILPEN]);
 775 #else
 776     SetAPen(rp,
 777         mhd->dri->dri_Pens[(menu->
 778                 Flags & HIGHITEM) ? FILLTEXTPEN : TEXTPEN]);
 779 #endif
 780
 781     Move(rp, x, y + rp->TxBaseline);
 782     Text(rp, menu->MenuName, len);
 783
 784 #if MENUS_UNDERMOUSE
 785     if (menu->FirstItem)
 786     {
 787         WORD silen = TextLength(rp, subitemindicator, 1);
 788         WORD x2 =
 789             mhd->scr->MenuHBorder + mhd->menubaritemwidth -
 790             ITEXT_EXTRA_RIGHT - silen;
 791
 792         Move(rp, x2, y + rp->TxBaseline);
 793         Text(rp, subitemindicator, 1);
 794     }
 795 #endif
 796
 797     if (!(menu->Flags & MENUENABLED))
 798     {
 799 #if MENUS_UNDERMOUSE
 800         WORD x2 = mhd->scr->MenuHBorder + mhd->menubaritemwidth - 1;
 801 #else
 802         WORD x2 = x + TextLength(rp, menu->MenuName, len) - 1;
 803 #endif
 804         WORD y2 = y + rp->TxHeight - 1;
 805
 806         RenderDisabledPattern(rp, x, y, x2, y2, mhd);
 807     }
 808 }
 809
 810
 811 static void MakeMenuWin(struct MenuHandlerData *mhd)
 812 {
 813     struct MenuItem *item;
 814
 815     WORD width = mhd->activemenu->BeatX - mhd->activemenu->JazzX + 1;
 816     WORD height = mhd->activemenu->BeatY - mhd->activemenu->JazzY + 1;
 817 #if MENUS_UNDERMOUSE
 818     WORD xpos = mhd->menubarwin->LeftEdge + mhd->menubarwin->Width - 16;
 819     WORD ypos = mhd->menubarwin->TopEdge;
 820 #else
 821     WORD xpos =
 822         mhd->activemenu->LeftEdge + mhd->scr->BarHBorder +
 823         mhd->activemenu->JazzX;
 824
 825 #if MENUS_AMIGALOOK
 826     WORD ypos = mhd->scr->BarHeight + 1 + mhd->activemenu->JazzY;
 827 #else
 828     WORD ypos = mhd->scr->BarHeight + 1;
 829 #endif
 830
 831 #endif
 832
 833     struct TagItem win_tags[9];
 834
 835     win_tags[0].ti_Tag = WA_Left;
 836     win_tags[0].ti_Data = xpos;
 837     win_tags[1].ti_Tag = WA_Top;
 838     win_tags[1].ti_Data = ypos;
 839     win_tags[2].ti_Tag = WA_Width;
 840     win_tags[2].ti_Data = width;
 841     win_tags[3].ti_Tag = WA_Height;
 842     win_tags[3].ti_Data = height;
 843     win_tags[4].ti_Tag = WA_AutoAdjust;
 844     win_tags[4].ti_Data = TRUE;
 845     win_tags[5].ti_Tag = WA_Borderless;
 846     win_tags[5].ti_Data = TRUE;
 847     win_tags[6].ti_Tag = WA_CustomScreen;
 848     win_tags[6].ti_Data = (IPTR) mhd->scr;
 849     win_tags[7].ti_Tag = WA_BackFill;
 850     win_tags[7].ti_Tag = (IPTR) LAYERS_NOBACKFILL;
 851     win_tags[8].ti_Tag = TAG_DONE;
 852
 853
 854 #if MENUS_UNDERMOUSE
 855     win_tags[1].ti_Data +=
 856         (mhd->menubaritemheight * mhd->activemenunum +
 857         mhd->scr->MenuVBorder) - height / 2;
 858     if (xpos + width > mhd->scr->Width)
 859     {
 860         win_tags[0].ti_Data = mhd->menubarwin->LeftEdge - width + 16;
 861     }
 862 #endif
 863
 864     if ((item = mhd->activemenu->FirstItem))
 865     {
 866         while (item)
 867         {
 868             item->Flags &= ~HIGHITEM;
 869             item = item->NextItem;
 870         }
 871         mhd->menuwin = OpenWindowTagList(0, win_tags);
 872
 873         mhd->maxcommkeywidth_menu = CalcMaxCommKeyWidth(mhd->menuwin, mhd);
 874
 875         RenderMenu(mhd);
 876
 877         mhd->activemenu->Flags |= MIDRAWN;
 878     }
 879 }
 880
 881
 882 static void KillMenuWin(struct MenuHandlerData *mhd)
 883 {
 884     if (mhd->menuwin)
 885     {
 886         struct MenuItem *item;
 887
 888         CloseWindow(mhd->menuwin);
 889         mhd->menuwin = NULL;
 890
 891         for (item = mhd->activemenu->FirstItem; item; item = item->NextItem)
 892         {
 893             item->Flags &= ~ISDRAWN;
 894         }
 895
 896         mhd->activemenu->Flags &= ~MIDRAWN;
 897
 898         mhd->activeitemnum = -1;
 899         mhd->activeitem = NULL;
 900     }
 901 }
 902
 903
 904 static void RenderMenu(struct MenuHandlerData *mhd)
 905 {
 906
 907     if (mhd->menuwin)
 908     {
 909         struct MenuItem *item;
 910
 911         RenderMenuBG(mhd->menuwin, mhd);
 912
 913         SetFont(mhd->menuwin->RPort, mhd->dri->dri_Font);
 914
 915         for (item = mhd->activemenu->FirstItem; item; item = item->NextItem)
 916         {
 917             RenderItem(item, ITEM_ITEM,
 918                 (struct Rectangle *)(&mhd->activemenu->JazzX), mhd);
 919         }
 920     }
 921 }
 922
 923
 924 static void MakeSubMenuWin(struct MenuHandlerData *mhd)
 925 {
 926     struct MenuItem *item = mhd->activeitem->SubItem;
 927     struct TagItem win_tags[9];
 928
 929     win_tags[0].ti_Tag = WA_Left;
 930     win_tags[0].ti_Data = 0;
 931     win_tags[1].ti_Tag = WA_Top;
 932     win_tags[1].ti_Data = 0;
 933     win_tags[2].ti_Tag = WA_Width;
 934     win_tags[2].ti_Data = 0;
 935     win_tags[3].ti_Tag = WA_Height;
 936     win_tags[3].ti_Data = 0;
 937     win_tags[4].ti_Tag = WA_AutoAdjust;
 938     win_tags[4].ti_Data = TRUE;
 939     win_tags[5].ti_Tag = WA_Borderless;
 940     win_tags[5].ti_Data = TRUE;
 941     win_tags[6].ti_Tag = WA_CustomScreen;
 942     win_tags[6].ti_Data = (IPTR) mhd->scr;
 943     win_tags[7].ti_Tag = WA_BackFill;
 944     win_tags[7].ti_Tag = (IPTR) LAYERS_NOBACKFILL;
 945     win_tags[8].ti_Tag = TAG_DONE;
 946
 947     GetMenuBox(mhd->menubarwin, item, &mhd->submenubox.MinX,
 948         &mhd->submenubox.MinY,
 949         &mhd->submenubox.MaxX, &mhd->submenubox.MaxY);
 950
 951     win_tags[0].ti_Data = mhd->menuwin->LeftEdge +
 952         mhd->activeitem->LeftEdge - mhd->activemenu->JazzX +
 953         mhd->submenubox.MinX;
 954
 955     win_tags[1].ti_Data = mhd->menuwin->TopEdge +
 956         mhd->activeitem->TopEdge - mhd->activemenu->JazzY +
 957         mhd->submenubox.MinY;
 958
 959     win_tags[2].ti_Data = mhd->submenubox.MaxX - mhd->submenubox.MinX + 1;
 960     win_tags[3].ti_Data = mhd->submenubox.MaxY - mhd->submenubox.MinY + 1;
 961
 962     while (item)
 963     {
 964         item->Flags &= ~HIGHITEM;
 965         item = item->NextItem;
 966     }
 967
 968     mhd->submenuwin = OpenWindowTagList(0, win_tags);
 969
 970     mhd->maxcommkeywidth_submenu =
 971         CalcMaxCommKeyWidth(mhd->submenuwin, mhd);
 972
 973     RenderSubMenu(mhd);
 974 }
 975
 976
 977 static void KillSubMenuWin(struct MenuHandlerData *mhd)
 978 {
 979     if (mhd->submenuwin)
 980     {
 981         CloseWindow(mhd->submenuwin);
 982         mhd->submenuwin = NULL;
 983
 984         mhd->activesubitemnum = -1;
 985         mhd->activesubitem = NULL;
 986     }
 987 }
 988
 989
 990 static void RenderSubMenu(struct MenuHandlerData *mhd)
 991 {
 992
 993     if (mhd->submenuwin)
 994     {
 995         struct MenuItem *item;
 996
 997         RenderMenuBG(mhd->submenuwin, mhd);
 998
 999         SetFont(mhd->submenuwin->RPort, mhd->dri->dri_Font);
1000
1001         for (item = mhd->activeitem->SubItem; item; item = item->NextItem)
1002         {
1003             RenderItem(item, ITEM_SUBITEM,
1004                 (struct Rectangle *)(&mhd->submenubox), mhd);
1005         }
1006     }
1007 }
1008
1009
1010 static void RenderItem(struct MenuItem *item, WORD itemtype,
1011     struct Rectangle *box, struct MenuHandlerData *mhd)
1012 {
1013     struct Window *win =
1014         ((itemtype == ITEM_ITEM) ? mhd->menuwin : mhd->submenuwin);
1015     struct RastPort *rp = win->RPort;
1016     WORD offx = -box->MinX;
1017     WORD offy = -box->MinY;
1018     BOOL enabled = ((item->Flags & ITEMENABLED) &&
1019         (mhd->activemenu->Flags & MENUENABLED) &&
1020         ((itemtype == ITEM_ITEM)
1021             || (mhd->activeitem->Flags & ITEMENABLED)));
1022     BOOL item_supports_disable = FALSE;
1023
1024     SetDrMd(rp, JAM1);
1025
1026     if (item->ItemFill)
1027     {
1028         if (item->Flags & ITEMTEXT)
1029         {
1030 #if MENUS_AMIGALOOK
1031             struct IntuiText *it = (struct IntuiText *)item->ItemFill;
1032
1033             PrintIText(rp, it, offx + item->LeftEdge, offy + item->TopEdge);
1034 #else
1035             struct IntuiText *it = (struct IntuiText *)item->ItemFill;
1036
1037             it->FrontPen =
1038                 mhd->dri->dri_Pens[(item->
1039                     Flags & HIGHITEM) ? FILLTEXTPEN : TEXTPEN];
1040             it->DrawMode = JAM1;
1041
1042             PrintIText(rp, it, offx + item->LeftEdge, offy + item->TopEdge);
1043 #endif
1044         }
1045         else
1046         {
1047             struct Image *im = (struct Image *)item->ItemFill;
1048             LONG state = IDS_NORMAL;
1049
1050             if (!enabled && (im->Depth == CUSTOMIMAGEDEPTH))
1051             {
1052                 IPTR val = 0;
1053
1054                 GetAttr(IA_SupportsDisable, (Object *) im, &val);
1055                 if (val)
1056                 {
1057                     item_supports_disable = TRUE;
1058                     state = IDS_DISABLED;
1059                 }
1060             }
1061
1062             DrawImageState(rp, im, offx + item->LeftEdge,
1063                 offy + item->TopEdge, state, mhd->dri);
1064         }
1065
1066     }                           /* if (item->ItemFill) */
1067
1068     RenderCheckMark(item, itemtype, mhd);
1069     RenderAmigaKey(item, itemtype, mhd);
1070
1071     if (!enabled && !item_supports_disable)
1072     {
1073         RenderDisabledPattern(rp, offx + item->LeftEdge,
1074             offy + item->TopEdge,
1075             offx + item->LeftEdge + item->Width - 1,
1076             offy + item->TopEdge + item->Height - 1, mhd);
1077     }
1078
1079 }
1080
1081
1082 static void RenderMenuBG(struct Window *win, struct MenuHandlerData *mhd)
1083 {
1084     struct RastPort *rp = win->RPort;
1085
1086 #if MENUS_AMIGALOOK
1087     WORD borderx = mhd->scr->MenuHBorder / 2;
1088     WORD bordery = mhd->scr->MenuVBorder / 2;
1089 #else
1090     WORD borderx = 1;
1091     WORD bordery = 1;
1092 #endif
1093
1094     /* White background */
1095
1096 #if MENUS_AMIGALOOK
1097     SetABPenDrMd(rp, mhd->dri->dri_Pens[BARBLOCKPEN], 0, JAM1);
1098 #else
1099     SetABPenDrMd(rp, mhd->dri->dri_Pens[BACKGROUNDPEN], 0, JAM1);
1100 #endif
1101     RectFill(rp, borderx,
1102         bordery, win->Width - 1 - borderx, win->Height - 1 - bordery);
1103
1104     /* Black border frame */
1105
1106 #if MENUS_AMIGALOOK
1107     SetAPen(rp, mhd->dri->dri_Pens[BARDETAILPEN]);
1108     RectFill(rp, 0, 0, win->Width - 1, bordery - 1);
1109     RectFill(rp, 0, bordery, borderx - 1, win->Height - 1 - bordery);
1110     RectFill(rp, win->Width - borderx, bordery, win->Width - 1,
1111         win->Height - 1);
1112     RectFill(rp, 0, win->Height - bordery, win->Width - 1 - borderx,
1113         win->Height - 1);
1114 #else
1115     RenderFrame(rp, 0, 0, win->Width - 1, win->Height - 1, IDS_NORMAL, mhd);
1116 #endif
1117 }
1118
1119
1120 static void RenderCheckMark(struct MenuItem *item, WORD itemtype,
1121     struct MenuHandlerData *mhd)
1122 {
1123     struct Window *win =
1124         ((itemtype == ITEM_ITEM) ? mhd->menuwin : mhd->submenuwin);
1125     struct RastPort *rp = win->RPort;
1126     struct Rectangle *box =
1127         ((itemtype ==
1128             ITEM_ITEM) ? ((struct Rectangle *)&mhd->activemenu->
1129             JazzX) : &mhd->submenubox);
1130     WORD offx = -box->MinX;
1131     WORD offy = -box->MinY;
1132     WORD state = ((item->Flags & HIGHITEM) &&
1133         ((item->Flags & HIGHFLAGS) ==
1134             HIGHCOMP)) ? IDS_SELECTED : IDS_NORMAL;
1135
1136     if (item->Flags & CHECKIT)
1137     {
1138         WORD x1, y1, x2, y2;
1139
1140         x1 = item->LeftEdge + offx;
1141         y1 = item->TopEdge + offy + (item->Height -
1142             mhd->checkmark->Height) / 2;
1143         x2 = x1 + mhd->checkmark->Width - 1;
1144         y2 = y1 + mhd->checkmark->Height - 1;
1145
1146         SetDrMd(rp, JAM1);
1147
1148         if (item->Flags & CHECKED)
1149         {
1150             DrawImageState(rp, mhd->checkmark, x1, y1, state, mhd->dri);
1151         }
1152         else
1153         {
1154 #if MENUS_AMIGALOOK
1155             SetAPen(rp, mhd->dri->dri_Pens[BARBLOCKPEN]);
1156 #else
1157             SetAPen(rp,
1158                 mhd->dri->dri_Pens[(state ==
1159                         IDS_SELECTED) ? FILLPEN : BACKGROUNDPEN]);
1160 #endif
1161             RectFill(rp, x1, y1, x2, y2);
1162         }
1163     }
1164
1165 }
1166
1167
1168 static void RenderAmigaKey(struct MenuItem *item, WORD itemtype,
1169     struct MenuHandlerData *mhd)
1170 {
1171     struct Window *win =
1172         ((itemtype == ITEM_ITEM) ? mhd->menuwin : mhd->submenuwin);
1173     struct RastPort *rp = win->RPort;
1174     struct Rectangle *box =
1175         ((itemtype ==
1176             ITEM_ITEM) ? ((struct Rectangle *)&mhd->activemenu->
1177             JazzX) : &mhd->submenubox);
1178     WORD commkeywidth =
1179         ((itemtype ==
1180             ITEM_ITEM) ? mhd->maxcommkeywidth_menu : mhd->
1181         maxcommkeywidth_submenu);
1182     WORD offx = -box->MinX;
1183     WORD offy = -box->MinY;
1184     WORD state = ((item->Flags & HIGHITEM) &&
1185         ((item->Flags & HIGHFLAGS) ==
1186             HIGHCOMP)) ? IDS_SELECTED : IDS_NORMAL;
1187
1188     if (item->Flags & COMMSEQ)
1189     {
1190         struct TextFont *oldfont = rp->Font;
1191         struct TextFont *newfont = NULL;
1192
1193         WORD x1, y1;
1194
1195         if (item->Flags & ITEMTEXT)
1196         {
1197             struct IntuiText *it = (struct IntuiText *)item->ItemFill;
1198
1199             if (it->ITextFont)
1200             {
1201                 if ((newfont = OpenFont(it->ITextFont)))
1202                 {
1203                     SetFont(rp, newfont);
1204                 }
1205             }
1206         }
1207
1208         x1 = item->LeftEdge + offx + item->Width - AMIGAKEY_BORDER_SPACING -
1209             mhd->amigakey->Width - AMIGAKEY_KEY_SPACING - commkeywidth;
1210         y1 = item->TopEdge + offy + (item->Height - mhd->amigakey->Height +
1211             1) / 2;
1212
1213         SetDrMd(rp, JAM1);
1214
1215         DrawImageState(rp, mhd->amigakey, x1, y1, state, mhd->dri);
1216
1217         x1 += mhd->amigakey->Width + AMIGAKEY_KEY_SPACING;
1218
1219 #if MENUS_AMIGALOOK
1220         SetAPen(rp, mhd->dri->dri_Pens[BARDETAILPEN]);
1221 #else
1222         SetAPen(rp,
1223             mhd->dri->dri_Pens[(item->
1224                     Flags & HIGHITEM) ? FILLTEXTPEN : TEXTPEN]);
1225 #endif
1226         Move(rp, x1,
1227             item->TopEdge + offy + (item->Height - rp->TxHeight) / 2 +
1228             rp->TxBaseline);
1229         Text(rp, &item->Command, 1);
1230
1231         if (newfont)
1232         {
1233             CloseFont(newfont);
1234             SetFont(rp, oldfont);
1235         }
1236     }
1237 }
1238
1239
1240 static void RenderDisabledPattern(struct RastPort *rp, WORD x1, WORD y1,
1241     WORD x2, WORD y2, struct MenuHandlerData *mhd)
1242 {
1243     static UWORD pattern[] = { 0x8888, 0x2222 };
1244
1245     SetDrMd(rp, JAM1);
1246 #if MENUS_AMIGALOOK
1247     SetAPen(rp, mhd->dri->dri_Pens[BARBLOCKPEN]);
1248 #else
1249     SetAPen(rp, mhd->dri->dri_Pens[BACKGROUNDPEN]);
1250 #endif
1251
1252     SetAfPt(rp, pattern, 1);
1253
1254     RectFill(rp, x1, y1, x2, y2);
1255
1256     SetAfPt(rp, NULL, 0);
1257 }
1258
1259
1260 #if 0
1261 static void RenderFrame(struct RastPort *rp, WORD x1, WORD y1, WORD x2,
1262     WORD y2, WORD state, struct MenuHandlerData *mhd)
1263 {
1264     SetAPen(rp,
1265         mhd->dri->dri_Pens[(state == IDS_SELECTED) ? SHADOWPEN : SHINEPEN]);
1266
1267     RectFill(rp, x1, y1, x2, y1);
1268     RectFill(rp, x1, y1 + 1, x1, y2);
1269
1270     SetAPen(rp,
1271         mhd->dri->dri_Pens[(state == IDS_SELECTED) ? SHINEPEN : SHADOWPEN]);
1272     RectFill(rp, x2, y1 + 1, x2, y2);
1273     RectFill(rp, x1 + 1, y2, x2 - 1, y2);
1274 }
1275 #endif
1276
1277
1278 static void HighlightItem(struct MenuItem *item, WORD itemtype,
1279     struct MenuHandlerData *mhd)
1280 {
1281     struct Window *win =
1282         ((itemtype == ITEM_ITEM) ? mhd->menuwin : mhd->submenuwin);
1283     struct RastPort *rp = win->RPort;
1284     struct Rectangle *box =
1285         ((itemtype ==
1286             ITEM_ITEM) ? ((struct Rectangle *)&mhd->activemenu->
1287             JazzX) : &mhd->submenubox);
1288     APTR fill;
1289     WORD offx = -box->MinX;
1290     WORD offy = -box->MinY;
1291     WORD x1, y1, x2, y2;
1292     BOOL enabled;
1293
1294     enabled = (item->Flags & ITEMENABLED) ? TRUE : FALSE;
1295     if (!(mhd->activemenu->Flags & MENUENABLED))
1296         enabled = FALSE;
1297     if ((itemtype == ITEM_SUBITEM)
1298         && !(mhd->activeitem->Flags & ITEMENABLED))
1299         enabled = FALSE;
1300
1301     if (enabled)
1302     {
1303         item->Flags ^= HIGHITEM;
1304
1305         fill = item->ItemFill;
1306         if ((item->Flags & HIGHITEM) && (item->SelectFill))
1307             fill = item->SelectFill;
1308
1309         x1 = offx + item->LeftEdge;
1310         y1 = offy + item->TopEdge;
1311         x2 = x1 + item->Width - 1;
1312         y2 = y1 + item->Height - 1;
1313
1314         switch (item->Flags & HIGHFLAGS)
1315         {
1316         case HIGHIMAGE:
1317             SetDrMd(rp, JAM1);
1318
1319             if (item->Flags & ITEMTEXT)
1320             {
1321 #if MENUS_AMIGALOOK
1322                 PrintIText(rp, (struct IntuiText *)fill, x1, y1);
1323 #else
1324                 struct IntuiText *it = (struct IntuiText *)fill;
1325
1326                 it->FrontPen = mhd->dri->dri_Pens[TEXTPEN];
1327                 it->DrawMode = JAM1;
1328
1329                 PrintIText(rp, it, x1, y1);
1330 #endif
1331             }
1332             else
1333             {
1334                 EraseImage(rp, (struct Image *)fill, x1, y1);
1335                 DrawImageState(rp, (struct Image *)fill, x1, y1,
1336                     IDS_SELECTED, mhd->dri);
1337             }
1338             break;
1339
1340         case HIGHCOMP:
1341 #if MENUS_AMIGALOOK
1342             SetDrMd(rp, COMPLEMENT);
1343             RectFill(rp, x1, y1, x2, y2);
1344 #else
1345             {
1346                 WORD state =
1347                     (item->Flags & HIGHITEM) ? IDS_SELECTED : IDS_NORMAL;
1348
1349                 SetDrMd(rp, JAM1);
1350                 SetAPen(rp,
1351                     mhd->dri->dri_Pens[(state ==
1352                             IDS_SELECTED) ? FILLPEN : BACKGROUNDPEN]);
1353                 RectFill(rp, x1, y1, x2, y2);
1354
1355                 RenderItem(item, itemtype, box, mhd);
1356
1357                 if (state == IDS_SELECTED)
1358                 {
1359                     RenderFrame(rp, x1, y1, x2, y2, state, mhd);
1360                 }
1361             }
1362 #endif
1363             break;
1364
1365         case HIGHBOX:
1366             SetDrMd(rp, COMPLEMENT);
1367             offx = mhd->scr->MenuHBorder;
1368             offy = mhd->scr->MenuVBorder;
1369
1370             x1 -= offx;
1371             x2 += offx;
1372             y1 -= offy;
1373             y2 += offy;
1374
1375             RectFill(rp, x1, y1, x2, y1 + offy - 1);
1376             RectFill(rp, x2 - offx + 1, y1 + offy, x2, y2);
1377             RectFill(rp, x1, y2 - offy + 1, x2 - offx, y2);
1378             RectFill(rp, x1, y1 + offy, x1 + offx - 1, y2 - offy);
1379             break;
1380
1381         case HIGHNONE:
1382             /* Do nothing */
1383             break;
1384
1385         }
1386     }
1387 }
1388
1389
1390 static WORD CalcMaxCommKeyWidth(struct Window *win,
1391     struct MenuHandlerData *mhd)
1392 {
1393     WORD maxwidth = mhd->dri->dri_Font->tf_XSize;
1394
1395     if (win)
1396     {
1397         struct MenuItem *item;
1398
1399         if ((win == mhd->menuwin))
1400         {
1401             item = mhd->activemenu->FirstItem;
1402         }
1403         else
1404         {
1405             item = mhd->activeitem->SubItem;
1406         }
1407
1408         for (; item; item = item->NextItem)
1409         {
1410             if (item->Flags & ITEMTEXT)
1411             {
1412                 struct IntuiText *it = (struct IntuiText *)item->ItemFill;
1413
1414                 if (it->ITextFont)
1415                 {
1416                     struct TextFont *font;
1417
1418                     if ((font = OpenFont(it->ITextFont)))
1419                     {
1420                         if (font->tf_XSize > maxwidth)
1421                             maxwidth = font->tf_XSize;
1422
1423                         CloseFont(font);
1424                     }
1425                 }
1426             }
1427         }
1428     }
1429
1430     return maxwidth;
1431 }
1432
1433
1434 static void AddToSelection(struct MenuHandlerData *mhd)
1435 {
1436     if ((mhd->activemenunum != -1) && (mhd->activemenu->Flags & MENUENABLED)
1437         && (mhd->activeitemnum != -1)
1438         && (mhd->activeitem->Flags & ITEMENABLED))
1439     {
1440         struct MenuItem *item = NULL;
1441         UWORD men =
1442             FULLMENUNUM(mhd->activemenunum, mhd->activeitemnum,
1443             mhd->activesubitemnum);
1444
1445         if (mhd->activesubitemnum != -1)
1446         {
1447             if (mhd->activesubitem->Flags & ITEMENABLED)
1448                 item = mhd->activesubitem;
1449         }
1450         else if (!mhd->activeitem->SubItem)
1451         {
1452             item = mhd->activeitem;
1453         }
1454
1455         if (item && (ItemAddress(mhd->menu, men) == item))
1456         {
1457             UWORD men =
1458                 FULLMENUNUM(mhd->activemenunum, mhd->activeitemnum,
1459                 mhd->activesubitemnum);
1460
1461             if (mhd->firstmenupick == MENUNULL)
1462             {
1463                 mhd->firstmenupick = men;
1464             }
1465             else if (men != mhd->lastmenupick)
1466             {
1467                 struct MenuItem *checkitem, *prevcheckitem = NULL;
1468                 UWORD checkmen = mhd->firstmenupick;
1469
1470                 /* Remove men from pick queue, if it was already in there
1471                    and then add it at the end of the pick queue */
1472
1473                 while (checkmen != MENUNULL)
1474                 {
1475                     checkitem = ItemAddress(mhd->menu, checkmen);
1476
1477                     if (checkmen == men)
1478                     {
1479                         if (prevcheckitem == NULL)
1480                         {
1481                             mhd->firstmenupick = checkitem->NextSelect;
1482                         }
1483                         else
1484                         {
1485                             prevcheckitem->NextSelect =
1486                                 checkitem->NextSelect;
1487                         }
1488                     }
1489
1490                     checkmen = checkitem->NextSelect;
1491                     prevcheckitem = checkitem;
1492
1493                 }
1494                 checkitem->NextSelect = men;
1495             }
1496
1497             mhd->lastmenupick = men;
1498             item->NextSelect = MENUNULL;
1499         }
1500     }
1501 }
1502
1503
1504 /** END AROS **/
1505
1506 struct ZMenu
1507 {
1508     struct MenuHandlerData mhd;
1509 };
1510
1511 struct ZMenu *zune_open_menu(struct Window *wnd, struct NewMenu *newmenu)
1512 {
1513     struct TagItem tags[] = {
1514         {GTMN_NewLookMenus, TRUE},
1515         {TAG_DONE}
1516     };
1517
1518     struct ZMenu *zmenu;
1519     struct Menu *menu;
1520     APTR visinfo;
1521     zmenu = (struct ZMenu *)AllocVec(sizeof(struct ZMenu), MEMF_CLEAR);
1522     if (!zmenu)
1523         return NULL;
1524
1525     visinfo = GetVisualInfoA(wnd->WScreen, NULL);
1526     if (!visinfo)
1527     {
1528         FreeVec(zmenu);
1529         return NULL;
1530     }
1531
1532     if (!(menu = CreateMenusA(newmenu, NULL)))
1533     {
1534         FreeVec(zmenu);
1535         return NULL;
1536     }
1537
1538     LayoutMenusA(menu, visinfo, tags);
1539     FreeVisualInfo(visinfo);
1540
1541     Characterize(menu);
1542     CalculateDims(wnd, menu);
1543
1544     zmenu->mhd.win = wnd;
1545     zmenu->mhd.scr = zmenu->mhd.win->WScreen;
1546     zmenu->mhd.dri = GetScreenDrawInfo(zmenu->mhd.scr);
1547     zmenu->mhd.menu = menu;
1548     zmenu->mhd.activemenunum = -1;
1549     zmenu->mhd.activeitemnum = -1;
1550     zmenu->mhd.activesubitemnum = -1;
1551     zmenu->mhd.checkmark = zmenu->mhd.dri->dri_CheckMark;
1552     zmenu->mhd.amigakey = zmenu->mhd.dri->dri_AmigaKey;
1553     zmenu->mhd.scrmousex = zmenu->mhd.scr->MouseX;
1554     zmenu->mhd.scrmousey = zmenu->mhd.scr->MouseY;
1555     zmenu->mhd.firstmenupick = MENUNULL;
1556
1557     MakeMenuBarWin(&zmenu->mhd);
1558     HandleMouseMove(&zmenu->mhd);
1559     return zmenu;
1560 }
1561
1562 void zune_mouse_update(struct ZMenu *zmenu, int left_down)
1563 {
1564     if (!zmenu)
1565         return;
1566
1567     if (!left_down)
1568         HandleMouseMove(&zmenu->mhd);
1569     else
1570         HandleMouseClick(&zmenu->mhd, 0);
1571 }
1572
1573 struct MenuItem *zune_leave_menu(struct ZMenu *zmenu)
1574 {
1575     HandleMouseClick(&zmenu->mhd, 1);
1576
1577     return ItemAddress(zmenu->mhd.menu, zmenu->mhd.firstmenupick);
1578 }
1579
1580 /* returns the address of the selected menuitem entry */
1581 void zune_close_menu(struct ZMenu *zmenu)
1582 {
1583     if (!zmenu)
1584         return;
1585
1586     KillMenuBarWin(&zmenu->mhd);
1587     KillMenuWin(&zmenu->mhd);
1588     KillSubMenuWin(&zmenu->mhd);
1589
1590     FreeMenus(zmenu->mhd.menu);
1591     zmenu->mhd.menu = 0;
1592
1593     if (zmenu->mhd.dri)
1594     {
1595         FreeScreenDrawInfo(zmenu->mhd.scr, zmenu->mhd.dri);
1596         zmenu->mhd.dri = 0;
1597     }
1598
1599 //      MH2Int_MakeMenusInactive(mhd->win, mhd->firstmenupick);
1600     zmenu->mhd.active = FALSE;
1601
1602     FreeVec(zmenu);
1603 }
1604
1605 struct Menu *zune_get_menu_pointer(struct ZMenu *menu)
1606 {
1607     return menu->mhd.menu;
1608 }