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