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