?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
some fixes to accented characters
[tangerine.git] / rom / intuition / inputhandler.c
blob7c8f7862a2edb4a237aa2446c183f6e7e5f1fe47
1 /*
2 Copyright 1995-2003, The AROS Development Team. All rights reserved.
3 Copyright 2001-2003, The MorphOS Development Team. All Rights Reserved.
4 $Id$
5 */
6
7 /****************************************************************************************/
8
9 #include <proto/exec.h>
10 #include <proto/intuition.h>
11 #include <proto/alib.h>
12 #include <proto/layers.h>
13 #include <proto/graphics.h>
14 #include <proto/keymap.h>
15 #include <proto/utility.h>
16 #include <proto/input.h>
17 #include <proto/timer.h>
18 #include <exec/memory.h>
19 #include <exec/alerts.h>
20 #include <exec/interrupts.h>
21 #include <exec/ports.h>
22 #include <intuition/intuition.h>
23 #include <intuition/intuitionbase.h>
24 #include <intuition/gadgetclass.h>
25 #include <intuition/pointerclass.h>
26 #include <intuition/cghooks.h>
27 #include <intuition/sghooks.h>
28 #include <devices/inputevent.h>
29 #include <devices/rawkeycodes.h>
30 #include <clib/macros.h>
31 #include "inputhandler.h"
32
33 #include "boopsigadgets.h"
34 #include "boolgadgets.h"
35 #include "propgadgets.h"
36 #include "strgadgets.h"
37 #include "gadgets.h"
38 #include "intuition_intern.h" /* EWFLG_xxx */
39 #include "inputhandler_support.h"
40 #include "inputhandler_actions.h"
41 #include "menus.h"
42
43 #ifdef SKINS
44 # include "smallmenu.h"
45 # include "intuition_customizesupport.h"
46 #endif
47
48 #undef DEBUG
49 #define DEBUG 0
50 #include <aros/debug.h>
51
52 #define DEBUG_HANDLER(x) ;
53 #define DEBUG_KEY(x) ;
54 #define DEBUG_SCREENKEY(x) ;
55
56 /****************************************************************************************/
57
58 struct Interrupt *InitIIH(struct IntuitionBase *IntuitionBase)
59 {
60 struct Interrupt *iihandler;
61
62 D(bug("InitIIH(IntuitionBase=%p)\n", IntuitionBase));
63
64 iihandler = AllocMem(sizeof (struct Interrupt), MEMF_PUBLIC | MEMF_CLEAR);
65 if (iihandler)
66 {
67 struct IIHData *iihdata;
68
69 iihdata = AllocMem(sizeof (struct IIHData), MEMF_PUBLIC | MEMF_CLEAR);
70 if (iihdata)
71 {
72 struct MsgPort *port;
73
74 port = AllocMem(sizeof (struct MsgPort), MEMF_PUBLIC | MEMF_CLEAR);
75 if (port)
76 {
77 if ((iihdata->InputEventMemPool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR,
78 sizeof(struct GeneratedInputEvent) * 10,
79 sizeof(struct GeneratedInputEvent) * 10)) &&
80 (iihdata->ActionsMemPool = CreatePool(MEMF_SEM_PROTECTED,
81 2000, 2000)))
82 {
83 const struct TagItem dragtags[] =
84 {
85 {GA_SysGadget , TRUE },
86 {GA_SysGType , GTYP_WDRAGGING},
87 {TAG_DONE }
88 };
89
90 const struct TagItem sizetags[] =
91 {
92 {GA_SysGadget , TRUE },
93 {GA_SysGType , GTYP_SIZING },
94 {TAG_DONE }
95 };
96
97 iihdata->MasterDragGadget = (struct Gadget *)NewObjectA(GetPrivIBase(IntuitionBase)->dragbarclass,
98 NULL,
99 dragtags);
100
101 iihdata->MasterSizeGadget = (struct Gadget *)NewObjectA(GetPrivIBase(IntuitionBase)->sizebuttonclass,
102 NULL,
103 sizetags);
104
105 if (iihdata->MasterDragGadget && iihdata->MasterSizeGadget)
106 {
107 ULONG lock;
108
109 /* We do not want to be woken up by message replies.
110 We are anyway woken up about 10 times a second by
111 timer events
112 */
113 port->mp_Flags = PA_IGNORE;
114
115 NEWLIST( &(port->mp_MsgList) );
116 iihdata->IntuiReplyPort = port;
117
118 NEWLIST((struct List*) &iihdata->IntuiActionQueue);
119 NEWLIST((struct List*)&iihdata->NewAllocatedInputEventList);
120 NEWLIST((struct List*)&iihdata->AllocatedInputEventList);
121 iihdata->EndInputEventChain = &iihdata->ReturnInputEvent;
122 iihdata->FreeInputEvents = NULL;
123
124 iihdata->ActQualifier = IEQUALIFIER_RELATIVEMOUSE;
125
126 /* Note: there are several routines like CloseWindow, which
127 expect is_Data to point to the IIHData structure, so don't
128 change this! */
129
130 iihandler->is_Code = (APTR)AROS_ASMSYMNAME(IntuiInputHandler);
131 iihandler->is_Data = iihdata;
132 iihandler->is_Node.ln_Pri = 50;
133 iihandler->is_Node.ln_Name = "Intuition InputHandler";
134
135 lock = LockIBase(0UL);
136
137 iihdata->IntuitionBase = IntuitionBase;
138
139 UnlockIBase(lock);
140
141 GetPrivIBase(IntuitionBase)->IntuiReplyPort = iihdata->IntuiReplyPort;
142 GetPrivIBase(IntuitionBase)->IntuiActionQueue = &iihdata->IntuiActionQueue;
143
144 ReturnPtr ("InitIIH", struct Interrupt *, iihandler);
145 } /* f (iihdata->MasterDragGadget && iihdata->MasterSizeGadget) */
146
147 DisposeObject((Object *)iihdata->MasterDragGadget);
148 DisposeObject((Object *)iihdata->MasterSizeGadget);
149
150 DeletePool(iihdata->ActionsMemPool);
151 DeletePool(iihdata->InputEventMemPool);
152
153 } /* if (iihdata->InputEventMemPool = ... */
154 FreeMem(port, sizeof(struct MsgPort));
155
156 } /* if (port) */
157 FreeMem(iihdata, sizeof (struct IIHData));
158 iihdata->MouseBoundsActiveFlag = FALSE;
159
160 } /* if (iihdata) */
161 FreeMem(iihandler, sizeof (struct Interrupt));
162
163 } /* if (iihandler) */
164
165 ReturnPtr ("InitIIH", struct Interrupt *, NULL);
166 }
167
168 /****************************************************************************************/
169
170 VOID CleanupIIH(struct Interrupt *iihandler, struct IntuitionBase *IntuitionBase)
171 {
172 struct IIHData *iihdata = (struct IIHData *)iihandler->is_Data;
173
174 DisposeObject((Object *)iihdata->MasterDragGadget);
175 DisposeObject((Object *)iihdata->MasterSizeGadget);
176
177 FreeGeneratedInputEvents(iihdata);
178 DeletePool(iihdata->InputEventMemPool);
179 DeletePool(iihdata->ActionsMemPool);
180
181 /* One might think that this port is still in use by the inputhandler.
182 ** However, if intuition is closed for the last time, there should be no
183 ** windows that IntuiMessage can be sent to.
184 */
185 FreeMem(iihdata->IntuiReplyPort, sizeof (struct MsgPort));
186
187 FreeMem(iihdata, sizeof (struct IIHData));
188 FreeMem(iihandler, sizeof (struct Interrupt));
189
190 return;
191 }
192
193 /****************************************************************************************/
194
195 static void HandleIntuiReplyPort(struct IIHData *iihdata, struct IntuitionBase *IntuitionBase)
196 {
197 struct IntuiMessage *im;
198
199 while ((im = (struct IntuiMessage *)GetMsg(iihdata->IntuiReplyPort)))
200 {
201 if (im->IDCMPWindow && ResourceExisting(im->IDCMPWindow, RESOURCE_WINDOW, IntuitionBase))
202 {
203 struct IntWindow *win = (struct IntWindow *)im->IDCMPWindow;
204
205 Forbid();
206 GetSysTime(&win->lastmsgreplied);
207 Permit();
208
209 switch(im->Class)
210 {
211 case IDCMP_MOUSEMOVE:
212 IW(im->IDCMPWindow)->num_mouseevents--;
213 break;
214
215 case IDCMP_INTUITICKS:
216 AROS_ATOMIC_AND(im->IDCMPWindow->Flags, ~WFLG_WINDOWTICKED);
217 break;
218
219 #if USE_IDCMPUPDATE_MESSAGECACHE
220 case IDCMP_IDCMPUPDATE:
221 IW(im->IDCMPWindow)->num_idcmpupdate--;
222
223 if (!(IW(im->IDCMPWindow)->num_idcmpupdate) && IW(im->IDCMPWindow)->messagecache)
224 {
225 SendIntuiMessage(im->IDCMPWindow,IW(im->IDCMPWindow)->messagecache);
226 IW(im->IDCMPWindow)->messagecache = 0;
227 }
228 break;
229 #endif
230
231 case IDCMP_MENUVERIFY:
232 {
233 struct Window *w = im->IDCMPWindow;
234 struct IntScreen *scr = 0;
235
236 scr = GetPrivScreen(w->WScreen);
237
238 if (scr != GetPrivIBase(IntuitionBase)->MenuVerifyScreen ||
239 scr->MenuVerifySeconds > im->Seconds ||
240 (scr->MenuVerifySeconds == im->Seconds &&
241 scr->MenuVerifyMicros > im->Micros))
242 {
243 /* The timeout has expired, just ignore. */
244 }
245 else
246 {
247 --scr->MenuVerifyMsgCount;
248 if (w == scr->MenuVerifyActiveWindow &&
249 im->Code == MENUCANCEL)
250 {
251 ULONG lock = LockIBase(0);
252 struct Window *w1;
253
254 for (w1 = scr->Screen.FirstWindow; w1; w1 = w1->NextWindow)
255 {
256 if (w1->IDCMPFlags & IDCMP_MENUVERIFY && w1 != scr->MenuVerifyActiveWindow)
257 {
258 ih_fire_intuimessage(w1,
259 IDCMP_MOUSEBUTTONS,
260 MENUUP,
261 w1,
262 IntuitionBase);
263 }
264 }
265
266 UnlockIBase(lock);
267
268 scr->MenuVerifyActiveWindow = NULL;
269 scr->MenuVerifyTimeOut = 0;
270 scr->MenuVerifyMsgCount = 0;
271 scr->MenuVerifySeconds = 0;
272 scr->MenuVerifyMicros = 0;
273 GetPrivIBase(IntuitionBase)->MenuVerifyScreen = NULL;
274 }
275 else if (scr->MenuVerifyMsgCount == 0)
276 {
277 struct InputEvent ie;
278
279 /* currently we ONLY need the menu open time ! */
280 ie.ie_TimeStamp.tv_secs = im->Seconds;
281 ie.ie_TimeStamp.tv_micro = im->Micros;
282
283 if (FireMenuMessage(MMCODE_START, scr->MenuVerifyActiveWindow, &ie, IntuitionBase))
284 {
285 /* This lock will be released only when the user is
286 done with menus = when IECLASS_MENU + IESUBCLASS_MENUSTOP
287 event arrives (generated by MenuHandler task) */
288
289 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->MenuLock);
290 iihdata->MenuWindow = scr->MenuVerifyActiveWindow;
291 MENUS_ACTIVE = TRUE;
292 }
293
294 scr->MenuVerifyActiveWindow = NULL;
295 scr->MenuVerifyTimeOut = 0;
296 scr->MenuVerifyMsgCount = 0;
297 scr->MenuVerifySeconds = 0;
298 scr->MenuVerifyMicros = 0;
299 GetPrivIBase(IntuitionBase)->MenuVerifyScreen = NULL;
300 }
301 }
302 break;
303 }
304
305 case IDCMP_SIZEVERIFY:
306 {
307 struct GadgetInfo *gi = &iihdata->GadgetInfo;
308 struct Window *w = im->IDCMPWindow;
309 struct Gadget *gadget = im->IAddress;
310 struct InputEvent ie;
311 BOOL reuse_event;
312
313 PrepareGadgetInfo(gi, IntuitionBase->ActiveScreen, w, NULL);
314 SetGadgetInfoGadget(gi, gadget, IntuitionBase);
315
316 if (IS_BOOPSI_GADGET(gadget))
317 {
318 ie.ie_NextEvent = NULL;
319 ie.ie_Class = IECLASS_RAWMOUSE;
320 ie.ie_SubClass = 0;
321 ie.ie_Code = IECODE_LBUTTON;
322 ie.ie_Qualifier = im->Qualifier;
323 ie.ie_X = im->MouseX;
324 ie.ie_Y = im->MouseY;
325 ie.ie_TimeStamp.tv_secs = IntuitionBase->Seconds;
326 ie.ie_TimeStamp.tv_micro = IntuitionBase->Micros;
327
328 DoGPInput(gi,
329 gadget,
330 &ie,
331 GM_GOACTIVE,
332 &reuse_event,
333 IntuitionBase);
334
335 /* For compatibility, send a GM_HANDLEINPUT too */
336 ie.ie_Class = IECLASS_RAWMOUSE;
337 ie.ie_Code = IECODE_NOBUTTON;
338 ie.ie_X = 0;
339 ie.ie_Y = 0;
340
341 gadget = DoGPInput(gi,
342 gadget,
343 &ie,
344 GM_HANDLEINPUT,
345 &reuse_event,
346 IntuitionBase);
347 }
348
349 /* From now on the master drag/size gadget takes over */
350
351 iihdata->ActiveSysGadget = gadget;
352 gadget = iihdata->MasterSizeGadget;
353 iihdata->ActiveGadget = gadget;
354
355 ie.ie_Class = IECLASS_RAWMOUSE;
356 ie.ie_Code = IECODE_LBUTTON;
357 ie.ie_X = im->MouseX;
358 ie.ie_Y = im->MouseY;
359
360 DoGPInput(gi,
361 gadget,
362 &ie,
363 GM_GOACTIVE,
364 &reuse_event,
365 IntuitionBase);
366 break;
367 }
368
369 case IDCMP_REQVERIFY:
370 {
371 struct Window *w = im->IDCMPWindow;
372
373 EndRequest(w->DMRequest, w);
374
375 ih_fire_intuimessage(w,
376 IDCMP_REQSET,
377 0,
378 w,
379 IntuitionBase);
380 }
381 break;
382
383 case IDCMP_WBENCHMESSAGE:
384 DEBUG_WORKBENCH(dprintf("HandleIntuiReplyPort: code 0x%lx\n",
385 im->Code));
386 break;
387
388 } /* switch(im->Class) */
389
390 if (im->Qualifier & IEQUALIFIER_REPEAT)
391 {
392 /* IDCMP_IDCMPUPDATE messages can also be sent from app task, therefore
393 it would be better if there was an ATOMIC_DEC macro or something */
394
395 if (IW(im->IDCMPWindow)->num_repeatevents)
396 {
397 IW(im->IDCMPWindow)->num_repeatevents--;
398 }
399 }
400 }
401 FreeIntuiMessage(im);
402
403 } /* while ((im = (struct IntuiMessage *)GetMsg(iihdata->IntuiReplyPort))) */
404 }
405 /****************************************************************************************/
406
407 struct Window *GetToolBoxWindow(struct InputEvent *ie, struct IntuitionBase *IntuitionBase)
408 {
409 /* The caller has checked that the input event is a IECLASS_RAWMOUSE, SELECTDOWN event */
410 /* NOTE: may be called with NULL ie ptr! */
411 struct Layer *l;
412 struct Window *new_w = NULL;
413 struct Screen *scr;
414 ULONG lock;
415
416 lock = LockIBase(0UL);
417
418 UnlockIBase(lock);
419
420 scr = IntuitionBase->FirstScreen;
421
422 if (scr)
423 {
424 D(bug("GetToolBoxWindow: Click at (%d,%d)\n",scr->MouseX,scr->MouseY));
425
426 /* What layer ? */
427 LockLayerInfo(&scr->LayerInfo);
428
429 l = WhichLayer(&scr->LayerInfo, scr->MouseX, scr->MouseY);
430
431 UnlockLayerInfo(&scr->LayerInfo);
432
433 if (NULL == l)
434 {
435 new_w = NULL;
436 D(bug("GetToolBoxWindow: Click not inside layer\n"));
437 }
438 else if (l == scr->BarLayer)
439 {
440 }
441 else
442 {
443 new_w = (struct Window *)l->Window;
444 if (new_w)
445 {
446 if ((new_w->Flags & WFLG_TOOLBOX) == 0) new_w = NULL;
447 }
448 if (!new_w)
449 {
450 D(bug("GetToolBoxWindow: Selected layer is not a ToolBox window\n"));
451 }
452 else
453 {
454 D(bug("GetToolBoxWindow: Found layer %p\n", l));
455 }
456 }
457 }
458
459 D(bug("GetToolBoxWindow: New window %p\n", new_w));
460 return new_w;
461 }
462
463 /****************************************************************************************/
464
465 AROS_UFH2(struct InputEvent *, IntuiInputHandler,
466 AROS_UFHA(struct InputEvent *, oldchain, A0),
467 AROS_UFHA(struct IIHData *, iihdata, A1)
468 )
469 {
470 AROS_USERFUNC_INIT
471
472 struct InputEvent *ie, *orig_ie, *next_ie, stackie;
473 struct Gadget *gadget = NULL, *boxgadget = NULL;
474 struct IntuitionBase *IntuitionBase = iihdata->IntuitionBase;
475 //ULONG lock;
476 struct GadgetInfo *gi = &iihdata->GadgetInfo;
477 struct GadgetInfo *boxgi = &iihdata->BoxGadgetInfo;
478 BOOL reuse_event, ie_used;
479 struct Window *w, *toolbox;
480 struct Requester *req;
481 ULONG stitlebarhit = 0;
482 #if SINGLE_SETPOINTERPOS_PER_EVENTLOOP
483 WORD pointerposx, pointerposy;
484 BOOL call_setpointerpos = FALSE;
485 #endif
486
487 D(bug("Inside intuition inputhandler, active window=%p\n", IntuitionBase->ActiveWindow));
488
489 // DEBUG_HANDLER(dprintf("Handler: IBase 0x%lx KeyMapBase 0x%lx\n",IntuitionBase,KeymapBase));
490
491 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->InputHandlerLock);
492
493 if (!iihdata->InputDeviceTask) iihdata->InputDeviceTask = FindTask(NULL);
494
495 /* Then free generated InputEvents done in the previous round */
496
497 FreeGeneratedInputEvents(iihdata);
498
499 /* First handle IntuiMessages which were replied back to the IntuiReplyPort
500 by the apps */
501
502 HandleIntuiReplyPort(iihdata, IntuitionBase);
503
504 /* Handle action messages */
505
506 HandleIntuiActions(iihdata, IntuitionBase);
507
508 /* Now handle the input events */
509
510 ie = &stackie;
511 reuse_event = FALSE;
512 next_ie = oldchain;
513
514 /* shut up the compiler */
515 orig_ie = next_ie;
516 ie_used = FALSE;
517
518 gadget = iihdata->ActiveGadget;
519
520 while (reuse_event || next_ie)
521 {
522
523 struct Window *old_w;
524 BOOL keep_event = TRUE;
525 BOOL new_active_window = FALSE;
526
527 /* new event, we need to reset this */
528
529 iihdata->ActEventTablet = 0;
530
531 if (!reuse_event)
532 {
533 *ie = *next_ie;
534 orig_ie = next_ie;
535 next_ie = ie->ie_NextEvent;
536 ie_used = FALSE;
537 }
538
539 D(bug("iih: Handling event of class %d, code %d\n", ie->ie_Class, ie->ie_Code));
540 reuse_event = FALSE;
541
542 /* Set the timestamp in IntuitionBase */
543
544 IntuitionBase->Seconds = ie->ie_TimeStamp.tv_secs;
545 IntuitionBase->Micros = ie->ie_TimeStamp.tv_micro;
546
547 /* Use event to find the active window */
548
549 toolbox = GetToolBoxWindow(ie, IntuitionBase);
550
551 if (toolbox)
552 {
553
554 /* Do ToolBox Window Actions */
555 /* ToolBox Windows supports only a subset of IECLASS Actions */
556 w = toolbox;
557 req = NULL;
558 if (w)
559 {
560 req = w->FirstRequest;
561 }
562 switch (ie->ie_Class)
563 {
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593 case IECLASS_RAWMOUSE:
594 switch (ie->ie_Code)
595 {
596 case SELECTDOWN:
597 {
598
599 BOOL new_boxgadget = FALSE;
600 BOOL sizeverify = FALSE;
601
602 iihdata->ActQualifier |= IEQUALIFIER_LEFTBUTTON;
603
604 if (MENUS_ACTIVE)
605 {
606 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
607 keep_event = FALSE;
608 break;
609 }
610
611 if (!boxgadget)
612 {
613 /* use the *frontmost* screen rather than active one when searching
614 for sdepth gadget! */
615 boxgadget = FindGadget (IntuitionBase->FirstScreen,
616 stitlebarhit ? 0 : w, stitlebarhit ? 0 : req,
617 IntuitionBase->ActiveScreen ? IntuitionBase->ActiveScreen->MouseX : 0,
618 IntuitionBase->ActiveScreen ? IntuitionBase->ActiveScreen->MouseY : 0,
619 boxgi, FALSE, IntuitionBase);
620
621 D(bug("Click on gadget %p\n", boxgadget));
622 new_boxgadget = TRUE;
623
624 } /* if (!boxgadget) */
625
626
627 if (boxgadget && new_boxgadget)
628 {
629 if (w && (w->IDCMPFlags & IDCMP_SIZEVERIFY) &&
630 ((boxgadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SIZING /*||
631 (boxgadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WZOOM*/))
632 {
633 ih_fire_intuimessage(w,
634 IDCMP_SIZEVERIFY,
635 0,
636 boxgadget,
637 IntuitionBase);
638 boxgadget = NULL;
639 sizeverify = TRUE;
640 }
641 else
642 {
643 BOOL is_draggad, is_sizegad;
644
645 /* Whenever the active gadget changes the gi must be updated
646 because it is cached in iidata->GadgetInfo!!!! Don't
647 forget to do this if somewhere else the active
648 gadget is changed, for example in ActivateGadget!!! */
649
650 PrepareGadgetInfo(boxgi, IntuitionBase->ActiveScreen, w, req);
651 SetGadgetInfoGadget(boxgi, boxgadget, IntuitionBase);
652
653
654 is_draggad = ((boxgadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING);
655 is_sizegad = ((boxgadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SIZING);
656
657 /* jDc: intui68k sends IDCMPs for GACT_IMMEDIATE drag&sizegads! */
658 if (boxgadget->Activation & GACT_IMMEDIATE)
659 {
660 ih_fire_intuimessage(w,
661 IDCMP_GADGETDOWN,
662 0,
663 boxgadget,
664 IntuitionBase);
665 }
666
667 if (is_draggad || is_sizegad)
668 {
669 if (IS_BOOPSI_GADGET(boxgadget))
670 {
671 DoGPInput(boxgi,
672 boxgadget,
673 ie,
674 GM_GOACTIVE,
675 &reuse_event,
676 IntuitionBase);
677
678 /* Ignoring retval of dispatcher above is what
679 AmigaOS does too for boopsi drag/resize
680 gadgets */
681
682 }
683
684 /* From now on the master drag/size gadget takes over */
685 if ((w->MoreFlags & WMFLG_IAMMUI) && (w->Flags & WFLG_BORDERLESS))
686 {
687 iihdata->ActiveSysGadget = is_draggad ? boxgadget : 0;
688 }
689 else
690 {
691 iihdata->ActiveSysGadget = boxgadget;
692 }
693 boxgadget = is_draggad ? iihdata->MasterDragGadget : iihdata->MasterSizeGadget;
694 }
695 }
696 }
697
698 if (boxgadget)
699 {
700
701
702 switch (boxgadget->GadgetType & GTYP_GTYPEMASK)
703 {
704 case GTYP_BOOLGADGET:
705 /* Only set the GFLG_SELECTED flag for RELVERIFY and
706 * TOGGLESELECT gadget. It's for the user to do it if
707 * he wants for other GADGIMMEDIATE ones.
708 * Only RELVERIFY gadgets stay active.
709 */
710
711 if (boxgadget->Activation & (GACT_TOGGLESELECT | GACT_RELVERIFY))
712 {
713 boxgadget->Flags ^= GFLG_SELECTED;
714 RefreshBoolGadgetState(boxgadget, w, req, IntuitionBase);
715 }
716
717 if (boxgadget->Activation & GACT_RELVERIFY)
718 {
719 boxgadget->Activation |= GACT_ACTIVEGADGET;
720 iihdata->MouseWasInsideBoolGadget = TRUE;
721 }
722 else
723 {
724 boxgadget = NULL;
725 }
726
727 break;
728
729 case GTYP_PROPGADGET:
730 HandlePropSelectDown(boxgadget,
731 w,
732 req,
733 w->MouseX - boxgi->gi_Domain.Left - GetGadgetLeft(boxgadget, boxgi->gi_Screen, boxgi->gi_Window, NULL),
734 w->MouseY - boxgi->gi_Domain.Top - GetGadgetTop(boxgadget, boxgi->gi_Screen, boxgi->gi_Window, NULL),
735 IntuitionBase);
736
737
738 break;
739 /*
740 case GTYP_STRGADGET:
741
742
743 if (InsideGadget(boxgi->gi_Screen, boxgi->gi_Window,
744 boxgi->gi_Requester, boxgadget,
745 boxgi->gi_Screen->MouseX, boxgi->gi_Screen->MouseY))
746 {
747 UWORD imsgcode;
748
749 HandleStrInput(boxgadget, boxgi, ie, &imsgcode,
750 IntuitionBase);
751 }
752 else
753 {
754 boxgadget->Flags &= ~GFLG_SELECTED;
755
756 RefreshStrGadget(boxgadget, w, req, IntuitionBase);
757 boxgadget = NULL;
758 reuse_event = TRUE;
759 }
760 break;
761 */
762 case GTYP_CUSTOMGADGET:
763
764 boxgadget = DoGPInput(boxgi,
765 boxgadget,
766 ie,
767 (new_boxgadget ? GM_GOACTIVE : GM_HANDLEINPUT),
768 &reuse_event,
769 IntuitionBase);
770 D(bug("new_boxgadget %d, goactive %p\n", new_boxgadget, boxgadget));
771
772
773 if (boxgadget && new_boxgadget && (!(boxgadget->GadgetType & GTYP_SIZING)))
774 {
775 /* For compatibility, send a GM_HANDLEINPUT too */
776 struct InputEvent newie;
777 BOOL reuse_event;
778
779 newie.ie_NextEvent = NULL;
780 newie.ie_Class = IECLASS_RAWMOUSE;
781 newie.ie_SubClass = 0;
782 newie.ie_Code = IECODE_NOBUTTON;
783 newie.ie_Qualifier = ie->ie_Qualifier;
784 newie.ie_X = 0;
785 newie.ie_Y = 0;
786 newie.ie_TimeStamp.tv_secs = IntuitionBase->Seconds;
787 newie.ie_TimeStamp.tv_micro = IntuitionBase->Micros;
788
789 boxgadget = DoGPInput(boxgi,
790 boxgadget,
791 &newie,
792 GM_HANDLEINPUT,
793 &reuse_event,
794 IntuitionBase);
795 D(bug("handleinput %p\n", boxgadget));
796 }
797
798 break;
799
800 case 0: //orig gadtools / some 1.3 gadgets
801
802 if (IS_SYS_GADGET(boxgadget))
803 {
804 HandleSysGadgetVerify(boxgi, boxgadget, IntuitionBase);
805 }
806 else
807 {
808 if (boxgadget->Activation & GACT_RELVERIFY)
809 {
810 boxgadget->Activation |= GACT_ACTIVEGADGET;
811 iihdata->MouseWasInsideBoolGadget = TRUE;
812 if (boxgadget->Flags & GFLG_GADGHIMAGE)
813 {
814 boxgadget->Flags ^= GFLG_SELECTED;
815 RefreshBoolGadgetState(boxgadget, w, req, IntuitionBase);
816 }
817 }
818 else
819 {
820 /* jDc: this is what original intuition does, before crashing after a while ;)*/
821 ih_fire_intuimessage(w,
822 IDCMP_MOUSEBUTTONS,
823 SELECTDOWN,
824 w,
825 IntuitionBase);
826 }
827 }
828
829 break;
830 } /* switch (GadgetType) */
831
832 } /* if (a boxgadget is active) */
833 else if (w && (!req || req->Flags & NOISYREQ) && !sizeverify && !stitlebarhit)
834 {
835
836 ih_fire_intuimessage(w,
837 IDCMP_MOUSEBUTTONS,
838 SELECTDOWN,
839 w,
840 IntuitionBase);
841
842 }
843
844
845 } /* case SELECTDOWN */
846
847 break;
848
849 case SELECTUP:
850 iihdata->ActQualifier &= ~IEQUALIFIER_LEFTBUTTON;
851
852
853 if (MENUS_ACTIVE)
854 {
855 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
856 keep_event = FALSE;
857 break;
858 }
859
860 if (boxgadget)
861 {
862 BOOL inside = InsideGadget(boxgi->gi_Screen, boxgi->gi_Window,
863 boxgi->gi_Requester, boxgadget,
864 boxgi->gi_Screen->MouseX, boxgi->gi_Screen->MouseY);
865
866 /*int selected = (boxgadget->Flags & GFLG_SELECTED) != 0;*/
867
868 switch (boxgadget->GadgetType & GTYP_GTYPEMASK)
869 {
870 case GTYP_BOOLGADGET:
871 /* Must be a RELVERIFY boxgadget */
872
873 if (!(boxgadget->Activation & GACT_TOGGLESELECT) && inside)
874 {
875 boxgadget->Flags ^= GFLG_SELECTED;
876 RefreshBoolGadgetState(boxgadget, w, req, IntuitionBase);
877 }
878
879 if (inside)
880 {
881 if (IS_SYS_GADGET(boxgadget))
882 {
883 HandleSysGadgetVerify(boxgi, boxgadget, IntuitionBase);
884 }
885 else
886 {
887 if (req && boxgadget->Activation & GACT_ENDGADGET)
888 {
889 EndRequest(req, w);
890
891 req = w->FirstRequest;
892 }
893
894 ih_fire_intuimessage(w,
895 IDCMP_GADGETUP,
896 0,
897 boxgadget,
898 IntuitionBase);
899 }
900 }
901 else
902 {
903 /* RKRM say so */
904 ih_fire_intuimessage(w,
905 IDCMP_MOUSEBUTTONS,
906 SELECTUP,
907 w,
908 IntuitionBase);
909 }
910
911 boxgadget->Activation &= ~GACT_ACTIVEGADGET;
912 boxgadget = NULL;
913 break;
914
915 case GTYP_PROPGADGET:
916 HandlePropSelectUp(boxgadget, w, req, IntuitionBase);
917 if (boxgadget->Activation & GACT_RELVERIFY)
918 {
919 ih_fire_intuimessage(w,
920 IDCMP_GADGETUP,
921 0,
922 boxgadget,
923 IntuitionBase);
924 }
925
926 boxgadget = NULL;
927 break;
928
929 /* Intuition string gadgets don't care about SELECTUP */
930
931 case GTYP_CUSTOMGADGET:
932 boxgadget = DoGPInput(boxgi, boxgadget, ie, GM_HANDLEINPUT, &reuse_event, IntuitionBase);
933 break;
934 /*
935 case 0: //orig gadtools / some 1.3 gadgets
936
937 boxgadget->Activation &= ~GACT_ACTIVEGADGET;
938 if (boxgadget->Activation & GACT_RELVERIFY)
939 {
940 if (boxgadget->Flags & GFLG_GADGHIMAGE)
941 {
942 if (inside)
943 {
944 boxgadget->Flags ^= GFLG_SELECTED;
945 RefreshBoolGadgetState(boxgadget, w, req, IntuitionBase);
946 }
947 }
948
949 if (inside)
950 {
951 ih_fire_intuimessage(w,
952 IDCMP_GADGETUP,
953 0,
954 boxgadget,
955 IntuitionBase);
956 }
957 } else {
958 ih_fire_intuimessage(w,
959 IDCMP_MOUSEBUTTONS,
960 SELECTUP,
961 w,
962 IntuitionBase);
963 }
964 boxgadget = NULL;
965 break;
966 */
967
968 } /* switch GadgetType */
969
970 } /* if (a boxgadget is currently active) */
971 else if (w && (!req || req->Flags & NOISYREQ))
972 {
973 ih_fire_intuimessage(w,
974 IDCMP_MOUSEBUTTONS,
975 SELECTUP,
976 w,
977 IntuitionBase);
978 }
979
980 break; /* case SELECTUP */
981
982 case MENUDOWN:
983 iihdata->ActQualifier |= IEQUALIFIER_RBUTTON;
984
985
986 if (MENUS_ACTIVE)
987 {
988 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
989 keep_event = FALSE;
990 break;
991 }
992
993
994 if (w && !req && w->DMRequest && !(w->Flags & WFLG_RMBTRAP))
995 {
996 if (!MENUS_ACTIVE &&
997 DoubleClick(GetPrivIBase(IntuitionBase)->DMStartSecs,
998 GetPrivIBase(IntuitionBase)->DMStartMicro,
999 ie->ie_TimeStamp.tv_secs,
1000 ie->ie_TimeStamp.tv_micro))
1001 {
1002 if (w->IDCMPFlags & IDCMP_REQVERIFY)
1003 {
1004 ih_fire_intuimessage(w,
1005 IDCMP_REQVERIFY,
1006 MENUHOT,
1007 NULL,
1008 IntuitionBase);
1009 }
1010 else if (Request(w->DMRequest, w))
1011 {
1012 req = w->DMRequest;
1013
1014 ih_fire_intuimessage(w,
1015 IDCMP_REQSET,
1016 0,
1017 w,
1018 IntuitionBase);
1019 }
1020 keep_event = FALSE;
1021 break;
1022 }
1023
1024 }
1025
1026 if (w && !boxgadget)
1027 {
1028 if (!(w->Flags & WFLG_RMBTRAP) && !req)
1029 {
1030 struct IntScreen *scr = GetPrivScreen(w->WScreen);
1031 struct Window *w1;
1032 ULONG lock;
1033 BOOL mouseon = TRUE;
1034
1035 scr->MenuVerifyMsgCount = 0;
1036
1037 if (w->MouseX < 0 || w->MouseY < 0) mouseon = FALSE;
1038 if (w->MouseX > w->Width || w->MouseY > w->Height) mouseon = FALSE;
1039
1040 if (w->IDCMPFlags & IDCMP_MENUVERIFY && (!(IW(w)->specialflags & SPFLAG_IAMDEAD)))
1041 {
1042 ih_fire_intuimessage(w,
1043 IDCMP_MENUVERIFY,
1044 mouseon ? MENUHOT : MENUWAITING,
1045 w,
1046 IntuitionBase);
1047 scr->MenuVerifyMsgCount++;
1048 }
1049
1050 lock = LockIBase(0);
1051
1052 for (w1 = scr->Screen.FirstWindow; w1; w1 = w1->NextWindow)
1053 {
1054 if ((w1->IDCMPFlags & IDCMP_MENUVERIFY) && (w1 != w) && (!(IW(w)->specialflags & SPFLAG_IAMDEAD)))
1055 {
1056 ih_fire_intuimessage(w1,
1057 IDCMP_MENUVERIFY,
1058 MENUWAITING,
1059 w1,
1060 IntuitionBase);
1061 ++scr->MenuVerifyMsgCount;
1062 }
1063 }
1064
1065 UnlockIBase(lock);
1066
1067 /* FIXME: when a window is opened with IDCMP_MENUVERIFY
1068 * (or this event is requested via ModifyIDCMP), and a
1069 * verify operation is pending, the window should get
1070 * a verify message too. Oh well.
1071 */
1072
1073 if (scr->MenuVerifyMsgCount)
1074 {
1075 GetPrivIBase(IntuitionBase)->MenuVerifyScreen = scr;
1076 scr->MenuVerifyActiveWindow = w;
1077 scr->MenuVerifyTimeOut = 2;
1078 scr->MenuVerifySeconds = IntuitionBase->Seconds;
1079 scr->MenuVerifyMicros = IntuitionBase->Micros;
1080 }
1081 else if (FireMenuMessage(MMCODE_START, w, NULL/*ie*/, IntuitionBase))
1082 {
1083 /* This lock will be released only when the user is
1084 done with menus = when IECLASS_MENU + IESUBCLASS_MENUSTOP
1085 event arrives (generated by MenuHandler task) */
1086
1087 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->MenuLock);
1088 iihdata->MenuWindow = w;
1089 MENUS_ACTIVE = TRUE;
1090 }
1091 }
1092 }
1093 /* fall through */
1094
1095 case MENUUP:
1096 case MIDDLEDOWN:
1097 case MIDDLEUP:
1098
1099 switch(ie->ie_Code)
1100 {
1101 case MENUUP:
1102 iihdata->ActQualifier &= ~IEQUALIFIER_RBUTTON;
1103 if (GetPrivIBase(IntuitionBase)->MenuVerifyScreen)
1104 {
1105 struct Window *w1;
1106 struct IntScreen *scr = GetPrivIBase(IntuitionBase)->MenuVerifyScreen;
1107 ULONG lock = LockIBase(0);
1108
1109 for (w1 = scr->Screen.FirstWindow; w1; w1 = w1->NextWindow)
1110 {
1111 if (w1->IDCMPFlags & IDCMP_MENUVERIFY && w1->IDCMPFlags & IDCMP_MOUSEBUTTONS)
1112 {
1113 ih_fire_intuimessage(w1,
1114 IDCMP_MOUSEBUTTONS,
1115 MENUUP,
1116 w1,
1117 IntuitionBase);
1118 }
1119 }
1120
1121 UnlockIBase(lock);
1122
1123 /* FIXME: when the active window replies the verifymessage,
1124 * it should get a IDCMP_MENUPICK/MENUNULL message.
1125 */
1126 GetPrivIBase(IntuitionBase)->MenuVerifyScreen = NULL;
1127 scr->MenuVerifyActiveWindow = NULL;
1128 scr->MenuVerifyMsgCount = 0;
1129 scr->MenuVerifyTimeOut = 0;
1130 scr->MenuVerifySeconds = 0;
1131 scr->MenuVerifyMicros = 0;
1132 }
1133 break;
1134
1135 case MIDDLEDOWN:
1136 iihdata->ActQualifier |= IEQUALIFIER_MIDBUTTON;
1137 if (DoubleClick(GetPrivIBase(IntuitionBase)->LastClickSecs,GetPrivIBase(IntuitionBase)->LastClickMicro,
1138 ie->ie_TimeStamp.tv_secs,ie->ie_TimeStamp.tv_micro))
1139 {
1140 if (GetPrivIBase(IntuitionBase)->DoubleClickButton != MIDDLEDOWN)
1141 {
1142 GetPrivIBase(IntuitionBase)->DoubleClickCounter = 0;
1143 GetPrivIBase(IntuitionBase)->DoubleClickButton = MIDDLEDOWN;
1144 }
1145 else
1146 {
1147 GetPrivIBase(IntuitionBase)->DoubleClickCounter ++;
1148 }
1149 }
1150 else
1151 {
1152 GetPrivIBase(IntuitionBase)->DoubleClickButton = MIDDLEDOWN;
1153 GetPrivIBase(IntuitionBase)->DoubleClickCounter = 0;
1154 }
1155 /* update last click time for doubleclicktofront */
1156 GetPrivIBase(IntuitionBase)->LastClickSecs = ie->ie_TimeStamp.tv_secs;
1157 GetPrivIBase(IntuitionBase)->LastClickMicro = ie->ie_TimeStamp.tv_micro;
1158 break;
1159
1160 case MIDDLEUP:
1161 iihdata->ActQualifier &= ~IEQUALIFIER_MIDBUTTON;
1162 break;
1163 }
1164
1165 if (MENUS_ACTIVE)
1166 {
1167 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
1168 keep_event = FALSE;
1169 break;
1170 }
1171
1172
1173 if (boxgadget)
1174 {
1175 if (IS_BOOPSI_GADGET(boxgadget))
1176 {
1177 boxgadget = DoGPInput(boxgi, boxgadget, ie, GM_HANDLEINPUT, &reuse_event, IntuitionBase);
1178 }
1179
1180 } /* if (there is an active boxgadget) */
1181 else if (w && (!req || req->Flags & NOISYREQ) && w != GetPrivScreen(w->WScreen)->MenuVerifyActiveWindow)
1182 {
1183 ih_fire_intuimessage(w,
1184 IDCMP_MOUSEBUTTONS,
1185 ie->ie_Code,
1186 w,
1187 IntuitionBase);
1188 }
1189
1190 break; /* case MENUDOWN */
1191
1192 case IECODE_NOBUTTON: /* MOUSEMOVE */
1193 {
1194
1195 if (ie->ie_Qualifier & IEQUALIFIER_RELATIVEMOUSE)
1196 {
1197 struct Screen *scr;
1198 //ULONG Thresh;
1199
1200 /* Add delta information lost in previous mousemove event. See below. */
1201 iihdata->DeltaMouseX = ie->ie_X + iihdata->DeltaMouseX_Correction;
1202 iihdata->DeltaMouseY = ie->ie_Y + iihdata->DeltaMouseY_Correction;
1203
1204 #define ACCELERATOR_THRESH 2
1205 #define ACCELERATOR_MULTI 2
1206
1207 if (GetPrivIBase(IntuitionBase)->ActivePreferences->EnableCLI & MOUSE_ACCEL)
1208 {
1209 /* Acceleration */
1210 if (ABS(iihdata->DeltaMouseX) > ACCELERATOR_THRESH)
1211 {
1212 iihdata->DeltaMouseX *= ACCELERATOR_MULTI;
1213 }
1214 if (ABS(iihdata->DeltaMouseY) > ACCELERATOR_THRESH)
1215 {
1216 iihdata->DeltaMouseY *= ACCELERATOR_MULTI;
1217 }
1218 }
1219
1220 switch(GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks)
1221 {
1222 case 0:
1223 iihdata->DeltaMouseX_Correction = 0;
1224 iihdata->DeltaMouseX_Correction = 0;
1225 break;
1226
1227 default:
1228 /* Remember the delta information which gets lost because of division by PointerTicks.
1229 Will be added to prescaled deltas of next mousemove event. If this is not done, moving
1230 the mouse very slowly would cause it to not move at all */
1231
1232 iihdata->DeltaMouseX_Correction = iihdata->DeltaMouseX % GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks;
1233 iihdata->DeltaMouseY_Correction = iihdata->DeltaMouseY % GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks;
1234
1235 iihdata->DeltaMouseX /= GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks;
1236 iihdata->DeltaMouseY /= GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks;
1237 break;
1238 }
1239
1240
1241 ie->ie_X = iihdata->DeltaMouseX + iihdata->LastMouseX;
1242 ie->ie_Y = iihdata->DeltaMouseY + iihdata->LastMouseY;
1243
1244 //jDc: not really necessary to lock this for reading since this ptr is only modified
1245 //by functions synced with inputhandler
1246 //lock = LockIBase(0);
1247 scr = IntuitionBase->FirstScreen;
1248
1249 if (scr)
1250 {
1251 if (IntuitionBase->FirstScreen->Flags & AUTOSCROLL)
1252 {
1253
1254 #define VWIDTH IntuitionBase->ViewLord.ViewPort->DWidth
1255 #define VHEIGHT IntuitionBase->ViewLord.ViewPort->DHeight
1256 #define VDX IntuitionBase->ViewLord.ViewPort->DxOffset
1257 #define VDY IntuitionBase->ViewLord.ViewPort->DyOffset
1258
1259 if ((ie->ie_X > VWIDTH - scr->LeftEdge - 1) || (ie->ie_X < - scr->LeftEdge) ||
1260 (ie->ie_Y > VHEIGHT - scr->TopEdge - 1) || (ie->ie_Y < - scr->TopEdge))
1261 {
1262 if (ie->ie_X > VWIDTH - scr->LeftEdge - 1)
1263 {
1264 scr->LeftEdge = VWIDTH - ie->ie_X;
1265 if (VWIDTH - scr->LeftEdge > scr->Width) scr->LeftEdge = VWIDTH - scr->Width;
1266 VDX = scr->LeftEdge;
1267 }
1268
1269 if (ie->ie_X < -scr->LeftEdge)
1270 {
1271 scr->LeftEdge = -ie->ie_X;
1272 if (scr->LeftEdge < VWIDTH - scr->Width) scr->LeftEdge = VWIDTH - scr->Width;
1273 if(scr->LeftEdge > 0) scr->LeftEdge = 0; // we don't support > 0 LeftEdges
1274 VDX = scr->LeftEdge;
1275 }
1276
1277 if (ie->ie_Y > VHEIGHT - scr->TopEdge - 1)
1278 {
1279 scr->TopEdge = VHEIGHT - ie->ie_Y;
1280 if (VHEIGHT - scr->TopEdge > scr->Height) scr->TopEdge = VHEIGHT - scr->Height;
1281 VDY = scr->TopEdge;
1282 }
1283
1284 if (ie->ie_Y < -scr->TopEdge)
1285 {
1286 scr->TopEdge = - ie->ie_Y;
1287 if (scr->TopEdge < VHEIGHT - scr->Height) scr->TopEdge = VHEIGHT - scr->Height;
1288 if(scr->TopEdge > 0) scr->TopEdge = 0;
1289 VDY = scr->TopEdge;
1290 }
1291
1292 ScrollVPort(IntuitionBase->ViewLord.ViewPort);
1293 }
1294 }
1295
1296 if (ie->ie_X >= scr->Width + max(scr->LeftEdge,0)) ie->ie_X = scr->Width + max(scr->LeftEdge,0) - 1;
1297 if (ie->ie_Y >= scr->Height + max(scr->TopEdge,0)) ie->ie_Y = scr->Height + max(scr->TopEdge,0) - 1;
1298 if (ie->ie_X < - scr->LeftEdge) ie->ie_X = - scr->LeftEdge;
1299 if (ie->ie_Y < - scr->TopEdge) ie->ie_Y = - scr->TopEdge;
1300
1301 }
1302 else
1303 {
1304 if (ie->ie_X >= 320) ie->ie_X = 320 - 1;
1305 if (ie->ie_Y >= 200) ie->ie_Y = 200 - 1;
1306 if (ie->ie_X < 0) ie->ie_X = 0;
1307 if (ie->ie_Y < 0) ie->ie_Y = 0;
1308 }
1309 //UnlockIBase(lock);
1310 }
1311 else
1312 {
1313 iihdata->DeltaMouseX = ie->ie_X - iihdata->LastMouseX;
1314 iihdata->DeltaMouseY = ie->ie_Y - iihdata->LastMouseY;
1315 }
1316
1317
1318 /* Do Mouse Bounding - mouse will be most restrictive of screen size or mouse bounds */
1319 if (iihdata->MouseBoundsActiveFlag)
1320 {
1321 if (ie->ie_X < iihdata->MouseBoundsLeft)
1322 {
1323 ie->ie_X = iihdata->MouseBoundsLeft;
1324 }
1325 else if (ie->ie_X > iihdata->MouseBoundsRight)
1326 {
1327 ie->ie_X = iihdata->MouseBoundsRight;
1328 }
1329
1330 if (ie->ie_Y < iihdata->MouseBoundsTop)
1331 {
1332 ie->ie_Y = iihdata->MouseBoundsTop;
1333 }
1334 else if (ie->ie_Y > iihdata->MouseBoundsBottom)
1335 {
1336 ie->ie_Y = iihdata->MouseBoundsBottom;
1337 }
1338 }
1339
1340 #if !SINGLE_SETPOINTERPOS_PER_EVENTLOOP
1341 SetPointerPos(ie->ie_X, ie->ie_Y);
1342 #else
1343 pointerposx = ie->ie_X;
1344 pointerposy = ie->ie_Y;
1345 call_setpointerpos = TRUE;
1346 #endif
1347
1348 iihdata->LastMouseX = ie->ie_X;
1349 iihdata->LastMouseY = ie->ie_Y;
1350
1351 notify_mousemove_screensandwindows(ie->ie_X,
1352 ie->ie_Y,
1353 IntuitionBase);
1354
1355
1356 if (MENUS_ACTIVE)
1357 {
1358 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
1359 keep_event = FALSE;
1360 break;
1361 }
1362
1363 if (boxgadget)
1364 {
1365 keep_event = FALSE;
1366
1367 switch (boxgadget->GadgetType & GTYP_GTYPEMASK)
1368 {
1369 case GTYP_BOOLGADGET:
1370 case 0: //fallback for sucky gadgets
1371 /* Must be a RELVERIFY boxgadget */
1372 {
1373 BOOL inside;
1374
1375 inside = InsideGadget(boxgi->gi_Screen,
1376 boxgi->gi_Window,
1377 boxgi->gi_Requester,
1378 boxgadget,
1379 boxgi->gi_Screen->MouseX,
1380 boxgi->gi_Screen->MouseY);
1381
1382 if (inside != iihdata->MouseWasInsideBoolGadget)
1383 {
1384 iihdata->MouseWasInsideBoolGadget = inside;
1385
1386 boxgadget->Flags ^= GFLG_SELECTED;
1387 RefreshBoolGadgetState(boxgadget, w, req, IntuitionBase);
1388 }
1389 }
1390 break;
1391
1392 case GTYP_PROPGADGET:
1393 HandlePropMouseMove(boxgadget,
1394 w,
1395 req,
1396 w->MouseX - boxgi->gi_Domain.Left - GetGadgetLeft(boxgadget, boxgi->gi_Screen, boxgi->gi_Window, NULL),
1397 w->MouseY - boxgi->gi_Domain.Top - GetGadgetTop(boxgadget, boxgi->gi_Screen, boxgi->gi_Window, NULL),
1398 IntuitionBase);
1399
1400 break;
1401
1402 case GTYP_CUSTOMGADGET:
1403 boxgadget = DoGPInput(boxgi, boxgadget, ie, GM_HANDLEINPUT, &reuse_event, IntuitionBase);
1404 break;
1405
1406 } /* switch GadgetType */
1407
1408 } /* if (a boxgadget is currently active) */
1409
1410 keep_event = FALSE;
1411
1412 if (!w) break;
1413
1414 if (IW(w)->helpflags & HELPF_GADGETHELP && (!(PeekQualifier() & (IEQUALIFIER_LEFTBUTTON|IEQUALIFIER_RBUTTON|IEQUALIFIER_MIDBUTTON))))
1415 {
1416 struct Window *hw;
1417 struct Gadget *g;
1418
1419 hw = FindActiveWindow(ie, 0, IntuitionBase);
1420
1421 if (hw != w &&
1422 (!hw || !(IW(w)->helpflags & HELPF_ISHELPGROUP) ||
1423 !(IW(hw)->helpflags & HELPF_ISHELPGROUP) ||
1424 IW(w)->helpgroup != IW(hw)->helpgroup))
1425 {
1426
1427 if (iihdata->LastHelpWindow)
1428 {
1429 fire_intuimessage(w,
1430 IDCMP_GADGETHELP,
1431 0,
1432 NULL,
1433 IntuitionBase);
1434
1435 iihdata->LastHelpGadget = NULL;
1436 iihdata->LastHelpWindow = NULL;
1437 iihdata->HelpGadgetFindTime = 0;
1438 }
1439 }
1440 else
1441 {
1442 g = FindHelpGadget (hw,
1443 IntuitionBase->ActiveScreen->MouseX,
1444 IntuitionBase->ActiveScreen->MouseY,
1445 IntuitionBase);
1446 if (g && g != iihdata->LastHelpGadget)
1447 {
1448 if (!iihdata->LastHelpGadget)
1449 {
1450 iihdata->HelpGadgetFindTime = ((UQUAD)ie->ie_TimeStamp.tv_secs) * 50;
1451 iihdata->HelpGadgetFindTime += ie->ie_TimeStamp.tv_micro / 20000;
1452 }
1453 else
1454 {
1455 if (hw == iihdata->LastHelpWindow)
1456 {
1457 iihdata->HelpGadgetFindTime = ((UQUAD)ie->ie_TimeStamp.tv_secs) * 50;
1458 iihdata->HelpGadgetFindTime += ie->ie_TimeStamp.tv_micro / 20000;
1459 iihdata->HelpGadgetFindTime += 25;//smaller delay
1460 }
1461 }
1462 }
1463 else if (g != iihdata->LastHelpGadget ||
1464 hw != iihdata->LastHelpWindow)
1465 {
1466 fire_intuimessage(hw,
1467 IDCMP_GADGETHELP,
1468 0, /* Don't know what it should be */
1469 hw,
1470 IntuitionBase);
1471 }
1472
1473 iihdata->LastHelpGadget = g;
1474 iihdata->LastHelpWindow = hw;
1475 }
1476 }
1477 else
1478 {
1479 iihdata->LastHelpGadget = NULL;
1480 iihdata->LastHelpWindow = NULL;
1481 iihdata->HelpGadgetFindTime = 0;
1482 }
1483
1484 if (!(w->IDCMPFlags & IDCMP_MOUSEMOVE)) break;
1485
1486 /* Send IDCMP_MOUSEMOVE if WFLG_REPORTMOUSE is set
1487 and/or active boxgadget has GACT_FOLLOWMOUSE set */
1488
1489 /* jDc: do NOT send when sizegad is pressed */
1490
1491 if (!(w->Flags & WFLG_REPORTMOUSE))
1492 {
1493 if (!boxgadget) break;
1494 if (!(boxgadget->Activation & GACT_FOLLOWMOUSE)) break;
1495 }
1496 else
1497 {
1498 if (boxgadget && (boxgadget->GadgetType & (GTYP_SIZING|GTYP_WDRAGGING))) break;
1499 }
1500
1501 orig_ie->ie_Class = IECLASS_RAWMOUSE;
1502
1503 /* Limit the number of IDCMP_MOUSEMOVE messages sent to intuition.
1504 note that this comes after handling gadgets, because gadgets should get all events.
1505 */
1506
1507 if (IW(w)->num_mouseevents >= IW(w)->mousequeue)
1508 {
1509 BOOL old_msg_found = FALSE;
1510
1511 /* Mouse Queue is full, so try looking for a not
1512 yet GetMsg()ed IntuiMessage in w->UserPort
1513 trying to modify that. */
1514
1515 Forbid();
1516 if (w->UserPort)
1517 {
1518 struct IntuiMessage *im;
1519
1520 for (im = (struct IntuiMessage *)w->UserPort->mp_MsgList.lh_TailPred;
1521 im->ExecMessage.mn_Node.ln_Pred;
1522 im = (struct IntuiMessage *)im->ExecMessage.mn_Node.ln_Pred)
1523 {
1524 if ((im->Class == IDCMP_MOUSEMOVE) &&
1525 (im->IDCMPWindow == w))
1526 {
1527 im->Qualifier = iihdata->ActQualifier;
1528
1529 if (w->IDCMPFlags & IDCMP_DELTAMOVE)
1530 {
1531 im->MouseX = iihdata->DeltaMouseX;
1532 im->MouseY = iihdata->DeltaMouseY;
1533 }
1534 else
1535 {
1536 im->MouseX = w->MouseX;
1537 im->MouseY = w->MouseY;
1538 }
1539 CurrentTime(&im->Seconds, &im->Micros);
1540
1541 old_msg_found = TRUE;
1542 break;
1543 }
1544 }
1545 } /* if (w->UserPort) */
1546 Permit();
1547
1548 /* no need to send a new message if we modified
1549 an existing one ... */
1550
1551 if (old_msg_found) break;
1552
1553 /* ... otherwise we are in a strange situation. The mouse
1554 queue is full, but we did not find an existing MOUSEMOVE
1555 imsg in w->UserPort. So the app probably has removed
1556 an imsg from the UserPort with GetMsg but we did not get
1557 the ReplyMsg, yet. In this case we do send a new message */
1558
1559 HandleIntuiReplyPort(iihdata, IntuitionBase);
1560
1561 }
1562
1563 /* MouseQueue is not full, so we can send a message. We increase
1564 IntWindow->num_mouseevents which will later be decreased after
1565 the Intuition InputHandler gets the ReplyMessage from the app
1566 and handles it in HandleIntuiReplyPort() */
1567
1568 if (ih_fire_intuimessage(w,
1569 IDCMP_MOUSEMOVE,
1570 IECODE_NOBUTTON,
1571 w,
1572 IntuitionBase))
1573 {
1574 IW(w)->num_mouseevents++;
1575 }
1576
1577 break;
1578
1579 } /* case IECODE_NOBUTTON */
1580
1581 } /* switch (ie->ie_Code) (what button was pressed ?) */
1582 break;
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628 }
1629
1630 }
1631
1632 w = IntuitionBase->ActiveWindow;
1633
1634 if (!MENUS_ACTIVE && !SYSGADGET_ACTIVE)
1635 {
1636 /* lock = LockIBase(0UL); */
1637
1638 old_w = w;
1639 if (ie->ie_Class == IECLASS_RAWMOUSE && ie->ie_Code == SELECTDOWN)
1640 {
1641 w = FindActiveWindow(ie, &stitlebarhit, IntuitionBase);
1642 D(bug("iih:New active window: %p\n", w));
1643 }
1644
1645
1646 if ( w != old_w )
1647 {
1648 if (w)
1649 {
1650 D(bug("Activating new window (title %s)\n", w->Title ? w->Title : "<noname>"));
1651
1652 D(bug("Window activated\n"));
1653 }
1654 else
1655 {
1656 D(bug("Making active window inactive. Now there's no active window\n"));
1657 }
1658 new_active_window = TRUE;
1659 iihdata->NewActWindow = w;
1660 }
1661
1662 /* UnlockIBase(lock); */
1663
1664 if (new_active_window)
1665 {
1666 if (gadget && w &&
1667 (!(GetPrivScreen(w->WScreen)->MenuVerifyMsgCount)) &&
1668 (!(MENUS_ACTIVE)) && (!(SYSGADGET_ACTIVE)))
1669 {
1670 switch (gadget->GadgetType & GTYP_GTYPEMASK)
1671 {
1672
1673 case GTYP_CUSTOMGADGET:
1674 {
1675 struct gpGoInactive gpgi;
1676
1677 gpgi.MethodID = GM_GOINACTIVE;
1678 gpgi.gpgi_GInfo = gi;
1679 gpgi.gpgi_Abort = 1;
1680
1681 Locked_DoMethodA(gi->gi_Window, gadget, (Msg)&gpgi, IntuitionBase);
1682 break;
1683 }
1684
1685 case GTYP_STRGADGET:
1686 gadget->Flags &= ~GFLG_SELECTED;
1687 RefreshStrGadget(gadget, gi->gi_Window, gi->gi_Requester, IntuitionBase);
1688 break;
1689
1690 case GTYP_BOOLGADGET:
1691 /* That a bool gadget is active here can only happen
1692 if user used LMB to activate gadget and LAMIGA + LALT
1693 to activate other window, or viceversa */
1694 /* The gadget must be a RELVERIFY one */
1695 if (!(gadget->Activation & GACT_TOGGLESELECT))
1696 {
1697 BOOL inside;
1698
1699 inside = InsideGadget(gi->gi_Screen, gi->gi_Window,
1700 gi->gi_Requester, gadget,
1701 gi->gi_Screen->MouseX, gi->gi_Screen->MouseY);
1702
1703 if (inside)
1704 {
1705 gadget->Flags &= ~GFLG_SELECTED;
1706 RefreshBoolGadgetState(gadget, gi->gi_Window,
1707 gi->gi_Requester, IntuitionBase);
1708 }
1709 }
1710 break;
1711
1712 case GTYP_PROPGADGET:
1713 /* That a prop gadget is active here can only happen
1714 if user used LMB to activate gadget and LAMIGA + LALT
1715 to activate other window, or viceversa */
1716
1717 HandlePropSelectUp(gadget, gi->gi_Window, NULL, IntuitionBase);
1718 if (gadget->Activation & GACT_RELVERIFY)
1719 {
1720 ih_fire_intuimessage(gi->gi_Window,
1721 IDCMP_GADGETUP,
1722 0,
1723 gadget,
1724 IntuitionBase);
1725 }
1726 break;
1727
1728 } /* switch (gadget->GadgetType & GTYP_GTYPEMASK) */
1729
1730 gadget->Activation &= ~GACT_ACTIVEGADGET;
1731 iihdata->ActiveGadget = NULL;
1732 gadget = NULL;
1733 }
1734
1735 /* ActivateWindow works if w = NULL */
1736 /* jacaDcaps: some gui toolkits (die reaction, die!) close the window opened by a boopsi gadget when
1737 it gets hit with lmb, so we need to check if the new active window does not go away by
1738 performing GM_GOINACTIVE on the gadget. NOTE: CloseWindow's part performed on input.device context
1739 clears the iihdata->NewActWindow if it's the actually closed one. */
1740 if (w == iihdata->NewActWindow)
1741 {
1742 ActivateWindow(w);
1743 }
1744 else
1745 {
1746 w = IntuitionBase->ActiveWindow;
1747 new_active_window = FALSE;
1748 ie->ie_Class = IECLASS_NULL; //lose the event, otherwise the gadget will get activated again ;)
1749 }
1750
1751 iihdata->NewActWindow = 0;
1752
1753 } /* if (new_active_window) */
1754
1755 } /* if (!MENUS_ACTIVE) */
1756
1757 req = NULL;
1758 if (w)
1759 {
1760 req = w->FirstRequest;
1761 }
1762
1763 D(bug("w %p req %p gadget %p\n", w, req, gadget));
1764
1765 switch (ie->ie_Class)
1766 {
1767 case IECLASS_POINTERPOS:
1768 ie->ie_SubClass = IESUBCLASS_COMPATIBLE;
1769 /* fall through */
1770
1771 case IECLASS_NEWPOINTERPOS:
1772 switch (ie->ie_SubClass)
1773 {
1774 case IESUBCLASS_COMPATIBLE:
1775 ie->ie_Code = IECODE_NOBUTTON;
1776 break;
1777
1778 case IESUBCLASS_PIXEL:
1779 {
1780 struct IEPointerPixel *pp = ie->ie_EventAddress;
1781
1782 ie->ie_X = pp->iepp_Position.X + pp->iepp_Screen->LeftEdge;
1783 ie->ie_Y = pp->iepp_Position.Y + pp->iepp_Screen->TopEdge;
1784 }
1785 ie->ie_Code = IECODE_NOBUTTON;
1786 break;
1787
1788 case IESUBCLASS_TABLET:
1789 {
1790 //unsupported - does anything use it anyway? ;)
1791 }
1792 ie->ie_Code = 0;
1793 break;
1794
1795 case IESUBCLASS_NEWTABLET:
1796 {
1797 struct IENewTablet *nt = (struct IENewTablet *)ie->ie_EventAddress;
1798 struct Screen *scr = IntuitionBase->FirstScreen;
1799
1800 if (nt)
1801 {
1802 iihdata->ActEventTablet = nt; //cache this
1803 ie->ie_X = (scr->Width * nt->ient_TabletX) / nt->ient_RangeX;
1804 ie->ie_Y = (scr->Height * nt->ient_TabletY) / nt->ient_RangeY;
1805 }
1806 ie->ie_Class = IECLASS_RAWMOUSE;
1807 }
1808 break;
1809
1810 default:
1811 ie->ie_Code = 0;
1812 break;
1813 }
1814 /* fall through */
1815
1816 case IECLASS_RAWMOUSE:
1817 switch (ie->ie_Code)
1818 {
1819 case SELECTDOWN:
1820 {
1821 BOOL new_gadget = FALSE;
1822 BOOL sizeverify = FALSE;
1823
1824 iihdata->ActQualifier |= IEQUALIFIER_LEFTBUTTON;
1825
1826 #ifdef SKINS
1827 iihdata->TitlebarAppearTime = 0;
1828 #endif
1829 if (MENUS_ACTIVE)
1830 {
1831 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
1832 keep_event = FALSE;
1833 break;
1834 }
1835
1836 #ifdef SKINS
1837 if (!gadget && w)
1838 {
1839 struct Gadget * draggadget = 0;
1840
1841 if ((!(w->FirstRequest)) && (w->Flags & WFLG_DRAGBAR) && MatchHotkey(ie,IA_ACTIVEWINDOWMOVE,IntuitionBase))
1842 {
1843 if (w->MouseX < IW(w)->sizeimage_width || w->MouseX > w->Width - IW(w)->sizeimage_width - 1 || w->MouseY < ((IW(w)->sizeimage_height > w->BorderTop) ? IW(w)->sizeimage_height : w->BorderTop) || w->MouseY > w->Height - IW(w)->sizeimage_height - 1)
1844 {
1845 for (draggadget = w->FirstGadget; draggadget; draggadget = draggadget->NextGadget)
1846 {
1847 if ((draggadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING)
1848 {
1849 gadget = draggadget;
1850 new_gadget = TRUE;
1851 break;
1852 }
1853 }
1854 }
1855 }
1856
1857 if ((!(w->FirstRequest)) && (w->Flags & WFLG_SIZEGADGET) && MatchHotkey(ie,IA_ACTIVEWINDOWSIZE,IntuitionBase))
1858 {
1859 if (w->MouseX < IW(w)->sizeimage_width || w->MouseX > w->Width - IW(w)->sizeimage_width - 1 || w->MouseY < ((IW(w)->sizeimage_height > w->BorderTop) ? IW(w)->sizeimage_height : w->BorderTop) || w->MouseY > w->Height - IW(w)->sizeimage_height - 1)
1860 {
1861 for (draggadget = w->FirstGadget; draggadget; draggadget = draggadget->NextGadget)
1862 {
1863 if ((draggadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SIZING)
1864 {
1865 gadget = draggadget;
1866 new_gadget = TRUE;
1867 break;
1868 }
1869 }
1870 }
1871 }
1872 }
1873 #endif
1874
1875 if (!gadget)
1876 {
1877 /* use the *frontmost* screen rather than active one when searching
1878 for sdepth gadget! */
1879 gadget = FindGadget (IntuitionBase->FirstScreen,
1880 stitlebarhit ? 0 : w, stitlebarhit ? 0 : req,
1881 IntuitionBase->ActiveScreen ? IntuitionBase->ActiveScreen->MouseX : 0,
1882 IntuitionBase->ActiveScreen ? IntuitionBase->ActiveScreen->MouseY : 0,
1883 gi, FALSE, IntuitionBase);
1884
1885 D(bug("Click on gadget %p\n", gadget));
1886 new_gadget = TRUE;
1887
1888 } /* if (!gadget) */
1889
1890 if (!gadget && stitlebarhit)
1891 {
1892 struct Window *ww = 0;
1893
1894 if ((ww = FindDesktopWindow(IntuitionBase->FirstScreen,IntuitionBase)))
1895 {
1896 ActivateWindow(ww);
1897 w = ww;
1898 }
1899 }
1900
1901 if (!stitlebarhit && !new_active_window && DoubleClick(GetPrivIBase(IntuitionBase)->LastClickSecs,GetPrivIBase(IntuitionBase)->LastClickMicro,
1902 ie->ie_TimeStamp.tv_secs,ie->ie_TimeStamp.tv_micro))
1903 {
1904 if (GetPrivIBase(IntuitionBase)->DoubleClickButton != SELECTDOWN)
1905 {
1906 GetPrivIBase(IntuitionBase)->DoubleClickCounter = 0;
1907 GetPrivIBase(IntuitionBase)->DoubleClickButton = SELECTDOWN;
1908 }
1909 else
1910 {
1911 GetPrivIBase(IntuitionBase)->DoubleClickCounter ++;
1912 }
1913 }
1914 else
1915 {
1916 GetPrivIBase(IntuitionBase)->DoubleClickButton = SELECTDOWN;
1917 GetPrivIBase(IntuitionBase)->DoubleClickCounter = 0;
1918 }
1919
1920 /* update last click time for doubleclicktofront */
1921 GetPrivIBase(IntuitionBase)->LastClickSecs = ie->ie_TimeStamp.tv_secs;
1922 GetPrivIBase(IntuitionBase)->LastClickMicro = ie->ie_TimeStamp.tv_micro;
1923
1924 #ifdef SKINS
1925 if (!stitlebarhit)
1926 {
1927 ULONG result;
1928
1929 if (!(gadget && ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDEPTH)))
1930 if ((result = RunHotkeys(ie,IntuitionBase)))
1931 {
1932 //gadget = NULL;
1933 if (result == RUNHOTREUSE)
1934 {
1935 reuse_event = TRUE;
1936 }
1937 else
1938 {
1939 keep_event = FALSE;
1940 }
1941 }
1942 }
1943 #endif
1944 if (gadget && new_gadget)
1945 {
1946 if (w && (w->IDCMPFlags & IDCMP_SIZEVERIFY) &&
1947 ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SIZING /*||
1948 (gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WZOOM*/))
1949 {
1950 ih_fire_intuimessage(w,
1951 IDCMP_SIZEVERIFY,
1952 0,
1953 gadget,
1954 IntuitionBase);
1955 gadget = NULL;
1956 sizeverify = TRUE;
1957 }
1958 else
1959 {
1960 BOOL is_draggad, is_sizegad;
1961
1962 /* Whenever the active gadget changes the gi must be updated
1963 because it is cached in iidata->GadgetInfo!!!! Don't
1964 forget to do this if somewhere else the active
1965 gadget is changed, for example in ActivateGadget!!! */
1966
1967 PrepareGadgetInfo(gi, IntuitionBase->ActiveScreen, w, req);
1968 SetGadgetInfoGadget(gi, gadget, IntuitionBase);
1969
1970 #ifdef __MORPHOS__
1971 is_draggad = (((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING) || ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING2));
1972 #else
1973 is_draggad = ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDRAGGING);
1974 #endif
1975 is_sizegad = ((gadget->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SIZING);
1976
1977 #if 1
1978 /* jDc: intui68k sends IDCMPs for GACT_IMMEDIATE drag&sizegads! */
1979 if (gadget->Activation & GACT_IMMEDIATE)
1980 {
1981 ih_fire_intuimessage(w,
1982 IDCMP_GADGETDOWN,
1983 0,
1984 gadget,
1985 IntuitionBase);
1986 }
1987 #endif
1988
1989 if (is_draggad || is_sizegad)
1990 {
1991 if (IS_BOOPSI_GADGET(gadget))
1992 {
1993 DoGPInput(gi,
1994 gadget,
1995 ie,
1996 GM_GOACTIVE,
1997 &reuse_event,
1998 IntuitionBase);
1999
2000 /* Ignoring retval of dispatcher above is what
2001 AmigaOS does too for boopsi drag/resize
2002 gadgets */
2003
2004 }
2005
2006 /* From now on the master drag/size gadget takes over */
2007 if ((w->MoreFlags & WMFLG_IAMMUI) && (w->Flags & WFLG_BORDERLESS))
2008 {
2009 iihdata->ActiveSysGadget = is_draggad ? gadget : 0;
2010 }
2011 else
2012 {
2013 iihdata->ActiveSysGadget = gadget;
2014 }
2015 gadget = is_draggad ? iihdata->MasterDragGadget : iihdata->MasterSizeGadget;
2016 }
2017 }
2018 }
2019
2020 if (gadget)
2021 {
2022
2023 switch (gadget->GadgetType & GTYP_GTYPEMASK)
2024 {
2025 case GTYP_BOOLGADGET:
2026 /* Only set the GFLG_SELECTED flag for RELVERIFY and
2027 * TOGGLESELECT gadget. It's for the user to do it if
2028 * he wants for other GADGIMMEDIATE ones.
2029 * Only RELVERIFY gadgets stay active.
2030 */
2031
2032 if (gadget->Activation & (GACT_TOGGLESELECT | GACT_RELVERIFY))
2033 {
2034 gadget->Flags ^= GFLG_SELECTED;
2035 RefreshBoolGadgetState(gadget, w, req, IntuitionBase);
2036 }
2037
2038 if (gadget->Activation & GACT_RELVERIFY)
2039 {
2040 gadget->Activation |= GACT_ACTIVEGADGET;
2041 iihdata->MouseWasInsideBoolGadget = TRUE;
2042 }
2043 else
2044 {
2045 gadget = NULL;
2046 }
2047 break;
2048
2049 case GTYP_PROPGADGET:
2050 HandlePropSelectDown(gadget,
2051 w,
2052 req,
2053 w->MouseX - gi->gi_Domain.Left - GetGadgetLeft(gadget, gi->gi_Screen, gi->gi_Window, NULL),
2054 w->MouseY - gi->gi_Domain.Top - GetGadgetTop(gadget, gi->gi_Screen, gi->gi_Window, NULL),
2055 IntuitionBase);
2056
2057
2058 break;
2059
2060 case GTYP_STRGADGET:
2061 /* If the click was inside the active strgad,
2062 ** then let it update cursor pos,
2063 ** else deactivate stringadget and reuse event.
2064 */
2065
2066 if (InsideGadget(gi->gi_Screen, gi->gi_Window,
2067 gi->gi_Requester, gadget,
2068 gi->gi_Screen->MouseX, gi->gi_Screen->MouseY))
2069 {
2070 UWORD imsgcode;
2071
2072 HandleStrInput(gadget, gi, ie, &imsgcode,
2073 IntuitionBase);
2074 }
2075 else
2076 {
2077 gadget->Flags &= ~GFLG_SELECTED;
2078
2079 RefreshStrGadget(gadget, w, req, IntuitionBase);
2080 /* Gadget not active anymore */
2081 gadget = NULL;
2082 reuse_event = TRUE;
2083 }
2084 break;
2085
2086 case GTYP_CUSTOMGADGET:
2087 gadget = DoGPInput(gi,
2088 gadget,
2089 ie,
2090 (new_gadget ? GM_GOACTIVE : GM_HANDLEINPUT),
2091 &reuse_event,
2092 IntuitionBase);
2093 D(bug("new_gadget %d, goactive %p\n", new_gadget, gadget));
2094
2095 if (gadget && new_gadget && (!(gadget->GadgetType & GTYP_SIZING)))
2096 {
2097 /* For compatibility, send a GM_HANDLEINPUT too */
2098 struct InputEvent newie;
2099 BOOL reuse_event;
2100
2101 newie.ie_NextEvent = NULL;
2102 newie.ie_Class = IECLASS_RAWMOUSE;
2103 newie.ie_SubClass = 0;
2104 newie.ie_Code = IECODE_NOBUTTON;
2105 newie.ie_Qualifier = ie->ie_Qualifier;
2106 newie.ie_X = 0;
2107 newie.ie_Y = 0;
2108 newie.ie_TimeStamp.tv_secs = IntuitionBase->Seconds;
2109 newie.ie_TimeStamp.tv_micro = IntuitionBase->Micros;
2110
2111 gadget = DoGPInput(gi,
2112 gadget,
2113 &newie,
2114 GM_HANDLEINPUT,
2115 &reuse_event,
2116 IntuitionBase);
2117 D(bug("handleinput %p\n", gadget));
2118 }
2119 break;
2120
2121 case 0: //orig gadtools / some 1.3 gadgets
2122 if (IS_SYS_GADGET(gadget))
2123 {
2124 HandleSysGadgetVerify(gi, gadget, IntuitionBase);
2125 }
2126 else
2127 {
2128 if (gadget->Activation & GACT_RELVERIFY)
2129 {
2130 gadget->Activation |= GACT_ACTIVEGADGET;
2131 iihdata->MouseWasInsideBoolGadget = TRUE;
2132 if (gadget->Flags & GFLG_GADGHIMAGE)
2133 {
2134 gadget->Flags ^= GFLG_SELECTED;
2135 RefreshBoolGadgetState(gadget, w, req, IntuitionBase);
2136 }
2137 }
2138 else
2139 {
2140 /* jDc: this is what original intuition does, before crashing after a while ;)*/
2141 ih_fire_intuimessage(w,
2142 IDCMP_MOUSEBUTTONS,
2143 SELECTDOWN,
2144 w,
2145 IntuitionBase);
2146 }
2147 }
2148 break;
2149 } /* switch (GadgetType) */
2150
2151 } /* if (a gadget is active) */
2152 else if (w && (!req || req->Flags & NOISYREQ) && !sizeverify && !stitlebarhit)
2153 {
2154 ih_fire_intuimessage(w,
2155 IDCMP_MOUSEBUTTONS,
2156 SELECTDOWN,
2157 w,
2158 IntuitionBase);
2159 }
2160
2161
2162 } /* case SELECTDOWN */
2163 break;
2164
2165 case SELECTUP:
2166 iihdata->ActQualifier &= ~IEQUALIFIER_LEFTBUTTON;
2167
2168 #ifdef SKINS
2169 iihdata->TitlebarAppearTime = 0;
2170 #endif
2171 if (MENUS_ACTIVE)
2172 {
2173 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
2174 keep_event = FALSE;
2175 break;
2176 }
2177
2178 if (gadget)
2179 {
2180 BOOL inside = InsideGadget(gi->gi_Screen, gi->gi_Window,
2181 gi->gi_Requester, gadget,
2182 gi->gi_Screen->MouseX, gi->gi_Screen->MouseY);
2183
2184 /*int selected = (gadget->Flags & GFLG_SELECTED) != 0;*/
2185
2186 switch (gadget->GadgetType & GTYP_GTYPEMASK)
2187 {
2188 case GTYP_BOOLGADGET:
2189 /* Must be a RELVERIFY gadget */
2190
2191 if (!(gadget->Activation & GACT_TOGGLESELECT) && inside)
2192 {
2193 gadget->Flags ^= GFLG_SELECTED;
2194 RefreshBoolGadgetState(gadget, w, req, IntuitionBase);
2195 }
2196
2197 if (inside)
2198 {
2199 if (IS_SYS_GADGET(gadget))
2200 {
2201 HandleSysGadgetVerify(gi, gadget, IntuitionBase);
2202 }
2203 else
2204 {
2205 if (req && gadget->Activation & GACT_ENDGADGET)
2206 {
2207 EndRequest(req, w);
2208
2209 req = w->FirstRequest;
2210 }
2211
2212 ih_fire_intuimessage(w,
2213 IDCMP_GADGETUP,
2214 0,
2215 gadget,
2216 IntuitionBase);
2217 }
2218 }
2219 else
2220 {
2221 /* RKRM say so */
2222 ih_fire_intuimessage(w,
2223 IDCMP_MOUSEBUTTONS,
2224 SELECTUP,
2225 w,
2226 IntuitionBase);
2227 }
2228
2229 gadget->Activation &= ~GACT_ACTIVEGADGET;
2230 gadget = NULL;
2231 break;
2232
2233 case GTYP_PROPGADGET:
2234 HandlePropSelectUp(gadget, w, req, IntuitionBase);
2235 if (gadget->Activation & GACT_RELVERIFY)
2236 {
2237 ih_fire_intuimessage(w,
2238 IDCMP_GADGETUP,
2239 0,
2240 gadget,
2241 IntuitionBase);
2242 }
2243
2244 gadget = NULL;
2245 break;
2246
2247 /* Intuition string gadgets don't care about SELECTUP */
2248
2249 case GTYP_CUSTOMGADGET:
2250 gadget = DoGPInput(gi, gadget, ie, GM_HANDLEINPUT, &reuse_event, IntuitionBase);
2251 break;
2252
2253 case 0: //orig gadtools / some 1.3 gadgets
2254 /* jDc: adding a gadget with gtyp field set to NULL crashes intui68k
2255 ** seems we don't need compatibility on this field ;) anyway we should
2256 ** handle the case of GTYP_CLOSE, etc, set by some "cod3r"
2257 */
2258 gadget->Activation &= ~GACT_ACTIVEGADGET;
2259 if (gadget->Activation & GACT_RELVERIFY)
2260 {
2261 if (gadget->Flags & GFLG_GADGHIMAGE)
2262 {
2263 if (inside)
2264 {
2265 gadget->Flags ^= GFLG_SELECTED;
2266 RefreshBoolGadgetState(gadget, w, req, IntuitionBase);
2267 }
2268 }
2269
2270 if (inside)
2271 {
2272 ih_fire_intuimessage(w,
2273 IDCMP_GADGETUP,
2274 0,
2275 gadget,
2276 IntuitionBase);
2277 }
2278 } else {
2279 ih_fire_intuimessage(w,
2280 IDCMP_MOUSEBUTTONS,
2281 SELECTUP,
2282 w,
2283 IntuitionBase);
2284 }
2285 gadget = NULL;
2286 break;
2287
2288 } /* switch GadgetType */
2289
2290 } /* if (a gadget is currently active) */
2291 else if (w && (!req || req->Flags & NOISYREQ))
2292 {
2293 ih_fire_intuimessage(w,
2294 IDCMP_MOUSEBUTTONS,
2295 SELECTUP,
2296 w,
2297 IntuitionBase);
2298 }
2299
2300 break; /* case SELECTUP */
2301
2302 case MENUDOWN:
2303 iihdata->ActQualifier |= IEQUALIFIER_RBUTTON;
2304
2305 #ifdef SKINS
2306 iihdata->TitlebarAppearTime = 0;
2307 #endif
2308 if (MENUS_ACTIVE)
2309 {
2310 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
2311 keep_event = FALSE;
2312 break;
2313 }
2314
2315 if (DoubleClick(GetPrivIBase(IntuitionBase)->LastClickSecs,GetPrivIBase(IntuitionBase)->LastClickMicro,
2316 ie->ie_TimeStamp.tv_secs,ie->ie_TimeStamp.tv_micro))
2317 {
2318 if (GetPrivIBase(IntuitionBase)->DoubleClickButton != MENUDOWN)
2319 {
2320 GetPrivIBase(IntuitionBase)->DoubleClickCounter = 0;
2321 GetPrivIBase(IntuitionBase)->DoubleClickButton = MENUDOWN;
2322 }
2323 else
2324 {
2325 GetPrivIBase(IntuitionBase)->DoubleClickCounter ++;
2326 }
2327 }
2328 else
2329 {
2330 GetPrivIBase(IntuitionBase)->DoubleClickButton = MENUDOWN;
2331 GetPrivIBase(IntuitionBase)->DoubleClickCounter = 0;
2332 }
2333
2334 /* update last click time for doubleclicktofront */
2335 GetPrivIBase(IntuitionBase)->LastClickSecs = ie->ie_TimeStamp.tv_secs;
2336 GetPrivIBase(IntuitionBase)->LastClickMicro = ie->ie_TimeStamp.tv_micro;
2337
2338 #ifdef SKINS
2339 {
2340 ULONG result;
2341
2342 if ((result = RunHotkeys(ie,IntuitionBase)))
2343 {
2344 if (result == RUNHOTREUSE)
2345 {
2346 reuse_event = TRUE;
2347 }
2348 else
2349 {
2350 keep_event = FALSE;
2351 }
2352 break;
2353 }
2354 w = IntuitionBase->ActiveWindow;
2355 }
2356 #endif
2357
2358 #ifdef SKINS
2359 if ((!MENUS_ACTIVE) && (!gadget) && (!(iihdata->ActQualifier & (IEQUALIFIER_LEFTBUTTON|IEQUALIFIER_MIDBUTTON))))
2360 {
2361 struct Gadget *gad;
2362 struct GadgetInfo ginf;
2363 ULONG hit;
2364 struct Window *wind = FindActiveWindow(0,&hit,IntuitionBase);
2365
2366 if (wind)
2367 {
2368 gad = FindGadget (IntuitionBase->FirstScreen,
2369 hit ? 0 : wind,0,
2370 IntuitionBase->ActiveScreen->MouseX,
2371 IntuitionBase->ActiveScreen->MouseY,
2372 &ginf, TRUE, IntuitionBase);
2373
2374 if (gad && ((gad->GadgetType & GTYP_SYSTYPEMASK) == GTYP_WDEPTH))
2375 {
2376 CreateSmallMenuTask(wind,SMALLMENU_TYPE_WINDOWDEPTH,IntuitionBase);
2377 keep_event = FALSE;
2378 break;
2379 }
2380
2381 if (gad && ((gad->GadgetType & GTYP_SYSTYPEMASK) == GTYP_SDEPTH))
2382 {
2383 CreateSmallMenuTask(0,SMALLMENU_TYPE_SCREENDEPTH,IntuitionBase);
2384 keep_event = FALSE;
2385 break;
2386 }
2387 }
2388 }
2389 #endif
2390
2391 if (w && !req && w->DMRequest && !(w->Flags & WFLG_RMBTRAP))
2392 {
2393 if (!MENUS_ACTIVE &&
2394 DoubleClick(GetPrivIBase(IntuitionBase)->DMStartSecs,
2395 GetPrivIBase(IntuitionBase)->DMStartMicro,
2396 ie->ie_TimeStamp.tv_secs,
2397 ie->ie_TimeStamp.tv_micro))
2398 {
2399 if (w->IDCMPFlags & IDCMP_REQVERIFY)
2400 {
2401 ih_fire_intuimessage(w,
2402 IDCMP_REQVERIFY,
2403 MENUHOT,
2404 NULL,
2405 IntuitionBase);
2406 }
2407 else if (Request(w->DMRequest, w))
2408 {
2409 req = w->DMRequest;
2410
2411 ih_fire_intuimessage(w,
2412 IDCMP_REQSET,
2413 0,
2414 w,
2415 IntuitionBase);
2416 }
2417 keep_event = FALSE;
2418 break;
2419 }
2420
2421 GetPrivIBase(IntuitionBase)->DMStartSecs = ie->ie_TimeStamp.tv_secs;
2422 GetPrivIBase(IntuitionBase)->DMStartMicro = ie->ie_TimeStamp.tv_micro;
2423 }
2424
2425 if (w && !gadget)
2426 {
2427 if (!(w->Flags & WFLG_RMBTRAP) && !req)
2428 {
2429 struct IntScreen *scr = GetPrivScreen(w->WScreen);
2430 struct Window *w1;
2431 ULONG lock;
2432 BOOL mouseon = TRUE;
2433
2434 scr->MenuVerifyMsgCount = 0;
2435
2436 if (w->MouseX < 0 || w->MouseY < 0) mouseon = FALSE;
2437 if (w->MouseX > w->Width || w->MouseY > w->Height) mouseon = FALSE;
2438
2439 if (w->IDCMPFlags & IDCMP_MENUVERIFY && (!(IW(w)->specialflags & SPFLAG_IAMDEAD)))
2440 {
2441 ih_fire_intuimessage(w,
2442 IDCMP_MENUVERIFY,
2443 mouseon ? MENUHOT : MENUWAITING,
2444 w,
2445 IntuitionBase);
2446 scr->MenuVerifyMsgCount++;
2447 }
2448
2449 lock = LockIBase(0);
2450
2451 for (w1 = scr->Screen.FirstWindow; w1; w1 = w1->NextWindow)
2452 {
2453 if ((w1->IDCMPFlags & IDCMP_MENUVERIFY) && (w1 != w) && (!(IW(w)->specialflags & SPFLAG_IAMDEAD)))
2454 {
2455 ih_fire_intuimessage(w1,
2456 IDCMP_MENUVERIFY,
2457 MENUWAITING,
2458 w1,
2459 IntuitionBase);
2460 ++scr->MenuVerifyMsgCount;
2461 }
2462 }
2463
2464 UnlockIBase(lock);
2465
2466 /* FIXME: when a window is opened with IDCMP_MENUVERIFY
2467 * (or this event is requested via ModifyIDCMP), and a
2468 * verify operation is pending, the window should get
2469 * a verify message too. Oh well.
2470 */
2471
2472 if (scr->MenuVerifyMsgCount)
2473 {
2474 GetPrivIBase(IntuitionBase)->MenuVerifyScreen = scr;
2475 scr->MenuVerifyActiveWindow = w;
2476 scr->MenuVerifyTimeOut = 2;
2477 scr->MenuVerifySeconds = IntuitionBase->Seconds;
2478 scr->MenuVerifyMicros = IntuitionBase->Micros;
2479 }
2480 else if (FireMenuMessage(MMCODE_START, w, NULL/*ie*/, IntuitionBase))
2481 {
2482 /* This lock will be released only when the user is
2483 done with menus = when IECLASS_MENU + IESUBCLASS_MENUSTOP
2484 event arrives (generated by MenuHandler task) */
2485
2486 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->MenuLock);
2487 iihdata->MenuWindow = w;
2488 MENUS_ACTIVE = TRUE;
2489 }
2490 }
2491 }
2492 /* fall through */
2493
2494 case MENUUP:
2495 case MIDDLEDOWN:
2496 case MIDDLEUP:
2497
2498 switch(ie->ie_Code)
2499 {
2500 case MENUUP:
2501 iihdata->ActQualifier &= ~IEQUALIFIER_RBUTTON;
2502 if (GetPrivIBase(IntuitionBase)->MenuVerifyScreen)
2503 {
2504 struct Window *w1;
2505 struct IntScreen *scr = GetPrivIBase(IntuitionBase)->MenuVerifyScreen;
2506 ULONG lock = LockIBase(0);
2507
2508 for (w1 = scr->Screen.FirstWindow; w1; w1 = w1->NextWindow)
2509 {
2510 if (w1->IDCMPFlags & IDCMP_MENUVERIFY && w1->IDCMPFlags & IDCMP_MOUSEBUTTONS)
2511 {
2512 ih_fire_intuimessage(w1,
2513 IDCMP_MOUSEBUTTONS,
2514 MENUUP,
2515 w1,
2516 IntuitionBase);
2517 }
2518 }
2519
2520 UnlockIBase(lock);
2521
2522 /* FIXME: when the active window replies the verifymessage,
2523 * it should get a IDCMP_MENUPICK/MENUNULL message.
2524 */
2525 GetPrivIBase(IntuitionBase)->MenuVerifyScreen = NULL;
2526 scr->MenuVerifyActiveWindow = NULL;
2527 scr->MenuVerifyMsgCount = 0;
2528 scr->MenuVerifyTimeOut = 0;
2529 scr->MenuVerifySeconds = 0;
2530 scr->MenuVerifyMicros = 0;
2531 }
2532 break;
2533
2534 case MIDDLEDOWN:
2535 iihdata->ActQualifier |= IEQUALIFIER_MIDBUTTON;
2536 if (DoubleClick(GetPrivIBase(IntuitionBase)->LastClickSecs,GetPrivIBase(IntuitionBase)->LastClickMicro,
2537 ie->ie_TimeStamp.tv_secs,ie->ie_TimeStamp.tv_micro))
2538 {
2539 if (GetPrivIBase(IntuitionBase)->DoubleClickButton != MIDDLEDOWN)
2540 {
2541 GetPrivIBase(IntuitionBase)->DoubleClickCounter = 0;
2542 GetPrivIBase(IntuitionBase)->DoubleClickButton = MIDDLEDOWN;
2543 }
2544 else
2545 {
2546 GetPrivIBase(IntuitionBase)->DoubleClickCounter ++;
2547 }
2548 }
2549 else
2550 {
2551 GetPrivIBase(IntuitionBase)->DoubleClickButton = MIDDLEDOWN;
2552 GetPrivIBase(IntuitionBase)->DoubleClickCounter = 0;
2553 }
2554 /* update last click time for doubleclicktofront */
2555 GetPrivIBase(IntuitionBase)->LastClickSecs = ie->ie_TimeStamp.tv_secs;
2556 GetPrivIBase(IntuitionBase)->LastClickMicro = ie->ie_TimeStamp.tv_micro;
2557 break;
2558
2559 case MIDDLEUP:
2560 iihdata->ActQualifier &= ~IEQUALIFIER_MIDBUTTON;
2561 break;
2562 }
2563
2564 #ifdef SKINS
2565 iihdata->TitlebarAppearTime = 0;
2566 #endif
2567 if (MENUS_ACTIVE)
2568 {
2569 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
2570 keep_event = FALSE;
2571 break;
2572 }
2573
2574 #ifdef SKINS
2575 if (ie->ie_Code == MIDDLEDOWN)
2576 {
2577 ULONG result;
2578
2579 if ((result = RunHotkeys(ie,IntuitionBase)))
2580 {
2581 if (result == RUNHOTREUSE)
2582 {
2583 reuse_event = TRUE;
2584 }
2585 else
2586 {
2587 keep_event = FALSE;
2588 }
2589 break;
2590 }
2591 w = IntuitionBase->ActiveWindow;
2592 }
2593 #endif
2594 if (gadget)
2595 {
2596 if (IS_BOOPSI_GADGET(gadget))
2597 {
2598 gadget = DoGPInput(gi, gadget, ie, GM_HANDLEINPUT, &reuse_event, IntuitionBase);
2599 }
2600
2601 } /* if (there is an active gadget) */
2602 else if (w && (!req || req->Flags & NOISYREQ) && w != GetPrivScreen(w->WScreen)->MenuVerifyActiveWindow)
2603 {
2604 ih_fire_intuimessage(w,
2605 IDCMP_MOUSEBUTTONS,
2606 ie->ie_Code,
2607 w,
2608 IntuitionBase);
2609 }
2610
2611 break; /* case MENUDOWN */
2612
2613 case IECODE_NOBUTTON: /* MOUSEMOVE */
2614 {
2615
2616 if (ie->ie_Qualifier & IEQUALIFIER_RELATIVEMOUSE)
2617 {
2618 struct Screen *scr;
2619 //ULONG Thresh;
2620
2621 /* Add delta information lost in previous mousemove event. See below. */
2622 iihdata->DeltaMouseX = ie->ie_X + iihdata->DeltaMouseX_Correction;
2623 iihdata->DeltaMouseY = ie->ie_Y + iihdata->DeltaMouseY_Correction;
2624
2625 #define ACCELERATOR_THRESH 2
2626 #define ACCELERATOR_MULTI 2
2627
2628 if (GetPrivIBase(IntuitionBase)->ActivePreferences->EnableCLI & MOUSE_ACCEL)
2629 {
2630 /* Acceleration */
2631 if (ABS(iihdata->DeltaMouseX) > ACCELERATOR_THRESH)
2632 {
2633 iihdata->DeltaMouseX *= ACCELERATOR_MULTI;
2634 }
2635 if (ABS(iihdata->DeltaMouseY) > ACCELERATOR_THRESH)
2636 {
2637 iihdata->DeltaMouseY *= ACCELERATOR_MULTI;
2638 }
2639 }
2640
2641 switch(GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks)
2642 {
2643 case 0:
2644 iihdata->DeltaMouseX_Correction = 0;
2645 iihdata->DeltaMouseX_Correction = 0;
2646 break;
2647
2648 default:
2649 /* Remember the delta information which gets lost because of division by PointerTicks.
2650 Will be added to prescaled deltas of next mousemove event. If this is not done, moving
2651 the mouse very slowly would cause it to not move at all */
2652
2653 iihdata->DeltaMouseX_Correction = iihdata->DeltaMouseX % GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks;
2654 iihdata->DeltaMouseY_Correction = iihdata->DeltaMouseY % GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks;
2655
2656 iihdata->DeltaMouseX /= GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks;
2657 iihdata->DeltaMouseY /= GetPrivIBase(IntuitionBase)->ActivePreferences->PointerTicks;
2658 break;
2659 }
2660
2661
2662 ie->ie_X = iihdata->DeltaMouseX + iihdata->LastMouseX;
2663 ie->ie_Y = iihdata->DeltaMouseY + iihdata->LastMouseY;
2664
2665 //jDc: not really necessary to lock this for reading since this ptr is only modified
2666 //by functions synced with inputhandler
2667 //lock = LockIBase(0);
2668 scr = IntuitionBase->FirstScreen;
2669
2670 if (scr)
2671 {
2672 if (IntuitionBase->FirstScreen->Flags & AUTOSCROLL)
2673 {
2674
2675 #define VWIDTH IntuitionBase->ViewLord.ViewPort->DWidth
2676 #define VHEIGHT IntuitionBase->ViewLord.ViewPort->DHeight
2677 #define VDX IntuitionBase->ViewLord.ViewPort->DxOffset
2678 #define VDY IntuitionBase->ViewLord.ViewPort->DyOffset
2679
2680 if ((ie->ie_X > VWIDTH - scr->LeftEdge - 1) || (ie->ie_X < - scr->LeftEdge) ||
2681 (ie->ie_Y > VHEIGHT - scr->TopEdge - 1) || (ie->ie_Y < - scr->TopEdge))
2682 {
2683 if (ie->ie_X > VWIDTH - scr->LeftEdge - 1)
2684 {
2685 scr->LeftEdge = VWIDTH - ie->ie_X;
2686 if (VWIDTH - scr->LeftEdge > scr->Width) scr->LeftEdge = VWIDTH - scr->Width;
2687 VDX = scr->LeftEdge;
2688 }
2689
2690 if (ie->ie_X < -scr->LeftEdge)
2691 {
2692 scr->LeftEdge = -ie->ie_X;
2693 if (scr->LeftEdge < VWIDTH - scr->Width) scr->LeftEdge = VWIDTH - scr->Width;
2694 if(scr->LeftEdge > 0) scr->LeftEdge = 0; // we don't support > 0 LeftEdges
2695 VDX = scr->LeftEdge;
2696 }
2697
2698 if (ie->ie_Y > VHEIGHT - scr->TopEdge - 1)
2699 {
2700 scr->TopEdge = VHEIGHT - ie->ie_Y;
2701 if (VHEIGHT - scr->TopEdge > scr->Height) scr->TopEdge = VHEIGHT - scr->Height;
2702 VDY = scr->TopEdge;
2703 }
2704
2705 if (ie->ie_Y < -scr->TopEdge)
2706 {
2707 scr->TopEdge = - ie->ie_Y;
2708 if (scr->TopEdge < VHEIGHT - scr->Height) scr->TopEdge = VHEIGHT - scr->Height;
2709 if(scr->TopEdge > 0) scr->TopEdge = 0;
2710 VDY = scr->TopEdge;
2711 }
2712
2713 ScrollVPort(IntuitionBase->ViewLord.ViewPort);
2714 }
2715 }
2716
2717 if (ie->ie_X >= scr->Width + max(scr->LeftEdge,0)) ie->ie_X = scr->Width + max(scr->LeftEdge,0) - 1;
2718 if (ie->ie_Y >= scr->Height + max(scr->TopEdge,0)) ie->ie_Y = scr->Height + max(scr->TopEdge,0) - 1;
2719 if (ie->ie_X < - scr->LeftEdge) ie->ie_X = - scr->LeftEdge;
2720 if (ie->ie_Y < - scr->TopEdge) ie->ie_Y = - scr->TopEdge;
2721
2722 }
2723 else
2724 {
2725 if (ie->ie_X >= 320) ie->ie_X = 320 - 1;
2726 if (ie->ie_Y >= 200) ie->ie_Y = 200 - 1;
2727 if (ie->ie_X < 0) ie->ie_X = 0;
2728 if (ie->ie_Y < 0) ie->ie_Y = 0;
2729 }
2730 //UnlockIBase(lock);
2731 }
2732 else
2733 {
2734 iihdata->DeltaMouseX = ie->ie_X - iihdata->LastMouseX;
2735 iihdata->DeltaMouseY = ie->ie_Y - iihdata->LastMouseY;
2736 }
2737
2738 #ifdef SKINS
2739 if (gadget == iihdata->MasterDragGadget)
2740 {
2741 struct gpInput gpi;
2742 ULONG retval;
2743
2744 gpi.MethodID = GM_MOVETEST;
2745 gpi.gpi_GInfo = gi;
2746 gpi.gpi_Mouse.X = ie->ie_X - gi->gi_Window->WScreen->LeftEdge;
2747 gpi.gpi_Mouse.Y = ie->ie_Y - gi->gi_Window->WScreen->TopEdge;
2748 gpi.gpi_IEvent = ie;
2749
2750 retval = Locked_DoMethodA(gi->gi_Window, gadget, (Msg)&gpi, IntuitionBase);
2751 if (retval == MOVETEST_ADJUSTPOS)
2752 {
2753 ie->ie_X = gpi.gpi_Mouse.X + gi->gi_Window->WScreen->LeftEdge;
2754 ie->ie_Y = gpi.gpi_Mouse.Y + gi->gi_Window->WScreen->TopEdge;
2755 }
2756
2757 }
2758 #endif
2759 /* Do Mouse Bounding - mouse will be most restrictive of screen size or mouse bounds */
2760 if (iihdata->MouseBoundsActiveFlag)
2761 {
2762 if (ie->ie_X < iihdata->MouseBoundsLeft)
2763 {
2764 ie->ie_X = iihdata->MouseBoundsLeft;
2765 }
2766 else if (ie->ie_X > iihdata->MouseBoundsRight)
2767 {
2768 ie->ie_X = iihdata->MouseBoundsRight;
2769 }
2770
2771 if (ie->ie_Y < iihdata->MouseBoundsTop)
2772 {
2773 ie->ie_Y = iihdata->MouseBoundsTop;
2774 }
2775 else if (ie->ie_Y > iihdata->MouseBoundsBottom)
2776 {
2777 ie->ie_Y = iihdata->MouseBoundsBottom;
2778 }
2779 }
2780
2781 #if !SINGLE_SETPOINTERPOS_PER_EVENTLOOP
2782 SetPointerPos(ie->ie_X, ie->ie_Y);
2783 #else
2784 pointerposx = ie->ie_X;
2785 pointerposy = ie->ie_Y;
2786 call_setpointerpos = TRUE;
2787 #endif
2788
2789 iihdata->LastMouseX = ie->ie_X;
2790 iihdata->LastMouseY = ie->ie_Y;
2791
2792 notify_mousemove_screensandwindows(ie->ie_X,
2793 ie->ie_Y,
2794 IntuitionBase);
2795
2796 #ifdef SKINS
2797 if (!gadget)
2798 {
2799 if (iihdata->TitlebarOnTop)
2800 {
2801 if (IntuitionBase->FirstScreen->MouseY > IntuitionBase->FirstScreen->BarHeight && GetPrivScreen(IntuitionBase->FirstScreen)->SpecialFlags & SF_AppearingBar)
2802 {
2803 iihdata->TitlebarOnTop = FALSE;
2804 iihdata->TitlebarAppearTime = 0;
2805
2806 LOCK_REFRESH(IntuitionBase->FirstScreen);
2807
2808 MoveLayer(0,IntuitionBase->FirstScreen->BarLayer,0,-(IntuitionBase->FirstScreen->BarHeight + 1));
2809 CheckLayers(IntuitionBase->FirstScreen, IntuitionBase);
2810
2811 UNLOCK_REFRESH(IntuitionBase->FirstScreen);
2812 }
2813 }
2814 else
2815 {
2816 if (IntuitionBase->FirstScreen->MouseY == 0 && GetPrivScreen(IntuitionBase->FirstScreen)->SpecialFlags & SF_AppearingBar && !MENUS_ACTIVE && !(PeekQualifier() & (IEQUALIFIER_LEFTBUTTON|IEQUALIFIER_RBUTTON|IEQUALIFIER_MIDBUTTON)))
2817 {
2818 if (!(iihdata->TitlebarAppearTime))
2819 {
2820 iihdata->TitlebarAppearTime = ((UQUAD)ie->ie_TimeStamp.tv_secs) * 50;
2821 iihdata->TitlebarAppearTime += ie->ie_TimeStamp.tv_micro / 20000;
2822 }
2823 }
2824 else
2825 {
2826 iihdata->TitlebarAppearTime = 0;
2827 }
2828 }
2829 }
2830 #endif
2831
2832 if (MENUS_ACTIVE)
2833 {
2834 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
2835 keep_event = FALSE;
2836 break;
2837 }
2838
2839 if (gadget)
2840 {
2841 keep_event = FALSE;
2842
2843 switch (gadget->GadgetType & GTYP_GTYPEMASK)
2844 {
2845 case GTYP_BOOLGADGET:
2846 case 0: //fallback for sucky gadgets
2847 /* Must be a RELVERIFY gadget */
2848 {
2849 BOOL inside;
2850
2851 inside = InsideGadget(gi->gi_Screen,
2852 gi->gi_Window,
2853 gi->gi_Requester,
2854 gadget,
2855 gi->gi_Screen->MouseX,
2856 gi->gi_Screen->MouseY);
2857
2858 if (inside != iihdata->MouseWasInsideBoolGadget)
2859 {
2860 iihdata->MouseWasInsideBoolGadget = inside;
2861
2862 gadget->Flags ^= GFLG_SELECTED;
2863 RefreshBoolGadgetState(gadget, w, req, IntuitionBase);
2864 }
2865 }
2866 break;
2867
2868 case GTYP_PROPGADGET:
2869 HandlePropMouseMove(gadget,
2870 w,
2871 req,
2872 w->MouseX - gi->gi_Domain.Left - GetGadgetLeft(gadget, gi->gi_Screen, gi->gi_Window, NULL),
2873 w->MouseY - gi->gi_Domain.Top - GetGadgetTop(gadget, gi->gi_Screen, gi->gi_Window, NULL),
2874 IntuitionBase);
2875
2876 break;
2877
2878 case GTYP_CUSTOMGADGET:
2879 gadget = DoGPInput(gi, gadget, ie, GM_HANDLEINPUT, &reuse_event, IntuitionBase);
2880 break;
2881
2882 } /* switch GadgetType */
2883
2884 } /* if (a gadget is currently active) */
2885
2886 keep_event = FALSE;
2887
2888 if (!w) break;
2889
2890 if (IW(w)->helpflags & HELPF_GADGETHELP && (!(PeekQualifier() & (IEQUALIFIER_LEFTBUTTON|IEQUALIFIER_RBUTTON|IEQUALIFIER_MIDBUTTON))))
2891 {
2892 struct Window *hw;
2893 struct Gadget *g;
2894
2895 hw = FindActiveWindow(ie, 0, IntuitionBase);
2896
2897 if (hw != w &&
2898 (!hw || !(IW(w)->helpflags & HELPF_ISHELPGROUP) ||
2899 !(IW(hw)->helpflags & HELPF_ISHELPGROUP) ||
2900 IW(w)->helpgroup != IW(hw)->helpgroup))
2901 {
2902
2903 if (iihdata->LastHelpWindow)
2904 {
2905 fire_intuimessage(w,
2906 IDCMP_GADGETHELP,
2907 0,
2908 NULL,
2909 IntuitionBase);
2910
2911 iihdata->LastHelpGadget = NULL;
2912 iihdata->LastHelpWindow = NULL;
2913 iihdata->HelpGadgetFindTime = 0;
2914 }
2915 }
2916 else
2917 {
2918 g = FindHelpGadget (hw,
2919 IntuitionBase->ActiveScreen->MouseX,
2920 IntuitionBase->ActiveScreen->MouseY,
2921 IntuitionBase);
2922 if (g && g != iihdata->LastHelpGadget)
2923 {
2924 if (!iihdata->LastHelpGadget)
2925 {
2926 iihdata->HelpGadgetFindTime = ((UQUAD)ie->ie_TimeStamp.tv_secs) * 50;
2927 iihdata->HelpGadgetFindTime += ie->ie_TimeStamp.tv_micro / 20000;
2928 }
2929 else
2930 {
2931 if (hw == iihdata->LastHelpWindow)
2932 {
2933 iihdata->HelpGadgetFindTime = ((UQUAD)ie->ie_TimeStamp.tv_secs) * 50;
2934 iihdata->HelpGadgetFindTime += ie->ie_TimeStamp.tv_micro / 20000;
2935 iihdata->HelpGadgetFindTime += 25;//smaller delay
2936 }
2937 }
2938 }
2939 else if (g != iihdata->LastHelpGadget ||
2940 hw != iihdata->LastHelpWindow)
2941 {
2942 fire_intuimessage(hw,
2943 IDCMP_GADGETHELP,
2944 0, /* Don't know what it should be */
2945 hw,
2946 IntuitionBase);
2947 }
2948
2949 iihdata->LastHelpGadget = g;
2950 iihdata->LastHelpWindow = hw;
2951 }
2952 }
2953 else
2954 {
2955 iihdata->LastHelpGadget = NULL;
2956 iihdata->LastHelpWindow = NULL;
2957 iihdata->HelpGadgetFindTime = 0;
2958 }
2959
2960 if (!(w->IDCMPFlags & IDCMP_MOUSEMOVE)) break;
2961
2962 /* Send IDCMP_MOUSEMOVE if WFLG_REPORTMOUSE is set
2963 and/or active gadget has GACT_FOLLOWMOUSE set */
2964
2965 /* jDc: do NOT send when sizegad is pressed */
2966
2967 if (!(w->Flags & WFLG_REPORTMOUSE))
2968 {
2969 if (!gadget) break;
2970 if (!(gadget->Activation & GACT_FOLLOWMOUSE)) break;
2971 }
2972 else
2973 {
2974 if (gadget && (gadget->GadgetType & (GTYP_SIZING|GTYP_WDRAGGING))) break;
2975 }
2976
2977 orig_ie->ie_Class = IECLASS_RAWMOUSE;
2978
2979 /* Limit the number of IDCMP_MOUSEMOVE messages sent to intuition.
2980 note that this comes after handling gadgets, because gadgets should get all events.
2981 */
2982
2983 if (IW(w)->num_mouseevents >= IW(w)->mousequeue)
2984 {
2985 BOOL old_msg_found = FALSE;
2986
2987 /* Mouse Queue is full, so try looking for a not
2988 yet GetMsg()ed IntuiMessage in w->UserPort
2989 trying to modify that. */
2990
2991 Forbid();
2992 if (w->UserPort)
2993 {
2994 struct IntuiMessage *im;
2995
2996 for (im = (struct IntuiMessage *)w->UserPort->mp_MsgList.lh_TailPred;
2997 im->ExecMessage.mn_Node.ln_Pred;
2998 im = (struct IntuiMessage *)im->ExecMessage.mn_Node.ln_Pred)
2999 {
3000 if ((im->Class == IDCMP_MOUSEMOVE) &&
3001 (im->IDCMPWindow == w))
3002 {
3003 im->Qualifier = iihdata->ActQualifier;
3004
3005 if (w->IDCMPFlags & IDCMP_DELTAMOVE)
3006 {
3007 im->MouseX = iihdata->DeltaMouseX;
3008 im->MouseY = iihdata->DeltaMouseY;
3009 }
3010 else
3011 {
3012 im->MouseX = w->MouseX;
3013 im->MouseY = w->MouseY;
3014 }
3015 CurrentTime(&im->Seconds, &im->Micros);
3016
3017 old_msg_found = TRUE;
3018 break;
3019 }
3020 }
3021 } /* if (w->UserPort) */
3022 Permit();
3023
3024 /* no need to send a new message if we modified
3025 an existing one ... */
3026
3027 if (old_msg_found) break;
3028
3029 /* ... otherwise we are in a strange situation. The mouse
3030 queue is full, but we did not find an existing MOUSEMOVE
3031 imsg in w->UserPort. So the app probably has removed
3032 an imsg from the UserPort with GetMsg but we did not get
3033 the ReplyMsg, yet. In this case we do send a new message */
3034
3035 HandleIntuiReplyPort(iihdata, IntuitionBase);
3036
3037 }
3038
3039 /* MouseQueue is not full, so we can send a message. We increase
3040 IntWindow->num_mouseevents which will later be decreased after
3041 the Intuition InputHandler gets the ReplyMessage from the app
3042 and handles it in HandleIntuiReplyPort() */
3043
3044 if (ih_fire_intuimessage(w,
3045 IDCMP_MOUSEMOVE,
3046 IECODE_NOBUTTON,
3047 w,
3048 IntuitionBase))
3049 {
3050 IW(w)->num_mouseevents++;
3051 }
3052
3053 break;
3054
3055 } /* case IECODE_NOBUTTON */
3056
3057 } /* switch (ie->ie_Code) (what button was pressed ?) */
3058 break;
3059
3060 #define KEY_QUALIFIERS (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT | \
3061 IEQUALIFIER_CAPSLOCK | IEQUALIFIER_CONTROL | \
3062 IEQUALIFIER_LALT | IEQUALIFIER_RALT | \
3063 IEQUALIFIER_LCOMMAND | IEQUALIFIER_RCOMMAND | \
3064 IEQUALIFIER_NUMERICPAD | IEQUALIFIER_REPEAT)
3065
3066 case IECLASS_RAWKEY:
3067 /* release events go only to gadgets and windows who
3068 have not set IDCMP_VANILLAKEY */
3069
3070 DEBUG_HANDLER(dprintf("Handler: IECLASS_RAWKEY\n"));
3071 DEBUG_KEY(dprintf("Handler: Qual 0x%lx\n",iihdata->ActQualifier));
3072
3073 iihdata->ActQualifier &= ~KEY_QUALIFIERS;
3074 iihdata->ActQualifier |= (ie->ie_Qualifier & KEY_QUALIFIERS);
3075
3076 DEBUG_KEY(dprintf("Handler: real Qual 0x%lx\n",iihdata->ActQualifier));
3077
3078 /* Keyboard mouse emulation */
3079
3080 {
3081 UWORD code = ie->ie_Code & ~IECODE_UP_PREFIX;
3082
3083 /* Mouse button emulation: LALT + LAMIGA = LBUTTON, RALT + RAMIGA = RBUTTON */
3084
3085 DEBUG_KEY(dprintf("Handler: code 0x%lx\n",code));
3086 if ((code == RAWKEY_LAMIGA) ||
3087 (code == RAWKEY_LALT) ||
3088 (code == RAWKEY_RAMIGA) ||
3089 (code == RAWKEY_RALT))
3090 {
3091 DEBUG_KEY(dprintf("Handler: KeyMouseEmul\n"));
3092 iihdata->PrevKeyMouseState = iihdata->ActKeyMouseState;
3093 iihdata->ActKeyMouseState = 0;
3094 if ((ie->ie_Qualifier & (IEQUALIFIER_LCOMMAND | IEQUALIFIER_LALT)) == (IEQUALIFIER_LCOMMAND | IEQUALIFIER_LALT))
3095 {
3096 iihdata->ActKeyMouseState |= IEQUALIFIER_LEFTBUTTON;
3097 }
3098 if ((ie->ie_Qualifier & (IEQUALIFIER_RCOMMAND | IEQUALIFIER_RALT)) == (IEQUALIFIER_RCOMMAND | IEQUALIFIER_RALT))
3099 {
3100 iihdata->ActKeyMouseState |= IEQUALIFIER_RBUTTON;
3101 }
3102
3103 if ((iihdata->ActKeyMouseState & IEQUALIFIER_LEFTBUTTON) != (iihdata->PrevKeyMouseState & IEQUALIFIER_LEFTBUTTON))
3104 {
3105 orig_ie->ie_Class = IECLASS_RAWMOUSE;
3106 orig_ie->ie_SubClass = 0;
3107 orig_ie->ie_Code = (iihdata->ActKeyMouseState & IEQUALIFIER_LEFTBUTTON) ? IECODE_LBUTTON : IECODE_LBUTTON | IECODE_UP_PREFIX;
3108 orig_ie->ie_X = 0;
3109 orig_ie->ie_Y = 0;
3110 *ie = *orig_ie;
3111
3112 reuse_event = TRUE;
3113 break;
3114 }
3115
3116 if ((iihdata->ActKeyMouseState & IEQUALIFIER_RBUTTON) != (iihdata->PrevKeyMouseState & IEQUALIFIER_RBUTTON))
3117 {
3118 orig_ie->ie_Class = IECLASS_RAWMOUSE;
3119 orig_ie->ie_SubClass = 0;
3120 orig_ie->ie_Code = (iihdata->ActKeyMouseState & IEQUALIFIER_RBUTTON) ? IECODE_RBUTTON : IECODE_RBUTTON | IECODE_UP_PREFIX;
3121 orig_ie->ie_X = 0;
3122 orig_ie->ie_Y = 0;
3123 *ie = *orig_ie;
3124
3125 reuse_event = TRUE;
3126 break;
3127 }
3128
3129 } /* if key is one of LAMIGA/LALT/RAMIGA/RALT */
3130
3131 if ((iihdata->ActQualifier & (IEQUALIFIER_LCOMMAND | IEQUALIFIER_RCOMMAND)) &&
3132 MouseCoordsRelative() &&
3133 ((ie->ie_Code == RAWKEY_UP) ||
3134 (ie->ie_Code == RAWKEY_DOWN) ||
3135 (ie->ie_Code == RAWKEY_LEFT) ||
3136 (ie->ie_Code == RAWKEY_RIGHT)))
3137 {
3138 static BYTE xmap[] = { 0, 0, 1, -1};
3139 static BYTE ymap[] = {-1, 1, 0, 0};
3140 WORD shift;
3141
3142 shift = (iihdata->ActQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)) ? 40 : 1;
3143
3144 /* Mouse Move Emulation */
3145
3146 orig_ie->ie_Class = IECLASS_RAWMOUSE;
3147 orig_ie->ie_SubClass = 0;
3148 orig_ie->ie_Code = IECODE_NOBUTTON;
3149 orig_ie->ie_Qualifier = IEQUALIFIER_RELATIVEMOUSE;
3150 orig_ie->ie_X = xmap[code - RAWKEY_UP] * shift;
3151 orig_ie->ie_Y = ymap[code - RAWKEY_UP] * shift;
3152
3153 *ie = *orig_ie;
3154 reuse_event = TRUE;
3155 break;
3156 }
3157
3158 } /**/
3159
3160 /* End Keyboard mouse emulation */
3161
3162 if (MENUS_ACTIVE)
3163 {
3164 DEBUG_KEY(dprintf("Handler: FireMenuMessage\n"));
3165 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
3166 keep_event = FALSE;
3167 break;
3168 }
3169
3170 /* Hotkeys processing */
3171 #ifdef SKINS
3172 {
3173 ULONG result;
3174
3175 if (!(ie->ie_Code & IECODE_UP_PREFIX))
3176 if ((result = RunHotkeys(ie,IntuitionBase)))
3177 {
3178 if (result == RUNHOTREUSE)
3179 {
3180 reuse_event = TRUE;
3181 }
3182 else
3183 {
3184 keep_event = FALSE;
3185 }
3186 break;
3187 }
3188 w = IntuitionBase->ActiveWindow;
3189 }
3190 #endif
3191
3192 if ( keep_event &&
3193 ((!(ie->ie_Code & IECODE_UP_PREFIX)) ||
3194 gadget ||
3195 (w && ((w->IDCMPFlags & IDCMP_VANILLAKEY) == 0)) ))
3196 {
3197 if (gadget)
3198 {
3199 keep_event = FALSE;
3200
3201 DEBUG_KEY(dprintf("Handler: Gadget 0x%lx active\n",gadget));
3202 DEBUG_KEY(dprintf("Handler: GadgetID 0x%lx UserData 0x%lx\n",
3203 gadget->GadgetID,
3204 gadget->UserData));
3205 DEBUG_KEY(dprintf("Handler: GadgetType 0x%lx Flags 0x%lx Activation 0x%lx\n",
3206 gadget->GadgetType,
3207 gadget->Flags,
3208 gadget->Activation));
3209 DEBUG_KEY(dprintf("Handler: MoreFlags 0x%lx\n",
3210 ((struct ExtGadget*)gadget)->MoreFlags));
3211
3212 switch (gadget->GadgetType & GTYP_GTYPEMASK)
3213 {
3214 case GTYP_STRGADGET:
3215 {
3216 UWORD imsgcode;
3217 ULONG ret = HandleStrInput(gadget, gi, ie, &imsgcode,
3218 IntuitionBase);
3219
3220 DEBUG_KEY(dprintf("Handler: Key GTYP_STRGADGET ret 0x%lx\n",ret));
3221 if (ret & (SGA_END | SGA_NEXTACTIVE | SGA_PREVACTIVE))
3222 {
3223 if (gadget->Activation & GACT_RELVERIFY)
3224 {
3225 DEBUG_KEY(dprintf("Handler: GACT_RELVERIFY\n"));
3226 ih_fire_intuimessage(w,
3227 IDCMP_GADGETUP,
3228 imsgcode,
3229 gadget,
3230 IntuitionBase);
3231
3232 if (req && gadget->Activation & GACT_ENDGADGET)
3233 {
3234 DEBUG_KEY(dprintf("Handler: GACT_ENDGADGET\n"));
3235 EndRequest(req, w);
3236
3237 req = w->FirstRequest;
3238 ret = 0;
3239 }
3240 }
3241
3242 if ((gadget->Flags & GFLG_TABCYCLE) && (ret & SGA_NEXTACTIVE))
3243 {
3244 gadget = FindCycleGadget(w, req, gadget, GMR_NEXTACTIVE);
3245 DEBUG_KEY(dprintf("Handler: TabCycle next gadget 0x%lx\n",gadget));
3246 }
3247 else if ((gadget->Flags & GFLG_TABCYCLE) && (ret & SGA_PREVACTIVE))
3248 {
3249 gadget = FindCycleGadget(w, req, gadget, GMR_PREVACTIVE);
3250 DEBUG_KEY(dprintf("Handler: TabCycle prev gadget 0x%lx\n",gadget));
3251 }
3252 else
3253 {
3254 gadget = NULL;
3255 }
3256
3257 if (gadget)
3258 {
3259 gadget = DoActivateGadget(w, req, gadget, IntuitionBase);
3260 }
3261
3262 } /* if (ret & (SGA_END | SGA_NEXTACTIVE | SGA_PREVACTIVE)) */
3263
3264 break;
3265 }
3266
3267 case GTYP_CUSTOMGADGET:
3268 DEBUG_KEY(dprintf("Handler: GTYP_CUSTOMGADGET\n"));
3269 DEBUG_KEY(dprintf("Handler: send GM_HANDLEINPUT\n"));
3270 gadget = DoGPInput(gi,
3271 gadget,
3272 ie,
3273 GM_HANDLEINPUT,
3274 &reuse_event,
3275 IntuitionBase);
3276 DEBUG_KEY(dprintf("Handler: reuse %ld\n",reuse_event));
3277 break;
3278
3279 } /* switch (gadget type) */
3280
3281 } /* if (a gadget is currently active) */
3282 else if (w && (!req || req->Flags & NOISYREQ))
3283 {
3284 BOOL menushortcut = FALSE;
3285
3286 DEBUG_KEY(dprintf("Handler: No Gadget active\n"));
3287 DEBUG_KEY(dprintf("Handler: Qualifier 0x%lx WinFlags 0x%lx IDCMP 0x%lx\n",ie->ie_Qualifier,w->Flags,w->IDCMPFlags));
3288
3289 if ((ie->ie_Qualifier & IEQUALIFIER_RCOMMAND) &&
3290 (!(w->Flags & WFLG_RMBTRAP)) &&
3291 (w->IDCMPFlags & IDCMP_MENUPICK))
3292 {
3293 struct Menu *strip = 0;
3294
3295 DEBUG_KEY(dprintf("Handler: MenuKey\n"));
3296 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->MenuLock);
3297
3298 strip = w->MenuStrip;
3299
3300 if (((struct IntWindow *)w)->menulendwindow)
3301 {
3302 strip = ((struct IntWindow *)w)->menulendwindow->MenuStrip;
3303 }
3304
3305 DEBUG_KEY(dprintf("Handler: MenuStrip 0x%lx\n",strip));
3306 if (strip)
3307 {
3308 UBYTE key;
3309
3310 if (MapRawKey(ie, &key, 1, NULL) == 1)
3311 {
3312 UWORD menucode;
3313
3314 menucode = FindMenuShortCut(strip, key, TRUE, IntuitionBase);
3315
3316 DEBUG_KEY(dprintf("Handler: menucode 0x%lx\n",menucode));
3317
3318 if (menucode != MENUNULL)
3319 {
3320 DEBUG_KEY(dprintf("Handler: build menuevent\n"));
3321 ie->ie_Class = IECLASS_MENU;
3322 ie->ie_SubClass = IESUBCLASS_MENUSTOP;
3323 ie->ie_EventAddress = w;
3324 ie->ie_Code = menucode;
3325
3326 reuse_event = TRUE;
3327 menushortcut = TRUE;
3328
3329 MENUS_ACTIVE = TRUE;
3330 iihdata->MenuWindow = w;
3331 }
3332 }
3333 else
3334 {
3335 DEBUG_KEY(dprintf("Handler: MapRawKey failed\n"));
3336 }
3337 }
3338 if (!menushortcut) /* !! */
3339 ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->MenuLock);
3340
3341 } /* if could be a menu short cut */
3342 else
3343 if ((ie->ie_Qualifier & IEQUALIFIER_RCOMMAND) &&
3344 (!(w->IDCMPFlags & IDCMP_MENUPICK)))
3345 {
3346 struct Menu *strip = 0;
3347 struct Window *window = w;
3348
3349 /* not sure here about RMBTRAP */
3350 DEBUG_KEY(dprintf("Handler: no idcmp, create a MENULIST idcmp\n"));
3351
3352 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->MenuLock);
3353
3354 strip = w->MenuStrip;
3355
3356 if (((struct IntWindow *)w)->menulendwindow)
3357 {
3358 strip = ((struct IntWindow *)w)->menulendwindow->MenuStrip;
3359 window = ((struct IntWindow *)w)->menulendwindow;
3360 }
3361
3362 DEBUG_KEY(dprintf("Handler: MenuStrip 0x%lx\n",strip));
3363 if (strip)
3364 {
3365 UBYTE key;
3366
3367 if (MapRawKey(ie, &key, 1, NULL) == 1)
3368 {
3369 UWORD menucode;
3370
3371 menucode = FindMenuShortCut(strip, key, TRUE, IntuitionBase);
3372
3373 DEBUG_KEY(dprintf("Handler: menucode 0x%lx\n",menucode));
3374
3375 if (menucode != MENUNULL)
3376 {
3377 DEBUG_KEY(dprintf("Handler: build menuevent\n"));
3378 ih_fire_intuimessage(window,
3379 IDCMP_MENUPICK,
3380 menucode,
3381 ie->ie_position.ie_addr, /* ie_dead.ie_prev[1|2]Down[Code|Qual]. 64 bit machines!? */
3382 IntuitionBase);
3383 keep_event = FALSE;
3384 menushortcut = TRUE;
3385 }
3386 }
3387 else
3388 {
3389 DEBUG_KEY(dprintf("Handler: MapRawKey failed\n"));
3390 }
3391 }
3392 ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->MenuLock);
3393 } /* if could be a menu short but current window has no idcmp cut */
3394
3395 if (menushortcut)
3396 {
3397 DEBUG_KEY(dprintf("Handler: menu shortcut..break\n"));
3398 break;
3399 }
3400
3401 /* This is a regular RAWKEY event (no gadget taking care
3402 of it...). */
3403
3404 if (iihdata->ActQualifier & IEQUALIFIER_REPEAT)
3405 {
3406 /* don't send repeat key events if repeatqueue is full */
3407 if (IW(w)->num_repeatevents >= IW(w)->repeatqueue)
3408 {
3409 DEBUG_KEY(dprintf("Handler: RepeatEvents full..don't send more\n"));
3410 break;
3411 }
3412 }
3413
3414 if (w->IDCMPFlags & IDCMP_VANILLAKEY)
3415 {
3416 UBYTE keyBuffer;
3417
3418 DEBUG_KEY(dprintf("Handler: VANILLAKEY\n"));
3419 // DEBUG_KEY(dprintf("Handler: MapRawKey ie 0x%lx KeyMapBase 0x%lx IntutionBase 0x%lx\n",ie,KeymapBase,IntuitionBase));
3420
3421 if (MapRawKey(ie, &keyBuffer, 1, NULL) == 1)
3422 {
3423 DEBUG_KEY(dprintf("Handler: send VANILLAKEY msg\n"));
3424 ih_fire_intuimessage(w,
3425 IDCMP_VANILLAKEY,
3426 keyBuffer,
3427 ie->ie_position.ie_addr, /* ie_dead.ie_prev[1|2]Down[Code|Qual]. 64 bit machines!? */
3428 IntuitionBase);
3429 DEBUG_KEY(dprintf("Handler: done\n"));
3430 break;
3431 }
3432
3433 /* If the event mapped to more than one byte, it is not
3434 a legal VANILLAKEY, so we send it as the original
3435 RAWKEY event. */
3436
3437 }
3438
3439 if (w->IDCMPFlags & IDCMP_RAWKEY)
3440 {
3441 DEBUG_KEY(dprintf("Handler: send IDCMP_RAWKEY Qual 0x%lx Code 0x%lx addr 0x%lx Event\n",
3442 ie->ie_Qualifier,ie->ie_Code,ie->ie_position.ie_addr));
3443 ih_fire_intuimessage(w,
3444 IDCMP_RAWKEY,
3445 ie->ie_Code,
3446 ie->ie_position.ie_addr, /* ie_dead.ie_prev[1|2]Down[Code|Qual]. 64 bit machine!? */
3447 IntuitionBase);
3448 keep_event = FALSE;
3449 }
3450
3451 DEBUG_KEY(dprintf("Handler: done\n"));
3452 } /* regular RAWKEY */
3453 }
3454
3455 break; /* case IECLASS_RAWKEY */
3456
3457 case IECLASS_TIMER:
3458 if (iihdata->MouseBoundsKillTimer)
3459 {
3460 iihdata->MouseBoundsKillTimer--;
3461 if (iihdata->MouseBoundsKillTimer == 0)
3462 {
3463 iihdata->MouseBoundsActiveFlag = FALSE;
3464 }
3465 }
3466
3467 if (GetPrivIBase(IntuitionBase)->PointerDelay)
3468 {
3469 ULONG lock = LockIBase(0);
3470
3471 if (--GetPrivIBase(IntuitionBase)->PointerDelay == 0)
3472 {
3473 struct SharedPointer *shared_pointer;
3474 struct Window *window = IntuitionBase->ActiveWindow;
3475 struct IntScreen *scr;
3476 Object *pointer = ((struct IntWindow *)window)->pointer;
3477
3478 DEBUG_POINTER(dprintf("InputHandler: PointerDelay\n"));
3479 DEBUG_POINTER(dprintf("InputHandler: Pointer 0x%lx\n",
3480 pointer));
3481
3482 if (window)
3483 {
3484 DEBUG_POINTER(dprintf("InputHandler: Window 0x%lx\n",
3485 window));
3486 scr = GetPrivScreen(window->WScreen);
3487 if (scr)
3488 {
3489 DEBUG_POINTER(dprintf("InputHandler: Screen 0x%lx\n",
3490 scr));
3491 if (pointer == NULL)
3492 {
3493 pointer = GetPrivIBase(IntuitionBase)->DefaultPointer;
3494 }
3495
3496 if (((struct IntWindow *)window)->busy)
3497 {
3498 pointer = GetPrivIBase(IntuitionBase)->BusyPointer;
3499 }
3500
3501 GetAttr(POINTERA_SharedPointer, pointer, (ULONG *) &shared_pointer);
3502
3503 DEBUG_POINTER(dprintf("InputHandler: scr 0x%lx pointer 0x%lx shared_pointer 0x%lx\n",
3504 scr, pointer, shared_pointer));
3505 DEBUG_POINTER(dprintf("InputHandler: sprite 0x%lx\n",
3506 shared_pointer->sprite));
3507
3508 if (ChangeExtSpriteA(&scr->Screen.ViewPort,
3509 scr->Pointer->sprite, shared_pointer->sprite, NULL))
3510 {
3511 ObtainSharedPointer(shared_pointer, IntuitionBase);
3512 ReleaseSharedPointer(scr->Pointer, IntuitionBase);
3513 scr->Pointer = shared_pointer;
3514 if (window)
3515 {
3516 window->XOffset = shared_pointer->xoffset;
3517 window->YOffset = shared_pointer->yoffset;
3518 }
3519 }
3520 else
3521 {
3522 DEBUG_POINTER(dprintf("InputHandler: can't set pointer.\n"));
3523 }
3524 }
3525 else
3526 {
3527 DEBUG_POINTER(dprintf("InputHandler: no screen.\n"));
3528 }
3529 }
3530 else
3531 {
3532 DEBUG_POINTER(dprintf("InputHandler: no window.\n"));
3533 }
3534 }
3535
3536 UnlockIBase(lock);
3537 }
3538
3539 if (GetPrivIBase(IntuitionBase)->MenuVerifyScreen)
3540 {
3541 struct IntScreen *scr = GetPrivIBase(IntuitionBase)->MenuVerifyScreen;
3542
3543 if ((--scr->MenuVerifyTimeOut) <= 0)
3544 {
3545 struct InputEvent ie;
3546
3547 /* currently we ONLY need the menu open time ! */
3548 ie.ie_TimeStamp.tv_secs = IntuitionBase->Seconds;
3549 ie.ie_TimeStamp.tv_micro = IntuitionBase->Micros;
3550
3551 if (FireMenuMessage(MMCODE_START, scr->MenuVerifyActiveWindow, &ie, IntuitionBase))
3552 {
3553 /* This lock will be released only when the user is
3554 done with menus = when IECLASS_MENU + IESUBCLASS_MENUSTOP
3555 event arrives (generated by MenuHandler task) */
3556
3557 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->MenuLock);
3558 iihdata->MenuWindow = scr->MenuVerifyActiveWindow;
3559 MENUS_ACTIVE = TRUE;
3560 }
3561
3562 scr->MenuVerifyActiveWindow = NULL;
3563 scr->MenuVerifyTimeOut = 0;
3564 scr->MenuVerifyMsgCount = 0;
3565 scr->MenuVerifySeconds = 0;
3566 scr->MenuVerifyMicros = 0;
3567 GetPrivIBase(IntuitionBase)->MenuVerifyScreen = NULL;
3568 }
3569 }
3570 else if (MENUS_ACTIVE)
3571 {
3572 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
3573 keep_event = FALSE;
3574 break;
3575 }
3576
3577 #ifdef SKINS
3578 if (IntuitionBase->FirstScreen->MouseY <= IntuitionBase->FirstScreen->BarHeight && GetPrivScreen(IntuitionBase->FirstScreen)->SpecialFlags & SF_AppearingBar && !iihdata->TitlebarOnTop && iihdata->TitlebarAppearTime)
3579 {
3580 UQUAD currenttime = (((UQUAD)ie->ie_TimeStamp.tv_secs) * 50) + (UQUAD)(ie->ie_TimeStamp.tv_micro / 20000);
3581 if (currenttime >= iihdata->TitlebarAppearTime + 10)
3582 {
3583 iihdata->TitlebarOnTop = TRUE;
3584 iihdata->TitlebarAppearTime = 0;
3585
3586 LOCK_REFRESH(IntuitionBase->FirstScreen);
3587
3588 MoveLayer(0,IntuitionBase->FirstScreen->BarLayer,0,IntuitionBase->FirstScreen->BarHeight + 1);
3589 UpfrontLayer(0,IntuitionBase->FirstScreen->BarLayer);
3590 CheckLayers(IntuitionBase->FirstScreen, IntuitionBase);
3591
3592 UNLOCK_REFRESH(IntuitionBase->FirstScreen);
3593 }
3594 }
3595 #endif
3596
3597 {
3598 UQUAD currenttime = (((UQUAD)ie->ie_TimeStamp.tv_secs) * 50) + (UQUAD)(ie->ie_TimeStamp.tv_micro / 20000);
3599 #define SECONDS(x) (x*50)
3600 if (iihdata->HelpGadgetFindTime && (currenttime >= iihdata->HelpGadgetFindTime + SECONDS(1)))
3601 {
3602 struct Gadget *lhg = iihdata->LastHelpGadget;
3603 fire_intuimessage(iihdata->LastHelpWindow,
3604 IDCMP_GADGETHELP,
3605 lhg ? lhg->GadgetID : NULL, /* Don't know what it should be */
3606 lhg,
3607 IntuitionBase);
3608 iihdata->HelpGadgetFindTime = 0;
3609 }
3610 }
3611
3612 if (gadget)
3613 {
3614 if (IS_BOOPSI_GADGET(gadget))
3615 {
3616 gadget = DoGPInput(gi, gadget, ie, GM_HANDLEINPUT, &reuse_event, IntuitionBase);
3617 }
3618
3619 } /* if (gadget) */
3620
3621 #if USE_NEWDISPLAYBEEP
3622
3623 if (GetPrivIBase(IntuitionBase)->BeepingScreens)
3624 {
3625 ULONG lock;
3626 struct Screen *scr;
3627
3628 lock = LockIBase(0);
3629
3630 for (scr = IntuitionBase->FirstScreen;
3631 scr && GetPrivIBase(IntuitionBase)->BeepingScreens;
3632 scr = scr->NextScreen)
3633 {
3634 if ((scr->Flags & BEEPING) &&
3635 !GetPrivScreen(scr)->BeepingCounter--)
3636 {
3637 GetPrivIBase(IntuitionBase)->BeepingScreens--;
3638 scr->Flags &= (UWORD) ~BEEPING;
3639
3640 /* if (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) <= 8)
3641 // visual beep on CLUT-screen
3642 {
3643 // SetRGB4 (&screen->ViewPort, 0, scr->SaveColor0 & 0x000F, (scr->SaveColor0 & 0x00F0) >> 4, (scr->SaveColor0 & 0x0F00) >> 8);
3644 SetRGB32 (&scr->ViewPort, 0,
3645 GetPrivScreen(scr)->DisplayBeepColor0[0],
3646 GetPrivScreen(scr)->DisplayBeepColor0[1],
3647 GetPrivScreen(scr)->DisplayBeepColor0[2]
3648 );
3649 }
3650 else
3651 // visual beep on hi- and truecolor screens
3652 {
3653 RenderScreenBar(scr, FALSE, IntuitionBase);
3654 }*/
3655
3656 RenderScreenBar(scr, FALSE, IntuitionBase);
3657 }
3658 }
3659
3660 UnlockIBase(lock);
3661 }
3662 #endif /* USE_NEWDISPLAYBEEP */
3663
3664
3665 /* stegerg: on the Amiga, Intuition's InputHandler seems to always
3666 swallow IECLASS_TIMER InputEvents. They never reach InputHandlers with
3667 lower priorities. So we mark the event as eaten by Intuition */
3668 keep_event = FALSE;
3669
3670 if (!w) break;
3671
3672 /* Send INTUITICK msg only if app already replied the last INTUITICK msg */
3673 if (w->Flags & WFLG_WINDOWTICKED) break;
3674
3675 if (w->IDCMPFlags & IDCMP_INTUITICKS)
3676 {
3677 /* Set the WINDOWTICKED flag, it will be cleared again when the app
3678 replies back the msg and the InputHandler handles the replymsg
3679 in HandleIntuiReplyPort() */
3680
3681 ih_fire_intuimessage(w,
3682 IDCMP_INTUITICKS,
3683 0,
3684 w,
3685 IntuitionBase);
3686 }
3687 break; /* case IECLASS_TIMER */
3688
3689 case IECLASS_MENU:
3690 if (MENUS_ACTIVE && (ie->ie_SubClass == IESUBCLASS_MENUSTOP))
3691 {
3692 struct Window *eventwin = (struct Window *)ie->ie_EventAddress;
3693
3694 iihdata->MenuWindow = NULL;
3695 MENUS_ACTIVE = FALSE;
3696
3697 /* semaphore was locked when menu action started, see
3698 above where MMCODE_START MenuMessage is sent.
3699
3700 It could have also have been looked if the user
3701 activated one of the menu key shortcuts, see
3702 "case IECLASS_RAWKEY" */
3703
3704 ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->MenuLock);
3705
3706 keep_event = FALSE;
3707
3708 if (((struct IntWindow *)eventwin)->menulendwindow)
3709 {
3710 eventwin = ((struct IntWindow *)eventwin)->menulendwindow;
3711 }
3712
3713 ih_fire_intuimessage((struct Window *)eventwin,
3714 IDCMP_MENUPICK,
3715 ie->ie_Code,
3716 (struct Window *)ie->ie_EventAddress,
3717 IntuitionBase);
3718
3719 }
3720 break;
3721
3722 case IECLASS_DISKINSERTED:
3723 case IECLASS_DISKREMOVED:
3724 case IECLASS_NEWPREFS:
3725 {
3726 struct Screen *scr;
3727 ULONG idcmp;
3728 LONG lock;
3729
3730 switch (ie->ie_Class)
3731 {
3732 case IECLASS_DISKINSERTED:
3733 idcmp = IDCMP_DISKINSERTED;
3734 break;
3735
3736 case IECLASS_DISKREMOVED:
3737 idcmp = IDCMP_DISKREMOVED;
3738 break;
3739
3740 default:
3741 idcmp = IDCMP_NEWPREFS;
3742 /*
3743 * Here we need to update the mouse prefs and
3744 * maybe other stuff which comes from the global prefs file.
3745 */
3746 break;
3747 }
3748
3749 lock = LockIBase(0);
3750
3751 for (scr = IntuitionBase->FirstScreen; scr; scr = scr->NextScreen)
3752 {
3753 struct Window *win;
3754
3755 for (win = scr->FirstWindow; win; win = win->NextWindow)
3756 {
3757 /* stegerg:
3758 CHECKME, really use fire_intuimessage() here,
3759 instead of ih_fireintuimessage? Same for
3760 IDCMP_GADGETHELP above, BTW. */
3761
3762 fire_intuimessage(win,
3763 idcmp,
3764 0,
3765 NULL,
3766 IntuitionBase);
3767 }
3768 }
3769
3770 UnlockIBase(lock);
3771 }
3772 break;
3773
3774 #ifdef __MORPHOS__
3775 #define NEWMOUSEIDCMP !SysBase->MaxLocMem
3776 #else
3777 #define NEWMOUSEIDCMP FALSE
3778 #endif
3779 case IECLASS_NEWMOUSE:
3780 /*
3781 * The following is only needed on hardware not running
3782 * the NewMouse driver.
3783 */
3784 if (w->IDCMPFlags & IDCMP_RAWKEY && NEWMOUSEIDCMP)
3785 {
3786 ih_fire_intuimessage(w,
3787 IDCMP_RAWKEY,
3788 ie->ie_Code,
3789 ie->ie_position.ie_addr, /* ie_dead.ie_prev[1|2]Down[Code|Qual]. 64 bit machine!? */
3790 IntuitionBase);
3791 keep_event = FALSE;
3792 }
3793 break;
3794
3795 case IECLASS_NULL:
3796 break;
3797
3798 #ifdef __MORPHOS__
3799 case IECLASS_NEWTIMER:
3800 if (MENUS_ACTIVE)
3801 {
3802 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
3803 keep_event = FALSE;
3804 break;
3805 }
3806
3807 if (gadget)
3808 {
3809 if (gadget == iihdata->MasterSizeGadget)
3810 {
3811 gadget = DoGPInput(gi, gadget, ie, GM_HANDLEINPUT, &reuse_event, IntuitionBase);
3812 }
3813
3814 } /* if (gadget) */
3815 break;
3816 #endif /* __MORPHOS__ */
3817
3818 default:
3819 if (MENUS_ACTIVE)
3820 {
3821 FireMenuMessage(MMCODE_EVENT, 0, ie, IntuitionBase);
3822 keep_event = FALSE;
3823 break;
3824 }
3825
3826 bug
3827 (
3828 "[Intui] InputHandler: Unknown IEClass: addr = %x class = %d (origclass = %d)\n",
3829 orig_ie, ie->ie_Class,orig_ie->ie_Class
3830 );
3831
3832 break;
3833 } /* switch (ie->ie_Class) */
3834
3835 if (reuse_event)
3836 {
3837 }
3838 else if (keep_event && !ie_used)
3839 {
3840 *iihdata->EndInputEventChain = orig_ie;
3841 iihdata->EndInputEventChain = &orig_ie->ie_NextEvent;
3842 ie_used = TRUE;
3843 }
3844 else if (!ie_used)
3845 {
3846 orig_ie->ie_NextEvent = iihdata->FreeInputEvents;
3847 iihdata->FreeInputEvents = orig_ie;
3848 }
3849
3850 } /* for (each event in the chain) */
3851
3852 iihdata->ActiveGadget = gadget;
3853
3854 D(bug("Outside pollingloop\n"));
3855
3856 #if SINGLE_SETPOINTERPOS_PER_EVENTLOOP
3857 if (call_setpointerpos)
3858 {
3859 SetPointerPos(pointerposx, pointerposy);
3860 }
3861 #endif
3862
3863 /* Terminate the event chain. */
3864 *iihdata->EndInputEventChain = NULL;
3865
3866 /* Transfer the list of allocated events in the list of events that should
3867 * be freed the next time the handler is entered.
3868 */
3869 iihdata->AllocatedInputEventList = iihdata->NewAllocatedInputEventList;
3870 NEWLIST((struct List*)&iihdata->NewAllocatedInputEventList);
3871
3872 /* Reset the event chain here, not at the beginning of the handler, for
3873 * events that might be allocated in other handers.
3874 */
3875 iihdata->EndInputEventChain = &iihdata->ReturnInputEvent;
3876 iihdata->FreeInputEvents = NULL;
3877
3878 ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->InputHandlerLock);
3879
3880 // DEBUG_HANDLER(dprintf("Handler: ->IBase 0x%lx KeyMapBase 0x%lx\n",IntuitionBase,KeymapBase));
3881
3882 return iihdata->ReturnInputEvent;
3883
3884 AROS_USERFUNC_EXIT
3885 }
3886
3887 /****************************************************************************************/
3888
A totally sweet operating system