?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use the cached method id's to improve performance.
[AROS.git] / rom / intuition / menutask.c
bloba53b816a3bc6d6f12c2ae082a09a4247dbd3dafe
1 /*
2 Copyright © 1995-2012, The AROS Development Team. All rights reserved.
3 Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
4 $Id$
5 */
6
7 #include <proto/exec.h>
8 #include <proto/intuition.h>
9 #include <proto/alib.h>
10 #include <proto/layers.h>
11 #include <proto/graphics.h>
12 #include <proto/keymap.h>
13 #include <proto/cybergraphics.h>
14 #include <exec/memory.h>
15 #include <exec/alerts.h>
16 #include <exec/interrupts.h>
17 #include <exec/ports.h>
18 #include <intuition/intuition.h>
19 #include <intuition/intuitionbase.h>
20 #include <intuition/imageclass.h>
21 #include <graphics/gfxmacros.h>
22 #include <graphics/rpattr.h>
23 #include <devices/inputevent.h>
24 #include <devices/input.h>
25 #include <devices/timer.h>
26 #include "inputhandler.h"
27 #include "intuition_intern.h"
28 #include <string.h>
29
30 #ifdef SKINS
31 #include "intuition_customize.h"
32 #endif
33
34 #include "menus.h"
35 #include "menutask.h"
36 #include <cybergraphx/cybergraphics.h>
37
38 #undef DEBUG
39 #define DEBUG 0
40 #include <aros/debug.h>
41
42 extern IPTR HookEntry();
43
44 /**************************************************************************************************/
45
46 /* this #defines are taken from workbench/libs/gadtools/menus.c!! */
47
48 #define TEXT_AMIGAKEY_SPACING 6
49
50 #define ITEXT_EXTRA_LEFT 2
51 #define ITEXT_EXTRA_RIGHT 2
52 #define ITEXT_EXTRA_TOP 1
53 #define ITEXT_EXTRA_BOTTOM 1
54
55 /**************************************************************************************************/
56
57 static void HandleMouseMove(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
58 static void HandleMouseClick(struct InputEvent *ie, struct MenuHandlerData *mhd,
59 struct IntuitionBase *IntuitionBase);
60 static void HandleCheckItem(struct Window *win, struct MenuItem *item,
61 struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
62
63 static void HighlightMenuTitle(struct Menu *menu, struct MenuHandlerData *mhd,
64 struct IntuitionBase *IntuitionBase);
65
66 static struct Menu *FindMenu(WORD *var, struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
67 static struct MenuItem *FindItem(WORD *var, struct MenuHandlerData *mhd);
68 static struct MenuItem *FindSubItem(WORD *var, struct MenuHandlerData *mhd);
69
70 static void MakeMenuBarWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
71 static void KillMenuBarWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
72 static void RenderMenuBar(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
73
74 static void MakeMenuWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
75 static void KillMenuWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
76 static void RenderMenu(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
77 static void RenderMenuTitle(struct Menu *menu, struct MenuHandlerData *mhd,
78 struct IntuitionBase *IntuitionBase);
79
80 static void MakeSubMenuWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
81 static void KillSubMenuWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
82 static void RenderSubMenu(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
83
84 static void RenderItem(struct MenuItem *item, WORD itemtype, struct Rectangle *box,
85 struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
86
87 static void RenderMenuBG(struct Window *win, struct MenuHandlerData *mhd,
88 struct IntuitionBase *IntuitionBase);
89 static void RenderCheckMark(struct MenuItem *item, WORD itemtype, struct MenuHandlerData *mhd,
90 struct IntuitionBase *IntuitionBase);
91 static void RenderAmigaKey(struct MenuItem *item, WORD itemtype, struct MenuHandlerData *mhd,
92 struct IntuitionBase *IntuitionBase);
93 static void RenderDisabledPattern(struct RastPort *rp, WORD x1, WORD y1, WORD x2, WORD y2,
94 struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
95 static void RenderFrame(struct RastPort *rp, WORD x1, WORD y1, WORD x2, WORD y2, WORD state,
96 struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
97 static void HighlightItem(struct MenuItem *item, WORD itemtype, struct MenuHandlerData *mhd,
98 struct IntuitionBase *IntuitionBase);
99 static WORD CalcMaxCommKeyWidth(struct Window *win, struct MenuHandlerData *mhd,
100 struct IntuitionBase *IntuitionBase);
101 static void AddToSelection(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase);
102
103 /**************************************************************************************************/
104
105 /***************************
106 ** DefaultMenuHandler() **
107 ***************************/
108 void DefaultMenuHandler(struct MenuTaskParams *taskparams)
109 {
110 struct IntuitionBase *IntuitionBase = taskparams->intuitionBase;
111 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
112 struct MenuHandlerData *mhd = NULL;
113 UBYTE *mem;
114 struct MsgPort *port = NULL;
115 BOOL success = FALSE;
116
117 if ((mem = AllocMem(sizeof(struct MsgPort) +
118 sizeof(struct MenuHandlerData), MEMF_PUBLIC | MEMF_CLEAR)))
119 {
120 port = (struct MsgPort *)mem;
121
122 port->mp_Node.ln_Type = NT_MSGPORT;
123 port->mp_Flags = PA_SIGNAL;
124 port->mp_SigBit = AllocSignal(-1);
125 port->mp_SigTask = FindTask(0);
126 NEWLIST(&port->mp_MsgList);
127
128 mhd = (struct MenuHandlerData *)(mem + sizeof(struct MsgPort));
129
130 success = TRUE;
131
132 } /* if ((mem = AllocMem(sizeof(struct MsgPort), MEMF_PUBLIC | MEMF_CLEAR))) */
133
134 if (success)
135 {
136 taskparams->MenuHandlerPort = port;
137 taskparams->success = TRUE;
138 }
139
140 Signal(taskparams->Caller, SIGF_INTUITION);
141
142 if (!success)
143 {
144 D(bug("DefaultMenuHandler: initialization failed. waiting for parent task to kill me.\n"));
145 Wait(0);
146 }
147
148 D(bug("DefaultMenuHandler: initialization ok. Now waiting for messages from Intuition.\n"));
149
150 for(;;)
151 {
152 struct MenuMessage *msg;
153
154 WaitPort(port);
155 while((msg = GetMenuMessage(port, IntuitionBase)))
156 {
157 switch(msg->code)
158 {
159 case MMCODE_START:
160 mhd->win = msg->win;
161 mhd->scr = mhd->win->WScreen;
162 mhd->dri = GetScreenDrawInfo(mhd->scr);
163 mhd->menu = msg->win->MenuStrip;
164 mhd->activemenunum = -1;
165 mhd->activeitemnum = -1;
166 mhd->activesubitemnum = -1;
167 mhd->checkmark = ((struct IntWindow *)mhd->win)->Checkmark;
168 mhd->amigakey = ((struct IntWindow *)mhd->win)->AmigaKey;
169 mhd->submenuimage = ((struct IntWindow *)mhd->win)->SubMenuImage;
170 mhd->scrmousex = mhd->scr->MouseX;
171 mhd->scrmousey = mhd->scr->MouseY;
172 mhd->firstmenupick = MENUNULL;
173 mhd->keepmenuup = TRUE;
174 mhd->TrueColor = GetBitMapAttr(mhd->scr->RastPort.BitMap, BMA_DEPTH) > 8 ? TRUE: FALSE;
175
176 /* close windows in the back first because
177 this is faster */
178 MakeMenuBarWin(mhd, IntuitionBase);
179 HandleMouseMove(mhd, IntuitionBase);
180 mhd->active = TRUE;
181 break;
182
183 case MMCODE_EVENT:
184 /* there might come additional messages from Intuition
185 even when we have already told it to make the menus
186 inactive, but since everything is async, this cannot
187 be avoided, so check if we are really active */
188
189 if (mhd->active)
190 {
191 switch(msg->ie.ie_Class)
192 {
193 case IECLASS_RAWMOUSE:
194 if (msg->ie.ie_Code == IECODE_NOBUTTON)
195 {
196 HandleMouseMove(mhd, IntuitionBase);
197 }
198 else
199 {
200 HandleMouseClick(&msg->ie, mhd, IntuitionBase);
201 }
202 break;
203 }
204
205 } /* if (mhd->active) */
206 break;
207
208 } /* switch(msg->code) */
209
210 ReplyMenuMessage(msg, IntuitionBase);
211
212 } /* while((msg = (struct MenuMessage *)GetMsg(port))) */
213
214 } /* for(;;) */
215 }
216
217 /**************************************************************************************************/
218
219 /*******************************
220 ** InitDefaultMenuHandler() **
221 *******************************/
222 BOOL InitDefaultMenuHandler(struct IntuitionBase *IntuitionBase)
223 {
224 struct MenuTaskParams params;
225 struct Task *task;
226 BOOL result = FALSE;
227
228 params.intuitionBase = IntuitionBase;
229 params.Caller = FindTask(NULL);
230 params.success = FALSE;
231
232 SetSignal(0, SIGF_INTUITION);
233
234 task = NewCreateTask(TASKTAG_NAME, "Intuition menu handler",
235 TASKTAG_PC , DefaultMenuHandler,
236 TASKTAG_ARG1, &params,
237 TAG_DONE);
238
239 if (task)
240 {
241 Wait(SIGF_INTUITION);
242
243 if (params.success)
244 {
245 result = TRUE;
246 GetPrivIBase(IntuitionBase)->MenuHandlerPort = params.MenuHandlerPort;
247 }
248 else
249 {
250 RemTask(task);
251 }
252
253 } /* if ((task = CreateMenuHandlerTask(&params, IntuitionBase))) */
254
255 return result;
256 }
257
258
259 /**************************************************************************************************/
260
261 static void HandleMouseMove(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
262 {
263 struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
264 struct Layer *lay;
265 struct Window *win = NULL;
266 struct Menu *menu;
267 struct MenuItem *item;
268 WORD new_activemenunum = mhd->activemenunum;
269 WORD new_activeitemnum = mhd->activeitemnum;
270 WORD new_activesubitemnum = mhd->activesubitemnum;
271
272 mhd->scrmousex = mhd->scr->MouseX;
273 mhd->scrmousey = mhd->scr->MouseY;
274
275 LockLayerInfo(&mhd->scr->LayerInfo);
276 lay = WhichLayer(&mhd->scr->LayerInfo, mhd->scrmousex, mhd->scrmousey);
277 UnlockLayerInfo(&mhd->scr->LayerInfo);
278
279 if (lay)
280 {
281 win = (struct Window *)lay->Window;
282
283 if (win && (win == mhd->submenuwin))
284 {
285 /* Mouse over submenu box */
286 item = FindSubItem(&new_activesubitemnum, mhd);
287
288 if (new_activesubitemnum != mhd->activesubitemnum)
289 {
290 if (mhd->activesubitemnum != -1)
291 {
292 HighlightItem(mhd->activesubitem, ITEM_SUBITEM, mhd, IntuitionBase);
293 }
294
295 mhd->activesubitemnum = new_activesubitemnum;
296 mhd->activesubitem = item;
297
298 if (item)
299 {
300 HighlightItem(mhd->activesubitem, ITEM_SUBITEM, mhd, IntuitionBase);
301 }
302 }
303
304 }
305 else if (win && (win == mhd->menuwin))
306 {
307 item = FindItem(&new_activeitemnum, mhd);
308
309 if (new_activeitemnum != mhd->activeitemnum)
310 {
311 if (mhd->activeitemnum != -1)
312 {
313 HighlightItem(mhd->activeitem, ITEM_ITEM, mhd, IntuitionBase);
314 KillSubMenuWin(mhd, IntuitionBase);
315 }
316
317 mhd->activeitemnum = new_activeitemnum;
318 mhd->activeitem = item;
319
320 if (item)
321 {
322 HighlightItem(mhd->activeitem, ITEM_ITEM, mhd, IntuitionBase);
323
324 if (item->SubItem)
325 {
326 MakeSubMenuWin(mhd, IntuitionBase);
327 }
328 }
329 }
330 } /* if (win && (win == mhd->menuwin)) */
331 else if (win && (win == mhd->menubarwin))
332 {
333 /* Mouse over menu box */
334
335 menu = FindMenu(&new_activemenunum, mhd, IntuitionBase);
336
337 if (new_activemenunum != mhd->activemenunum)
338 {
339
340 if (mhd->activemenunum != -1)
341 {
342 HighlightMenuTitle(mhd->activemenu, mhd, IntuitionBase);
343 KillMenuWin(mhd, IntuitionBase);
344 KillSubMenuWin(mhd, IntuitionBase);
345 }
346
347 mhd->activemenunum = new_activemenunum;
348 mhd->activemenu = menu;
349
350 if (menu)
351 {
352 HighlightMenuTitle(mhd->activemenu, mhd, IntuitionBase);
353 MakeMenuWin(mhd, IntuitionBase);
354 }
355 }
356
357 if ((mhd->activeitemnum != -1) && (!mhd->submenuwin))
358 {
359 HighlightItem(mhd->activeitem, ITEM_ITEM, mhd, IntuitionBase);
360 mhd->activeitemnum = -1;
361 mhd->activeitem = NULL;
362 }
363
364 } /* if (win && (win == mhd->menubarwin)) */
365 else
366 {
367 win = NULL;
368 }
369 } /* if ((lay = WhichLayer(&mhd->scr->LayerInfo, mhd->scrmousex, mhd->scrmousey))) */
370
371 if (!win)
372 {
373 /* mouse outside any menu window */
374
375 if ((mhd->activeitemnum != -1) && (!mhd->submenuwin))
376 {
377 HighlightItem(mhd->activeitem, ITEM_ITEM, mhd, IntuitionBase);
378 mhd->activeitemnum = -1;
379 mhd->activeitem = NULL;
380 }
381 else if (mhd->activesubitemnum != -1)
382 {
383 HighlightItem(mhd->activesubitem, ITEM_SUBITEM, mhd, IntuitionBase);
384 mhd->activesubitemnum = -1;
385 mhd->activesubitem = NULL;
386 }
387 }
388
389 }
390
391 /**************************************************************************************************/
392
393 static void HandleSelection(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
394 {
395 struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
396 struct Layer *lay;
397
398 LockLayerInfo(&mhd->scr->LayerInfo);
399 lay = WhichLayer(&mhd->scr->LayerInfo, mhd->scrmousex, mhd->scrmousey);
400 UnlockLayerInfo(&mhd->scr->LayerInfo);
401
402 if (lay)
403 {
404 struct Window *win = (struct Window *)lay->Window;
405 struct MenuItem *item = NULL;
406
407 if (win && (win == mhd->submenuwin) && (mhd->activesubitemnum != -1))
408 item = mhd->activesubitem;
409 else if (win && (win == mhd->menuwin) && (mhd->activeitemnum != -1))
410 item = mhd->activeitem;
411
412 if (item) {
413 if (item->Flags & CHECKIT)
414 HandleCheckItem(win, item, mhd, IntuitionBase);
415 }
416
417 AddToSelection(mhd, IntuitionBase);
418 }
419 }
420
421 /**************************************************************************************************/
422
423 static void HandleMouseClick(struct InputEvent *ie, struct MenuHandlerData *mhd,
424 struct IntuitionBase *IntuitionBase)
425 {
426 BOOL die = FALSE;
427 ULONG sticky = GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_STICKYMENUS; /* ic_Flags is ULONG */
428
429 switch(ie->ie_Code)
430 {
431 case MENUUP:
432 sticky = sticky && (DoubleClick(
433 GetPrivIBase(IntuitionBase)->LastMenuDownSecs,
434 GetPrivIBase(IntuitionBase)->LastMenuDownMicro,
435 ie->ie_TimeStamp.tv_secs, ie->ie_TimeStamp.tv_micro)
436 || mhd->keepmenuup);
437 if (sticky)
438 break;
439
440 case SELECTDOWN:
441 if (!sticky)
442 {
443 HandleSelection(mhd, IntuitionBase);
444
445 if (ie->ie_Code == MENUUP)
446 die = TRUE;
447 }
448
449 break;
450
451 case SELECTUP:
452 if (sticky)
453 {
454 HandleSelection(mhd, IntuitionBase);
455 die = TRUE;
456 }
457 break;
458
459 case MENUDOWN:
460 if (sticky)
461 {
462 if (mhd->keepmenuup)
463 mhd->keepmenuup = FALSE;
464 else {
465 HandleSelection(mhd, IntuitionBase);
466 die = TRUE;
467 }
468 GetPrivIBase(IntuitionBase)->LastMenuDownSecs =
469 ie->ie_TimeStamp.tv_secs;
470 GetPrivIBase(IntuitionBase)->LastMenuDownMicro =
471 ie->ie_TimeStamp.tv_micro;
472 }
473 break;
474 } /* switch(ie->ie_Code) */
475
476 if (die)
477 {
478 KillMenuBarWin(mhd, IntuitionBase);
479 KillMenuWin(mhd, IntuitionBase);
480 KillSubMenuWin(mhd, IntuitionBase);
481
482 if (mhd->dri)
483 {
484 FreeScreenDrawInfo(mhd->scr, mhd->dri);
485 mhd->dri = 0;
486 }
487 MH2Int_MakeMenusInactive(mhd->win, mhd->firstmenupick, IntuitionBase);
488 mhd->active = FALSE;
489 }
490 }
491
492 /**************************************************************************************************/
493
494 static void HandleCheckItem(struct Window *win, struct MenuItem *item,
495 struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
496 {
497 /* Note: If you change something here, you probably must also change
498 menus.c/CheckMenuItemWasClicked() which is used when the
499 user uses the menu key shortcuts! */
500
501 WORD itemtype = ((win == mhd->menuwin) ? ITEM_ITEM : ITEM_SUBITEM);
502
503 BOOL re_render = FALSE;
504
505 if (item->Flags & MENUTOGGLE)
506 {
507 item->Flags ^= CHECKED;
508 re_render = TRUE;
509 }
510 else
511 {
512 if (!(item->Flags & CHECKED))
513 {
514 item->Flags |= CHECKED;
515 re_render = TRUE;
516 }
517 }
518
519 if (re_render)
520 {
521 BOOL toggle_hi = FALSE;
522
523 if ((item->Flags & HIGHITEM) &&
524 ((item->Flags & HIGHFLAGS) == HIGHCOMP)) toggle_hi = TRUE;
525
526 if (toggle_hi) HighlightItem(item, itemtype, mhd, IntuitionBase);
527 RenderCheckMark(item, itemtype, mhd, IntuitionBase);
528 if (toggle_hi) HighlightItem(item, itemtype, mhd, IntuitionBase);
529
530 }
531
532 if (item->MutualExclude)
533 {
534 struct MenuItem *checkitem = (itemtype == ITEM_ITEM) ? mhd->activemenu->FirstItem :
535 mhd->activeitem->SubItem;
536 BOOL toggle_hi = FALSE;
537 WORD i;
538
539 if ((item->Flags & HIGHITEM) &&
540 ((item->Flags & HIGHFLAGS) == HIGHBOX)) toggle_hi = TRUE;
541
542 if (toggle_hi) HighlightItem(item, itemtype, mhd, IntuitionBase);
543
544 for(i = 0; (i < 32) && checkitem; i++, checkitem = checkitem->NextItem)
545 {
546 if ((item->MutualExclude & (1L << i)) &&
547 ((checkitem->Flags & (CHECKED | CHECKIT)) == (CHECKIT | CHECKED)))
548 {
549 checkitem->Flags &= ~CHECKED;
550 RenderCheckMark(checkitem, itemtype, mhd, IntuitionBase);
551 }
552 }
553
554 if (toggle_hi) HighlightItem(item, itemtype, mhd, IntuitionBase);
555
556 } /* if (item->MutualExclude) */
557 }
558
559 /**************************************************************************************************/
560
561 static inline BOOL CustomDrawBackground(struct RastPort *rp, struct Window *win,
562 LONG itemleft, LONG itemtop, LONG itemwidth, LONG itemheight, UWORD flags,
563 struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
564 {
565 struct mdpDrawBackground msg;
566
567 msg.MethodID = MDM_DRAWBACKGROUND;
568 msg.mdp_RPort = rp;
569 msg.mdp_TrueColor = mhd->TrueColor;
570 msg.mdp_X = 0;
571 msg.mdp_Y = 0;
572 msg.mdp_Width = win->Width - 1;
573 msg.mdp_Height = win->Height - 1;
574 msg.mdp_ItemLeft = itemleft;
575 msg.mdp_ItemTop = itemtop;
576 msg.mdp_ItemWidth = itemwidth;
577 msg.mdp_ItemHeight = itemheight;
578 msg.mdp_Flags = flags;
579
580 msg.mdp_MenuDecorFlags = (MENUS_UNDERMOUSE(IntuitionBase)) ? MDP_MDF_MENUS_UNDERMOUSE : 0;
581 if (win == mhd->submenuwin) { msg.mdp_UserBuffer = mhd->SubDecorUserBuffer; msg.mdp_MenuDecorFlags |= MDP_MDF_SUBITEM; }
582 else if (win == mhd->menuwin) { msg.mdp_UserBuffer = mhd->DecorUserBuffer; msg.mdp_MenuDecorFlags |= MDP_MDF_ITEM; }
583 else { msg.mdp_UserBuffer = mhd->BarDecorUserBuffer; msg.mdp_MenuDecorFlags |= MDP_MDF_MENU; }
584
585 return DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
586 }
587
588 /**************************************************************************************************/
589
590 static void HighlightMenuTitle(struct Menu *menu, struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
591 {
592 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
593
594 if ((menu->Flags & MENUENABLED) && mhd->menubarwin)
595 {
596 struct RastPort *rp = mhd->menubarwin->RPort;
597 WORD x1, x2, y1, y2;
598
599 if (MENUS_UNDERMOUSE(IntuitionBase))
600 {
601 WORD i;
602 struct Menu *m = mhd->menu;
603
604 x1 = mhd->innerleft;
605
606 x2 = x1 + mhd->menubaritemwidth - 1;
607
608 for(i = 0; m != menu; m = m->NextMenu) i++;
609
610 y1 = mhd->innertop + i * mhd->menubaritemheight;
611 y2 = y1 + mhd->menubaritemheight - 1;
612
613 }
614 else
615 {
616 x1 = menu->LeftEdge + mhd->scr->BarHBorder - mhd->scr->MenuHBorder;
617 if (x1 < 0) x1 = 0;
618 y1 = 0;
619 x2 = x1 + menu->Width - 1;
620 y2 = mhd->scr->BarHeight - 1;
621 }
622
623 menu->Flags ^= HIGHITEM;
624 if (CustomDrawBackground(rp, mhd->win, x1, y1, x2 - x1 + 1, y2 - y1 + 1, menu->Flags, mhd, IntuitionBase))
625 {
626 RenderMenuTitle(menu, mhd, IntuitionBase);
627 return;
628 }
629
630 if (MENUS_AMIGALOOK(IntuitionBase))
631 {
632 SetDrMd(rp, COMPLEMENT);
633 RectFill(rp, x1, y1, x2, y2);
634 }
635 else
636 {
637 if (!MENUS_UNDERMOUSE(IntuitionBase))
638 y1++;
639
640 SetDrMd(rp, JAM1);
641 SetAPen(rp, mhd->dri->dri_Pens[(menu->Flags & HIGHITEM) ? FILLPEN : BACKGROUNDPEN]);
642 RectFill(rp, x1, y1, x2, y2);
643 RenderMenuTitle(menu, mhd, IntuitionBase);
644
645 if ((menu->Flags & HIGHITEM))
646 {
647 if (MENUS_UNDERMOUSE(IntuitionBase))
648 {
649 RenderFrame(rp, x1, y1, x2, y2, IDS_SELECTED, mhd, IntuitionBase);
650 }
651 else
652 {
653 SetAPen(rp, mhd->dri->dri_Pens[SHINEPEN]);
654 RectFill(rp, x1, y1, x1, y2);
655 SetAPen(rp, mhd->dri->dri_Pens[SHADOWPEN]);
656 RectFill(rp, x2, y1, x2, y2);
657 }
658 }
659 }
660 }
661 }
662
663 /**************************************************************************************************/
664
665 static struct Menu *FindMenu(WORD *var, struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
666 {
667 struct Menu *menu = NULL;
668 WORD mouse_x, mouse_y, i;
669
670 if(mhd->menubarwin)
671 {
672 mouse_x = mhd->scrmousex - mhd->menubarwin->LeftEdge;
673 mouse_y = mhd->scrmousey - mhd->menubarwin->TopEdge;
674
675 if (MENUS_UNDERMOUSE(IntuitionBase))
676 {
677 menu = NULL;
678
679 mouse_x -= mhd->innerleft;
680 mouse_y -= mhd->innertop;
681
682 if ((mouse_x >= 0) && (mouse_x < mhd->menubaritemwidth) && (mouse_y >= 0))
683 {
684 i = mouse_y / mhd->menubaritemheight;
685
686 if ((i >= 0) && (i < mhd->nummenubaritems))
687 {
688 WORD i2 = i;
689
690 menu = mhd->menu;
691 while(i && menu)
692 {
693 i--;
694 menu = menu->NextMenu;
695 }
696
697 if (menu && (i == 0))
698 {
699 *var = i2;
700 }
701 }
702 }
703 }
704 else
705 {
706 for(menu = mhd->menu, i = 0; menu; menu = menu->NextMenu, i++)
707 {
708 if ((mouse_x >= menu->LeftEdge) &&
709 (mouse_x < menu->LeftEdge + menu->Width) &&
710 (mouse_y >= 0) &&
711 (mouse_y <= mhd->scr->BarHeight))
712 {
713 *var = i;
714 break;
715 }
716 }
717 }
718 }
719 return menu;
720 }
721
722 /**************************************************************************************************/
723
724 static struct MenuItem *FindItem(WORD *var, struct MenuHandlerData *mhd)
725 {
726 struct MenuItem *item = NULL;
727 WORD mouse_x, mouse_y, i;
728
729 if (mhd->menuwin)
730 {
731 mouse_x = mhd->scrmousex - mhd->menuwin->LeftEdge
732 + mhd->activemenu->JazzX - mhd->innerleft - mhd->menuinnerleft;
733 mouse_y = mhd->scrmousey - mhd->menuwin->TopEdge
734 + mhd->activemenu->JazzY - mhd->innertop - mhd->menuinnertop;
735
736 for(item = mhd->activemenu->FirstItem, i = 0; item; item = item->NextItem, i++)
737 {
738 if ((mouse_x >= item->LeftEdge) &&
739 (mouse_x < item->LeftEdge + item->Width) &&
740 (mouse_y >= item->TopEdge) &&
741 (mouse_y < item->TopEdge + item->Height))
742 {
743 *var = i;
744 break;
745 }
746 }
747 } /* if (mhd->menuwin) */
748
749 if ((item == NULL) && !mhd->submenuwin) *var = -1;
750
751 return item;
752 }
753
754 /**************************************************************************************************/
755
756 static struct MenuItem *FindSubItem(WORD *var, struct MenuHandlerData *mhd)
757 {
758 struct MenuItem *item = NULL;
759 WORD mouse_x, mouse_y, i;
760
761 if (mhd->submenuwin)
762 {
763 mouse_x = mhd->scrmousex - mhd->submenuwin->LeftEdge + mhd->submenubox.MinX - mhd->menuinnerleft;
764 mouse_y = mhd->scrmousey - mhd->submenuwin->TopEdge + mhd->submenubox.MinY - mhd->menuinnertop;
765
766 *var = -1;
767
768 for(item = mhd->activeitem->SubItem, i = 0; item; item = item->NextItem, i++)
769 {
770 if ((mouse_x >= item->LeftEdge) &&
771 (mouse_x < item->LeftEdge + item->Width) &&
772 (mouse_y >= item->TopEdge) &&
773 (mouse_y < item->TopEdge + item->Height))
774 {
775 *var = i;
776 break;
777 }
778 }
779
780 } /* if (mhd->menuwin) */
781
782 return item;
783 }
784
785 /**************************************************************************************************/
786
787 static void MakeMenuBarWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
788 {
789 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
790 struct TagItem win_tags[] =
791 {
792 {WA_Left , 0 },
793 {WA_Top , 0 },
794 {WA_Width , mhd->scr->Width },
795 {WA_Height , mhd->scr->BarHeight + 1},
796 {WA_AutoAdjust , TRUE },
797 {WA_Borderless , TRUE },
798 {WA_CustomScreen, (IPTR)mhd->scr },
799 {WA_BackFill , (IPTR)LAYERS_NOBACKFILL},
800 {TAG_DONE , 0 }
801 };
802 struct Menu *menu;
803
804 mhd->menubarwin = NULL;
805 /* No entry to draw ? */
806 if(mhd->menu == NULL) return;
807
808 if (MENUS_UNDERMOUSE(IntuitionBase))
809 {
810 struct RastPort *temprp;
811 WORD w, maxw = 0;
812
813 if (!(temprp = CloneRastPort(&mhd->scr->RastPort))) return;
814
815 mhd->nummenubaritems = 0;
816 for(menu = mhd->menu; menu; menu = menu->NextMenu)
817 {
818 w = TextLength(temprp, menu->MenuName, strlen(menu->MenuName));
819 if (w > maxw) maxw = w;
820 mhd->nummenubaritems++;
821 }
822
823 mhd->menubaritemwidth = maxw + mhd->submenuimage->Width +
824 TEXT_AMIGAKEY_SPACING +
825 ITEXT_EXTRA_LEFT +
826 ITEXT_EXTRA_RIGHT;
827
828 if (temprp->TxHeight > mhd->submenuimage->Height)
829 {
830 mhd->menubaritemheight = temprp->TxHeight;
831 }
832 else
833 {
834 mhd->menubaritemheight = mhd->submenuimage->Height;
835 }
836
837 mhd->menubaritemheight += (ITEXT_EXTRA_TOP + ITEXT_EXTRA_BOTTOM);
838
839 struct mdpGetMenuSpaces msg;
840
841 msg.MethodID = MDM_GETMENUSPACES;
842 msg.mdp_TrueColor = mhd->TrueColor;
843 msg.mdp_InnerLeft = mhd->scr->MenuHBorder;
844 msg.mdp_InnerTop = mhd->scr->MenuVBorder;
845 msg.mdp_InnerRight = mhd->scr->MenuHBorder;
846 msg.mdp_InnerBottom = mhd->scr->MenuVBorder;
847 msg.mdp_ItemInnerLeft = 0;
848 msg.mdp_ItemInnerTop = 0;
849 msg.mdp_ItemInnerRight = 0;
850 msg.mdp_ItemInnerBottom = 0;
851 msg.mdp_MinWidth = 0;
852 msg.mdp_MinHeight = 0;
853 DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
854 mhd->innerleft = msg.mdp_InnerLeft;
855 mhd->innerright = msg.mdp_InnerRight;
856 mhd->innertop = msg.mdp_InnerTop;
857 mhd->innerbottom = msg.mdp_InnerBottom;
858 mhd->iteminnerleft = msg.mdp_ItemInnerLeft;
859 mhd->iteminnerright = msg.mdp_ItemInnerRight;
860 mhd->iteminnertop = msg.mdp_ItemInnerTop;
861 mhd->iteminnerbottom = msg.mdp_ItemInnerBottom;
862 mhd->menubaritemwidth += (mhd->iteminnerleft + mhd->iteminnerright);
863 mhd->menubaritemheight += (mhd->iteminnertop + mhd->iteminnerbottom);
864
865 win_tags[2].ti_Data = mhd->menubaritemwidth + mhd->innerleft + mhd->innerright;
866 win_tags[3].ti_Data = mhd->menubaritemheight * mhd->nummenubaritems + mhd->innertop + mhd->innerbottom;
867
868 if (win_tags[2].ti_Data < msg.mdp_MinWidth)
869 {
870 mhd->menubaritemwidth += (msg.mdp_MinWidth - win_tags[2].ti_Data);
871 win_tags[2].ti_Data = msg.mdp_MinWidth;
872 }
873
874 if (win_tags[3].ti_Data < msg.mdp_MinHeight)
875 {
876 win_tags[3].ti_Data = msg.mdp_MinHeight;
877 }
878
879 WORD PosX = mhd->scr->MouseX - win_tags[2].ti_Data / 2;
880 win_tags[1].ti_Data = mhd->scr->MouseY;
881
882 if ((PosX + win_tags[2].ti_Data) > mhd->scr->Width) PosX = mhd->scr->Width - win_tags[2].ti_Data;
883 if ((win_tags[1].ti_Data + win_tags[3].ti_Data) > mhd->scr->Height) win_tags[1].ti_Data = mhd->scr->Height - win_tags[3].ti_Data;
884 if (PosX < 0) PosX = 0;
885 if (win_tags[1].ti_Data > 32000) win_tags[1].ti_Data = 0;
886
887 win_tags[0].ti_Data = PosX;
888
889 FreeRastPort(temprp);
890 }
891
892 {
893 IPTR userbuffersize;
894 struct mdpInitMenu msg;
895
896 GetAttr(MDA_UserBuffer, ((struct IntScreen *)(mhd->scr))->MenuDecorObj, &userbuffersize);
897
898 if (userbuffersize)
899 {
900 mhd->DecorUserBufferSize = userbuffersize;
901 mhd->BarDecorUserBuffer = (IPTR) AllocMem(userbuffersize, MEMF_ANY | MEMF_CLEAR);
902 if (0 == mhd->BarDecorUserBuffer) return;
903 }
904
905 msg.MethodID = MDM_INITMENU;
906 msg.mdp_TrueColor = mhd->TrueColor;
907 msg.mdp_RPort = &mhd->scr->RastPort;
908 msg.mdp_Left = win_tags[0].ti_Data;
909 msg.mdp_Top = win_tags[1].ti_Data;
910 msg.mdp_Width = win_tags[2].ti_Data;
911 msg.mdp_Height = win_tags[3].ti_Data;
912 msg.mdp_UserBuffer = mhd->BarDecorUserBuffer;
913 msg.mdp_ScreenUserBuffer = ((struct IntScreen *) mhd->scr)->DecorUserBuffer;
914 msg.mdp_MenuDecorFlags = (MENUS_UNDERMOUSE(IntuitionBase)) ? MDP_MDF_MENUS_UNDERMOUSE : 0;
915 msg.mdp_MenuDecorFlags |= MDP_MDF_MENU;
916
917 msg.mdp_Screen = mhd->scr;
918
919 DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
920 }
921
922
923 D(bug("MakeMenuBarWin: mhd 0x%lx\n", mhd));
924
925 mhd->menubarwin = OpenWindowTagList(0, win_tags);
926
927 for(menu = mhd->menu; menu; menu = menu->NextMenu)
928 {
929 menu->Flags &= ~HIGHITEM;
930 }
931
932 RenderMenuBar(mhd, IntuitionBase);
933 }
934
935 /**************************************************************************************************/
936
937 static void KillMenuBarWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
938 {
939 if (mhd->menubarwin)
940 {
941 struct mdpExitMenu msg;
942
943 CloseWindow(mhd->menubarwin);
944 mhd->menubarwin = NULL;
945
946 msg.MethodID = MDM_EXITMENU;
947 msg.mdp_UserBuffer = mhd->BarDecorUserBuffer;
948 msg.mdp_TrueColor = mhd->TrueColor;
949 DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
950
951 if (mhd->BarDecorUserBuffer)
952 {
953 FreeMem((void *)mhd->BarDecorUserBuffer, mhd->DecorUserBufferSize);
954 }
955 mhd->BarDecorUserBuffer = 0;
956 }
957
958 }
959
960 /**************************************************************************************************/
961
962 static void RenderMenuBar(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
963 {
964 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
965 if (mhd->menubarwin)
966 {
967 struct Menu *menu = mhd->menu;
968 struct Window *win = mhd->menubarwin;
969 struct RastPort *rp = win->RPort;
970
971 SetFont(rp, mhd->dri->dri_Font);
972
973 /* Bar renders using different pens in Amiga mode than rest of menu */
974 if (MENUS_UNDERMOUSE(IntuitionBase))
975 {
976 RenderMenuBG(win, mhd, IntuitionBase);
977 }
978 else
979 {
980 if (!CustomDrawBackground(rp, win, 0, 0, win->Width - 1, win->Height - 1, 0, mhd, IntuitionBase))
981 {
982 if (MENUS_AMIGALOOK(IntuitionBase))
983 {
984 SetABPenDrMd(rp, mhd->dri->dri_Pens[BARBLOCKPEN], 0, JAM1);
985 }
986 else
987 {
988 SetABPenDrMd(rp, mhd->dri->dri_Pens[BACKGROUNDPEN], 0, JAM1);
989 }
990
991 RectFill(rp, 0, 0, win->Width - 1, win->Height - 2);
992
993 SetAPen(rp, mhd->dri->dri_Pens[BARTRIMPEN]);
994 RectFill(rp, 0, win->Height - 1, win->Width - 1, win->Height - 1);
995
996 if (!MENUS_AMIGALOOK(IntuitionBase))
997 {
998 SetAPen(rp, mhd->dri->dri_Pens[SHINEPEN]);
999 RectFill(rp, 0, 0, 0, win->Height - 2);
1000 RectFill(rp, 1, 0, win->Width - 1, 0);
1001 SetAPen(rp, mhd->dri->dri_Pens[SHADOWPEN]);
1002 RectFill(rp, win->Width - 1, 1, win->Width - 1, win->Height - 2);
1003 }
1004 }
1005 }
1006
1007 for(; menu; menu = menu->NextMenu)
1008 {
1009 RenderMenuTitle(menu, mhd, IntuitionBase);
1010 }
1011 }
1012 }
1013
1014 /**************************************************************************************************/
1015
1016 static void RenderMenuTitle(struct Menu *menu, struct MenuHandlerData *mhd,
1017 struct IntuitionBase *IntuitionBase)
1018 {
1019 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1020 struct RastPort *rp;
1021 WORD len = 0;
1022 WORD x, y;
1023
1024 if (menu->MenuName)
1025 len = strlen(menu->MenuName);
1026 else
1027 {
1028 bug("Intuition: MenuEntry with missing string @ 0x%p\n", menu);
1029 }
1030
1031 if(mhd->menubarwin)
1032 {
1033 rp = mhd->menubarwin->RPort;
1034 SetDrMd(rp, JAM1);
1035
1036 if (MENUS_UNDERMOUSE(IntuitionBase))
1037 {
1038 struct Menu *m;
1039 WORD yoff;
1040
1041 yoff = 0;
1042 for(m = mhd->menu; m && (m != menu);m = m ->NextMenu)
1043 {
1044 yoff++;
1045 }
1046
1047 x = mhd->innerleft + ITEXT_EXTRA_LEFT;
1048 y = mhd->innertop + ITEXT_EXTRA_TOP + yoff * mhd->menubaritemheight;
1049 }
1050 else
1051 {
1052 x = mhd->scr->BarHBorder + menu->LeftEdge;
1053 y = mhd->scr->BarVBorder + ((mhd->scr->BarHeight - rp->Font->tf_YSize) / 2);
1054 }
1055
1056 if (menu->MenuName)
1057 {
1058 if (MENUS_AMIGALOOK(IntuitionBase))
1059 {
1060 SetAPen(rp, mhd->dri->dri_Pens[BARDETAILPEN]);
1061 }
1062 else
1063 {
1064 SetAPen(rp, mhd->dri->dri_Pens[(menu->Flags & HIGHITEM) ? FILLTEXTPEN : TEXTPEN]);
1065 }
1066
1067 Move(rp, x, y + rp->TxBaseline);
1068 Text(rp, menu->MenuName, len);
1069 }
1070
1071 if (MENUS_UNDERMOUSE(IntuitionBase))
1072 {
1073 if (menu->FirstItem)
1074 {
1075 WORD x2 = mhd->scr->MenuHBorder + mhd->menubaritemwidth - ITEXT_EXTRA_RIGHT - mhd->submenuimage->Width;
1076
1077 DrawImageState(rp, mhd->submenuimage, x2, y + ((mhd->menubaritemheight - mhd->submenuimage->Height) >> 1), IDS_NORMAL, mhd->dri);
1078 }
1079 }
1080
1081 if (!(menu->Flags & MENUENABLED))
1082 {
1083 WORD y2 = y + rp->TxHeight - 1;
1084 WORD x2;
1085
1086 if (MENUS_UNDERMOUSE(IntuitionBase))
1087 {
1088 x2 = mhd->scr->MenuHBorder + mhd->menubaritemwidth - 1;
1089 }
1090 else if (menu->MenuName)
1091 {
1092 x2 = x + TextLength(rp, menu->MenuName, len) - 1;
1093 } else {
1094 x2 = x + TextLength(rp, " ", 1) - 1;
1095 }
1096
1097 RenderDisabledPattern(rp, x, y, x2, y2, mhd, IntuitionBase);
1098 }
1099 }
1100 }
1101
1102 /**************************************************************************************************/
1103
1104 static void MakeMenuWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1105 {
1106 struct MenuItem *item;
1107
1108 WORD width = mhd->activemenu->BeatX - mhd->activemenu->JazzX + 1;
1109 WORD height = mhd->activemenu->BeatY - mhd->activemenu->JazzY + 1;
1110 WORD xpos,ypos;
1111
1112 struct mdpGetMenuSpaces msg;
1113
1114 msg.MethodID = MDM_GETMENUSPACES;
1115 msg.mdp_TrueColor = mhd->TrueColor;
1116 msg.mdp_InnerLeft = 0;
1117 msg.mdp_InnerTop = 0;
1118 msg.mdp_InnerRight = 0;
1119 msg.mdp_InnerBottom = 0;
1120 msg.mdp_ItemInnerLeft = 0;
1121 msg.mdp_ItemInnerTop = 0;
1122 msg.mdp_ItemInnerRight = 0;
1123 msg.mdp_ItemInnerBottom = 0;
1124 DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
1125 mhd->menuinnerleft = msg.mdp_InnerLeft;
1126 mhd->menuinnerright = msg.mdp_InnerRight;
1127 mhd->menuinnertop = msg.mdp_InnerTop;
1128 mhd->menuinnerbottom = msg.mdp_InnerBottom;
1129
1130 width += (mhd->menuinnerleft + mhd->menuinnerright);
1131 height += (mhd->menuinnertop + mhd->menuinnerbottom);
1132
1133 if (MENUS_UNDERMOUSE(IntuitionBase))
1134 {
1135 xpos = mhd->menubarwin->LeftEdge + mhd->menubarwin->Width - 16;
1136 ypos = mhd->menubarwin->TopEdge;
1137 }
1138 else
1139 {
1140 xpos = mhd->activemenu->LeftEdge + mhd->scr->BarHBorder + mhd->activemenu->JazzX;
1141
1142 if (MENUS_AMIGALOOK(IntuitionBase))
1143 {
1144 ypos = mhd->scr->BarHeight + 1 + mhd->activemenu->JazzY;
1145 }
1146 else
1147 {
1148 ypos = mhd->scr->BarHeight + 1;
1149 }
1150 }
1151
1152 {
1153 struct TagItem win_tags[] =
1154 {
1155 {WA_Left , xpos },
1156 {WA_Top , ypos },
1157 {WA_Width , width },
1158 {WA_Height , height },
1159 {WA_AutoAdjust , TRUE },
1160 {WA_Borderless , TRUE },
1161 {WA_CustomScreen, (IPTR)mhd->scr },
1162 {WA_BackFill , (IPTR)LAYERS_NOBACKFILL},
1163 {TAG_DONE , 0 }
1164 };
1165
1166 if (MENUS_UNDERMOUSE(IntuitionBase))
1167 {
1168 win_tags[1].ti_Data += (mhd->menubaritemheight * mhd->activemenunum + mhd->scr->MenuVBorder) -
1169 height / 2;
1170 if (xpos + width > mhd->scr->Width)
1171 {
1172 win_tags[0].ti_Data = mhd->menubarwin->LeftEdge - width + 16;
1173 }
1174 }
1175
1176 if ((win_tags[0].ti_Data + win_tags[2].ti_Data) > mhd->scr->Width) win_tags[0].ti_Data = mhd->scr->Width - win_tags[2].ti_Data;
1177 if ((win_tags[1].ti_Data + win_tags[3].ti_Data) > mhd->scr->Height) win_tags[1].ti_Data = mhd->scr->Height - win_tags[3].ti_Data;
1178 if (((LONG) win_tags[0].ti_Data) < 0) win_tags[0].ti_Data = 0;
1179 if (((LONG) win_tags[1].ti_Data) < 0) win_tags[1].ti_Data = 0;
1180
1181 if ((item = mhd->activemenu->FirstItem))
1182 {
1183
1184 while(item)
1185 {
1186 item->Flags &= ~HIGHITEM;
1187 item = item->NextItem;
1188 }
1189
1190 IPTR userbuffersize;
1191
1192 GetAttr(MDA_UserBuffer, ((struct IntScreen *)(mhd->scr))->MenuDecorObj, &userbuffersize);
1193
1194 if (userbuffersize)
1195 {
1196 mhd->DecorUserBufferSize = userbuffersize;
1197 mhd->DecorUserBuffer = (IPTR) AllocMem(userbuffersize, MEMF_ANY | MEMF_CLEAR);
1198 if (0 == mhd->DecorUserBuffer) return;
1199 }
1200
1201 struct mdpInitMenu msg;
1202
1203 msg.MethodID = MDM_INITMENU;
1204 msg.mdp_TrueColor = mhd->TrueColor;
1205 msg.mdp_RPort = &mhd->scr->RastPort;
1206 msg.mdp_Left = win_tags[0].ti_Data;
1207 msg.mdp_Top = win_tags[1].ti_Data;
1208 msg.mdp_Width = width;
1209 msg.mdp_Height = height;
1210 msg.mdp_UserBuffer = mhd->DecorUserBuffer;
1211 msg.mdp_ScreenUserBuffer = ((struct IntScreen *) mhd->scr)->DecorUserBuffer;
1212 msg.mdp_Screen = mhd->scr;
1213 msg.mdp_MenuDecorFlags = (MENUS_UNDERMOUSE(IntuitionBase)) ? MDP_MDF_MENUS_UNDERMOUSE : 0;
1214 msg.mdp_MenuDecorFlags |= MDP_MDF_ITEM;
1215
1216 DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
1217
1218 mhd->menuwin = OpenWindowTagList(0, win_tags);
1219
1220 mhd->maxcommkeywidth_menu = CalcMaxCommKeyWidth(mhd->menuwin, mhd, IntuitionBase);
1221
1222 RenderMenu(mhd, IntuitionBase);
1223
1224 mhd->activemenu->Flags |= MIDRAWN;
1225 }
1226 }
1227 }
1228
1229 /**************************************************************************************************/
1230
1231 static void KillMenuWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1232 {
1233 if (mhd->menuwin)
1234 {
1235 struct MenuItem *item;
1236
1237 CloseWindow(mhd->menuwin);
1238 mhd->menuwin = NULL;
1239
1240 TimeDelay(UNIT_VBLANK,0,20000);
1241
1242 for(item = mhd->activemenu->FirstItem; item; item = item->NextItem)
1243 {
1244 item->Flags &= ~ISDRAWN;
1245 }
1246 struct mdpExitMenu msg;
1247
1248 msg.MethodID = MDM_EXITMENU;
1249 msg.mdp_TrueColor = mhd->TrueColor;
1250 msg.mdp_UserBuffer = mhd->DecorUserBuffer;
1251 DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
1252
1253 if (mhd->DecorUserBuffer)
1254 {
1255 FreeMem((void *)mhd->DecorUserBuffer, mhd->DecorUserBufferSize);
1256 }
1257 mhd->DecorUserBuffer = 0;
1258
1259 mhd->activemenu->Flags &= ~MIDRAWN;
1260
1261 mhd->activeitemnum = -1;
1262 mhd->activeitem = NULL;
1263 }
1264 }
1265
1266 /**************************************************************************************************/
1267
1268 static void RenderMenu(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1269 {
1270 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1271
1272 if (mhd->menuwin)
1273 {
1274 struct MenuItem *item;
1275
1276 RenderMenuBG(mhd->menuwin, mhd, IntuitionBase);
1277
1278 SetFont(mhd->menuwin->RPort, mhd->dri->dri_Font);
1279
1280 for(item = mhd->activemenu->FirstItem; item; item = item->NextItem)
1281 {
1282 RenderItem(item, ITEM_ITEM, (struct Rectangle *)(&mhd->activemenu->JazzX), mhd, IntuitionBase);
1283 }
1284
1285 } /* if (mhd->menuwin) */
1286 }
1287
1288 /**************************************************************************************************/
1289
1290 static void MakeSubMenuWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1291 {
1292 struct MenuItem *item = mhd->activeitem->SubItem;
1293
1294 struct TagItem win_tags[] =
1295 {
1296 {WA_Left , 0 },
1297 {WA_Top , 0 },
1298 {WA_Width , 0 },
1299 {WA_Height , 0 },
1300 {WA_AutoAdjust , TRUE },
1301 {WA_Borderless , TRUE },
1302 {WA_CustomScreen, (IPTR)mhd->scr },
1303 {WA_BackFill , (IPTR)LAYERS_NOBACKFILL },
1304 {TAG_DONE }
1305 };
1306
1307 if(mhd->menubarwin)
1308 {
1309 GetMenuBox(mhd->menubarwin, item, &mhd->submenubox.MinX,
1310 &mhd->submenubox.MinY,
1311 &mhd->submenubox.MaxX,
1312 &mhd->submenubox.MaxY);
1313
1314 {
1315 struct mdpGetMenuSpaces msg;
1316
1317 msg.MethodID = MDM_GETMENUSPACES;
1318 msg.mdp_TrueColor = mhd->TrueColor;
1319 msg.mdp_InnerLeft = 0;
1320 msg.mdp_InnerTop = 0;
1321 msg.mdp_InnerRight = 0;
1322 msg.mdp_InnerBottom = 0;
1323
1324 DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
1325 mhd->menuinnerleft = msg.mdp_InnerLeft;
1326 mhd->menuinnerright = msg.mdp_InnerRight;
1327 mhd->menuinnertop = msg.mdp_InnerTop;
1328 mhd->menuinnerbottom = msg.mdp_InnerBottom;
1329 }
1330
1331 win_tags[0].ti_Data = mhd->menuwin->LeftEdge +
1332 mhd->activeitem->LeftEdge - mhd->activemenu->JazzX +
1333 mhd->submenubox.MinX;
1334
1335 win_tags[1].ti_Data = mhd->menuwin->TopEdge +
1336 mhd->activeitem->TopEdge - mhd->activemenu->JazzY +
1337 mhd->submenubox.MinY;
1338
1339 win_tags[2].ti_Data = mhd->submenubox.MaxX - mhd->submenubox.MinX + 1 + mhd->menuinnerleft + mhd->menuinnerright;
1340 win_tags[3].ti_Data = mhd->submenubox.MaxY - mhd->submenubox.MinY + 1 + mhd->menuinnertop + mhd->menuinnerbottom;
1341
1342 if ((win_tags[0].ti_Data + win_tags[2].ti_Data) > mhd->scr->Width) win_tags[0].ti_Data = mhd->scr->Width - win_tags[2].ti_Data;
1343 if ((win_tags[1].ti_Data + win_tags[3].ti_Data) > mhd->scr->Height) win_tags[1].ti_Data = mhd->scr->Height - win_tags[3].ti_Data;
1344 if (((LONG) win_tags[0].ti_Data) < 0) win_tags[0].ti_Data = 0;
1345 if (((LONG) win_tags[1].ti_Data) < 0) win_tags[1].ti_Data = 0;
1346
1347 while(item)
1348 {
1349 item->Flags &= ~HIGHITEM;
1350 item = item->NextItem;
1351 }
1352
1353 IPTR userbuffersize;
1354
1355 GetAttr(MDA_UserBuffer, ((struct IntScreen *)(mhd->scr))->MenuDecorObj, &userbuffersize);
1356
1357 if (userbuffersize)
1358 {
1359 mhd->DecorUserBufferSize = userbuffersize;
1360 mhd->SubDecorUserBuffer = (IPTR) AllocMem(userbuffersize, MEMF_ANY | MEMF_CLEAR);
1361 if (0 == mhd->SubDecorUserBuffer) return;
1362 }
1363
1364 {
1365 struct mdpInitMenu msg;
1366 msg.MethodID = MDM_INITMENU;
1367 msg.mdp_TrueColor = mhd->TrueColor;
1368 msg.mdp_RPort = &mhd->scr->RastPort;
1369 msg.mdp_Left = win_tags[0].ti_Data;
1370 msg.mdp_Top = win_tags[1].ti_Data;
1371 msg.mdp_Width = win_tags[2].ti_Data;
1372 msg.mdp_Height = win_tags[3].ti_Data;
1373 msg.mdp_UserBuffer = mhd->SubDecorUserBuffer;
1374 msg.mdp_ScreenUserBuffer = ((struct IntScreen *) mhd->scr)->DecorUserBuffer;
1375 msg.mdp_TrueColor = mhd->TrueColor;
1376 msg.mdp_Screen = mhd->scr;
1377 msg.mdp_MenuDecorFlags = (MENUS_UNDERMOUSE(IntuitionBase)) ? MDP_MDF_MENUS_UNDERMOUSE : 0;
1378 msg.mdp_MenuDecorFlags |= MDP_MDF_SUBITEM;
1379
1380 DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
1381 }
1382 mhd->submenuwin = OpenWindowTagList(0, win_tags);
1383
1384 mhd->maxcommkeywidth_submenu = CalcMaxCommKeyWidth(mhd->submenuwin, mhd, IntuitionBase);
1385
1386 RenderSubMenu(mhd, IntuitionBase);
1387 }
1388 }
1389
1390 /**************************************************************************************************/
1391
1392 static void KillSubMenuWin(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1393 {
1394 if (mhd->submenuwin)
1395 {
1396 CloseWindow(mhd->submenuwin);
1397
1398 TimeDelay(UNIT_VBLANK,0,20000);
1399 struct mdpExitMenu msg;
1400
1401 msg.MethodID = MDM_EXITMENU;
1402 msg.mdp_TrueColor = mhd->TrueColor;
1403 msg.mdp_UserBuffer = mhd->SubDecorUserBuffer;
1404 DoMethodA(((struct IntScreen *)(mhd->scr))->MenuDecorObj, (Msg)&msg);
1405
1406 if (mhd->SubDecorUserBuffer)
1407 {
1408 FreeMem((void *)mhd->SubDecorUserBuffer, mhd->DecorUserBufferSize);
1409 }
1410 mhd->SubDecorUserBuffer = 0;
1411
1412 mhd->submenuwin = NULL;
1413
1414 mhd->activesubitemnum = -1;
1415 mhd->activesubitem = NULL;
1416 }
1417 }
1418
1419 /**************************************************************************************************/
1420
1421 static void RenderSubMenu(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1422 {
1423 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1424
1425 if (mhd->submenuwin)
1426 {
1427 struct MenuItem *item;
1428
1429 RenderMenuBG(mhd->submenuwin, mhd, IntuitionBase);
1430
1431 SetFont(mhd->submenuwin->RPort, mhd->dri->dri_Font);
1432
1433 for(item = mhd->activeitem->SubItem; item; item = item->NextItem)
1434 {
1435 RenderItem(item, ITEM_SUBITEM, (struct Rectangle *)(&mhd->submenubox), mhd, IntuitionBase);
1436 }
1437
1438 } /* if (mhd->submenuwin) */
1439 }
1440
1441 /**************************************************************************************************/
1442
1443 static void RenderItem(struct MenuItem *item, WORD itemtype, struct Rectangle *box,
1444 struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1445 {
1446 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1447 struct Window *win = ((itemtype == ITEM_ITEM) ? mhd->menuwin : mhd->submenuwin);
1448 struct RastPort *rp = win->RPort;
1449 WORD offx = -box->MinX + mhd->menuinnerleft;
1450 WORD offy = -box->MinY + mhd->menuinnertop;
1451 BOOL enabled = ((item->Flags & ITEMENABLED) &&
1452 (mhd->activemenu->Flags & MENUENABLED) &&
1453 ((itemtype == ITEM_ITEM) || (mhd->activeitem->Flags & ITEMENABLED)));
1454 BOOL item_supports_disable = FALSE;
1455
1456 SetDrMd(rp, JAM1);
1457
1458 if (item->ItemFill)
1459 {
1460
1461 if (item->Flags & ITEMTEXT)
1462 {
1463 struct IntuiText *save = ((struct IntuiText*) item->ItemFill)->NextText;
1464
1465 if (item->SubItem)
1466 {
1467 Forbid();
1468 ((struct IntuiText*) item->ItemFill)->NextText = NULL;
1469 }
1470
1471 struct IntuiText *it = (struct IntuiText *)item->ItemFill;
1472
1473 if (MENUS_AMIGALOOK(IntuitionBase))
1474 {
1475 PrintIText(rp, it, offx + item->LeftEdge, offy + item->TopEdge);
1476 }
1477 else
1478 {
1479 it->FrontPen = mhd->dri->dri_Pens[(item->Flags & HIGHITEM) ? FILLTEXTPEN : TEXTPEN];
1480 it->DrawMode = JAM1;
1481
1482 PrintIText(rp, it, offx + item->LeftEdge, offy + item->TopEdge);
1483 }
1484 if (item->SubItem)
1485 {
1486 DrawImageState(rp, mhd->submenuimage, offx + item->Width - mhd->submenuimage->Width, offy + item->TopEdge + ((item->Height - mhd->submenuimage->Height) >> 1), IDS_NORMAL, mhd->dri);
1487 ((struct IntuiText*) item->ItemFill)->NextText = save;
1488 Permit();
1489 }
1490 }
1491 else
1492 {
1493 struct Image *im = (struct Image *)item->ItemFill;
1494 LONG state = IDS_NORMAL;
1495
1496 if (!enabled && (im->Depth == CUSTOMIMAGEDEPTH))
1497 {
1498 IPTR val = 0;
1499
1500 GetAttr(IA_SupportsDisable, (Object *)im, &val);
1501 if (val)
1502 {
1503 item_supports_disable = TRUE;
1504 state = IDS_DISABLED;
1505 }
1506 }
1507
1508 DrawImageState(rp, im, offx + item->LeftEdge, offy + item->TopEdge, state, mhd->dri);
1509 }
1510
1511 } /* if (item->ItemFill) */
1512
1513 RenderCheckMark(item, itemtype, mhd, IntuitionBase);
1514 RenderAmigaKey(item, itemtype, mhd, IntuitionBase);
1515
1516 if (!enabled && !item_supports_disable)
1517 {
1518 RenderDisabledPattern(rp, offx + item->LeftEdge,
1519 offy + item->TopEdge,
1520 offx + item->LeftEdge + item->Width - 1,
1521 offy + item->TopEdge + item->Height - 1,
1522 mhd,
1523 IntuitionBase);
1524 }
1525
1526 }
1527
1528 /**************************************************************************************************/
1529
1530 static void RenderMenuBG(struct Window *win, struct MenuHandlerData *mhd,
1531 struct IntuitionBase *IntuitionBase)
1532 {
1533
1534 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1535 struct RastPort *rp = win->RPort;
1536 WORD borderx, bordery;
1537
1538 if (CustomDrawBackground(rp, win, 0, 0, win->Width - 1, win->Height - 1, 0, mhd, IntuitionBase)) return;
1539
1540 if (MENUS_AMIGALOOK(IntuitionBase))
1541 {
1542 borderx = mhd->scr->MenuHBorder / 2;
1543 bordery = mhd->scr->MenuVBorder / 2;
1544 }
1545 else
1546 {
1547 borderx = 1;
1548 bordery = 1;
1549 }
1550
1551 /* White background */
1552
1553 if (MENUS_AMIGALOOK(IntuitionBase))
1554 {
1555 SetABPenDrMd(rp, mhd->dri->dri_Pens[BARBLOCKPEN], 0, JAM1);
1556 }
1557 else
1558 {
1559 SetABPenDrMd(rp, mhd->dri->dri_Pens[BACKGROUNDPEN], 0, JAM1);
1560 }
1561
1562 RectFill(rp, borderx,
1563 bordery,
1564 win->Width - 1 - borderx,
1565 win->Height - 1 - bordery);
1566
1567 /* Black border frame */
1568
1569 if (MENUS_AMIGALOOK(IntuitionBase))
1570 {
1571 SetAPen(rp, mhd->dri->dri_Pens[BARDETAILPEN]);
1572 RectFill(rp, 0, 0, win->Width - 1, bordery - 1);
1573 RectFill(rp, 0, bordery, borderx - 1, win->Height - 1 - bordery);
1574 RectFill(rp, win->Width - borderx, bordery, win->Width - 1, win->Height - 1);
1575 RectFill(rp, 0, win->Height - bordery, win->Width - 1 - borderx, win->Height - 1);
1576 }
1577 else
1578 {
1579 RenderFrame(rp, 0, 0, win->Width - 1, win->Height - 1, IDS_NORMAL, mhd, IntuitionBase);
1580 }
1581 }
1582
1583 /**************************************************************************************************/
1584
1585 static void RenderCheckMark(struct MenuItem *item, WORD itemtype, struct MenuHandlerData *mhd,
1586 struct IntuitionBase *IntuitionBase)
1587 {
1588 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1589 struct Window *win = ((itemtype == ITEM_ITEM) ? mhd->menuwin : mhd->submenuwin);
1590 struct RastPort *rp = win->RPort;
1591 struct Rectangle *box = ((itemtype == ITEM_ITEM) ? ((struct Rectangle *)&mhd->activemenu->JazzX) : &mhd->submenubox);
1592 WORD offx = -box->MinX + mhd->menuinnerleft;
1593 WORD offy = -box->MinY + mhd->menuinnertop;
1594 WORD state = ((item->Flags & HIGHITEM) &&
1595 ((item->Flags & HIGHFLAGS) == HIGHCOMP)) ? IDS_SELECTED : IDS_NORMAL;
1596
1597 if (item->Flags & CHECKIT)
1598 {
1599 WORD x1, y1, x2, y2;
1600
1601 x1 = item->LeftEdge + offx;
1602 y1 = item->TopEdge + offy + (item->Height - mhd->checkmark->Height) / 2;
1603 x2 = x1 + mhd->checkmark->Width - 1;
1604 y2 = y1 + mhd->checkmark->Height - 1;
1605
1606 SetDrMd(rp, JAM1);
1607
1608 if (item->Flags & CHECKED)
1609 {
1610 DrawImageState(rp, mhd->checkmark, x1, y1, state, mhd->dri);
1611 }
1612 else
1613 {
1614 if (MENUS_AMIGALOOK(IntuitionBase))
1615 {
1616 SetAPen(rp, mhd->dri->dri_Pens[BARBLOCKPEN]);
1617 }
1618 else
1619 {
1620 SetAPen(rp, mhd->dri->dri_Pens[(state == IDS_SELECTED) ? FILLPEN : BACKGROUNDPEN]);
1621 }
1622
1623 if (!CustomDrawBackground(rp, win, x1, y1, x2 - x1 + 1, y2 - y1 + 1, item->Flags, mhd, IntuitionBase)) RectFill(rp, x1, y1, x2, y2);
1624 }
1625 }
1626
1627 }
1628
1629 /**************************************************************************************************/
1630
1631 static void RenderAmigaKey(struct MenuItem *item, WORD itemtype, struct MenuHandlerData *mhd,
1632 struct IntuitionBase *IntuitionBase)
1633 {
1634 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1635 struct Window *win = ((itemtype == ITEM_ITEM) ? mhd->menuwin : mhd->submenuwin);
1636 struct RastPort *rp = win->RPort;
1637 struct Rectangle *box = ((itemtype == ITEM_ITEM) ? ((struct Rectangle *)&mhd->activemenu->JazzX) : &mhd->submenubox);
1638 WORD commkeywidth = ((itemtype == ITEM_ITEM) ? mhd->maxcommkeywidth_menu : mhd->maxcommkeywidth_submenu);
1639 WORD offx = -box->MinX + mhd->menuinnerleft;
1640 WORD offy = -box->MinY + mhd->menuinnertop;
1641 WORD state = ((item->Flags & HIGHITEM) &&
1642 ((item->Flags & HIGHFLAGS) == HIGHCOMP)) ? IDS_SELECTED : IDS_NORMAL;
1643
1644 if (item->Flags & COMMSEQ)
1645 {
1646 struct TextFont *oldfont = rp->Font;
1647 struct TextFont *newfont = NULL;
1648
1649 WORD x1, y1;
1650
1651 if (item->Flags & ITEMTEXT)
1652 {
1653 struct IntuiText *it = (struct IntuiText *)item->ItemFill;
1654
1655 if (it->ITextFont)
1656 {
1657 if ((newfont = OpenFont(it->ITextFont)))
1658 {
1659 SetFont(rp, newfont);
1660 }
1661 }
1662 }
1663
1664 x1 = item->LeftEdge + offx + item->Width - AMIGAKEY_BORDER_SPACING -
1665 mhd->amigakey->Width - AMIGAKEY_KEY_SPACING - commkeywidth;
1666 y1 = item->TopEdge + offy + (item->Height - mhd->amigakey->Height + 1) / 2;
1667
1668 SetDrMd(rp, JAM1);
1669
1670 DrawImageState(rp, mhd->amigakey, x1, y1, state, mhd->dri);
1671
1672 x1 += mhd->amigakey->Width + AMIGAKEY_KEY_SPACING;
1673
1674 if (MENUS_AMIGALOOK(IntuitionBase))
1675 {
1676 SetAPen(rp, mhd->dri->dri_Pens[BARDETAILPEN]);
1677 }
1678 else
1679 {
1680 SetAPen(rp, mhd->dri->dri_Pens[(item->Flags & HIGHITEM) ? FILLTEXTPEN : TEXTPEN]);
1681 }
1682
1683 Move(rp, x1, item->TopEdge + offy + (item->Height - rp->TxHeight) / 2 +
1684 rp->TxBaseline);
1685 Text(rp, &item->Command, 1);
1686
1687 if (newfont)
1688 {
1689 CloseFont(newfont);
1690 SetFont(rp, oldfont);
1691 }
1692
1693 } /* if (item->Flags & COMMSEQ) */
1694 }
1695
1696 /**************************************************************************************************/
1697
1698 static void RenderDisabledPattern(struct RastPort *rp, WORD x1, WORD y1, WORD x2, WORD y2,
1699 struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1700 {
1701 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1702 static CONST UWORD pattern [] = {0x8888, 0x2222};
1703
1704 SetDrMd(rp, JAM1);
1705
1706 if (MENUS_AMIGALOOK(IntuitionBase))
1707 {
1708 SetAPen(rp, mhd->dri->dri_Pens[BARBLOCKPEN]);
1709 }
1710 else
1711 {
1712 SetAPen(rp, mhd->dri->dri_Pens[BACKGROUNDPEN]);
1713 }
1714
1715 SetAfPt(rp, pattern, 1);
1716
1717 RectFill(rp, x1, y1, x2, y2);
1718
1719 SetAfPt(rp, NULL, 0);
1720
1721 }
1722
1723 /**************************************************************************************************/
1724
1725 static void RenderFrame(struct RastPort *rp, WORD x1, WORD y1, WORD x2, WORD y2, WORD state,
1726 struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1727 {
1728 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1729
1730 SetAPen(rp, mhd->dri->dri_Pens[(state == IDS_SELECTED) ? SHADOWPEN : SHINEPEN]);
1731
1732 RectFill(rp, x1, y1, x2, y1);
1733 RectFill(rp, x1, y1 + 1, x1, y2);
1734
1735 SetAPen(rp, mhd->dri->dri_Pens[(state == IDS_SELECTED) ? SHINEPEN : SHADOWPEN]);
1736 RectFill(rp, x2, y1 + 1, x2, y2);
1737 RectFill(rp, x1 + 1, y2, x2 - 1, y2);
1738 }
1739 /**************************************************************************************************/
1740
1741 static void HighlightItem(struct MenuItem *item, WORD itemtype, struct MenuHandlerData *mhd,
1742 struct IntuitionBase *IntuitionBase)
1743 {
1744 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1745 struct Window *win = ((itemtype == ITEM_ITEM) ? mhd->menuwin : mhd->submenuwin);
1746 struct RastPort *rp = win->RPort;
1747 struct Rectangle *box = ((itemtype == ITEM_ITEM) ? ((struct Rectangle *)&mhd->activemenu->JazzX) : &mhd->submenubox);
1748 APTR fill;
1749 WORD offx = -box->MinX + mhd->menuinnerleft;
1750 WORD offy = -box->MinY + mhd->menuinnertop;
1751 WORD x1, y1, x2, y2;
1752 BOOL enabled;
1753
1754 enabled = (item->Flags & ITEMENABLED) ? TRUE : FALSE;
1755 if (!(mhd->activemenu->Flags & MENUENABLED)) enabled = FALSE;
1756 if ((itemtype == ITEM_SUBITEM) && !(mhd->activeitem->Flags & ITEMENABLED)) enabled = FALSE;
1757
1758 if (enabled)
1759 {
1760 item->Flags ^= HIGHITEM;
1761
1762 fill = item->ItemFill;
1763 if ((item->Flags & HIGHITEM) && (item->SelectFill)) fill = item->SelectFill;
1764
1765 x1 = offx + item->LeftEdge;
1766 y1 = offy + item->TopEdge;
1767 x2 = x1 + item->Width - 1;
1768 y2 = y1 + item->Height - 1;
1769
1770 if (CustomDrawBackground(rp, win, x1, y1, x2 - x1 + 1, y2 - y1 + 1, item->Flags, mhd, IntuitionBase)) {
1771 SetDrMd(rp, JAM1);
1772
1773 if(item->Flags & ITEMTEXT)
1774 {
1775 struct IntuiText *save = ((struct IntuiText*) fill)->NextText;
1776
1777 if (item->SubItem)
1778 {
1779 Forbid();
1780 ((struct IntuiText*) fill)->NextText = NULL;
1781 }
1782
1783 if (MENUS_AMIGALOOK(IntuitionBase))
1784 {
1785 PrintIText(rp, (struct IntuiText *)fill, x1, y1);
1786 }
1787 else
1788 {
1789 struct IntuiText *it = (struct IntuiText *)fill;
1790
1791 it->FrontPen = mhd->dri->dri_Pens[TEXTPEN];
1792 it->DrawMode = JAM1;
1793
1794 PrintIText(rp, it, x1, y1);
1795 }
1796 if (item->SubItem)
1797 {
1798 DrawImageState(rp, mhd->submenuimage, offx + item->Width - mhd->submenuimage->Width, offy + item->TopEdge + ((item->Height - mhd->submenuimage->Height) >> 1), IDS_NORMAL, mhd->dri);
1799 ((struct IntuiText*) fill)->NextText = save;
1800 Permit();
1801 }
1802 }
1803 else
1804 {
1805 EraseImage(rp, (struct Image *)fill, x1, y1);
1806 DrawImageState(rp, (struct Image *)fill, x1, y1, IDS_SELECTED, mhd->dri);
1807 }
1808 RenderItem(item, itemtype, box, mhd, IntuitionBase);
1809 return;
1810 }
1811
1812 switch(item->Flags & HIGHFLAGS)
1813 {
1814 case HIGHIMAGE:
1815 SetDrMd(rp, JAM1);
1816
1817 if(item->Flags & ITEMTEXT)
1818 {
1819 struct IntuiText *save = ((struct IntuiText*) fill)->NextText;
1820
1821 if (item->SubItem)
1822 {
1823 Forbid();
1824 ((struct IntuiText*) fill)->NextText = NULL;
1825 }
1826 if (MENUS_AMIGALOOK(IntuitionBase))
1827 {
1828 PrintIText(rp, (struct IntuiText *)fill, x1, y1);
1829 }
1830 else
1831 {
1832 struct IntuiText *it = (struct IntuiText *)fill;
1833
1834 it->FrontPen = mhd->dri->dri_Pens[TEXTPEN];
1835 it->DrawMode = JAM1;
1836
1837 PrintIText(rp, it, x1, y1);
1838 }
1839 if (item->SubItem)
1840 {
1841 DrawImageState(rp, mhd->submenuimage, offx + item->Width - mhd->submenuimage->Width, offy + item->TopEdge + ((item->Height - mhd->submenuimage->Height) >> 1), IDS_NORMAL, mhd->dri);
1842 ((struct IntuiText*) fill)->NextText = save;
1843 Permit();
1844 }
1845 }
1846 else
1847 {
1848 EraseImage(rp, (struct Image *)fill, x1, y1);
1849 DrawImageState(rp, (struct Image *)fill, x1, y1, IDS_SELECTED, mhd->dri);
1850 }
1851 break;
1852
1853 case HIGHCOMP:
1854 if (MENUS_AMIGALOOK(IntuitionBase))
1855 {
1856 SetDrMd(rp, COMPLEMENT);
1857 RectFill(rp, x1, y1, x2, y2);
1858 }
1859 else
1860 {
1861 WORD state = (item->Flags & HIGHITEM) ? IDS_SELECTED : IDS_NORMAL;
1862
1863 SetDrMd(rp, JAM1);
1864 SetAPen(rp, mhd->dri->dri_Pens[(state == IDS_SELECTED) ? FILLPEN : BACKGROUNDPEN]);
1865 RectFill(rp, x1, y1, x2, y2);
1866
1867 RenderItem(item, itemtype, box, mhd, IntuitionBase);
1868
1869 if (state == IDS_SELECTED)
1870 {
1871 RenderFrame(rp, x1, y1, x2, y2, state, mhd, IntuitionBase);
1872 }
1873 }
1874 break;
1875
1876 case HIGHBOX:
1877 SetDrMd(rp, COMPLEMENT);
1878 offx = mhd->scr->MenuHBorder;
1879 offy = mhd->scr->MenuVBorder;
1880
1881 x1 -= offx;
1882 x2 += offx;
1883 y1 -= offy;
1884 y2 += offy;
1885
1886 RectFill(rp, x1, y1, x2, y1 + offy - 1);
1887 RectFill(rp, x2 - offx + 1, y1 + offy, x2, y2);
1888 RectFill(rp, x1, y2 - offy + 1, x2 - offx, y2);
1889 RectFill(rp, x1, y1 + offy, x1 + offx - 1,y2 - offy);
1890 break;
1891
1892 case HIGHNONE:
1893 /* Do nothing */
1894 break;
1895
1896 } /* switch(item->Flags & HIGHFLAGS) */
1897
1898 } /* if (enabled) */
1899
1900 }
1901
1902 /**************************************************************************************************/
1903
1904 static WORD CalcMaxCommKeyWidth(struct Window *win, struct MenuHandlerData *mhd,
1905 struct IntuitionBase *IntuitionBase)
1906 {
1907 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
1908 struct TextExtent te;
1909 WORD maxwidth;
1910
1911 FontExtent(mhd->dri->dri_Font, &te);
1912 maxwidth = te.te_Width;
1913
1914 if (win)
1915 {
1916 struct MenuItem *item;
1917
1918 if ((win == mhd->menuwin))
1919 {
1920 item = mhd->activemenu->FirstItem;
1921 }
1922 else
1923 {
1924 item = mhd->activeitem->SubItem;
1925 }
1926
1927 for(; item; item = item->NextItem)
1928 {
1929 if (item->Flags & ITEMTEXT)
1930 {
1931 struct IntuiText *it = (struct IntuiText *)item->ItemFill;
1932
1933 if (it->ITextFont)
1934 {
1935 struct TextFont *font;
1936
1937 if ((font = OpenFont(it->ITextFont)))
1938 {
1939 FontExtent(font, &te);
1940 if (te.te_Width > maxwidth) maxwidth = te.te_Width;
1941
1942 CloseFont(font);
1943 }
1944 }
1945
1946 } /* if (item->Flags & ITEMTEXT) */
1947
1948 } /* for(; item; item = item->NextItem); */
1949
1950 } /* if (win) */
1951
1952 return maxwidth;
1953 }
1954
1955 /**************************************************************************************************/
1956
1957 static void AddToSelection(struct MenuHandlerData *mhd, struct IntuitionBase *IntuitionBase)
1958 {
1959 if ((mhd->activemenunum != -1) && (mhd->activemenu->Flags & MENUENABLED) &&
1960 (mhd->activeitemnum != -1) && (mhd->activeitem->Flags & ITEMENABLED))
1961 {
1962 struct MenuItem *item = NULL;
1963 UWORD men = FULLMENUNUM(mhd->activemenunum, mhd->activeitemnum, mhd->activesubitemnum);
1964
1965 if (mhd->activesubitemnum != -1)
1966 {
1967 if (mhd->activesubitem->Flags & ITEMENABLED) item = mhd->activesubitem;
1968 }
1969 else if (!mhd->activeitem->SubItem)
1970 {
1971 item = mhd->activeitem;
1972 }
1973
1974 if (item && (ItemAddress(mhd->menu, men) == item))
1975 {
1976 UWORD men = FULLMENUNUM(mhd->activemenunum, mhd->activeitemnum, mhd->activesubitemnum);
1977
1978 if (mhd->firstmenupick == MENUNULL)
1979 {
1980 mhd->firstmenupick = men;
1981 }
1982 else if (men != mhd->lastmenupick)
1983 {
1984 struct MenuItem *checkitem, *prevcheckitem = NULL;
1985 UWORD checkmen = mhd->firstmenupick;
1986
1987 /* Remove men from pick queue, if it was already in there
1988 and then add it at the end of the pick queue */
1989
1990 while(checkmen != MENUNULL)
1991 {
1992 checkitem = ItemAddress(mhd->menu, checkmen);
1993
1994 if (checkmen == men)
1995 {
1996 if (prevcheckitem == NULL)
1997 {
1998 mhd->firstmenupick = checkitem->NextSelect;
1999 }
2000 else
2001 {
2002 prevcheckitem->NextSelect = checkitem->NextSelect;
2003 }
2004 }
2005
2006 checkmen = checkitem->NextSelect;
2007 prevcheckitem = checkitem;
2008
2009 } /* while(checkmen != MENUNULL) */
2010
2011 checkitem->NextSelect = men;
2012
2013 } /* else if (men != mhd->lastmenupick) */
2014
2015 mhd->lastmenupick = men;
2016 item->NextSelect = MENUNULL;
2017
2018 } /* if (item) */
2019
2020 } /* if ((mhd->activemenunum != -1) && (mhd->activeitemnum != -1)) */
2021 }
2022
Mirror of AROS' svn.