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