?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
muimaster.library: propagate IDCMP_CHANGEWINDOW to area event handlers
[AROS.git] / workbench / libs / muimaster / classes / window.c
blob409df4507aa16b7192727b90c38864debc06371f
1 /*
2 Copyright 1999, David Le Corfec.
3 Copyright 2002-2014, The AROS Development Team.
4 All rights reserved.
5
6 $Id$
7 */
8 #include <exec/types.h>
9 #include <exec/memory.h>
10
11 #include <string.h>
12
13 #include <intuition/imageclass.h>
14 #include <intuition/icclass.h>
15 #include <intuition/gadgetclass.h>
16 #ifdef __AROS__
17 #include <intuition/extensions.h>
18 #endif
19 #include <clib/alib_protos.h>
20 #include <graphics/gfxmacros.h>
21 #include <proto/exec.h>
22 #include <proto/intuition.h>
23 #include <proto/utility.h>
24 #include <proto/graphics.h>
25 #include <proto/commodities.h>
26 #include <proto/layers.h>
27 #include <proto/gadtools.h>
28 #include <proto/muimaster.h>
29 #include <proto/workbench.h>
30
31 #define MUI_OBSOLETE /* for the obsolete menu stuff */
32
33 #include "mui.h"
34 #include "support.h"
35 #include "classes/window.h"
36 #include "classes/area.h"
37 #include "imspec.h"
38 #include "datatypescache.h"
39 #include "prefs.h"
40 #include "dragndrop.h"
41
42 #include "muimaster_intern.h"
43
44 //#define MYDEBUG 1
45 #include "debug.h"
46
47 extern struct Library *MUIMasterBase;
48
49 static const int __version = 1;
50 static const int __revision = 1;
51
52 #define IM(x) ((struct Image*)(x))
53 #define G(x) ((struct Gadget*)(x))
54 #define GADGETID(x) (((struct Gadget*)(x))->GadgetID)
55
56 /* this is for the cycle list */
57 struct ObjNode
58 {
59 struct MinNode node;
60 Object *obj;
61 };
62
63 /* For the gadget ids */
64 struct IDNode
65 {
66 struct MinNode node;
67 UWORD id;
68 };
69
70 struct MUI_ImageSpec_intern;
71
72 struct MUI_WindowData
73 {
74 struct MUI_RenderInfo wd_RenderInfo;
75 struct MUI_MinMax wd_MinMax;
76 struct IBox wd_AltDim; /* zoomed dimensions */
77 BOOL wd_ZoomGadget; /* enable/disable zoomgadget (altdim stuff) */
78 APTR wd_MemoryPool; /* for nodes and stuff to deallocate at
79 * OM_DISPOSE */
80 struct MinList wd_CycleChain; /* objects activated with tab */
81 struct MinList wd_EHList; /* event handlers */
82 struct MinList wd_CCList; /* control chars */
83 struct MinList wd_IDList; /* gadget ids */
84 ULONG wd_Events; /* events received */
85 ULONG wd_CrtFlags; /* window creation flags, see below */
86 Object *wd_ActiveObject; /* the active object */
87 Object *wd_OldActive; /* active object before window was closed */
88 APTR wd_DefaultObject;
89 ULONG wd_ID;
90 STRPTR wd_Title;
91 STRPTR wd_ScreenTitle;
92 LONG wd_Height; /* Current dimensions */
93 LONG wd_Width;
94 LONG wd_X;
95 LONG wd_Y;
96 LONG wd_ReqHeight; /* given by programmer */
97 LONG wd_ReqWidth;
98 APTR wd_RootObject; /* unique child */
99 ULONG wd_Flags; /* various status flags */
100 struct MUI_ImageSpec_intern *wd_Background;
101 ULONG wd_DisabledKeys;
102 BOOL wd_NoMenus; /* MUIA_Window_NoMenus */
103
104 Object *wd_DragObject; /* the object which is being dragged */
105 struct Window *wd_DropWindow; /* the destination window, for faster
106 * access */
107 Object *wd_DropObject; /* the destination object */
108 struct DragNDrop *wd_dnd;
109 struct MUI_DragImage *wd_DragImage;
110 struct AppWindow *wd_AppWindow;
111
112 Object *wd_Menustrip; /* The menustrip object which is actually
113 * used (either apps or windows or NULL) */
114 Object *wd_ChildMenustrip; /* If window has an own Menustrip */
115 struct Menu *wd_Menu; /* the intuition menustrip */
116
117 Object *wd_VertProp;
118 Object *wd_UpButton;
119 Object *wd_DownButton;
120
121 Object *wd_HorizProp;
122 Object *wd_LeftButton;
123 Object *wd_RightButton;
124 Object *wd_RefWindow;
125
126 Object *wd_MUIGadget;
127
128 Object *wd_HelpObject;
129 APTR wd_HelpBubble;
130 WORD wd_HelpTicker;
131
132 struct Screen *wd_UserScreen;
133 STRPTR wd_UserPublicScreen;
134 LONG wd_XStore; /* store MUIV_Window_LeftEdge_Centered Tags
135 * etc. because wd_X is overwritten by a
136 * value in CalcDimension. Popup windows work
137 * OK on AmiGG when main window is moved */
138 LONG wd_YStore;
139
140 WORD wd_SleepCount; /* MUIA_Window_Sleep nests */
141 };
142
143 #ifndef WFLG_SIZEGADGET
144
145 #define WFLG_CLOSEGADGET (1<<0) /* has close gadget */
146 #define WFLG_SIZEGADGET (1<<1) /* has size gadget */
147 #define WFLG_BACKDROP (1<<2) /* is backdrop window */
148 #define WFLG_BORDERLESS (1<<3) /* has no borders */
149 #define WFLG_DEPTHGADGET (1<<4) /* has depth gadget */
150 #define WFLG_DRAGBAR (1<<5) /* is draggable */
151 #define WFLG_SIZEBRIGHT (1<<6) /* size gadget is in right border */
152
153 #endif
154
155 /* wd_Flags */
156 #define MUIWF_OPENED (1<<0) /* window currently opened */
157 #define MUIWF_HIDDEN (1<<1) /* window currently iconified */
158 #define MUIWF_ACTIVE (1<<2) /* window currently active */
159 #define MUIWF_RESIZING (1<<4) /* window currently resizing */
160 #define MUIWF_DONTACTIVATE (1<<7) /* do not activate the window when
161 * opening */
162 #define MUIWF_USERIGHTSCROLLER (1<<8) /* should have right scroller */
163 #define MUIWF_USEBOTTOMSCROLLER (1<<9) /* should have bottom scroller */
164 #define MUIWF_ERASEAREA (1<<10) /* Erase area after a window resize */
165 #define MUIWF_ISAPPWINDOW (1<<11) /* Is an AppWindow */
166 #define MUIWF_ISSUBWINDOW (1<<12) /* Don't get automatically disposed
167 * with app */
168 #define MUIWF_BUBBLEMODE (1<<13) /* Quick bubble mode. Bubbles appear
169 * quick when moving */
170 #define MUIWF_OPENONUNHIDE (1<<14) /* Open the window when unhiding */
171 #define MUIWF_SCREENLOCKED (1<<15) /* A pub screen was locked in
172 * SetupRenderInfo. Unlock it in
173 * CleanupRenderInfo! */
174 #define MUIWF_OBJECTGOACTIVESENT (1<<16) /* A MUIM_GoActive msg was sent to
175 * window's active object */
176 #define MUIWF_TOOLBOX (1<<17) /* Window should be opened as
177 * ToolBox */
178
179 #define BUBBLEHELP_TICKER_FIRST 10
180 #define BUBBLEHELP_TICKER_LATER 3
181
182 struct __dummyXFC3__
183 {
184 struct MUI_NotifyData mnd;
185 struct MUI_WindowData mwd;
186 };
187
188 #define muiWindowData(obj) (&(((struct __dummyXFC3__ *)(obj))->mwd))
189
190 static void ActivateObject(struct MUI_WindowData *data);
191 static void HandleInputEvent(Object *win, struct MUI_WindowData *data,
192 struct IntuiMessage *event);
193
194 static ULONG DoHalfshineGun(ULONG a, ULONG b)
195 {
196 ULONG val = ((((a) >> 24) + 3 * ((b) >> 24)) / 4);
197 val = val + (val << 8) + (val << 16) + (val << 24);
198 return val;
199 }
200
201 static ULONG DoHalfshadowGun(ULONG a, ULONG b)
202 {
203 ULONG val = ((((a) >> 24) + 5 * ((b) >> 24)) / 6);
204 val = val + (val << 8) + (val << 16) + (val << 24);
205 return val;
206 }
207
208 static Object *CreateSysimage(struct DrawInfo *dri, ULONG which)
209 {
210 return NewObject(NULL, "sysiclass",
211 SYSIA_DrawInfo, (IPTR) dri, SYSIA_Which, which, TAG_DONE);
212 }
213
214 static void EnqueueByPriAndAddress(struct List *list, struct Node *node)
215 {
216 struct Node *scannode;
217
218 /* Sort by priority and by node address, so that a
219 "remove - modify - enqueue" sequence will re-add
220 the node at the same place in the list it was
221 initially */
222 ForeachNode(list, scannode)
223 {
224 if (((struct Node *)node)->ln_Pri > scannode->ln_Pri)
225 break;
226 if (((struct Node *)node)->ln_Pri == scannode->ln_Pri)
227 {
228 if ((IPTR) node > (IPTR) scannode)
229 break;
230 }
231 }
232
233 Insert(list, (struct Node *)node, scannode->ln_Pred);
234 }
235
236 static BOOL InitCustomFrames(Object *obj, struct MUI_RenderInfo *mri)
237 {
238 int i;
239
240 for (i = 0; i < 16; i++)
241 {
242 mri->mri_FrameImage[i] = NULL;
243 }
244
245 mri->mri_FrameImage[0] =
246 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
247 customframe_config_1, mri->mri_Screen);
248 mri->mri_FrameImage[1] =
249 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
250 customframe_config_2, mri->mri_Screen);
251 mri->mri_FrameImage[2] =
252 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
253 customframe_config_3, mri->mri_Screen);
254 mri->mri_FrameImage[3] =
255 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
256 customframe_config_4, mri->mri_Screen);
257 mri->mri_FrameImage[4] =
258 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
259 customframe_config_5, mri->mri_Screen);
260 mri->mri_FrameImage[5] =
261 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
262 customframe_config_6, mri->mri_Screen);
263 mri->mri_FrameImage[6] =
264 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
265 customframe_config_7, mri->mri_Screen);
266 mri->mri_FrameImage[7] =
267 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
268 customframe_config_8, mri->mri_Screen);
269 mri->mri_FrameImage[8] =
270 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
271 customframe_config_9, mri->mri_Screen);
272 mri->mri_FrameImage[9] =
273 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
274 customframe_config_10, mri->mri_Screen);
275 mri->mri_FrameImage[10] =
276 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
277 customframe_config_11, mri->mri_Screen);
278 mri->mri_FrameImage[11] =
279 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
280 customframe_config_12, mri->mri_Screen);
281 mri->mri_FrameImage[12] =
282 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
283 customframe_config_13, mri->mri_Screen);
284 mri->mri_FrameImage[13] =
285 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
286 customframe_config_14, mri->mri_Screen);
287 mri->mri_FrameImage[14] =
288 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
289 customframe_config_15, mri->mri_Screen);
290 mri->mri_FrameImage[15] =
291 load_custom_frame(muiGlobalInfo(obj)->mgi_Prefs->
292 customframe_config_16, mri->mri_Screen);
293
294 return TRUE;
295 }
296
297 static void DisposeCustomFrames(struct MUI_RenderInfo *mri)
298 {
299 int i;
300
301 for (i = 0; i < 16; i++)
302 {
303 dispose_custom_frame(mri->mri_FrameImage[i]);
304
305 mri->mri_FrameImage[i] = NULL;
306 }
307 }
308
309 static BOOL SetupRenderInfo(Object *obj, struct MUI_WindowData *data,
310 struct MUI_RenderInfo *mri)
311 {
312 ULONG rgbtable[3 * 3];
313 Object *temp_obj;
314 IPTR val;
315 int i;
316
317 /* TODO: Move this whole screen locking/opening stuff into the
318 * application class by creating methods for this purpose */
319
320 /* If no user screen has been specified try to open the application
321 * specific screen */
322 if (!data->wd_UserScreen)
323 {
324 ULONG screenmodeid = muiGlobalInfo(obj)->mgi_Prefs->screenmodeid;
325
326 if (screenmodeid != ~0)
327 {
328 if (!muiGlobalInfo(obj)->mgi_CustomScreen)
329 {
330 muiGlobalInfo(obj)->mgi_CustomScreen = OpenScreenTags
331 (NULL,
332 SA_DisplayID, screenmodeid,
333 SA_SharePens, TRUE,
334 SA_FullPalette, TRUE, SA_LikeWorkbench, TRUE, TAG_DONE);
335 /* It's fine if this fails as there is a fallback case below */
336 }
337
338 data->wd_UserScreen = muiGlobalInfo(obj)->mgi_CustomScreen;
339 }
340 }
341 if (data->wd_UserScreen)
342 {
343 mri->mri_Screen = data->wd_UserScreen;
344 }
345 else
346 {
347 if (data->wd_UserPublicScreen)
348 {
349 mri->mri_Screen = LockPubScreen(data->wd_UserPublicScreen);
350 }
351 else if (muiGlobalInfo(obj)->mgi_Prefs->publicscreen_name
352 && muiGlobalInfo(obj)->mgi_Prefs->publicscreen_name[0])
353 {
354 mri->mri_Screen =
355 LockPubScreen(muiGlobalInfo(obj)->mgi_Prefs->
356 publicscreen_name);
357 // FIXME: open the public screen if necessary
358 }
359
360 if (mri->mri_Screen == NULL)
361 {
362 mri->mri_Screen = LockPubScreen(NULL);
363 if (mri->mri_Screen == NULL)
364 {
365 return FALSE;
366 }
367 }
368
369 // FIXME: is this the right place for this action?
370 if (mri->mri_Screen
371 && muiGlobalInfo(obj)->mgi_Prefs->publicscreen_pop_to_front)
372 {
373 ScreenToFront(mri->mri_Screen);
374 }
375
376 data->wd_Flags |= MUIWF_SCREENLOCKED;
377 }
378
379 if (!(mri->mri_DrawInfo = GetScreenDrawInfo(mri->mri_Screen)))
380 {
381 if (data->wd_Flags & MUIWF_SCREENLOCKED)
382 {
383 UnlockPubScreen(NULL, mri->mri_Screen);
384 data->wd_Flags &= ~MUIWF_SCREENLOCKED;
385 }
386 return FALSE;
387 }
388
389 if (!InitCustomFrames(obj, mri))
390 {
391 if (data->wd_Flags & MUIWF_SCREENLOCKED)
392 {
393 UnlockPubScreen(NULL, mri->mri_Screen);
394 data->wd_Flags &= ~MUIWF_SCREENLOCKED;
395 }
396 return FALSE;
397 }
398
399 mri->mri_Colormap = mri->mri_Screen->ViewPort.ColorMap;
400 mri->mri_ScreenWidth = mri->mri_Screen->Width;
401 mri->mri_ScreenHeight = mri->mri_Screen->Height;
402
403 if (mri->mri_ScreenWidth / mri->mri_ScreenHeight < 2)
404 {
405 mri->mri_Flags |= MUIMRI_THINFRAMES;
406 }
407
408 if (GetBitMapAttr(mri->mri_Screen->RastPort.BitMap, BMA_DEPTH) >= 15)
409 {
410 mri->mri_Flags |= MUIMRI_TRUECOLOR;
411 }
412
413 mri->mri_PensStorage[MPEN_SHINE] =
414 mri->mri_DrawInfo->dri_Pens[SHINEPEN];
415 mri->mri_PensStorage[MPEN_BACKGROUND] =
416 mri->mri_DrawInfo->dri_Pens[BACKGROUNDPEN];
417 mri->mri_PensStorage[MPEN_SHADOW] =
418 mri->mri_DrawInfo->dri_Pens[SHADOWPEN];
419 mri->mri_PensStorage[MPEN_TEXT] = mri->mri_DrawInfo->dri_Pens[TEXTPEN];
420 mri->mri_PensStorage[MPEN_FILL] = mri->mri_DrawInfo->dri_Pens[FILLPEN];
421
422 GetRGB32(mri->mri_Colormap, mri->mri_DrawInfo->dri_Pens[SHINEPEN], 1,
423 rgbtable);
424 GetRGB32(mri->mri_Colormap, mri->mri_DrawInfo->dri_Pens[BACKGROUNDPEN],
425 1, rgbtable + 3);
426 GetRGB32(mri->mri_Colormap, mri->mri_DrawInfo->dri_Pens[SHADOWPEN], 1,
427 rgbtable + 6);
428
429 mri->mri_PensStorage[MPEN_HALFSHINE] = ObtainBestPenA
430 (mri->mri_Colormap,
431 DoHalfshineGun(rgbtable[0], rgbtable[3]),
432 DoHalfshineGun(rgbtable[1], rgbtable[4]),
433 DoHalfshineGun(rgbtable[2], rgbtable[5]), NULL);
434
435 mri->mri_PensStorage[MPEN_HALFSHADOW] = ObtainBestPenA
436 (mri->mri_Colormap,
437 DoHalfshadowGun(rgbtable[6], rgbtable[3]),
438 DoHalfshadowGun(rgbtable[7], rgbtable[4]),
439 DoHalfshadowGun(rgbtable[8], rgbtable[5]), NULL);
440
441 /* I'm really not sure that MUI does this for MPEN_MARK, but it seems
442 * mostly acceptable -dlc */
443 mri->mri_PensStorage[MPEN_MARK] = ObtainBestPenA
444 (mri->mri_Colormap, 0xf4f4f4f4, 0xb5b5b5b5, 0x8b8b8b8b, NULL);
445
446 mri->mri_Pens = mri->mri_PensStorage;
447
448 for (i = 0; i < -MUIV_Font_NegCount; i++)
449 {
450 mri->mri_Fonts[i] = NULL;
451 }
452
453 if (data->wd_Flags & MUIWF_USEBOTTOMSCROLLER)
454 {
455 mri->mri_LeftImage = CreateSysimage(mri->mri_DrawInfo, LEFTIMAGE);
456 mri->mri_RightImage = CreateSysimage(mri->mri_DrawInfo, RIGHTIMAGE);
457 }
458 else
459 {
460 mri->mri_LeftImage = mri->mri_RightImage = NULL;
461 }
462
463 if (data->wd_Flags & MUIWF_USERIGHTSCROLLER)
464 {
465 mri->mri_UpImage = CreateSysimage(mri->mri_DrawInfo, UPIMAGE);
466 mri->mri_DownImage = CreateSysimage(mri->mri_DrawInfo, DOWNIMAGE);
467 }
468 else
469 {
470 mri->mri_UpImage = mri->mri_DownImage = NULL;
471 }
472
473 if ((data->wd_Flags & MUIWF_USEBOTTOMSCROLLER) ||
474 (data->wd_Flags & MUIWF_USERIGHTSCROLLER))
475 mri->mri_SizeImage = CreateSysimage(mri->mri_DrawInfo, SIZEIMAGE);
476 else
477 mri->mri_SizeImage = NULL;
478
479 if (data->wd_CrtFlags & WFLG_BORDERLESS)
480 {
481 /* In fact borderless windows could also have borders (if they have
482 * a window title e.g. but since they look ugly anyway we ignore it
483 * for now */
484 mri->mri_BorderLeft = 0;
485 mri->mri_BorderRight = 0;
486 mri->mri_BorderTop = 0;
487 mri->mri_BorderBottom = 0;
488 }
489 else
490 {
491 mri->mri_BorderLeft = mri->mri_Screen->WBorLeft;
492 mri->mri_BorderTop =
493 mri->mri_Screen->WBorTop + mri->mri_Screen->Font->ta_YSize + 1;
494 temp_obj =
495 NewObject(NULL, "sysiclass", SYSIA_DrawInfo,
496 (IPTR) mri->mri_DrawInfo, SYSIA_Which, SIZEIMAGE, TAG_DONE);
497 if (temp_obj)
498 {
499 GetAttr(IA_Height, temp_obj, &val);
500 DisposeObject(temp_obj);
501 mri->mri_BorderBottom = val;
502 }
503 else
504 mri->mri_BorderBottom = mri->mri_Screen->WBorBottom;
505 }
506
507 return TRUE;
508 }
509
510 static void CleanupRenderInfo(Object *obj, struct MUI_WindowData *data,
511 struct MUI_RenderInfo *mri)
512 {
513 int i;
514
515 DisposeCustomFrames(mri);
516
517 if (mri->mri_LeftImage)
518 {
519 DisposeObject(mri->mri_LeftImage);
520 mri->mri_LeftImage = NULL;
521 };
522 if (mri->mri_RightImage)
523 {
524 DisposeObject(mri->mri_RightImage);
525 mri->mri_RightImage = NULL;
526 };
527 if (mri->mri_UpImage)
528 {
529 DisposeObject(mri->mri_UpImage);
530 mri->mri_UpImage = NULL;
531 };
532 if (mri->mri_DownImage)
533 {
534 DisposeObject(mri->mri_DownImage);
535 mri->mri_DownImage = NULL;
536 };
537 if (mri->mri_SizeImage)
538 {
539 DisposeObject(mri->mri_SizeImage);
540 mri->mri_SizeImage = NULL;
541 };
542
543 /* bug("CleanupRenderInfo\n"); */
544 for (i = 0; i < -MUIV_Font_NegCount; i++)
545 {
546 if (mri->mri_Fonts[i])
547 {
548 /* bug("CleanupRenderInfo: closing font %p (%s/%d)\n", */
549 /* mri->mri_Fonts[i], */
550 /* mri->mri_Fonts[i]->tf_Message.mn_Node.ln_Name, */
551 /* mri->mri_Fonts[i]->tf_YSize); */
552 CloseFont(mri->mri_Fonts[i]);
553 mri->mri_Fonts[i] = NULL;
554 }
555 }
556 ReleasePen(mri->mri_Colormap, mri->mri_PensStorage[MPEN_MARK]);
557 ReleasePen(mri->mri_Colormap, mri->mri_PensStorage[MPEN_HALFSHADOW]);
558 ReleasePen(mri->mri_Colormap, mri->mri_PensStorage[MPEN_HALFSHINE]);
559 FreeScreenDrawInfo(mri->mri_Screen, mri->mri_DrawInfo);
560 mri->mri_DrawInfo = NULL;
561
562 /* If a custom screen has been opened by zune, close it as soon as zero
563 * windows are opened. See above for comments about refactorization. */
564 if (muiGlobalInfo(obj)->mgi_CustomScreen)
565 {
566 BOOL screenclose = TRUE;
567 Object *_app = _app(obj);
568 if (_app != NULL)
569 {
570 struct List *store = NULL;
571 get(_app, MUIA_Application_WindowList, &store);
572 if (store != NULL)
573 {
574 if (!IsListEmpty(store))
575 screenclose = FALSE;
576 }
577 }
578 if (screenclose)
579 {
580 /* If the window's user screen really was the custom screen,
581 * clear the reference */
582 if (data->wd_UserScreen == muiGlobalInfo(obj)->mgi_CustomScreen)
583 data->wd_UserScreen = NULL;
584
585 CloseScreen(muiGlobalInfo(obj)->mgi_CustomScreen);
586 muiGlobalInfo(obj)->mgi_CustomScreen = NULL;
587 }
588 }
589
590 if (data->wd_Flags & MUIWF_SCREENLOCKED)
591 {
592 UnlockPubScreen(NULL, mri->mri_Screen);
593 data->wd_Flags &= ~MUIWF_SCREENLOCKED;
594 }
595 mri->mri_Screen = NULL;
596 }
597
598 static void ShowRenderInfo(struct MUI_RenderInfo *mri)
599 {
600 if (mri->mri_BufferBM)
601 {
602 mri->mri_RastPort = &mri->mri_BufferRP;
603 }
604 else
605 {
606 mri->mri_RastPort = mri->mri_Window->RPort;
607 }
608 }
609
610 static void HideRenderInfo(struct MUI_RenderInfo *mri)
611 {
612 mri->mri_RastPort = NULL;
613 }
614
615 static ULONG GetDefaultEvents(void)
616 {
617 return IDCMP_NEWSIZE | IDCMP_CHANGEWINDOW | IDCMP_REFRESHWINDOW
618 | IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_MENUPICK
619 | IDCMP_CLOSEWINDOW | IDCMP_RAWKEY | IDCMP_INTUITICKS
620 | IDCMP_ACTIVEWINDOW | IDCMP_INACTIVEWINDOW | IDCMP_GADGETUP;
621 }
622
623 static void ChangeEvents(struct MUI_WindowData *data, ULONG new_events)
624 {
625 struct MinNode *mn;
626 struct MUI_EventHandlerNode *ehn;
627 ULONG old_events = data->wd_Events;
628
629 for (mn = data->wd_EHList.mlh_Head; mn->mln_Succ; mn = mn->mln_Succ)
630 {
631 ehn = (struct MUI_EventHandlerNode *)mn;
632 new_events |= ehn->ehn_Events;
633 }
634
635 /* sba: kill the IDCMP_VANILLAKEY flag. MUI doesn't do this but programs
636 ** which use this will behave different if they request for this flag
637 ** (also on MUI)
638 */
639 new_events &= ~IDCMP_VANILLAKEY;
640
641 data->wd_Events = new_events;
642 if ((old_events != new_events) && (data->wd_Flags & MUIWF_OPENED))
643 {
644 ModifyIDCMP(data->wd_RenderInfo.mri_Window, new_events);
645 }
646 }
647
648 static void CalcWindowPosition(Object *obj, struct MUI_WindowData *data);
649 static void CreateWindowScrollbars(Object *obj,
650 struct MUI_WindowData *data);
651 static void CalcAltDimensions(Object *obj, struct MUI_WindowData *data);
652 static void UndisplayWindow(Object *obj, struct MUI_WindowData *data);
653 static struct ObjNode *FindObjNode(struct MinList *list, Object *obj);
654
655 static BOOL DisplayWindow(Object *obj, struct MUI_WindowData *data)
656 {
657 struct Window *win;
658 ULONG flags = data->wd_CrtFlags;
659 struct IBox altdims;
660 ULONG backfill, buttons;
661
662 struct Menu *menu = NULL;
663 struct NewMenu *newmenu = NULL;
664 APTR visinfo = NULL;
665
666 Object *gadgets;
667
668 if (!(data->wd_Flags & MUIWF_DONTACTIVATE))
669 {
670 flags |= WFLG_ACTIVATE;
671 }
672
673 /* Toolboxes are handled differently on AmigaOS */
674 #ifdef __AROS__
675 if (data->wd_Flags & MUIWF_TOOLBOX)
676 flags |= WFLG_TOOLBOX;
677 #endif
678
679 if (data->wd_MinMax.MinHeight == data->wd_MinMax.MaxHeight
680 && data->wd_MinMax.MinWidth == data->wd_MinMax.MaxWidth)
681 flags &= ~WFLG_SIZEGADGET;
682
683 if (!(flags & WFLG_SIZEBRIGHT))
684 flags |= WFLG_SIZEBBOTTOM;
685
686 CalcWindowPosition(obj, data);
687
688 if ((visinfo = GetVisualInfoA(data->wd_RenderInfo.mri_Screen, NULL)))
689 {
690 if (data->wd_Menustrip)
691 {
692 get(data->wd_Menustrip, MUIA_Menuitem_NewMenu, &newmenu);
693 if (newmenu)
694 {
695 if ((menu = CreateMenusA(newmenu, NULL)))
696 {
697 struct TagItem tags[] = {
698 {GTMN_NewLookMenus, TRUE},
699 {TAG_DONE, (IPTR) NULL}
700 };
701 LayoutMenusA(menu, visinfo, tags);
702 }
703 }
704 }
705 FreeVisualInfo(visinfo);
706 }
707
708 CreateWindowScrollbars(obj, data);
709 CalcAltDimensions(obj, data);
710 altdims = data->wd_AltDim;
711
712 /* hack to account for border size, as we only know the innersize and
713 * must give the total size.
714 */
715 altdims.Width +=
716 data->wd_RenderInfo.mri_Screen->WBorLeft +
717 data->wd_RenderInfo.mri_Screen->WBorRight;
718 altdims.Height +=
719 data->wd_RenderInfo.mri_Screen->WBorTop +
720 data->wd_RenderInfo.mri_Screen->WBorBottom +
721 data->wd_RenderInfo.mri_DrawInfo->dri_Font->tf_YSize + 1;
722
723 if (muiGlobalInfo(obj)->mgi_Prefs->window_redraw ==
724 WINDOW_REDRAW_WITHOUT_CLEAR)
725 backfill = WA_BackFill;
726 else
727 backfill = TAG_IGNORE;
728
729 if (muiGlobalInfo(obj)->mgi_Prefs->window_refresh ==
730 WINDOW_REFRESH_SMART)
731 flags &= ~WFLG_SIMPLE_REFRESH;
732 set(_app(obj), MUIA_Application_SearchWinId, data->wd_ID);
733 struct windowpos *winp = 0;
734 get(_app(obj), MUIA_Application_GetWinPos, &winp);
735 if (winp)
736 {
737 if (data->wd_RenderInfo.mri_ScreenWidth >
738 (data->wd_X + data->wd_Width))
739 {
740 data->wd_X = winp->x1;
741 data->wd_Width = winp->w1;
742 }
743 if (data->wd_RenderInfo.mri_ScreenHeight >
744 (data->wd_Y + data->wd_Height))
745 {
746 data->wd_Y = winp->y1;
747 data->wd_Height = winp->h1;
748 }
749 }
750
751 gadgets =
752 (data->wd_VertProp !=
753 NULL) ? data->wd_VertProp : data->wd_HorizProp;
754 buttons = muiGlobalInfo(obj)->mgi_Prefs->window_buttons;
755
756 win = OpenWindowTags
757 (NULL,
758 WA_Left, (IPTR) data->wd_X,
759 WA_Top, (IPTR) data->wd_Y,
760 WA_Flags, (IPTR) flags,
761 data->wd_Title ?
762 WA_Title :
763 TAG_IGNORE, (IPTR) data->wd_Title,
764 data->wd_ScreenTitle ?
765 WA_ScreenTitle :
766 TAG_IGNORE, (IPTR) data->wd_ScreenTitle,
767 WA_CustomScreen, (IPTR) data->wd_RenderInfo.mri_Screen,
768 WA_InnerWidth, (IPTR) data->wd_Width,
769 WA_InnerHeight, (IPTR) data->wd_Height,
770 WA_AutoAdjust, (IPTR) TRUE, WA_NewLookMenus, (IPTR) TRUE,
771 /* AmigaOS v4 extension */
772 #ifdef WA_ToolBox
773 WA_ToolBox, (IPTR) ! !(data->wd_Flags & MUIWF_TOOLBOX),
774 #endif
775 /* MorphOS extensions */
776 #ifdef WA_ExtraGadget_MUI
777 WA_ExtraGadget_MUI,
778 (IPTR) ((buttons & MUIV_Window_Button_MUI) != 0) ? TRUE : FALSE,
779 WA_ExtraGadget_PopUp,
780 (IPTR) ((buttons & MUIV_Window_Button_Popup) != 0) ? TRUE : FALSE,
781 WA_ExtraGadget_Snapshot,
782 (IPTR) ((buttons & MUIV_Window_Button_Snapshot) !=
783 0) ? TRUE : FALSE, WA_ExtraGadget_Iconify,
784 (IPTR) ((buttons & MUIV_Window_Button_Iconify) != 0) ? TRUE : FALSE,
785 #endif
786 data->wd_NoMenus ?
787 WA_RMBTrap :
788 TAG_IGNORE, (IPTR) TRUE,
789 WA_Gadgets, (IPTR) gadgets,
790 data->wd_ZoomGadget ?
791 WA_Zoom :
792 TAG_IGNORE, (IPTR) & altdims,
793 backfill, (IPTR) LAYERS_NOBACKFILL, TAG_DONE);
794
795 if (win)
796 {
797
798 int hborders = win->BorderLeft + win->BorderRight;
799 int vborders = win->BorderTop + win->BorderBottom;
800
801 /* recalc window size (which will hopefully equal our requested
802 * size) */
803 data->wd_Width = win->GZZWidth;
804 data->wd_Height = win->GZZHeight;
805
806 /* set window limits according to window contents */
807 WindowLimits
808 (win, data->wd_MinMax.MinWidth + hborders,
809 data->wd_MinMax.MinHeight + vborders,
810 data->wd_MinMax.MaxWidth + hborders,
811 data->wd_MinMax.MaxHeight + vborders);
812
813 win->UserData = (BYTE *) data->wd_RenderInfo.mri_WindowObject;
814 win->UserPort = muiGlobalInfo(obj)->mgi_WindowsPort;
815 /* Same port for all windows */
816 ModifyIDCMP(win, data->wd_Events);
817
818 data->wd_RenderInfo.mri_Window = win;
819 data->wd_RenderInfo.mri_VertProp = data->wd_VertProp;
820 data->wd_RenderInfo.mri_HorizProp = data->wd_HorizProp;
821 SetDrMd(win->RPort, JAM1);
822 //text is drawn wrong in toolbarclass if not set
823
824 if (menu)
825 {
826 data->wd_Menu = menu;
827 SetMenuStrip(win, menu);
828 }
829
830 if (flags & WFLG_ACTIVATE)
831 {
832 data->wd_Flags |= MUIWF_ACTIVE;
833 }
834
835 if (data->wd_Flags & MUIWF_ISAPPWINDOW)
836 {
837 data->wd_AppWindow = AddAppWindowA(0, (IPTR) obj, win,
838 muiGlobalInfo(obj)->mgi_AppPort, NULL);
839 }
840
841 return TRUE;
842 }
843
844 if (menu)
845 FreeMenus(menu);
846 UndisplayWindow(obj, data);
847
848 return FALSE;
849 }
850
851
852 static void UndisplayWindow(Object *obj, struct MUI_WindowData *data)
853 {
854 struct Window *win = data->wd_RenderInfo.mri_Window;
855 BOOL prefssnap =
856 ((muiGlobalInfo(obj)->mgi_Prefs->window_position ==
857 WINDOW_POSITION_REMEMBER_ON_EXIT)
858 || (muiGlobalInfo(obj)->mgi_Prefs->window_position ==
859 WINDOW_POSITION_SAVE_ON_EXIT));
860
861 if (((data->wd_XStore >= 0) && (data->wd_YStore >= 0)) || prefssnap)
862 {
863 DoMethod(obj, MUIM_Window_Snapshot, 1);
864 }
865
866 data->wd_RenderInfo.mri_Window = NULL;
867 data->wd_RenderInfo.mri_VertProp = NULL;
868 data->wd_RenderInfo.mri_HorizProp = NULL;
869
870 data->wd_Flags &= ~MUIWF_ACTIVE;
871
872 if (win != NULL)
873 {
874 /* store position and size */
875 if (data->wd_XStore >= 0)
876 data->wd_X = win->LeftEdge;
877 else
878 data->wd_X = data->wd_XStore;
879 if (data->wd_YStore >= 0)
880 data->wd_Y = win->TopEdge;
881 else
882 data->wd_Y = data->wd_YStore;
883 data->wd_Width = win->GZZWidth;
884 data->wd_Height = win->GZZHeight;
885
886 ClearMenuStrip(win);
887 if (data->wd_Menu)
888 {
889 FreeMenus(data->wd_Menu);
890 data->wd_Menu = NULL;
891 }
892
893 if (win->UserPort)
894 {
895 struct IntuiMessage *msg, *succ;
896
897 /* remove all messages pending for this window */
898 Forbid();
899 for (msg =
900 (struct IntuiMessage *)win->UserPort->mp_MsgList.lh_Head;
901 (succ =
902 (struct IntuiMessage *)msg->ExecMessage.mn_Node.
903 ln_Succ); msg = succ)
904 {
905 if (msg->IDCMPWindow == win)
906 {
907 Remove((struct Node *)msg);
908 ReplyMsg((struct Message *)msg);
909 }
910 }
911 win->UserPort = NULL;
912 ModifyIDCMP(win, 0);
913 Permit();
914 }
915
916 /* D(bug("before CloseWindow\n")); */
917 CloseWindow(win);
918 /* D(bug("after CloseWindow\n")); */
919 }
920
921 #define DISPOSEGADGET(x) \
922 if (x)\
923 {\
924 DoMethod(obj, MUIM_Window_FreeGadgetID,\
925 ((struct Gadget*)x)->GadgetID);\
926 DisposeObject(x);\
927 x = NULL;\
928 }
929
930 DISPOSEGADGET(data->wd_VertProp);
931 DISPOSEGADGET(data->wd_UpButton);
932 DISPOSEGADGET(data->wd_DownButton);
933 DISPOSEGADGET(data->wd_HorizProp);
934 DISPOSEGADGET(data->wd_LeftButton);
935 DISPOSEGADGET(data->wd_RightButton);
936 #undef DISPOSEGADGET
937 }
938
939
940 static VOID RefreshWindow(Object *oWin, struct MUI_WindowData *data)
941 {
942 if (data->wd_Flags & MUIWF_RESIZING)
943 {
944 //LONG left,top,right,bottom;
945 if (MUI_BeginRefresh(&data->wd_RenderInfo, 0))
946 {
947 MUI_EndRefresh(&data->wd_RenderInfo, 0);
948 }
949 RefreshWindowFrame(data->wd_RenderInfo.mri_Window);
950
951 data->wd_Flags &= ~MUIWF_RESIZING;
952 _width(data->wd_RootObject) = data->wd_Width;
953 _height(data->wd_RootObject) = data->wd_Height;
954 DoMethod(data->wd_RootObject, MUIM_Layout);
955 DoShowMethod(data->wd_RootObject);
956
957 if (muiGlobalInfo(oWin)->mgi_Prefs->window_redraw ==
958 WINDOW_REDRAW_WITH_CLEAR)
959 {
960 LONG left, top, width, height;
961
962 left = data->wd_RenderInfo.mri_Window->BorderLeft;
963 top = data->wd_RenderInfo.mri_Window->BorderTop;
964 width =
965 data->wd_RenderInfo.mri_Window->Width -
966 data->wd_RenderInfo.mri_Window->BorderRight - left;
967 height =
968 data->wd_RenderInfo.mri_Window->Height -
969 data->wd_RenderInfo.mri_Window->BorderBottom - top;
970
971 if (data->wd_Flags & MUIWF_ERASEAREA)
972 {
973 //D(bug("%d:zune_imspec_draw(%p) "
974 // "l=%d t=%d w=%d h=%d xo=%d yo=%d\n",
975 // __LINE__, data->wd_Background, left, top, width,
976 // height, left, top));
977 zune_imspec_draw(data->wd_Background,
978 &data->wd_RenderInfo, left, top, width, height,
979 left, top, 0);
980 }
981 MUI_Redraw(data->wd_RootObject, MADF_DRAWALL);
982 }
983 else
984 MUI_Redraw(data->wd_RootObject, MADF_DRAWOBJECT);
985 // but should only draw focus without using MUIM_GoActive !
986 ActivateObject(data);
987 }
988 else
989 {
990 if (MUI_BeginRefresh(&data->wd_RenderInfo, 0))
991 {
992 MUI_Redraw(data->wd_RootObject, MADF_DRAWALL);
993 // but should only draw focus without using MUIM_GoActive !
994 ActivateObject(data);
995 MUI_EndRefresh(&data->wd_RenderInfo, 0);
996 }
997 }
998 }
999
1000
1001 /* Initialize data->wd_X and data->wd_Y for DisplayWindow */
1002 /* FIXME 20030817: needs some fixing, seems not fully implemented */
1003 static void CalcWindowPosition(Object *obj, struct MUI_WindowData *data)
1004 {
1005 data->wd_XStore = data->wd_X;
1006 data->wd_YStore = data->wd_Y;
1007 if (NULL == data->wd_RefWindow)
1008 {
1009 /* The following calculations are not very correct, the size and
1010 * dragbar are ignored also the current overscan view */
1011 if (data->wd_X == MUIV_Window_LeftEdge_Centered)
1012 {
1013 data->wd_X =
1014 (data->wd_RenderInfo.mri_Screen->ViewPort.DWidth -
1015 data->wd_Width) / 2 -
1016 data->wd_RenderInfo.mri_Screen->LeftEdge;
1017 }
1018 else if (data->wd_X == MUIV_Window_LeftEdge_Moused)
1019 {
1020 data->wd_X = data->wd_RenderInfo.mri_Screen->MouseX;
1021 }
1022
1023 if (data->wd_Y == MUIV_Window_TopEdge_Centered)
1024 {
1025 data->wd_Y =
1026 (data->wd_RenderInfo.mri_Screen->ViewPort.DHeight -
1027 data->wd_Height) / 2 -
1028 data->wd_RenderInfo.mri_Screen->TopEdge;
1029 }
1030 else if (data->wd_Y == MUIV_Window_TopEdge_Moused)
1031 {
1032 data->wd_Y = data->wd_RenderInfo.mri_Screen->MouseY;
1033 }
1034 else if (data->wd_Y <= MUIV_Window_TopEdge_Delta(0))
1035 {
1036 data->wd_Y = data->wd_RenderInfo.mri_Screen->BarHeight + 1
1037 + MUIV_Window_TopEdge_Delta(0) - data->wd_Y;
1038 }
1039 }
1040 else
1041 {
1042 ULONG w = 0, x = 0;
1043 ULONG h = 0, y = 0;
1044
1045 get(data->wd_RefWindow, MUIA_Window_Width, &w);
1046 get(data->wd_RefWindow, MUIA_Window_LeftEdge, &x);
1047
1048 if (data->wd_X == MUIV_Window_LeftEdge_Centered)
1049 {
1050 data->wd_X = x + (w - data->wd_Width) / 2;
1051 }
1052 else
1053 {
1054 data->wd_X += x;
1055 }
1056
1057 get(data->wd_RefWindow, MUIA_Window_Height, &h);
1058 get(data->wd_RefWindow, MUIA_Window_TopEdge, &y);
1059
1060 if (data->wd_Y == MUIV_Window_TopEdge_Centered)
1061 {
1062 /* D(bug("y=%ld, h=%ld, wdh=%ld\n", y, h, data->wd_Height)); */
1063 data->wd_Y = y + (h - data->wd_Height) / 2;
1064 }
1065 else if (data->wd_Y <= MUIV_Window_TopEdge_Delta(0))
1066 {
1067 /* ??? surely incorrect implementation */
1068 data->wd_Y = y + 1 + MUIV_Window_TopEdge_Delta(0) - data->wd_Y;
1069 }
1070 else
1071 {
1072 data->wd_Y += y;
1073 }
1074 }
1075 }
1076
1077 /* Initialize data->wd_AltDim for DisplayWindow */
1078 static void CalcAltDimensions(Object *obj, struct MUI_WindowData *data)
1079 {
1080 /* Calculate alternate (zoomed) dimensions.
1081 */
1082 if (data->wd_AltDim.Top == MUIV_Window_AltTopEdge_NoChange)
1083 data->wd_AltDim.Top = ~0;
1084 else if (data->wd_AltDim.Top == MUIV_Window_AltTopEdge_Centered)
1085 data->wd_AltDim.Top =
1086 (data->wd_RenderInfo.mri_Screen->Height - data->wd_Height) / 2;
1087 else if (data->wd_AltDim.Top == MUIV_Window_AltTopEdge_Moused)
1088 /* ? */ data->wd_AltDim.Top = ~0;
1089
1090 if (data->wd_AltDim.Left == MUIV_Window_AltLeftEdge_NoChange)
1091 data->wd_AltDim.Left = ~0;
1092 else if (data->wd_AltDim.Left == MUIV_Window_AltLeftEdge_Centered)
1093 data->wd_AltDim.Left =
1094 (data->wd_RenderInfo.mri_Screen->Width - data->wd_Width) / 2;
1095 else if (data->wd_AltDim.Left == MUIV_Window_AltLeftEdge_Moused)
1096 /* ? */ data->wd_AltDim.Left = ~0;
1097
1098 if (_between
1099 (MUIV_Window_AltWidth_MinMax(100),
1100 data->wd_AltDim.Width, MUIV_Window_AltWidth_MinMax(0)))
1101 {
1102 data->wd_AltDim.Width = data->wd_MinMax.MinWidth
1103 - data->wd_AltDim.Width
1104 * (data->wd_MinMax.MaxWidth - data->wd_MinMax.MinWidth);
1105 }
1106 else if
1107 (_between
1108 (MUIV_Window_AltWidth_Screen(100),
1109 data->wd_AltDim.Width, MUIV_Window_AltWidth_Screen(0)))
1110 {
1111 data->wd_AltDim.Width = data->wd_RenderInfo.mri_ScreenWidth
1112 * (-(data->wd_AltDim.Width + 200)) / 100;
1113 }
1114 else if
1115 (_between
1116 (MUIV_Window_AltWidth_Visible(100),
1117 data->wd_AltDim.Width, MUIV_Window_AltWidth_Visible(0)))
1118 {
1119 data->wd_AltDim.Width = data->wd_RenderInfo.mri_ScreenWidth
1120 * (-(data->wd_AltDim.Width + 100)) / 100;
1121 }
1122
1123 if (_between
1124 (MUIV_Window_AltHeight_MinMax(100),
1125 data->wd_AltDim.Height, MUIV_Window_AltHeight_MinMax(0)))
1126 {
1127 data->wd_AltDim.Height = data->wd_MinMax.MinHeight
1128 - data->wd_AltDim.Height
1129 * (data->wd_MinMax.MaxHeight - data->wd_MinMax.MinHeight);
1130 }
1131 else if
1132 (_between
1133 (MUIV_Window_AltHeight_Screen(100),
1134 data->wd_AltDim.Height, MUIV_Window_AltHeight_Screen(0)))
1135 {
1136 data->wd_AltDim.Height = data->wd_RenderInfo.mri_ScreenHeight
1137 * (-(data->wd_AltDim.Height + 200)) / 100;
1138 }
1139 else if
1140 (_between
1141 (MUIV_Window_AltHeight_Visible(100),
1142 data->wd_AltDim.Height, MUIV_Window_AltHeight_Visible(0)))
1143 {
1144 data->wd_AltDim.Height = data->wd_RenderInfo.mri_ScreenHeight
1145 * (-(data->wd_AltDim.Height + 100)) / 100;
1146 }
1147
1148 data->wd_AltDim.Width = CLAMP
1149 (data->wd_AltDim.Width, data->wd_MinMax.MinWidth,
1150 data->wd_MinMax.MaxWidth);
1151 data->wd_AltDim.Height = CLAMP
1152 (data->wd_AltDim.Height, data->wd_MinMax.MinHeight,
1153 data->wd_MinMax.MaxHeight);
1154 }
1155
1156
1157 /* Create horiz/vert window scrollbars for DisplayWindow */
1158 static void CreateWindowScrollbars(Object *obj,
1159 struct MUI_WindowData *data)
1160 {
1161 struct MUI_RenderInfo *mri = &data->wd_RenderInfo;
1162 Object *firstgad = NULL;
1163 Object *prevgad = NULL;
1164 LONG id;
1165
1166 /* Create the right border scrollers now if requested */
1167 if (data->wd_Flags & MUIWF_USERIGHTSCROLLER)
1168 {
1169 int voffset;
1170
1171 voffset = IM(mri->mri_DownImage)->Width / 4;
1172
1173 id = DoMethod(obj, MUIM_Window_AllocGadgetID);
1174 firstgad = prevgad = data->wd_VertProp = NewObject
1175 (NULL, "propgclass",
1176 GA_RelRight, 1 - (IM(mri->mri_UpImage)->Width - voffset),
1177 GA_Top, mri->mri_BorderTop + 2,
1178 GA_Width, IM(mri->mri_UpImage)->Width - voffset * 2,
1179 GA_RelHeight, -(mri->mri_BorderTop + 2)
1180 - IM(mri->mri_UpImage)->Height
1181 - IM(mri->mri_DownImage)->Height
1182 - IM(mri->mri_SizeImage)->Height - 2,
1183 GA_RightBorder, TRUE,
1184 GA_ID, id,
1185 PGA_Borderless, TRUE,
1186 PGA_NewLook, TRUE,
1187 PGA_Freedom, FREEVERT,
1188 PGA_Top, 0,
1189 PGA_Total, 2,
1190 PGA_Visible, 1, ICA_TARGET, ICTARGET_IDCMP, TAG_DONE);
1191
1192 id = DoMethod(obj, MUIM_Window_AllocGadgetID);
1193 prevgad = data->wd_UpButton = NewObject
1194 (NULL, "buttongclass",
1195 GA_Image, (IPTR) mri->mri_UpImage,
1196 GA_RelRight, 1 - IM(mri->mri_UpImage)->Width,
1197 GA_RelBottom, 1 - IM(mri->mri_UpImage)->Height
1198 - IM(mri->mri_DownImage)->Height
1199 - IM(mri->mri_SizeImage)->Height,
1200 GA_RightBorder, TRUE,
1201 GA_Previous, (IPTR) prevgad,
1202 GA_ID, id, ICA_TARGET, ICTARGET_IDCMP, TAG_DONE);
1203
1204 id = DoMethod(obj, MUIM_Window_AllocGadgetID);
1205 prevgad = data->wd_DownButton = NewObject
1206 (NULL, "buttongclass",
1207 GA_Image, (IPTR) mri->mri_DownImage,
1208 GA_RelRight, 1 - IM(mri->mri_DownImage)->Width,
1209 GA_RelBottom, 1 - IM(mri->mri_DownImage)->Height
1210 - IM(mri->mri_SizeImage)->Height,
1211 GA_RightBorder, TRUE,
1212 GA_Previous, (IPTR) prevgad,
1213 GA_ID, id, ICA_TARGET, ICTARGET_IDCMP, TAG_DONE);
1214 }
1215
1216 /* Create the bottom border scrollers now if requested */
1217 if (data->wd_Flags & MUIWF_USEBOTTOMSCROLLER)
1218 {
1219 int hoffset;
1220
1221 hoffset = IM(mri->mri_RightImage)->Height / 4;
1222
1223 id = DoMethod(obj, MUIM_Window_AllocGadgetID);
1224 prevgad = data->wd_HorizProp = NewObject
1225 (NULL, "propgclass",
1226 GA_RelBottom, 1 - (IM(mri->mri_LeftImage)->Height - hoffset),
1227 GA_Left, mri->mri_BorderLeft,
1228 GA_Height, IM(mri->mri_LeftImage)->Height
1229 - hoffset * 2,
1230 GA_RelWidth, -(mri->mri_BorderLeft)
1231 - IM(mri->mri_LeftImage)->Width
1232 - IM(mri->mri_RightImage)->Width
1233 - IM(mri->mri_SizeImage)->Width
1234 - 2,
1235 GA_BottomBorder, TRUE,
1236 GA_ID, id,
1237 prevgad ? GA_Previous : TAG_IGNORE, (IPTR) prevgad,
1238 PGA_Borderless, TRUE,
1239 PGA_NewLook, TRUE,
1240 PGA_Freedom, FREEHORIZ,
1241 PGA_Top, 0,
1242 PGA_Total, 2,
1243 PGA_Visible, 1, ICA_TARGET, ICTARGET_IDCMP, TAG_DONE);
1244
1245 if (!firstgad)
1246 firstgad = prevgad;
1247
1248 id = DoMethod(obj, MUIM_Window_AllocGadgetID);
1249 prevgad = data->wd_LeftButton = NewObject
1250 (NULL, "buttongclass",
1251 GA_Image, (IPTR) mri->mri_LeftImage,
1252 GA_RelRight, 1 - IM(mri->mri_LeftImage)->Width
1253 - IM(mri->mri_RightImage)->Width
1254 - IM(mri->mri_SizeImage)->Width,
1255 GA_RelBottom, 1 - IM(mri->mri_LeftImage)->Height,
1256 GA_BottomBorder, TRUE,
1257 GA_Previous, (IPTR) prevgad,
1258 GA_ID, id, ICA_TARGET, ICTARGET_IDCMP, TAG_DONE);
1259
1260 id = DoMethod(obj, MUIM_Window_AllocGadgetID);
1261 prevgad = data->wd_RightButton = NewObject
1262 (NULL, "buttongclass",
1263 GA_Image, (IPTR) mri->mri_RightImage,
1264 GA_RelRight, 1 - IM(mri->mri_RightImage)->Width
1265 - IM(mri->mri_SizeImage)->Width,
1266 GA_RelBottom, 1 - IM(mri->mri_RightImage)->Height,
1267 GA_BottomBorder, TRUE,
1268 GA_Previous, (IPTR) prevgad,
1269 GA_ID, id, ICA_TARGET, ICTARGET_IDCMP, TAG_DONE);
1270 }
1271 }
1272
1273 /* return FALSE only if no resize (dx=dy=0) occured */
1274 static BOOL WindowResize(struct MUI_WindowData *data)
1275 {
1276 struct Window *win = data->wd_RenderInfo.mri_Window;
1277 int hborders = win->BorderLeft + win->BorderRight;
1278 int vborders = win->BorderTop + win->BorderBottom;
1279 WORD dx = data->wd_Width - win->Width + hborders;
1280 WORD dy = data->wd_Height - win->Height + vborders;
1281
1282 /* Temporarily disable window limits to let SizeWindow below work
1283 regardless of the previous limits */
1284 WindowLimits(win, 1, 1, -1, -1);
1285 /* D(bug("_zune_window_resize : dx=%d, dy=%d\n", dx, dy)); */
1286 SizeWindow(win, dx, dy);
1287
1288 /* Set new window limits */
1289 WindowLimits
1290 (win, data->wd_MinMax.MinWidth + hborders,
1291 data->wd_MinMax.MinHeight + vborders,
1292 data->wd_MinMax.MaxWidth + hborders,
1293 data->wd_MinMax.MaxHeight + vborders);
1294
1295 return dx || dy;
1296 }
1297
1298 static void KillHelpBubble(struct MUI_WindowData *data, Object *obj,
1299 BOOL kill_bubblemode)
1300 {
1301 if (data->wd_HelpObject)
1302 {
1303 DoMethod(data->wd_HelpObject, MUIM_DeleteBubble,
1304 (IPTR) data->wd_HelpBubble);
1305 data->wd_HelpObject = NULL;
1306 data->wd_HelpBubble = NULL;
1307 }
1308
1309 if (kill_bubblemode)
1310 data->wd_Flags &= ~MUIWF_BUBBLEMODE;
1311
1312 if (data->wd_Flags & MUIWF_BUBBLEMODE)
1313 {
1314 data->wd_HelpTicker = BUBBLEHELP_TICKER_LATER;
1315 }
1316 else
1317 {
1318 data->wd_HelpTicker = BUBBLEHELP_TICKER_FIRST;
1319 }
1320
1321 }
1322
1323 /**************/
1324
1325 typedef BOOL(*UNDERCHECK_FUNC) (Object *obj);
1326
1327 static BOOL ShortHelpUnderPointerCheck(Object *obj)
1328 {
1329 return muiAreaData(obj)->mad_ShortHelp ? TRUE : FALSE;
1330 }
1331
1332 static Object *ObjectUnderPointer(struct MUI_WindowData *data, Object *obj,
1333 LONG x, LONG y, UNDERCHECK_FUNC func)
1334 {
1335 Object *cstate;
1336 Object *child;
1337 struct MinList *ChildList = NULL;
1338
1339 if (!(muiAreaData(obj)->mad_Flags & MADF_CANDRAW))
1340 return NULL;
1341
1342 if (!(x >= _left(obj) && x <= _right(obj)
1343 && y >= _top(obj) && y <= _bottom(obj)))
1344 {
1345 return NULL;
1346 }
1347
1348 if ((get(obj, MUIA_Group_ChildList, &(ChildList)))
1349 && (ChildList != NULL))
1350 {
1351 cstate = (Object *) ChildList->mlh_Head;
1352 while ((child = NextObject(&cstate)))
1353 {
1354 Object *ret;
1355
1356 if ((x >= _left(child) && x <= _right(child)
1357 &&
1358 y >= _top(child) && y <= _bottom(child))
1359 && (ret = ObjectUnderPointer(data, child, x, y, func)))
1360 {
1361 return ret;
1362 }
1363 }
1364 }
1365
1366 if (!(*func) (obj))
1367 return NULL;
1368
1369 return obj;
1370 }
1371
1372 static BOOL ContextMenuUnderPointer(struct MUI_WindowData *data,
1373 Object *obj, LONG x, LONG y)
1374 {
1375 Object *cstate;
1376 Object *child;
1377 struct MinList *ChildList = NULL;
1378
1379 if (!(x >= _left(obj) && x <= _right(obj)
1380 && y >= _top(obj) && y <= _bottom(obj)))
1381 {
1382 return FALSE;
1383 }
1384
1385 if ((get(obj, MUIA_Group_ChildList, &(ChildList)))
1386 && (ChildList != NULL))
1387 {
1388
1389 cstate = (Object *) ChildList->mlh_Head;
1390 while ((child = NextObject(&cstate)))
1391 {
1392 if ((x >= _left(child) && x <= _right(child)
1393 &&
1394 y >= _top(child) && y <= _bottom(child))
1395 && (ContextMenuUnderPointer(data, child, x, y)))
1396 return TRUE;
1397 }
1398 }
1399
1400 if (!(muiAreaData(obj)->mad_Flags & MADF_CANDRAW))
1401 return FALSE;
1402 if (!(muiAreaData(obj)->mad_ContextMenu))
1403 return FALSE;
1404
1405 return TRUE;
1406 }
1407
1408 /**************/
1409
1410 static void ActivateObject(struct MUI_WindowData *data)
1411 {
1412 //bug("Window::ActivateObject (dummy) %08lx\n", data->wd_ActiveObject);
1413 // if (FindObjNode(&data->wd_CycleChain, data->wd_ActiveObject))
1414 // DoMethod(data->wd_ActiveObject, MUIM_GoActive);
1415 // else
1416 // data->wd_ActiveObject = NULL;
1417
1418 //activate better string gadgets.Fix from Georg S On ML List
1419 if (FindObjNode(&data->wd_CycleChain, data->wd_ActiveObject))
1420 {
1421 if (!(data->wd_Flags & MUIWF_OBJECTGOACTIVESENT))
1422 {
1423 data->wd_Flags |= MUIWF_OBJECTGOACTIVESENT;
1424 DoMethod(data->wd_ActiveObject, MUIM_GoActive);
1425 }
1426 }
1427 else
1428 data->wd_ActiveObject = NULL;
1429 }
1430
1431 /**************/
1432
1433 /* handle intuimessage while an object is being dragged
1434 * (reply imsg before returning)
1435 * Returns TRUE if finished dragging.
1436 */
1437 static BOOL HandleDragging(Object *oWin, struct MUI_WindowData *data,
1438 struct IntuiMessage *imsg)
1439 {
1440 struct Window *iWin;
1441 BOOL finish_drag = FALSE;
1442
1443 iWin = imsg->IDCMPWindow;
1444
1445 if (imsg->Class == IDCMP_MOUSEMOVE)
1446 {
1447 struct Layer *layer;
1448
1449 LockLayerInfo(&iWin->WScreen->LayerInfo);
1450 layer = WhichLayer(&iWin->WScreen->LayerInfo, iWin->LeftEdge + imsg->MouseX,
1451 iWin->TopEdge + imsg->MouseY);
1452 UnlockLayerInfo(&iWin->WScreen->LayerInfo);
1453
1454 if (data->wd_DropObject)
1455 {
1456 struct Window *wnd;
1457 WORD mousex =
1458 imsg->MouseX + iWin->LeftEdge -
1459 data->wd_DropWindow->LeftEdge;
1460 WORD mousey =
1461 imsg->MouseY + iWin->TopEdge - data->wd_DropWindow->TopEdge;
1462
1463 wnd = _window(data->wd_DropObject);
1464 if (mousex < _left(data->wd_DropObject)
1465 || mousex > _right(data->wd_DropObject)
1466 || mousey < _top(data->wd_DropObject)
1467 || mousey > _bottom(data->wd_DropObject)
1468 || layer != wnd->WLayer)
1469 {
1470 /* We have left the object */
1471 UndrawDragNDrop(data->wd_dnd);
1472 DoMethod(data->wd_DropObject, MUIM_DragFinish,
1473 (IPTR) data->wd_DragObject);
1474 data->wd_DropObject = NULL;
1475 }
1476 } /* if (data->wd_DropObject) */
1477
1478 if (!data->wd_DropObject)
1479 {
1480 Object *dest_wnd = NULL;
1481
1482 /* Find out if app has an open window at this position */
1483 if (layer)
1484 {
1485 Object *cstate;
1486 Object *child;
1487 struct MinList *ChildList = 0;
1488
1489 get(_app(oWin), MUIA_Application_WindowList, &(ChildList));
1490 cstate = (Object *) ChildList->mlh_Head;
1491 while ((child = NextObject(&cstate)))
1492 {
1493 struct Window *wnd = NULL;
1494 get(child, MUIA_Window_Window, &wnd);
1495 if (!wnd)
1496 continue;
1497
1498 if (wnd->WLayer == layer)
1499 {
1500 data->wd_DropWindow = wnd;
1501 dest_wnd = child;
1502 break;
1503 }
1504 }
1505 } /* if (layer) */
1506
1507 if (dest_wnd)
1508 {
1509 Object *root = NULL;
1510 get(dest_wnd, MUIA_Window_RootObject, &root);
1511
1512 if (root)
1513 {
1514 if ((data->wd_DropObject = (Object *) DoMethod
1515 (root, MUIM_DragQueryExtended,
1516 (IPTR) data->wd_DragObject,
1517 imsg->MouseX + iWin->LeftEdge -
1518 data->wd_DropWindow->LeftEdge,
1519 imsg->MouseY + iWin->TopEdge -
1520 data->wd_DropWindow->TopEdge)))
1521 {
1522 UndrawDragNDrop(data->wd_dnd);
1523 DoMethod(data->wd_DropObject, MUIM_DragBegin,
1524 (IPTR) data->wd_DragObject);
1525 }
1526 }
1527 }
1528 }
1529
1530 if (data->wd_DropObject)
1531 {
1532 LONG update = 0;
1533 LONG i;
1534 for (i = 0; i < 2; i++)
1535 {
1536 LONG res = DoMethod(data->wd_DropObject, MUIM_DragReport,
1537 (IPTR) data->wd_DragObject,
1538 imsg->MouseX + iWin->LeftEdge -
1539 data->wd_DropWindow->LeftEdge,
1540 imsg->MouseY + iWin->TopEdge -
1541 data->wd_DropWindow->TopEdge, update);
1542 switch (res)
1543 {
1544 case MUIV_DragReport_Abort:
1545 UndrawDragNDrop(data->wd_dnd);
1546 DoMethod(data->wd_DropObject, MUIM_DragFinish,
1547 (IPTR) data->wd_DragObject);
1548 data->wd_DropObject = NULL;
1549 i = 1;
1550 break;
1551
1552 case MUIV_DragReport_Continue:
1553 break;
1554 case MUIV_DragReport_Lock:
1555 break; /* NYI */
1556 case MUIV_DragReport_Refresh:
1557 UndrawDragNDrop(data->wd_dnd);
1558 update = 1;
1559 break;
1560 }
1561 }
1562 }
1563 DrawDragNDrop(data->wd_dnd, imsg->MouseX + iWin->LeftEdge,
1564 imsg->MouseY + iWin->TopEdge);
1565 }
1566
1567 if (imsg->Class == IDCMP_MOUSEBUTTONS)
1568 {
1569 if ((imsg->Code == MENUDOWN) || (imsg->Code == SELECTUP))
1570 {
1571 UndrawDragNDrop(data->wd_dnd);
1572 if (imsg->Code == SELECTUP && data->wd_DropObject)
1573 {
1574 DoMethod(data->wd_DropObject, MUIM_DragDrop,
1575 (IPTR) data->wd_DragObject,
1576 imsg->MouseX + iWin->LeftEdge -
1577 data->wd_DropWindow->LeftEdge,
1578 imsg->MouseY + iWin->TopEdge -
1579 data->wd_DropWindow->TopEdge);
1580 DoMethod(data->wd_DropObject, MUIM_DragFinish,
1581 (IPTR) data->wd_DragObject);
1582 data->wd_DropObject = NULL;
1583 }
1584 else if (imsg->Code == SELECTUP)
1585 {
1586 DoMethod(data->wd_DragObject, MUIM_UnknownDropDestination,
1587 imsg);
1588 }
1589 finish_drag = TRUE;
1590 }
1591 }
1592
1593 if (imsg->Class == IDCMP_CLOSEWINDOW)
1594 finish_drag = TRUE;
1595
1596 if (finish_drag)
1597 {
1598 if (data->wd_DropObject)
1599 {
1600 UndrawDragNDrop(data->wd_dnd);
1601 DoMethod(data->wd_DropObject, MUIM_DragFinish,
1602 (IPTR) data->wd_DragObject);
1603 data->wd_DropObject = NULL;
1604 }
1605 DeleteDragNDrop(data->wd_dnd);
1606 DoMethod(data->wd_DragObject, MUIM_DeleteDragImage,
1607 (IPTR) data->wd_DragImage);
1608 muiAreaData(data->wd_DragObject)->mad_Flags &= ~MADF_DRAGGING;
1609 data->wd_DragImage = NULL;
1610 data->wd_DragObject = NULL;
1611 data->wd_DropWindow = NULL;
1612 data->wd_dnd = NULL;
1613
1614 /* stop listening to IDCMP_MOUSEMOVE */
1615 ChangeEvents(data, GetDefaultEvents());
1616 }
1617 if (!finish_drag)
1618 ReplyMsg((struct Message *)imsg);
1619
1620 return finish_drag;
1621 }
1622
1623 /* Reply to imsg if handled */
1624 BOOL HandleWindowEvent(Object *oWin, struct MUI_WindowData *data,
1625 struct IntuiMessage *imsg)
1626 {
1627 struct Window *iWin;
1628 BOOL is_handled = TRUE;
1629 BOOL replied = FALSE;
1630
1631 iWin = imsg->IDCMPWindow;
1632 switch (imsg->Class)
1633 {
1634 case IDCMP_ACTIVEWINDOW:
1635 data->wd_Flags |= MUIWF_ACTIVE;
1636 if (data->wd_OldActive)
1637 set(oWin, MUIA_Window_ActiveObject, data->wd_OldActive);
1638 set(oWin, MUIA_Window_Activate, TRUE);
1639 is_handled = FALSE; /* forwardable to area event handlers */
1640 break;
1641
1642 case IDCMP_INACTIVEWINDOW:
1643 KillHelpBubble(data, oWin, TRUE);
1644 if (data->wd_ActiveObject)
1645 {
1646 data->wd_OldActive = data->wd_ActiveObject;
1647 set(oWin, MUIA_Window_ActiveObject,
1648 MUIV_Window_ActiveObject_None);
1649 }
1650 data->wd_Flags &= ~MUIWF_ACTIVE;
1651 set(oWin, MUIA_Window_Activate, FALSE);
1652 is_handled = FALSE; /* forwardable to area event handlers */
1653 break;
1654
1655 case IDCMP_NEWSIZE:
1656 case IDCMP_CHANGEWINDOW:
1657 {
1658 int hborders = iWin->BorderLeft + iWin->BorderRight;
1659 int vborders = iWin->BorderTop + iWin->BorderBottom;
1660
1661 /* set window limits according to window contents */
1662 WindowLimits
1663 (iWin,
1664 data->wd_MinMax.MinWidth + hborders,
1665 data->wd_MinMax.MinHeight + vborders,
1666 data->wd_MinMax.MaxWidth + hborders,
1667 data->wd_MinMax.MaxHeight + vborders);
1668 }
1669
1670 if ((iWin->GZZWidth != data->wd_Width)
1671 || (iWin->GZZHeight != data->wd_Height))
1672 {
1673 data->wd_Width = iWin->GZZWidth;
1674 data->wd_Height = iWin->GZZHeight;
1675 DoHideMethod(data->wd_RootObject);
1676
1677 data->wd_Flags |= MUIWF_RESIZING;
1678 RefreshWindow(oWin, data);
1679 }
1680 is_handled = FALSE; /* forwardable to area event handlers */
1681 break;
1682
1683 case IDCMP_REFRESHWINDOW:
1684 ReplyMsg((struct Message *)imsg);
1685 replied = TRUE;
1686 RefreshWindow(oWin, data);
1687 break;
1688
1689 case IDCMP_CLOSEWINDOW:
1690 ReplyMsg((struct Message *)imsg);
1691 replied = TRUE;
1692 set(oWin, MUIA_Window_CloseRequest, TRUE);
1693 break;
1694
1695 case IDCMP_MENUPICK:
1696 ReplyMsg((struct Message *)imsg);
1697 replied = TRUE;
1698
1699 if (data->wd_Menu)
1700 {
1701 if (MENUNUM(imsg->Code) != NOMENU
1702 && ITEMNUM(imsg->Code) != NOITEM)
1703 {
1704 struct MenuItem *item =
1705 ItemAddress(data->wd_Menu, imsg->Code);
1706 if (item)
1707 {
1708 Object *item_obj = (Object *) GTMENUITEM_USERDATA(item);
1709 if (item_obj)
1710 {
1711 Object *app = NULL;
1712 IPTR udata = 0;
1713
1714 if (item->Flags & CHECKIT)
1715 set(item_obj, MUIA_Menuitem_Checked,
1716 ! !(item->Flags & CHECKED));
1717
1718 set(item_obj, MUIA_Menuitem_Trigger, (IPTR) item);
1719
1720 get(oWin, MUIA_ApplicationObject, &app);
1721 get(item_obj, MUIA_UserData, &udata);
1722
1723 set(app, MUIA_Application_MenuAction, udata);
1724 set(oWin, MUIA_Window_MenuAction, udata);
1725 DoMethod(app, MUIM_Application_ReturnID, udata);
1726 }
1727 }
1728 }
1729 }
1730 break;
1731
1732 case IDCMP_IDCMPUPDATE:
1733 is_handled = FALSE; /* forwardable to area event handlers */
1734 if (data->wd_VertProp || data->wd_HorizProp)
1735 {
1736 struct TagItem *tag;
1737 tag = FindTagItem(GA_ID, (struct TagItem *)imsg->IAddress);
1738 if (tag)
1739 {
1740 /* If there's a propclass object connected to the prop
1741 gadget, the prop gadget's userdata will point to
1742 that propclass object. See classes/prop.c */
1743
1744 if (data->wd_VertProp)
1745 {
1746 if (tag->ti_Data == GADGETID(data->wd_VertProp))
1747 ;
1748
1749 if (tag->ti_Data == GADGETID(data->wd_UpButton))
1750 {
1751 Object *prop =
1752 (Object *) ((struct Gadget *)data->
1753 wd_VertProp)->UserData;
1754 is_handled = TRUE;
1755 if (prop)
1756 DoMethod(prop, MUIM_Prop_Decrease, 1);
1757 }
1758
1759 if (tag->ti_Data == GADGETID(data->wd_DownButton))
1760 {
1761 Object *prop =
1762 (Object *) ((struct Gadget *)data->
1763 wd_VertProp)->UserData;
1764 is_handled = TRUE;
1765 if (prop)
1766 DoMethod(prop, MUIM_Prop_Increase, 1);
1767 }
1768
1769 }
1770
1771 if (data->wd_HorizProp)
1772 {
1773 if (tag->ti_Data == GADGETID(data->wd_HorizProp))
1774 ;
1775
1776 if (tag->ti_Data == GADGETID(data->wd_LeftButton))
1777 {
1778 Object *prop =
1779 (Object *) ((struct Gadget *)data->
1780 wd_HorizProp)->UserData;
1781 is_handled = TRUE;
1782 if (prop)
1783 DoMethod(prop, MUIM_Prop_Decrease, 1);
1784 }
1785
1786 if (tag->ti_Data == GADGETID(data->wd_RightButton))
1787 {
1788 Object *prop =
1789 (Object *) ((struct Gadget *)data->
1790 wd_HorizProp)->UserData;
1791 is_handled = TRUE;
1792 if (prop)
1793 DoMethod(prop, MUIM_Prop_Increase, 1);
1794 }
1795
1796 }
1797 }
1798 }
1799 break;
1800
1801 case IDCMP_INTUITICKS:
1802 if (data->wd_HelpTicker)
1803 {
1804 data->wd_HelpTicker--;
1805
1806 if (data->wd_HelpTicker == 0)
1807 {
1808 Object *underobj =
1809 ObjectUnderPointer(data, data->wd_RootObject,
1810 imsg->MouseX, imsg->MouseY,
1811 ShortHelpUnderPointerCheck);
1812
1813 if (underobj != data->wd_HelpObject)
1814 {
1815 if (data->wd_HelpObject)
1816 {
1817 DoMethod(data->wd_HelpObject, MUIM_DeleteBubble,
1818 (IPTR) data->wd_HelpBubble);
1819
1820 data->wd_HelpObject = NULL;
1821 data->wd_HelpBubble = NULL;
1822 }
1823
1824 if (underobj)
1825 {
1826 data->wd_HelpBubble =
1827 (APTR) DoMethod(underobj, MUIM_CreateBubble,
1828 imsg->MouseX, imsg->MouseY, 0, 0);
1829 if (data->wd_HelpBubble)
1830 {
1831 data->wd_HelpObject = underobj;
1832 data->wd_Flags |= MUIWF_BUBBLEMODE;
1833 }
1834 }
1835 }
1836
1837 if (data->wd_Flags & MUIWF_BUBBLEMODE)
1838 {
1839 data->wd_HelpTicker = BUBBLEHELP_TICKER_LATER;
1840 }
1841 else
1842 {
1843 data->wd_HelpTicker = BUBBLEHELP_TICKER_FIRST;
1844 }
1845 }
1846 }
1847
1848 is_handled = FALSE; /* forwardable to area event handlers */
1849 break;
1850
1851 case IDCMP_MOUSEBUTTONS:
1852 DoMethod(oWin, MUIM_Window_Snapshot, 0);
1853 KillHelpBubble(data, oWin, TRUE);
1854 is_handled = FALSE;
1855 break;
1856
1857
1858 case IDCMP_MOUSEMOVE:
1859 KillHelpBubble(data, oWin, FALSE);
1860 is_handled = FALSE;
1861 break;
1862
1863 default:
1864 is_handled = FALSE;
1865 break;
1866 }
1867
1868 if (is_handled && !replied)
1869 ReplyMsg((struct Message *)imsg);
1870
1871 return is_handled;
1872 }
1873
1874 static ULONG InvokeEventHandler(struct MUI_EventHandlerNode *ehn,
1875 struct IntuiMessage *event, ULONG muikey)
1876 {
1877 ULONG res;
1878
1879 if (!(_flags(ehn->ehn_Object) & MADF_CANDRAW))
1880 return 0;
1881 if (!(_flags(ehn->ehn_Object) & MADF_SHOWME))
1882 return 0;
1883
1884 if (event != NULL
1885 && event->Class == IDCMP_MOUSEBUTTONS
1886 && event->Code == SELECTDOWN
1887 && (_flags(ehn->ehn_Object) & MADF_INVIRTUALGROUP))
1888 {
1889 /*
1890 Here we filter out SELECTDOWN messages if objects is in a virtual
1891 group but the click went out of the virtual group
1892 */
1893 Object *obj = ehn->ehn_Object;
1894 Object *parent = obj;
1895 Object *wnd = _win(obj);
1896
1897 while (get(parent, MUIA_Parent, &parent))
1898 {
1899 if (!parent)
1900 break;
1901 if (wnd == parent)
1902 break;
1903 if (_flags(parent) & MADF_ISVIRTUALGROUP)
1904 {
1905 if (event->MouseX < _mleft(parent)
1906 || event->MouseX > _mright(parent)
1907 || event->MouseY < _mtop(parent)
1908 || event->MouseY > _mbottom(parent))
1909 {
1910 return 0;
1911 }
1912 }
1913 }
1914
1915 }
1916
1917 if (ehn->ehn_Flags & MUI_EHF_HANDLEINPUT)
1918 {
1919 DoMethod(ehn->ehn_Object, MUIM_HandleInput, (IPTR) event, muikey);
1920 res = 0;
1921 }
1922 else
1923 {
1924 if (ehn->ehn_Class)
1925 res = CoerceMethod
1926 (ehn->ehn_Class, ehn->ehn_Object, MUIM_HandleEvent,
1927 (IPTR) event, muikey);
1928 else
1929 res =
1930 DoMethod(ehn->ehn_Object, MUIM_HandleEvent, (IPTR) event,
1931 muikey);
1932 }
1933
1934 return res;
1935 }
1936
1937 static void HandleRawkey(Object *win, struct MUI_WindowData *data,
1938 struct IntuiMessage *event)
1939 {
1940 struct MinNode *mn;
1941 struct MUI_EventHandlerNode *ehn;
1942 struct IntuiMessage imsg_copy;
1943 struct InputEvent ie = { 0 };
1944 ULONG res;
1945 LONG muikey = MUIKEY_NONE;
1946 Object *active_object = NULL;
1947 IPTR disabled = 0;
1948 ULONG key;
1949 ULONG deadkey;
1950
1951 KillHelpBubble(data, win, BUBBLEHELP_TICKER_FIRST);
1952
1953 ie.ie_NextEvent = NULL;
1954 ie.ie_Class = IECLASS_RAWKEY;
1955 ie.ie_SubClass = 0;
1956 ie.ie_Code = event->Code;
1957 ie.ie_Qualifier = event->Qualifier;
1958 ie.ie_EventAddress = (APTR) * (IPTR *) event->IAddress;
1959 #ifdef __AMIGAOS4__
1960 ie.ie_TimeStamp.Seconds = event->Seconds;
1961 ie.ie_TimeStamp.Microseconds = event->Micros;
1962 #else
1963 ie.ie_TimeStamp.tv_secs = event->Seconds;
1964 ie.ie_TimeStamp.tv_micro = event->Micros;
1965 #endif
1966
1967 set(win, MUIA_Window_InputEvent, (IPTR) & ie);
1968
1969 /* get the vanilla key for control char */
1970 {
1971 UWORD msg_code;
1972
1973 /* Remove the up prefix as convert key does not convert upkey event */
1974 msg_code = event->Code;
1975 event->Code &= ~IECODE_UP_PREFIX;
1976 key = ConvertKey(event);
1977 event->Code = msg_code;
1978 }
1979
1980 imsg_copy = *event;
1981 deadkey = *(ULONG *) event->IAddress;
1982 imsg_copy.IAddress = &deadkey;
1983 ReplyMsg((struct Message *)event);
1984 event = &imsg_copy;
1985
1986 //bug("rawkey: code=%lx, qual=%lx\n", event->Code, event->Qualifier);
1987
1988 /* check if imsg translates to predefined keystroke */
1989 {
1990 struct InputEvent ievent;
1991 BOOL matched = FALSE;
1992
1993 ievent.ie_NextEvent = NULL;
1994 ievent.ie_Class = IECLASS_RAWKEY;
1995 ievent.ie_SubClass = 0;
1996 ievent.ie_Code = event->Code;
1997 ievent.ie_Qualifier = event->Qualifier;
1998 /* ie_EventAddress is not used by MatchIX. If needed, it should be
1999 * ensured that it is still a valid address because of the shallow
2000 * IntuiMessage copy currently done in _zune_window_message before
2001 * message is replied.
2002 */
2003 ievent.ie_EventAddress = NULL;
2004 //ievent.ie_EventAddress = (APTR *) *((ULONG *)(event->IAddress));
2005
2006 for (muikey = MUIKEY_COUNT - 1; muikey >= MUIKEY_PRESS; muikey--)
2007 {
2008 if (muiGlobalInfo(win)->mgi_Prefs->muikeys[muikey].ix_well != 0
2009 && MatchIX(&ievent,
2010 &muiGlobalInfo(win)->mgi_Prefs->muikeys[muikey].ix))
2011 {
2012 matched = TRUE;
2013 break;
2014 }
2015 }
2016
2017 if (matched)
2018 {
2019 if (muikey == MUIKEY_PRESS && (event->Code & IECODE_UP_PREFIX))
2020 muikey = MUIKEY_RELEASE;
2021 }
2022 else
2023 {
2024 muikey = MUIKEY_NONE;
2025 }
2026 } /* check if imsg translate to predefined keystroke */
2027
2028 if ((muikey != MUIKEY_NONE) && !(data->wd_DisabledKeys & (1 << muikey)))
2029 {
2030 D(bug("HandleRawkey: try MUIKEY %ld on window %0x08lx\n", muikey,
2031 win));
2032 switch (muikey)
2033 {
2034 case MUIKEY_PRESS:
2035 break;
2036 case MUIKEY_TOGGLE:
2037 break;
2038 case MUIKEY_UP:
2039 break;
2040 case MUIKEY_DOWN:
2041 break;
2042 case MUIKEY_PAGEUP:
2043 break;
2044 case MUIKEY_PAGEDOWN:
2045 break;
2046 case MUIKEY_TOP:
2047 break;
2048 case MUIKEY_BOTTOM:
2049 break;
2050 case MUIKEY_LEFT:
2051 break;
2052 case MUIKEY_RIGHT:
2053 break;
2054 case MUIKEY_WORDLEFT:
2055 break;
2056 case MUIKEY_WORDRIGHT:
2057 break;
2058 case MUIKEY_LINESTART:
2059 break;
2060 case MUIKEY_LINEEND:
2061 break;
2062 case MUIKEY_GADGET_NEXT:
2063 set(win, MUIA_Window_ActiveObject,
2064 MUIV_Window_ActiveObject_Next);
2065 break;
2066 case MUIKEY_GADGET_PREV:
2067 set(win, MUIA_Window_ActiveObject,
2068 MUIV_Window_ActiveObject_Prev);
2069 break;
2070 case MUIKEY_GADGET_OFF:
2071 set(win, MUIA_Window_ActiveObject,
2072 MUIV_Window_ActiveObject_None);
2073 break;
2074 case MUIKEY_WINDOW_CLOSE:
2075 set(win, MUIA_Window_CloseRequest, TRUE);
2076 break;
2077 case MUIKEY_WINDOW_NEXT:
2078 break;
2079 case MUIKEY_WINDOW_PREV:
2080 break;
2081 case MUIKEY_HELP:
2082 break;
2083 case MUIKEY_POPUP:
2084 break;
2085 default:
2086 break;
2087 }
2088 }
2089
2090 active_object = NULL;
2091 if ((data->wd_ActiveObject != NULL)
2092 && (DoMethod(data->wd_RootObject, MUIM_FindAreaObject,
2093 (IPTR) data->wd_ActiveObject) != (IPTR) NULL))
2094 {
2095 active_object = data->wd_ActiveObject;
2096 get(active_object, MUIA_Disabled, &disabled);
2097 }
2098 else
2099 data->wd_ActiveObject = NULL;
2100
2101 /* try ActiveObject */
2102 if ((active_object != NULL) && !disabled)
2103 {
2104 #if 0
2105 /* sba:
2106 ** Which method should be used for muikeys? MUIM_HandleInput or
2107 ** MUIM_HandleEvent. Also note that there is a flag MUI_EHF_ALWAYSKEYS
2108 ** which probably means that all keys events are requested??
2109 ** For now MUIM_HandleEvent is used as this is currently implemented
2110 ** in Area class ;) although I guess it should be MUIM_HandleInput as
2111 ** this was earlier
2112 */
2113
2114 if (muikey != MUIKEY_NONE)
2115 {
2116 res =
2117 DoMethod(active_object, MUIM_HandleEvent, (IPTR) event,
2118 muikey);
2119 if (res & MUI_EventHandlerRC_Eat)
2120 return;
2121 }
2122 #endif
2123 D(bug("HandleRawkey: try active object (%08lx) handlers\n",
2124 active_object));
2125
2126 for (mn = data->wd_EHList.mlh_Head; mn->mln_Succ; mn = mn->mln_Succ)
2127 {
2128 ehn = (struct MUI_EventHandlerNode *)mn;
2129
2130 if ((ehn->ehn_Object == active_object)
2131 && ((ehn->ehn_Events & IDCMP_RAWKEY)
2132 || (ehn->ehn_Flags & MUI_EHF_ALWAYSKEYS)))
2133 {
2134 D(bug("HandleRawkey: (active) invoking on %p (ehn=%p) "
2135 "event=%p muikey=%p\n",
2136 ehn->ehn_Object, ehn, event, muikey));
2137 res = InvokeEventHandler(ehn, event, muikey);
2138 D(bug("HandleRawkey: (active) got res=%d\n", res));
2139 if (res & MUI_EventHandlerRC_Eat)
2140 return;
2141
2142 /* Leave the loop if a different object has been activated */
2143 if (active_object != data->wd_ActiveObject)
2144 break;
2145 }
2146 }
2147
2148 // event not eaten by active object, try its parents
2149 // this is to implement popup key in Popstring
2150 if (active_object == data->wd_ActiveObject)
2151 {
2152 Object *current_obj = active_object;
2153
2154 D(bug("HandleRawkey: try active object parents handlers\n"));
2155 while (current_obj != NULL)
2156 {
2157 for (mn = data->wd_EHList.mlh_Head; mn->mln_Succ;
2158 mn = mn->mln_Succ)
2159 {
2160 ehn = (struct MUI_EventHandlerNode *)mn;
2161
2162 if ((ehn->ehn_Object == current_obj)
2163 && ((ehn->ehn_Events & IDCMP_RAWKEY)
2164 || (ehn->ehn_Flags & MUI_EHF_ALWAYSKEYS)))
2165 {
2166 //D(bug("HandleRawkey: (active parents) invoking on "
2167 // "%p (ehn=%p) event=%p muikey=%p\n",
2168 // ehn->ehn_Object, ehn, event, muikey));
2169 res = InvokeEventHandler(ehn, event, muikey);
2170 //D(bug("HandleRawkey: (active parents) got res=%d\n",
2171 // res));
2172 if (res & MUI_EventHandlerRC_Eat)
2173 return;
2174
2175 /* Leave the loop if a different object has been
2176 * activated */
2177 if (active_object != data->wd_ActiveObject)
2178 break;
2179 }
2180 }
2181 current_obj = (Object *) XGET(current_obj, MUIA_Parent);
2182 }
2183 }
2184 }
2185
2186 D(bug("HandleRawkey: try default object handlers\n"));
2187
2188 /* try DefaultObject */
2189 if (data->wd_DefaultObject != NULL)
2190 get(data->wd_DefaultObject, MUIA_Disabled, &disabled);
2191
2192 if ((data->wd_DefaultObject != NULL) && !disabled
2193 && (active_object != data->wd_DefaultObject))
2194 {
2195 /* No, we only should do this if the object actually has requested
2196 * this via RequestIDCMP()! */
2197 // if (muikey != MUIKEY_NONE
2198 // && (_flags(data->wd_DefaultObject) & MADF_CANDRAW))
2199 // {
2200 // DoMethod(data->wd_DefaultObject, MUIM_HandleInput, event, muikey);
2201 // return;
2202 // }
2203
2204 for (mn = data->wd_EHList.mlh_Head; mn->mln_Succ; mn = mn->mln_Succ)
2205 {
2206 ehn = (struct MUI_EventHandlerNode *)mn;
2207
2208 if ((ehn->ehn_Object == data->wd_DefaultObject)
2209 && ((ehn->ehn_Events & IDCMP_RAWKEY)
2210 || (ehn->ehn_Flags & MUI_EHF_ALWAYSKEYS)))
2211 {
2212 //D(bug("HandleRawkey: (default) invoking on %p (ehn=%p) "
2213 //"event=%p muikey=%p\n",
2214 //ehn->ehn_Object, ehn, event, muikey));
2215 res = InvokeEventHandler(ehn, event, muikey);
2216 //D(bug("HandleRawkey: (default) got res=%d\n", res));
2217 if (res & MUI_EventHandlerRC_Eat)
2218 return;
2219 }
2220 }
2221
2222 }
2223
2224 D(bug("HandleRawkey: try other handlers\n"));
2225
2226 // try other handlers
2227 for (mn = data->wd_EHList.mlh_Head; mn->mln_Succ; mn = mn->mln_Succ)
2228 {
2229 ehn = (struct MUI_EventHandlerNode *)mn;
2230
2231 // skip Active and Default object as they have already been
2232 // handled
2233 if (ehn->ehn_Object == data->wd_ActiveObject
2234 || ehn->ehn_Object == data->wd_DefaultObject)
2235 continue;
2236
2237 if (ehn->ehn_Events & IDCMP_RAWKEY)
2238 {
2239 //D(bug("HandleRawkey: (others) invoking on %p (ehn=%p) "
2240 //"event=%p muikey=%p\n",
2241 //ehn->ehn_Object, ehn, event, muikey));
2242 res = InvokeEventHandler(ehn, event, MUIKEY_NONE);
2243 //D(bug("HandleRawkey: (others) got res=%d\n", res));
2244 if (res & MUI_EventHandlerRC_Eat)
2245 return;
2246 }
2247 }
2248
2249 D(bug("HandleRawkey: try control chars handlers\n"));
2250
2251 /* try Control Chars */
2252 //bug("ctrlchar, key='%c' code=0x%08lx\n", key, event->Code);
2253 if (key)
2254 {
2255 for (mn = data->wd_CCList.mlh_Head; mn->mln_Succ; mn = mn->mln_Succ)
2256 {
2257 ehn = (struct MUI_EventHandlerNode *)mn;
2258
2259 if (ehn->ehn_Events == key)
2260 {
2261 IPTR disabled = 0;
2262 LONG muikey2 = ehn->ehn_Flags;
2263
2264 get(ehn->ehn_Object, MUIA_Disabled, &disabled);
2265 if (disabled)
2266 continue;
2267
2268 //bug("control char\n");
2269 if (event->Code & IECODE_UP_PREFIX)
2270 {
2271 /* simulate a release */
2272 if (muikey2 == MUIKEY_PRESS)
2273 muikey2 = MUIKEY_RELEASE;
2274 else
2275 return;
2276 }
2277
2278 if ((muikey2 != MUIKEY_NONE)
2279 && (_flags(ehn->ehn_Object) & MADF_CANDRAW)
2280 && (_flags(ehn->ehn_Object) & MADF_SHOWME))
2281 {
2282 res = CoerceMethod
2283 (ehn->ehn_Class, ehn->ehn_Object, MUIM_HandleEvent,
2284 (IPTR) NULL, muikey2);
2285 if (res & MUI_EventHandlerRC_Eat)
2286 return;
2287 }
2288 }
2289 }
2290 }
2291 }
2292
2293 /* forward non-keystroke events to event handlers */
2294 static void HandleInputEvent(Object *win, struct MUI_WindowData *data,
2295 struct IntuiMessage *event)
2296 {
2297 struct MinNode *mn;
2298 struct MUI_EventHandlerNode *ehn;
2299 struct IntuiMessage imsg_copy;
2300 ULONG res;
2301 ULONG mask = event->Class;
2302
2303 if (mask != IDCMP_IDCMPUPDATE)
2304 {
2305 imsg_copy = *event;
2306 imsg_copy.IAddress = NULL; /* be sure to trap access to that */
2307 ReplyMsg((struct Message *)event);
2308 event = &imsg_copy;
2309 }
2310
2311 if (mask == IDCMP_MOUSEMOVE)
2312 {
2313 struct Window *iWin;
2314 iWin = event->IDCMPWindow;
2315
2316 if (ContextMenuUnderPointer(data, data->wd_RootObject,
2317 event->MouseX, event->MouseY))
2318 {
2319 iWin->Flags |= WFLG_RMBTRAP;
2320 }
2321 else if (!data->wd_NoMenus)
2322 {
2323 iWin->Flags &= ~WFLG_RMBTRAP;
2324 }
2325 }
2326
2327 for (mn = data->wd_EHList.mlh_Head; mn->mln_Succ; mn = mn->mln_Succ)
2328 {
2329 ehn = (struct MUI_EventHandlerNode *)mn;
2330
2331 if (ehn->ehn_Events & mask)
2332 {
2333 IPTR disabled = 0;
2334
2335 get(ehn->ehn_Object, MUIA_Disabled, &disabled);
2336 if (disabled)
2337 continue;
2338
2339 res = InvokeEventHandler(ehn, event, MUIKEY_NONE);
2340 if (res & MUI_EventHandlerRC_Eat)
2341 return;
2342
2343 }
2344 }
2345
2346 if (mask == IDCMP_IDCMPUPDATE)
2347 ReplyMsg((struct Message *)event);
2348 }
2349
2350
2351 /* process window message; this does a ReplyMsg() to the message */
2352 /* Called from application.c */
2353 void _zune_window_message(struct IntuiMessage *imsg)
2354 {
2355 struct Window *iWin;
2356 Object *oWin;
2357 struct MUI_WindowData *data;
2358 BOOL handled;
2359
2360 iWin = imsg->IDCMPWindow;
2361 oWin = (Object *) iWin->UserData;
2362 data = muiWindowData(oWin);
2363
2364 if (data->wd_DragObject)
2365 {
2366 if (!HandleDragging(oWin, data, imsg))
2367 return;
2368 }
2369
2370 handled = HandleWindowEvent(oWin, data, imsg);
2371 if (!handled)
2372 {
2373 if (IDCMP_RAWKEY == imsg->Class)
2374 HandleRawkey(oWin, data, imsg);
2375 else if (IDCMP_GADGETUP == imsg->Class)
2376 {
2377 #ifdef __AROS__
2378 if (ETI_MUI == ((struct Gadget *)imsg->IAddress)->GadgetID)
2379 {
2380 DoMethod(_app(oWin), MUIM_Application_OpenConfigWindow);
2381 }
2382 #endif
2383 if (ETI_Iconify == ((struct Gadget *)imsg->IAddress)->GadgetID)
2384 {
2385 set(_app(oWin), MUIA_Application_Iconified, TRUE);
2386 }
2387 }
2388 else
2389 {
2390 HandleInputEvent(oWin, data, imsg);
2391 }
2392 }
2393 }
2394
2395 /**************************************************************************/
2396 /**************************************************************************/
2397
2398 /* code for setting MUIA_Window_RootObject */
2399 static void ChangeRootObject(struct MUI_WindowData *data, Object *obj,
2400 Object *newRoot)
2401 {
2402 Object *oldRoot;
2403
2404 ASSERT_VALID_PTR(data);
2405 ASSERT_VALID_PTR(obj);
2406
2407 oldRoot = data->wd_RootObject;
2408 if (!(data->wd_Flags & MUIWF_OPENED))
2409 {
2410 if (oldRoot)
2411 {
2412 if (data->wd_ActiveObject == oldRoot)
2413 set(obj, MUIA_Window_ActiveObject,
2414 MUIV_Window_ActiveObject_None);
2415 DoMethod(oldRoot, MUIM_DisconnectParent);
2416 }
2417
2418 data->wd_RootObject = newRoot;
2419 if (newRoot)
2420 {
2421 /* if window is in App tree, inform child */
2422 if (muiNotifyData(obj)->mnd_GlobalInfo)
2423 DoMethod(newRoot, MUIM_ConnectParent, (IPTR) obj);
2424 }
2425 }
2426 }
2427
2428 // find the ObjNode containing a pointer to the given object
2429 // currently only used for cycle chain objects
2430 static struct ObjNode *FindObjNode(struct MinList *list, Object *obj)
2431 {
2432 struct ObjNode *node;
2433
2434 ASSERT_VALID_PTR(list);
2435
2436 if (!obj)
2437 return NULL;
2438
2439 ASSERT_VALID_PTR(obj);
2440
2441 for (node = (struct ObjNode *)list->mlh_Head;
2442 node->node.mln_Succ; node = (struct ObjNode *)node->node.mln_Succ)
2443 {
2444 if (node->obj == obj)
2445 {
2446 return node;
2447 }
2448 }
2449 return NULL;
2450 }
2451
2452 static Object *GetFirstActiveObject(struct MUI_WindowData *data)
2453 {
2454 ASSERT_VALID_PTR(data);
2455
2456 if (!IsListEmpty((struct List *)&data->wd_CycleChain))
2457 return ((struct ObjNode *)data->wd_CycleChain.mlh_Head)->obj;
2458 else
2459 return NULL;
2460 }
2461
2462 static Object *GetLastActiveObject(struct MUI_WindowData *data)
2463 {
2464 ASSERT_VALID_PTR(data);
2465
2466 if (!IsListEmpty((struct List *)&data->wd_CycleChain))
2467 return ((struct ObjNode *)data->wd_CycleChain.mlh_TailPred)->obj;
2468 else
2469 return NULL;
2470 }
2471
2472 typedef struct ObjNode *objnode_iterator_t(struct ObjNode *curr_node);
2473
2474 static objnode_iterator_t NextObjNodeIterator;
2475 static objnode_iterator_t PrevObjNodeIterator;
2476
2477 static struct ObjNode *NextObjNodeIterator(struct ObjNode *curr_node)
2478 {
2479 if (curr_node->node.mln_Succ->mln_Succ)
2480 return (struct ObjNode *)curr_node->node.mln_Succ;
2481 else
2482 return NULL;
2483 }
2484
2485 static struct ObjNode *PrevObjNodeIterator(struct ObjNode *curr_node)
2486 {
2487 if (curr_node->node.mln_Pred->mln_Pred)
2488 return (struct ObjNode *)curr_node->node.mln_Pred;
2489 else
2490 return NULL;
2491 }
2492
2493 static Object *GetPrevNextActiveObject(struct ObjNode *old_activenode,
2494 objnode_iterator_t node_iterator)
2495 {
2496 struct ObjNode *curr_node;
2497 struct ObjNode *node;
2498 Object *obj;
2499
2500 ASSERT_VALID_PTR(old_activenode);
2501
2502 curr_node = old_activenode;
2503 node = NULL;
2504 obj = NULL;
2505
2506 while (curr_node)
2507 {
2508 node = node_iterator(curr_node);
2509
2510 if (node)
2511 obj = node->obj;
2512
2513 /* let's see if this object meets cycle requirements
2514 * (enabled & visible) */
2515 if (obj)
2516 {
2517 IPTR is_disabled = 0;
2518
2519 get(obj, MUIA_Disabled, &is_disabled);
2520
2521 if (!is_disabled && (_flags(obj) & MADF_SHOWME))
2522 {
2523 return obj;
2524 }
2525 }
2526
2527 curr_node = node;
2528 obj = NULL;
2529 node = NULL;
2530 }
2531 return obj;
2532 }
2533
2534
2535 /**************************************************************************
2536 Code for setting MUIA_Window_ActiveObject
2537 Basically, it will:
2538 - remove focus drawing for current active object
2539 - find (if needed) the new active object
2540 - set data->wd_ActiveObject to the new object
2541 - draw focus around the new active object
2542 **************************************************************************/
2543 static void SetActiveObject(struct MUI_WindowData *data, Object *obj,
2544 IPTR newval)
2545 {
2546 struct ObjNode *old_activenode = NULL;
2547
2548 ASSERT_VALID_PTR(data);
2549 ASSERT_VALID_PTR(obj);
2550
2551 D(bug("MUIC_Window:SetActiveObject(data, obj, %08lx) Active=%p\n",
2552 newval, data->wd_ActiveObject));
2553
2554 if ((data->wd_ActiveObject != NULL)
2555 && (DoMethod(data->wd_RootObject, MUIM_FindAreaObject,
2556 (IPTR) data->wd_ActiveObject) != (IPTR) NULL))
2557 {
2558 if ((IPTR) data->wd_ActiveObject != newval)
2559 {
2560 old_activenode =
2561 FindObjNode(&data->wd_CycleChain, data->wd_ActiveObject);
2562 if ((data->wd_Flags & MUIWF_OBJECTGOACTIVESENT)
2563 && (_flags(data->wd_ActiveObject) & MADF_SETUP))
2564 {
2565 D(bug("Deactivate=%p\n", data->wd_ActiveObject));
2566 DoMethod(data->wd_ActiveObject, MUIM_GoInactive);
2567 }
2568 }
2569 }
2570
2571 data->wd_ActiveObject = NULL;
2572 data->wd_Flags &= ~MUIWF_OBJECTGOACTIVESENT;
2573
2574 switch (newval)
2575 {
2576 case MUIV_Window_ActiveObject_None:
2577 break;
2578
2579 case MUIV_Window_ActiveObject_Next:
2580 if (old_activenode != NULL)
2581 data->wd_ActiveObject = GetPrevNextActiveObject(old_activenode,
2582 NextObjNodeIterator);
2583 if (NULL == data->wd_ActiveObject)
2584 data->wd_ActiveObject = GetFirstActiveObject(data);
2585 break;
2586
2587 case MUIV_Window_ActiveObject_Prev:
2588 if (old_activenode)
2589 data->wd_ActiveObject = GetPrevNextActiveObject(old_activenode,
2590 PrevObjNodeIterator);
2591 if (NULL == data->wd_ActiveObject)
2592 data->wd_ActiveObject = GetLastActiveObject(data);
2593 break;
2594
2595 default:
2596 data->wd_ActiveObject = (Object *) newval;
2597 break;
2598 }
2599
2600
2601 if (data->wd_ActiveObject != NULL
2602 && DoMethod(data->wd_RootObject, MUIM_FindAreaObject,
2603 (IPTR) data->wd_ActiveObject)
2604 && (_flags(data->wd_ActiveObject) & MADF_CANDRAW))
2605 {
2606 D(bug("Activate=%p\n", data->wd_ActiveObject));
2607 DoMethod(data->wd_ActiveObject, MUIM_GoActive);
2608 data->wd_Flags |= MUIWF_OBJECTGOACTIVESENT;
2609 }
2610 }
2611
2612
2613 static BOOL InBox(struct IBox *box, WORD x, WORD y)
2614 {
2615 return x >= box->Left && x < box->Left + box->Width
2616 && y >= box->Top && y < box->Top + box->Height;
2617 }
2618
2619
2620 /*
2621 * Pass on an AppMessage to all objects that it landed on.
2622 */
2623 static void ForwardAppMessage(struct MUI_WindowData *data, Object *child,
2624 struct AppMessage *appmsg)
2625 {
2626 WORD x = appmsg->am_MouseX, y = appmsg->am_MouseY;
2627 Object *cstate;
2628 struct List *children = NULL;
2629
2630 ASSERT_VALID_PTR(data);
2631 ASSERT_VALID_PTR(child);
2632
2633 set(child, MUIA_AppMessage, appmsg);
2634
2635 children = (struct List *)XGET(child, MUIA_Group_ChildList);
2636
2637 if (children != NULL)
2638 {
2639 cstate = (Object *) children->lh_Head;
2640 while ((child = NextObject(&cstate)))
2641 {
2642 if (InBox(&muiAreaData(child)->mad_Box, x, y))
2643 {
2644 ForwardAppMessage(data, child, appmsg);
2645 }
2646 }
2647 }
2648 }
2649
2650
2651 /*
2652 * calculate real dimensions from programmer requirements.
2653 * may be overridden by user settings if MUIA_Window_ID is set.
2654 */
2655 /* MUIV_Window_Height_Screen and MUIV_Window_Height_Visible
2656 * are not handled yet, as their Width couterparts.
2657 */
2658 static void WindowSelectDimensions(struct MUI_WindowData *data)
2659 {
2660 if (!data->wd_Width)
2661 {
2662 if (data->wd_ReqWidth > 0)
2663 data->wd_Width = data->wd_ReqWidth;
2664 else if (data->wd_ReqWidth == MUIV_Window_Width_Default)
2665 data->wd_Width = data->wd_MinMax.DefWidth;
2666 else if (_between(MUIV_Window_Width_MinMax(100),
2667 data->wd_ReqWidth, MUIV_Window_Width_MinMax(0)))
2668 {
2669 data->wd_Width = data->wd_MinMax.MinWidth
2670 - data->wd_ReqWidth
2671 * (data->wd_MinMax.MaxWidth - data->wd_MinMax.MinWidth);
2672 }
2673 else if (_between(MUIV_Window_Width_Screen(100),
2674 data->wd_ReqWidth, MUIV_Window_Width_Screen(0)))
2675 {
2676 data->wd_Width = data->wd_RenderInfo.mri_ScreenWidth
2677 * (-(data->wd_ReqWidth + 200)) / 100;
2678 }
2679 else if (_between(MUIV_Window_Width_Visible(100),
2680 data->wd_ReqWidth, MUIV_Window_Width_Visible(0)))
2681 {
2682 data->wd_Width = data->wd_RenderInfo.mri_ScreenWidth
2683 * (-(data->wd_ReqWidth + 100)) / 100;
2684 }
2685
2686 if (data->wd_ReqHeight > 0)
2687 data->wd_Height = data->wd_ReqHeight;
2688 else if (data->wd_ReqHeight == MUIV_Window_Height_Default)
2689 data->wd_Height = data->wd_MinMax.DefHeight;
2690 else if (_between(MUIV_Window_Height_MinMax(100),
2691 data->wd_ReqHeight, MUIV_Window_Height_MinMax(0)))
2692 {
2693 data->wd_Height = data->wd_MinMax.MinHeight
2694 - data->wd_ReqHeight
2695 * (data->wd_MinMax.MaxHeight - data->wd_MinMax.MinHeight);
2696 }
2697 else if (_between(MUIV_Window_Height_Screen(100),
2698 data->wd_ReqHeight, MUIV_Window_Height_Screen(0)))
2699 {
2700 struct Screen *scr;
2701 int height;
2702
2703 scr = data->wd_RenderInfo.mri_Screen;
2704
2705 height =
2706 scr->Height - data->wd_RenderInfo.mri_BorderTop -
2707 data->wd_RenderInfo.mri_BorderBottom;
2708
2709 /* This is new to Zune: If TopEdge Delta is requested
2710 * the screenheight doesn't cover the barlayer */
2711 if (data->wd_Y <= MUIV_Window_TopEdge_Delta(0))
2712 height -= scr->BarHeight + 1;
2713
2714 data->wd_Height = height * (-(data->wd_ReqHeight + 200)) / 100;
2715 }
2716 else if (_between(MUIV_Window_Height_Visible(100),
2717 data->wd_ReqHeight, MUIV_Window_Height_Visible(0)))
2718 {
2719 data->wd_Height = data->wd_RenderInfo.mri_ScreenHeight
2720 * (-(data->wd_ReqHeight + 100)) / 100;
2721 }
2722
2723 /* scaled */
2724 if (data->wd_ReqWidth == MUIV_Window_Width_Scaled)
2725 data->wd_Width = data->wd_Height * data->wd_MinMax.MinWidth
2726 / data->wd_MinMax.MinHeight;
2727 else if (data->wd_ReqHeight == MUIV_Window_Width_Scaled)
2728 data->wd_Height = data->wd_Width * data->wd_MinMax.MinHeight
2729 / data->wd_MinMax.MinWidth;
2730 }
2731 data->wd_Width = CLAMP(data->wd_Width, data->wd_MinMax.MinWidth,
2732 data->wd_MinMax.MaxWidth);
2733 data->wd_Height = CLAMP(data->wd_Height, data->wd_MinMax.MinHeight,
2734 data->wd_MinMax.MaxHeight);
2735 }
2736
2737
2738 /**************************************************************************
2739 OM_NEW
2740 **************************************************************************/
2741 IPTR Window__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
2742 {
2743 struct MUI_WindowData *data;
2744 struct TagItem *tags;
2745 struct TagItem *tag;
2746
2747 obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
2748 if (!obj)
2749 return FALSE;
2750
2751 /* Initial local instance data */
2752 data = INST_DATA(cl, obj);
2753
2754 data->wd_MemoryPool = CreatePool(0, 4096, 2048);
2755 if (NULL == data->wd_MemoryPool)
2756 {
2757 CoerceMethod(cl, obj, OM_DISPOSE);
2758 return (IPTR) NULL;
2759 }
2760
2761 data->wd_RenderInfo.mri_WindowObject = obj;
2762
2763 NewList((struct List *)&(data->wd_EHList));
2764 NewList((struct List *)&(data->wd_CCList));
2765 NewList((struct List *)&(data->wd_CycleChain));
2766 NewList((struct List *)&(data->wd_IDList));
2767
2768 data->wd_CrtFlags = WFLG_SIZEGADGET | WFLG_DRAGBAR | WFLG_DEPTHGADGET
2769 | WFLG_CLOSEGADGET | WFLG_SIMPLE_REFRESH
2770 | WFLG_REPORTMOUSE | WFLG_NEWLOOKMENUS;
2771 data->wd_ZoomGadget = TRUE;
2772 data->wd_Events = GetDefaultEvents();
2773 data->wd_ActiveObject = NULL;
2774 data->wd_ID = 0;
2775 data->wd_ReqHeight = MUIV_Window_Height_Default;
2776 data->wd_ReqWidth = MUIV_Window_Width_Default;
2777 data->wd_RootObject = NULL;
2778 data->wd_DefaultObject = NULL;
2779
2780 /* alternate dimensions */
2781 /* no change in coordinates */
2782 data->wd_AltDim.Top = MUIV_Window_AltTopEdge_NoChange;
2783 data->wd_AltDim.Left = MUIV_Window_AltLeftEdge_NoChange;
2784 /* default to min size */
2785 data->wd_AltDim.Width = MUIV_Window_AltWidth_MinMax(0);
2786 data->wd_AltDim.Height = MUIV_Window_AltHeight_MinMax(0);
2787 data->wd_X = MUIV_Window_LeftEdge_Centered;
2788 data->wd_Y = MUIV_Window_TopEdge_Centered;
2789 data->wd_DisabledKeys = 0L;
2790 data->wd_HelpTicker = BUBBLEHELP_TICKER_FIRST;
2791
2792 /* parse initial taglist */
2793
2794 for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
2795 {
2796 switch (tag->ti_Tag)
2797 {
2798 case MUIA_Window_EraseArea:
2799 _handle_bool_tag(data->wd_Flags, tag->ti_Data, MUIWF_ERASEAREA);
2800 break;
2801
2802 case MUIA_Window_ToolBox:
2803 _handle_bool_tag(data->wd_Flags, tag->ti_Data, MUIWF_TOOLBOX);
2804 break;
2805
2806 case MUIA_Window_CloseGadget:
2807 _handle_bool_tag(data->wd_CrtFlags, tag->ti_Data,
2808 WFLG_CLOSEGADGET);
2809 break;
2810
2811 case MUIA_Window_SizeGadget:
2812 _handle_bool_tag(data->wd_CrtFlags, tag->ti_Data,
2813 WFLG_SIZEGADGET);
2814 break;
2815
2816 case MUIA_Window_ZoomGadget:
2817 data->wd_ZoomGadget = tag->ti_Data;
2818 break;
2819
2820 case MUIA_Window_Backdrop:
2821 _handle_bool_tag(data->wd_CrtFlags, tag->ti_Data,
2822 WFLG_BACKDROP);
2823 break;
2824
2825 case MUIA_Window_Borderless:
2826 _handle_bool_tag(data->wd_CrtFlags, tag->ti_Data,
2827 WFLG_BORDERLESS);
2828 break;
2829
2830 case MUIA_Window_DepthGadget:
2831 _handle_bool_tag(data->wd_CrtFlags, tag->ti_Data,
2832 WFLG_DEPTHGADGET);
2833 break;
2834
2835 case MUIA_Window_DragBar:
2836 _handle_bool_tag(data->wd_CrtFlags, tag->ti_Data, WFLG_DRAGBAR);
2837 break;
2838
2839 case MUIA_Window_SizeRight:
2840 _handle_bool_tag(data->wd_CrtFlags, tag->ti_Data,
2841 WFLG_SIZEBRIGHT);
2842 break;
2843
2844 case MUIA_Window_Height:
2845 data->wd_ReqHeight = (LONG) tag->ti_Data;
2846 break;
2847
2848 case MUIA_Window_Width:
2849 data->wd_ReqWidth = (LONG) tag->ti_Data;
2850 break;
2851
2852 case MUIA_Window_ID:
2853 set(obj, MUIA_Window_ID, tag->ti_Data);
2854 break;
2855
2856 case MUIA_Window_IsSubWindow:
2857 _handle_bool_tag(data->wd_Flags, tag->ti_Data,
2858 MUIWF_ISSUBWINDOW);
2859 break;
2860
2861 case MUIA_Window_Title:
2862 set(obj, MUIA_Window_Title, tag->ti_Data);
2863 break;
2864
2865 case MUIA_Window_ScreenTitle:
2866 set(obj, MUIA_Window_ScreenTitle, tag->ti_Data);
2867 break;
2868
2869 case MUIA_Window_Activate:
2870 _handle_bool_tag(data->wd_Flags, !tag->ti_Data,
2871 MUIWF_DONTACTIVATE);
2872 break;
2873
2874 case MUIA_Window_DefaultObject:
2875 set(obj, MUIA_Window_DefaultObject, tag->ti_Data);
2876 break;
2877
2878 case MUIA_Window_Menustrip:
2879 data->wd_ChildMenustrip = (Object *) tag->ti_Data;
2880 break;
2881
2882 case MUIA_Window_NoMenus:
2883 data->wd_NoMenus = (BOOL) tag->ti_Data;
2884 break;
2885
2886 case MUIA_Window_RootObject:
2887 if (!tag->ti_Data)
2888 {
2889 CoerceMethod(cl, obj, OM_DISPOSE);
2890 return 0;
2891 }
2892 set(obj, MUIA_Window_RootObject, tag->ti_Data);
2893 break;
2894
2895 case MUIA_Window_AltHeight:
2896 data->wd_AltDim.Height = (WORD) tag->ti_Data;
2897 break;
2898
2899 case MUIA_Window_AltWidth:
2900 data->wd_AltDim.Width = (WORD) tag->ti_Data;
2901 break;
2902
2903 case MUIA_Window_AltLeftEdge:
2904 data->wd_AltDim.Left = (WORD) tag->ti_Data;
2905 break;
2906
2907 case MUIA_Window_AltTopEdge:
2908 data->wd_AltDim.Top = (WORD) tag->ti_Data;
2909 break;
2910
2911 case MUIA_Window_AppWindow:
2912 _handle_bool_tag(data->wd_Flags, tag->ti_Data,
2913 MUIWF_ISAPPWINDOW);
2914 break;
2915
2916 case MUIA_Window_LeftEdge:
2917 data->wd_X = tag->ti_Data;
2918 break;
2919
2920 case MUIA_Window_TopEdge:
2921 data->wd_Y = tag->ti_Data;
2922 break;
2923
2924 case MUIA_Window_UseBottomBorderScroller:
2925 _handle_bool_tag(data->wd_Flags, tag->ti_Data,
2926 MUIWF_USEBOTTOMSCROLLER);
2927 break;
2928
2929 case MUIA_Window_UseRightBorderScroller:
2930 _handle_bool_tag(data->wd_Flags, tag->ti_Data,
2931 MUIWF_USERIGHTSCROLLER);
2932 break;
2933
2934 case MUIA_Window_DisableKeys:
2935 data->wd_DisabledKeys = tag->ti_Data;
2936 break;
2937
2938 case MUIA_Window_RefWindow:
2939 data->wd_RefWindow = (Object *) tag->ti_Data;
2940 break;
2941
2942 case MUIA_Window_Screen:
2943 data->wd_UserScreen = (struct Screen *)tag->ti_Data;
2944 break;
2945
2946 case MUIA_Window_PublicScreen:
2947 data->wd_UserPublicScreen = (STRPTR) tag->ti_Data;
2948 break;
2949 }
2950 }
2951
2952 /* D(bug("muimaster.library/window.c: Window Object created at " */
2953 /* "0x%lx back=%lx\n", */
2954 /* obj,data->wd_Background)); */
2955
2956 return (IPTR) obj;
2957 }
2958
2959 /**************************************************************************
2960 OM_DISPOSE
2961 **************************************************************************/
2962 IPTR Window__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
2963 {
2964 struct MUI_WindowData *data = INST_DATA(cl, obj);
2965
2966 /* D(bug("Window_Dispose(%p)\n", obj)); */
2967
2968 #if 0
2969 /* We no longer clear muiGlobalInfo() during disconnections, so
2970 this can cause problems (remove object which is already removed).
2971 Furthermore AFAIK it is not legal to dispose a window object
2972 which is still ocnnected to the application object, anyway. */
2973
2974 if (muiGlobalInfo(obj) && _app(obj))
2975 {
2976 /* D(bug(" Window_Dispose(%p) : calling app->OM_REMMEMBER\n", obj)); */
2977 DoMethod(_app(obj), OM_REMMEMBER, (IPTR) obj);
2978 }
2979 #endif
2980
2981 if (data->wd_RootObject)
2982 MUI_DisposeObject(data->wd_RootObject);
2983
2984 if (data->wd_ChildMenustrip)
2985 MUI_DisposeObject(data->wd_ChildMenustrip);
2986
2987 if (data->wd_Title)
2988 FreeVec(data->wd_Title);
2989
2990 if (data->wd_ScreenTitle)
2991 FreeVec(data->wd_ScreenTitle);
2992
2993 DeletePool(data->wd_MemoryPool);
2994
2995 /* D(bug(" Window_Dispose(%p) : calling supermethod\n", obj)); */
2996 return DoSuperMethodA(cl, obj, msg);
2997 }
2998
2999 static ULONG WindowOpen(struct IClass *cl, Object *obj);
3000 static ULONG WindowClose(struct IClass *cl, Object *obj);
3001
3002 /**************************************************************************
3003 OM_SET
3004 **************************************************************************/
3005 IPTR Window__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
3006 {
3007 struct MUI_WindowData *data = INST_DATA(cl, obj);
3008 struct TagItem *tags = msg->ops_AttrList;
3009 struct TagItem *tag;
3010
3011 while ((tag = NextTagItem(&tags)) != NULL)
3012 {
3013 switch (tag->ti_Tag)
3014 {
3015 case MUIA_AppMessage:
3016 ForwardAppMessage(data, data->wd_RootObject,
3017 (struct AppMessage *)tag->ti_Data);
3018 break;
3019
3020 case MUIA_Window_Activate:
3021 if (data->wd_RenderInfo.mri_Window)
3022 {
3023 if (tag->ti_Data && !(data->wd_Flags & MUIWF_ACTIVE))
3024 {
3025 ActivateWindow(data->wd_RenderInfo.mri_Window);
3026 _handle_bool_tag(data->wd_Flags, tag->ti_Data,
3027 MUIWF_ACTIVE);
3028 }
3029 }
3030 else
3031 _handle_bool_tag(data->wd_Flags, !tag->ti_Data,
3032 MUIWF_DONTACTIVATE);
3033 break;
3034
3035 case MUIA_Window_ActiveObject:
3036 /* D(bug("MUIA_Window_ActiveObject %ld (%p)\n", */
3037 /* tag->ti_Data, tag->ti_Data)); */
3038 SetActiveObject(data, obj, tag->ti_Data);
3039 break;
3040
3041 case MUIA_Window_DefaultObject:
3042 data->wd_DefaultObject = (APTR) tag->ti_Data;
3043 break;
3044
3045 case MUIA_Window_ID:
3046 data->wd_ID = tag->ti_Data;
3047 break;
3048
3049 case MUIA_Window_IsSubWindow:
3050 _handle_bool_tag(data->wd_Flags, tag->ti_Data,
3051 MUIWF_ISSUBWINDOW);
3052 break;
3053
3054 case MUIA_Window_Open:
3055 if (tag->ti_Data)
3056 {
3057 if (data->wd_Flags & MUIWF_HIDDEN)
3058 data->wd_Flags |= MUIWF_OPENONUNHIDE;
3059 else if (!(data->wd_Flags & MUIWF_OPENED))
3060 WindowOpen(cl, obj);
3061 else
3062 {
3063 DoMethod(obj, MUIM_Window_ToFront);
3064 set(obj, MUIA_Window_Activate, TRUE);
3065 }
3066 }
3067 else if (data->wd_Flags & MUIWF_HIDDEN)
3068 data->wd_Flags &= ~MUIWF_OPENONUNHIDE;
3069 else if (data->wd_Flags & MUIWF_OPENED)
3070 WindowClose(cl, obj);
3071 break;
3072
3073 case MUIA_ShowMe: /* PRIVATE *abuse* of the Area's ShowMe attr */
3074 if (tag->ti_Data)
3075 {
3076 /* Deiconify */
3077
3078 if (data->wd_Flags & MUIWF_HIDDEN)
3079 {
3080 data->wd_Flags &= ~MUIWF_HIDDEN;
3081
3082 if (data->wd_Flags & MUIWF_OPENONUNHIDE)
3083 {
3084 data->wd_Flags &= ~MUIWF_OPENONUNHIDE;
3085 set(obj, MUIA_Window_Open, TRUE);
3086 }
3087 }
3088 }
3089 else
3090 {
3091 /* Iconify */
3092
3093 if (data->wd_Flags & MUIWF_OPENED)
3094 {
3095 data->wd_Flags |= MUIWF_OPENONUNHIDE;
3096
3097 set(obj, MUIA_Window_Open, FALSE);
3098 }
3099
3100 data->wd_Flags |= MUIWF_HIDDEN;
3101 }
3102 break;
3103
3104 case MUIA_Window_RootObject:
3105 ChangeRootObject(data, obj, (Object *) tag->ti_Data);
3106 break;
3107
3108 case MUIA_Window_Title:
3109 if (data->wd_Title)
3110 FreeVec(data->wd_Title);
3111 data->wd_Title = StrDup((STRPTR) tag->ti_Data);
3112 if (data->wd_RenderInfo.mri_Window)
3113 SetWindowTitles(data->wd_RenderInfo.mri_Window,
3114 data->wd_Title, (CONST_STRPTR) ~ 0);
3115 break;
3116
3117 case MUIA_Window_ScreenTitle:
3118 if (data->wd_ScreenTitle)
3119 FreeVec(data->wd_ScreenTitle);
3120 data->wd_ScreenTitle = StrDup((STRPTR) tag->ti_Data);
3121 if (data->wd_RenderInfo.mri_Window)
3122 SetWindowTitles(data->wd_RenderInfo.mri_Window,
3123 (CONST_STRPTR) ~ 0, data->wd_ScreenTitle);
3124 break;
3125
3126 case MUIA_Window_NoMenus:
3127 data->wd_NoMenus = (BOOL) tag->ti_Data;
3128 if (data->wd_RenderInfo.mri_Window)
3129 {
3130 if (data->wd_NoMenus)
3131 data->wd_RenderInfo.mri_Window->Flags |= WFLG_RMBTRAP;
3132 else
3133 data->wd_RenderInfo.mri_Window->Flags &= ~WFLG_RMBTRAP;
3134 }
3135 break;
3136
3137 case MUIA_Window_UseBottomBorderScroller:
3138 _handle_bool_tag(data->wd_Flags, tag->ti_Data,
3139 MUIWF_USEBOTTOMSCROLLER);
3140 break;
3141
3142 case MUIA_Window_UseRightBorderScroller:
3143 _handle_bool_tag(data->wd_Flags, tag->ti_Data,
3144 MUIWF_USERIGHTSCROLLER);
3145 break;
3146
3147 case MUIA_Window_DisableKeys:
3148 data->wd_DisabledKeys = tag->ti_Data;
3149 break;
3150
3151 case MUIA_Window_RefWindow:
3152 data->wd_RefWindow = (Object *) tag->ti_Data;
3153 break;
3154
3155 case MUIA_Window_LeftEdge:
3156 data->wd_X = tag->ti_Data;
3157 break;
3158
3159 case MUIA_Window_TopEdge:
3160 data->wd_Y = tag->ti_Data;
3161 break;
3162
3163 case MUIA_Window_Width:
3164 data->wd_ReqWidth = (LONG) tag->ti_Data;
3165 data->wd_Width = 0; /* otherwise windowselectdimensions()
3166 * ignores ReqWidth */
3167 break;
3168
3169 case MUIA_Window_Height:
3170 data->wd_ReqHeight = (LONG) tag->ti_Data;
3171 data->wd_Height = 0;
3172 break;
3173
3174 case MUIA_Window_Screen:
3175 data->wd_UserScreen = (struct Screen *)tag->ti_Data;
3176 break;
3177
3178 case MUIA_Window_PublicScreen:
3179 data->wd_UserPublicScreen = (STRPTR) tag->ti_Data;
3180 break;
3181
3182 case MUIA_Window_Sleep:
3183 if (tag->ti_Data)
3184 {
3185 data->wd_SleepCount++;
3186 if (data->wd_RenderInfo.mri_Window
3187 && (data->wd_SleepCount == 1))
3188 {
3189 SetWindowPointer
3190 (data->wd_RenderInfo.mri_Window,
3191 WA_BusyPointer, TRUE,
3192 WA_PointerDelay, TRUE, TAG_DONE);
3193 // FIXME: how to disable event handling?
3194 }
3195 }
3196 else
3197 {
3198 data->wd_SleepCount--;
3199 if (data->wd_RenderInfo.mri_Window
3200 && (data->wd_SleepCount == 0))
3201 {
3202 SetWindowPointerA(data->wd_RenderInfo.mri_Window, NULL);
3203 }
3204 }
3205 break;
3206
3207 }
3208 }
3209
3210 return DoSuperMethodA(cl, obj, (Msg) msg);
3211 }
3212
3213 /**************************************************************************
3214 OM_GET
3215 **************************************************************************/
3216 IPTR Window__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
3217 {
3218 #define STORE *(msg->opg_Storage)
3219
3220 struct MUI_WindowData *data = INST_DATA(cl, obj);
3221
3222 STORE = (IPTR) 0;
3223
3224 switch (msg->opg_AttrID)
3225 {
3226 case MUIA_Window_Activate:
3227 STORE =
3228 (data->wd_Flags & (MUIWF_ACTIVE | MUIWF_OPENED)) ==
3229 (MUIWF_ACTIVE | MUIWF_OPENED);
3230 return TRUE;
3231
3232 case MUIA_Window_Window:
3233 STORE = (IPTR) data->wd_RenderInfo.mri_Window;
3234 return TRUE;
3235
3236 case MUIA_Window_Screen:
3237 STORE = (IPTR) data->wd_RenderInfo.mri_Screen;
3238 return TRUE;
3239
3240 case MUIA_Window_PublicScreen:
3241 STORE = (IPTR) data->wd_UserPublicScreen;
3242 return TRUE;
3243
3244 case MUIA_Window_ActiveObject:
3245 if ((data->wd_ActiveObject != NULL)
3246 && (DoMethod(data->wd_RootObject, MUIM_FindAreaObject,
3247 (IPTR) data->wd_ActiveObject) != (IPTR) NULL))
3248 STORE = (IPTR) data->wd_ActiveObject;
3249 else
3250 STORE = (IPTR) NULL;
3251 return TRUE;
3252
3253 case MUIA_Window_CloseRequest:
3254 STORE = FALSE;
3255 return TRUE;
3256
3257 case MUIA_Window_DefaultObject:
3258 STORE = (IPTR) data->wd_DefaultObject;
3259 return TRUE;
3260
3261 case MUIA_Window_DisableKeys:
3262 STORE = data->wd_DisabledKeys;
3263 return TRUE;
3264
3265 case MUIA_Window_Height:
3266 STORE = (IPTR) data->wd_Height;
3267 return TRUE;
3268
3269 case MUIA_Window_ID:
3270 STORE = data->wd_ID;
3271 return TRUE;
3272
3273 case MUIA_Window_IsSubWindow:
3274 STORE = (data->wd_Flags & MUIWF_ISSUBWINDOW) == MUIWF_ISSUBWINDOW;
3275 return TRUE;
3276
3277 case MUIA_Window_LeftEdge:
3278 if (data->wd_RenderInfo.mri_Window)
3279 STORE = (IPTR) data->wd_RenderInfo.mri_Window->LeftEdge;
3280 else
3281 STORE = 0;
3282 return TRUE;
3283
3284 case MUIA_Window_Open:
3285 STORE = (data->wd_Flags & MUIWF_OPENED) == MUIWF_OPENED;
3286 return TRUE;
3287
3288 case MUIA_Window_RootObject:
3289 STORE = (IPTR) data->wd_RootObject;
3290 return TRUE;
3291
3292 case MUIA_Window_ScreenTitle:
3293 STORE = (IPTR) data->wd_ScreenTitle;
3294 return TRUE;
3295
3296 case MUIA_Window_Title:
3297 STORE = (IPTR) data->wd_Title;
3298 return TRUE;
3299
3300 case MUIA_Window_TopEdge:
3301 if (data->wd_RenderInfo.mri_Window)
3302 STORE = (IPTR) data->wd_RenderInfo.mri_Window->TopEdge;
3303 else
3304 STORE = (IPTR) 0;
3305 return (TRUE);
3306
3307 case MUIA_Window_Width:
3308 STORE = (IPTR) data->wd_Width;
3309 return TRUE;
3310
3311 case MUIA_Window_Menustrip:
3312 STORE = (IPTR) data->wd_ChildMenustrip;
3313 return TRUE;
3314
3315 case MUIA_Window_Sleep:
3316 STORE = data->wd_SleepCount ? TRUE : FALSE;
3317 return TRUE;
3318
3319 case MUIA_Version:
3320 STORE = __version;
3321 return TRUE;
3322
3323 case MUIA_Revision:
3324 STORE = __revision;
3325 return TRUE;
3326 }
3327
3328 return DoSuperMethodA(cl, obj, (Msg) msg);
3329 #undef STORE
3330 }
3331
3332 /*
3333 * MUIM_FindUData : tests if the MUIA_UserData of the object
3334 * contains the given <udata> and returns the object pointer in this case.
3335 */
3336 IPTR Window__MUIM_FindUData(struct IClass *cl, Object *obj,
3337 struct MUIP_FindUData *msg)
3338 {
3339 struct MUI_WindowData *data = INST_DATA(cl, obj);
3340
3341 if (muiNotifyData(obj)->mnd_UserData == msg->udata)
3342 return (IPTR) obj;
3343
3344 if (data->wd_RootObject)
3345 return DoMethodA(data->wd_RootObject, (Msg) msg);
3346
3347 return 0;
3348 }
3349
3350
3351 /*
3352 * MUIM_GetUData : This method tests if the MUIA_UserData of the object
3353 * contains the given <udata> and gets <attr> to <storage> for itself
3354 * in this case.
3355 */
3356 IPTR Window__MUIM_GetUData(struct IClass *cl, Object *obj,
3357 struct MUIP_GetUData *msg)
3358 {
3359 struct MUI_WindowData *data = INST_DATA(cl, obj);
3360
3361 if (muiNotifyData(obj)->mnd_UserData == msg->udata)
3362 {
3363 get(obj, msg->attr, msg->storage);
3364 return TRUE;
3365 }
3366
3367 if (data->wd_RootObject)
3368 return DoMethodA(data->wd_RootObject, (Msg) msg);
3369
3370 return FALSE;
3371 }
3372
3373
3374 /*
3375 * MUIM_SetUData : This method tests if the MUIA_UserData of the object
3376 * contains the given <udata> and sets <attr> to <val> for itself in this case.
3377 */
3378 IPTR Window__MUIM_SetUData(struct IClass *cl, Object *obj,
3379 struct MUIP_SetUData *msg)
3380 {
3381 struct MUI_WindowData *data = INST_DATA(cl, obj);
3382
3383 if (muiNotifyData(obj)->mnd_UserData == msg->udata)
3384 set(obj, msg->attr, msg->val);
3385
3386 if (data->wd_RootObject)
3387 DoMethodA(data->wd_RootObject, (Msg) msg);
3388
3389 return TRUE;
3390 }
3391
3392
3393 /*
3394 * MUIM_SetUDataOnce : This method tests if the MUIA_UserData of the object
3395 * contains the given <udata> and sets <attr> to <val> for itself in this case.
3396 */
3397 IPTR Window__MUIM_SetUDataOnce(struct IClass *cl, Object *obj,
3398 struct MUIP_SetUDataOnce *msg)
3399 {
3400 struct MUI_WindowData *data = INST_DATA(cl, obj);
3401
3402 if (muiNotifyData(obj)->mnd_UserData == msg->udata)
3403 {
3404 set(obj, msg->attr, msg->val);
3405 return TRUE;
3406 }
3407
3408 if (data->wd_RootObject)
3409 return DoMethodA(data->wd_RootObject, (Msg) msg);
3410
3411 return FALSE;
3412 }
3413
3414 /**************************************************************************
3415 Called by Application (parent) object whenever this object is added.
3416 init GlobalInfo
3417 **************************************************************************/
3418 IPTR Window__MUIM_ConnectParent(struct IClass *cl, Object *obj,
3419 struct MUIP_ConnectParent *msg)
3420 {
3421 struct MUI_WindowData *data = INST_DATA(cl, obj);
3422
3423 if (!DoSuperMethodA(cl, obj, (Msg) msg))
3424 return 0;
3425
3426 if (data->wd_RootObject)
3427 DoMethod(data->wd_RootObject, MUIM_ConnectParent, (IPTR) obj);
3428
3429 if (data->wd_ChildMenustrip)
3430 DoMethod(data->wd_ChildMenustrip, MUIM_ConnectParent, (IPTR) obj);
3431
3432 return TRUE;
3433 }
3434
3435
3436 /**************************************************************************
3437 called by parent object
3438 **************************************************************************/
3439 IPTR Window__MUIM_DisconnectParent(struct IClass *cl, Object *obj,
3440 struct MUIP_DisconnectParent *msg)
3441 {
3442 struct MUI_WindowData *data = INST_DATA(cl, obj);
3443
3444 /* D(bug("Window_DisconnectParent(%p) : muiGlobalInfo=%p\n", */
3445 /* muiGlobalInfo(obj))); */
3446 if (muiGlobalInfo(obj))
3447 {
3448 /* Close the window before disconnecting all the childs */
3449 if ((data->wd_Flags & MUIWF_OPENED))
3450 {
3451 /* D(bug(" Window_DisconnectParent(%p) : closing window\n", */
3452 /* muiGlobalInfo(obj))); */
3453 set(obj, MUIA_Window_Open, FALSE);
3454 }
3455 if (data->wd_ChildMenustrip)
3456 DoMethod(data->wd_ChildMenustrip, MUIM_DisconnectParent,
3457 (IPTR) obj);
3458
3459 if (data->wd_RootObject)
3460 DoMethodA(data->wd_RootObject, (Msg) msg);
3461
3462 /* D(bug(" Window_DisconnectParent(%p) : calling supermethod\n", */
3463 /* muiGlobalInfo(obj))); */
3464 return DoSuperMethodA(cl, obj, (Msg) msg);
3465 }
3466 else
3467 {
3468 return 0;
3469 }
3470 }
3471
3472 static void SetRootObjInnerSpacing(Object *obj,
3473 struct MUI_WindowData *data)
3474 {
3475 UWORD wd_innerLeft, wd_innerRight, wd_innerTop, wd_innerBottom;
3476
3477 if (data->wd_CrtFlags & WFLG_BORDERLESS)
3478 {
3479 wd_innerLeft = 0;
3480 wd_innerRight = 0;
3481 wd_innerTop = 0;
3482 wd_innerBottom = 0;
3483 }
3484 else
3485 {
3486 wd_innerLeft = muiGlobalInfo(obj)->mgi_Prefs->window_inner_left;
3487 wd_innerRight = muiGlobalInfo(obj)->mgi_Prefs->window_inner_right;
3488 wd_innerTop = muiGlobalInfo(obj)->mgi_Prefs->window_inner_top;
3489 wd_innerBottom = muiGlobalInfo(obj)->mgi_Prefs->window_inner_bottom;
3490 }
3491
3492 if (!(muiAreaData(data->wd_RootObject)->mad_Flags & MADF_INNERLEFT))
3493 {
3494 muiAreaData(data->wd_RootObject)->mad_InnerLeft = wd_innerLeft;
3495 }
3496
3497 if (!(muiAreaData(data->wd_RootObject)->mad_Flags & MADF_INNERTOP))
3498 {
3499 muiAreaData(data->wd_RootObject)->mad_InnerTop = wd_innerTop;
3500 }
3501
3502 if (!(muiAreaData(data->wd_RootObject)->mad_Flags & MADF_INNERRIGHT))
3503 {
3504 muiAreaData(data->wd_RootObject)->mad_InnerRight = wd_innerRight;
3505 }
3506
3507 if (!(muiAreaData(data->wd_RootObject)->mad_Flags & MADF_INNERBOTTOM))
3508 {
3509 muiAreaData(data->wd_RootObject)->mad_InnerBottom = wd_innerBottom;
3510 }
3511 }
3512
3513 /*
3514 * Called before window is opened or resized. It determines its bounds,
3515 * so you can call WindowSelectDimensions() to find the final dims.
3516 */
3517 static void WindowMinMax(Object *obj, struct MUI_WindowData *data)
3518 {
3519 SetRootObjInnerSpacing(obj, data);
3520 /* inquire about sizes */
3521 DoMethod(data->wd_RootObject, MUIM_AskMinMax, (IPTR) & data->wd_MinMax);
3522 /* D(bug("*** root minmax = %ld,%ld => %ld,%ld\n", */
3523 /* data->wd_MinMax.MinWidth, */
3524 /* data->wd_MinMax.MinHeight, */
3525 /* data->wd_MinMax.MaxWidth, data->wd_MinMax.MaxHeight)); */
3526 __area_finish_minmax(data->wd_RootObject, &data->wd_MinMax);
3527 /* D(bug("*** root minmax2 = %ld,%ld => %ld,%ld\n", */
3528 /* data->wd_MinMax.MinWidth, */
3529 /* data->wd_MinMax.MinHeight, */
3530 /* data->wd_MinMax.MaxWidth, data->wd_MinMax.MaxHeight)); */
3531 }
3532
3533
3534 static void InstallBackbuffer(struct IClass *cl, Object *obj)
3535 {
3536 struct MUI_WindowData *data = INST_DATA(cl, obj);
3537 #if 0
3538 struct Window *win = data->wd_RenderInfo.mri_Window;
3539
3540 data->wd_RenderInfo.mri_BufferBM =
3541 AllocBitMap(win->Width, win->Height, win->RPort->BitMap->Depth,
3542 0, win->RPort->BitMap);
3543 #endif
3544 if (data->wd_RenderInfo.mri_BufferBM)
3545 {
3546 /* D(bug("install_backbuffer : allocated bitmap %dx%dx%d " */
3547 /* "with friend %p\n", */
3548 /* win->Width, win->Height, win->RPort->BitMap->Depth, */
3549 /* win->RPort->BitMap)); */
3550 InitRastPort(&data->wd_RenderInfo.mri_BufferRP);
3551 data->wd_RenderInfo.mri_BufferRP.BitMap =
3552 data->wd_RenderInfo.mri_BufferBM;
3553 }
3554 }
3555
3556 static void DeinstallBackbuffer(struct IClass *cl, Object *obj)
3557 {
3558 struct MUI_WindowData *data = INST_DATA(cl, obj);
3559
3560 if (data->wd_RenderInfo.mri_BufferBM)
3561 {
3562 DeinitRastPort(&data->wd_RenderInfo.mri_BufferRP);
3563 FreeBitMap(data->wd_RenderInfo.mri_BufferBM);
3564 data->wd_RenderInfo.mri_BufferBM = NULL;
3565 }
3566 }
3567
3568 /*
3569 * Called after window is opened or resized.
3570 * An expose event is already queued, it will trigger
3571 * MUIM_Draw for us when going back to main loop.
3572 */
3573 static void WindowShow(struct IClass *cl, Object *obj)
3574 {
3575 struct MUI_WindowData *data = INST_DATA(cl, obj);
3576 struct Window *win = data->wd_RenderInfo.mri_Window;
3577 /* D(bug("WindowShow %s %d\n", __FILE__, __LINE__)); */
3578
3579 _left(data->wd_RootObject) = win->BorderLeft;
3580 _top(data->wd_RootObject) = win->BorderTop;
3581 _width(data->wd_RootObject) = data->wd_Width;
3582 _height(data->wd_RootObject) = data->wd_Height;
3583
3584 DoMethod(data->wd_RootObject, MUIM_Layout);
3585
3586 ShowRenderInfo(&data->wd_RenderInfo);
3587 /* D(bug("zune_imspec_show %s %d\n", __FILE__, __LINE__)); */
3588 zune_imspec_show(data->wd_Background, obj);
3589 DoShowMethod(data->wd_RootObject);
3590 }
3591
3592 static ULONG WindowOpen(struct IClass *cl, Object *obj)
3593 {
3594 struct MUI_WindowData *data = INST_DATA(cl, obj);
3595
3596 if (!data->wd_RootObject)
3597 return FALSE;
3598
3599 if (!DoMethod(obj, MUIM_Window_Setup))
3600 return FALSE;
3601
3602 /* I got display info, so calculate your display dependant data */
3603 if (!DoSetupMethod(data->wd_RootObject, &data->wd_RenderInfo))
3604 {
3605 DoMethod(obj, MUIM_Window_Cleanup);
3606 return FALSE;
3607 }
3608
3609 /* inquire about sizes */
3610 WindowMinMax(obj, data);
3611 WindowSelectDimensions(data);
3612
3613 /* Decide which menustrip should be used */
3614 if (!data->wd_ChildMenustrip)
3615 get(_app(obj), MUIA_Application_Menustrip, &data->wd_Menustrip);
3616 else
3617 data->wd_Menustrip = data->wd_ChildMenustrip;
3618
3619 /* open window here ... */
3620 if (!DisplayWindow(obj, data))
3621 {
3622 /* free display dependant data */
3623 data->wd_Menustrip = NULL;
3624 DoMethod(data->wd_RootObject, MUIM_Cleanup);
3625 DoMethod(obj, MUIM_Window_Cleanup);
3626 return FALSE;
3627 }
3628
3629 InstallBackbuffer(cl, obj);
3630
3631 data->wd_Flags |= MUIWF_OPENED;
3632
3633 WindowShow(cl, obj);
3634
3635 {
3636 LONG left, top, width, height;
3637
3638 left = data->wd_RenderInfo.mri_Window->BorderLeft;
3639 top = data->wd_RenderInfo.mri_Window->BorderTop,
3640 width = data->wd_RenderInfo.mri_Window->Width
3641 - data->wd_RenderInfo.mri_Window->BorderRight - left;
3642 height = data->wd_RenderInfo.mri_Window->Height
3643 - data->wd_RenderInfo.mri_Window->BorderBottom - top;
3644
3645 /* D(bug("zune_imspec_draw %s %d\n", __FILE__, __LINE__)); */
3646 // D(bug("%d:zune_imspec_draw(%p) l=%d t=%d w=%d h=%d xo=%d yo=%d\n",
3647 // __LINE__, data->wd_Background, left, top, width,
3648 // height, left, top));
3649
3650 zune_imspec_draw(data->wd_Background, &data->wd_RenderInfo,
3651 left, top, width, height, left, top, 0);
3652 }
3653
3654 MUI_Redraw(data->wd_RootObject, MADF_DRAWOBJECT);
3655
3656 D(bug("MUIC_Window:windowOpen() ActiveObject=%p\n",
3657 data->wd_ActiveObject));
3658 if (data->wd_OldActive != NULL)
3659 {
3660 set(obj, MUIA_Window_ActiveObject, data->wd_OldActive);
3661 }
3662
3663 return TRUE;
3664 }
3665
3666 /**************************************************************************/
3667 /**************************************************************************/
3668
3669 static ULONG WindowClose(struct IClass *cl, Object *obj)
3670 {
3671 struct MUI_WindowData *data = INST_DATA(cl, obj);
3672
3673 if (data->wd_ActiveObject != NULL)
3674 {
3675 data->wd_OldActive = data->wd_ActiveObject;
3676 set(obj, MUIA_Window_ActiveObject, MUIV_Window_ActiveObject_None);
3677 }
3678
3679 KillHelpBubble(data, obj, BUBBLEHELP_TICKER_FIRST);
3680
3681 /* remove from window */
3682 DoHideMethod(data->wd_RootObject);
3683 zune_imspec_hide(data->wd_Background);
3684
3685 DeinstallBackbuffer(cl, obj);
3686
3687 HideRenderInfo(&data->wd_RenderInfo);
3688
3689 /* close here ... */
3690 UndisplayWindow(obj, data);
3691
3692 data->wd_Flags &= ~MUIWF_OPENED;
3693 data->wd_Menustrip = NULL;
3694
3695 /* free display dependant data */
3696 DoMethod(data->wd_RootObject, MUIM_Cleanup);
3697 DoMethod(obj, MUIM_Window_Cleanup);
3698 return TRUE;
3699 }
3700
3701 /* calculate a new layout
3702 * see MUIA_ShowMe
3703 * see Group_ExitChange
3704 * see Group_Columns
3705 * see Group_Rows
3706 */
3707 IPTR Window__MUIM_RecalcDisplay(struct IClass *cl, Object *obj,
3708 struct MUIP_Window_RecalcDisplay *msg)
3709 {
3710 struct MUI_WindowData *data = INST_DATA(cl, obj);
3711 LONG left, top, width, height;
3712 BOOL resized, reshow = FALSE;
3713 Object *current_obj;
3714
3715 if (!(data->wd_Flags & MUIWF_OPENED))
3716 return 0;
3717
3718 current_obj = msg->originator;
3719
3720 // typically originator is a group which has been added/removed a child
3721 // calculate minmax of current obj
3722 // if new minmax can accomodate current obj size, stop
3723 // else try with its parent
3724 // the resulting object will get a new layout
3725 // it currently produces some redundant AskMinMax but allows
3726 // to not always relayout the whole window
3727
3728 D(bug("RecalcDisplay on %p\n", current_obj));
3729 while (current_obj != NULL)
3730 {
3731 DoMethod(current_obj, MUIM_AskMinMax,
3732 (IPTR) & muiAreaData(current_obj)->mad_MinMax);
3733 __area_finish_minmax(current_obj,
3734 &muiAreaData(current_obj)->mad_MinMax);
3735
3736 D(bug("size w = %d, h = %d\n", _width(current_obj),
3737 _height(current_obj)));
3738 D(bug("new w = %d-%d, h = %d-%d\n", _minwidth(current_obj),
3739 _maxwidth(current_obj), _minheight(current_obj),
3740 _maxheight(current_obj)));
3741
3742 if (!_between(_minwidth(current_obj), _width(current_obj),
3743 _maxwidth(current_obj))
3744 || !_between(_minheight(current_obj), _height(current_obj),
3745 _maxheight(current_obj)))
3746 {
3747 current_obj = _parent(current_obj);
3748 D(bug("RecalcDisplay, try parent %p\n", current_obj));
3749 }
3750 else
3751 {
3752 D(bug("found it\n"));
3753 break;
3754 }
3755 }
3756
3757 if (!current_obj)
3758 current_obj = data->wd_RootObject;
3759
3760 WindowMinMax(obj, data);
3761
3762 /* Important: current_obj could be hidden, like in an inactive page! */
3763 if (_flags(current_obj) & MADF_CANDRAW)
3764 {
3765 reshow = TRUE;
3766 }
3767
3768 if (reshow)
3769 DoHideMethod(current_obj);
3770
3771 /* resize window ? */
3772 WindowSelectDimensions(data);
3773 resized = WindowResize(data);
3774
3775 if (!resized)
3776 {
3777 /* FIXME: Should we short circuit the following
3778 * if the window size didn't change?
3779 */
3780 }
3781
3782 {
3783 struct Window *win = data->wd_RenderInfo.mri_Window;
3784 _left(data->wd_RootObject) = win->BorderLeft;
3785 _top(data->wd_RootObject) = win->BorderTop;
3786 _width(data->wd_RootObject) = data->wd_Width;
3787 _height(data->wd_RootObject) = data->wd_Height;
3788 }
3789 DoMethod(current_obj, MUIM_Layout);
3790
3791 if (reshow)
3792 DoShowMethod(current_obj);
3793
3794 if (muiGlobalInfo(obj)->mgi_Prefs->window_redraw ==
3795 WINDOW_REDRAW_WITHOUT_CLEAR)
3796 {
3797 if (reshow)
3798 MUI_Redraw(current_obj, MADF_DRAWOBJECT);
3799 }
3800 else
3801 {
3802 left = data->wd_RenderInfo.mri_Window->BorderLeft;
3803 top = data->wd_RenderInfo.mri_Window->BorderTop;
3804 width = data->wd_RenderInfo.mri_Window->Width
3805 - data->wd_RenderInfo.mri_Window->BorderRight - left;
3806 height = data->wd_RenderInfo.mri_Window->Height
3807 - data->wd_RenderInfo.mri_Window->BorderBottom - top;
3808
3809 zune_imspec_draw(data->wd_Background, &data->wd_RenderInfo,
3810 left, top, width, height, left, top, 0);
3811 MUI_Redraw(data->wd_RootObject, MADF_DRAWALL);
3812 }
3813
3814 ActivateObject(data);
3815
3816 return TRUE;
3817 }
3818
3819
3820 /**************************************************************************
3821 MUIM_AddEventHandler
3822 **************************************************************************/
3823 IPTR Window__MUIM_AddEventHandler(struct IClass *cl, Object *obj,
3824 struct MUIP_Window_AddEventHandler *msg)
3825 {
3826 struct MUI_WindowData *data = INST_DATA(cl, obj);
3827
3828 //D(bug("muimaster.library/window.c: Add Eventhandler %p\n", msg->ehnode));
3829
3830 msg->ehnode->ehn_Priority = msg->ehnode->ehn_Priority;
3831 EnqueueByPriAndAddress((struct List *)&data->wd_EHList,
3832 (struct Node *)msg->ehnode);
3833 ChangeEvents(data, GetDefaultEvents());
3834 return TRUE;
3835 }
3836
3837 /**************************************************************************
3838 MUIM_RemEventHandler
3839 **************************************************************************/
3840 IPTR Window__MUIM_RemEventHandler(struct IClass *cl, Object *obj,
3841 struct MUIP_Window_RemEventHandler *msg)
3842 {
3843 struct MUI_WindowData *data = INST_DATA(cl, obj);
3844
3845 //D(bug("muimaster.library/window.c: Rem Eventhandler %p\n", msg->ehnode));
3846
3847 Remove((struct Node *)msg->ehnode);
3848 ChangeEvents(data, GetDefaultEvents());
3849 return TRUE;
3850 }
3851
3852 /**************************************************************************
3853 Note that this is MUIM_Window_Setup, not MUIM_Setup
3854 **************************************************************************/
3855 IPTR Window__MUIM_Setup(struct IClass *cl, Object *obj, Msg msg)
3856 {
3857 struct MUI_WindowData *data = INST_DATA(cl, obj);
3858
3859 if (!SetupRenderInfo(obj, data, &data->wd_RenderInfo))
3860 return FALSE;
3861
3862 data->wd_Background =
3863 zune_imspec_setup(MUII_WindowBack, &data->wd_RenderInfo);
3864
3865 if (muiGlobalInfo(obj)->mgi_Prefs->window_redraw ==
3866 WINDOW_REDRAW_WITH_CLEAR)
3867 data->wd_Flags |= MUIWF_ERASEAREA;
3868
3869 return TRUE;
3870 }
3871
3872 /**************************************************************************
3873 MUIM_Cleanup
3874 **************************************************************************/
3875 IPTR Window__MUIM_Cleanup(struct IClass *cl, Object *obj, Msg msg)
3876 {
3877 struct MUI_WindowData *data = INST_DATA(cl, obj);
3878
3879 zune_imspec_cleanup(data->wd_Background);
3880
3881 if (data->wd_dnd)
3882 {
3883 DeleteDragNDrop(data->wd_dnd);
3884 data->wd_dnd = NULL;
3885 }
3886
3887 CleanupRenderInfo(obj, data, &data->wd_RenderInfo);
3888 return TRUE;
3889 }
3890
3891
3892 /**************************************************************************
3893 This adds the the control char handler and also do the MUIA_CycleChain
3894 stuff. Orginal MUI does this in an other way.
3895 **************************************************************************/
3896 IPTR Window__MUIM_AddControlCharHandler(struct IClass *cl, Object *obj,
3897 struct MUIP_Window_AddControlCharHandler *msg)
3898 {
3899 struct MUI_WindowData *data = INST_DATA(cl, obj);
3900 struct ObjNode *node;
3901
3902 if (msg->ccnode->ehn_Events)
3903 {
3904 msg->ccnode->ehn_Priority = msg->ccnode->ehn_Priority;
3905 Enqueue((struct List *)&data->wd_CCList,
3906 (struct Node *)msg->ccnode);
3907 }
3908 /* Due to the lack of a better idea ... */
3909 if (muiAreaData(msg->ccnode->ehn_Object)->mad_Flags & MADF_CYCLECHAIN)
3910 {
3911 node = AllocPooled(data->wd_MemoryPool, sizeof(struct ObjNode));
3912 if (node)
3913 {
3914 node->obj = msg->ccnode->ehn_Object;
3915 AddTail((struct List *)&data->wd_CycleChain,
3916 (struct Node *)node);
3917 }
3918 }
3919 return TRUE;
3920 }
3921
3922 /**************************************************************************
3923 MUIM_RemControlCharHandler
3924 **************************************************************************/
3925 IPTR Window__MUIM_RemControlCharHandler(struct IClass *cl, Object *obj,
3926 struct MUIP_Window_RemControlCharHandler *msg)
3927 {
3928 struct MUI_WindowData *data = INST_DATA(cl, obj);
3929 struct ObjNode *node =
3930 FindObjNode(&data->wd_CycleChain, msg->ccnode->ehn_Object);
3931
3932 if (msg->ccnode->ehn_Events)
3933 Remove((struct Node *)msg->ccnode);
3934
3935 if (node)
3936 {
3937 /* Remove from the chain list */
3938 Remove((struct Node *)node);
3939 FreePooled(data->wd_MemoryPool, node, sizeof(struct ObjNode));
3940 }
3941
3942 return TRUE;
3943 }
3944
3945 /**************************************************************************
3946 MUIM_DragObject
3947 **************************************************************************/
3948 IPTR Window__MUIM_DragObject(struct IClass *cl, Object *obj,
3949 struct MUIP_Window_DragObject *msg)
3950 {
3951 struct MUI_WindowData *data = INST_DATA(cl, obj);
3952 if (msg->obj)
3953 {
3954 struct DragNDrop *dnd;
3955 struct MUI_DragImage *di;
3956 struct BitMapNode *bmn;
3957
3958 if (!(dnd = CreateDragNDropA(NULL)))
3959 return 0;
3960
3961 if (!(di =
3962 (struct MUI_DragImage *)DoMethod(msg->obj,
3963 MUIM_CreateDragImage, -msg->touchx, -msg->touchy,
3964 msg->flags)))
3965 {
3966 DeleteDragNDrop(dnd);
3967 return 0;
3968 }
3969 if (!di->bm)
3970 {
3971 DoMethod(msg->obj, MUIM_DeleteDragImage, (IPTR) di);
3972 DeleteDragNDrop(dnd);
3973 return 0;
3974 }
3975
3976 if (!(bmn = CreateBitMapNodeA(TAGLIST(
3977 GUI_BitMap, (IPTR)di->bm,
3978 GUI_LeftOffset, di->touchx,
3979 GUI_TopOffset, di->touchy,
3980 GUI_Width, di->width,
3981 GUI_Height, di->height,
3982 GUI_SourceAlpha, !!(di->flags & MUIF_DRAGIMAGE_SOURCEALPHA)))))
3983 {
3984 DoMethod(msg->obj, MUIM_DeleteDragImage, (IPTR) di);
3985 DeleteDragNDrop(dnd);
3986 return 0;
3987 }
3988
3989 AttachBitMapNode(dnd, bmn);
3990
3991 if (!PrepareDragNDrop(dnd, data->wd_RenderInfo.mri_Screen))
3992 {
3993 DoMethod(msg->obj, MUIM_DeleteDragImage, (IPTR) di);
3994 DeleteDragNDrop(dnd);
3995 return 0;
3996 }
3997
3998 muiAreaData(msg->obj)->mad_Flags |= MADF_DRAGGING;
3999
4000 data->wd_DragObject = msg->obj;
4001 data->wd_dnd = dnd;
4002 data->wd_DragImage = di;
4003 return 1;
4004 }
4005 return 0;
4006 }
4007
4008 /**************************************************************************
4009 MUIM_AllocGadgetID
4010 **************************************************************************/
4011 IPTR Window__MUIM_AllocGadgetID(struct IClass *cl, Object *obj,
4012 struct MUIP_Window_AllocGadgetID *msg)
4013 {
4014 struct MUI_WindowData *data = INST_DATA(cl, obj);
4015 struct IDNode *newnode;
4016
4017 newnode = AllocPooled(data->wd_MemoryPool, sizeof(struct IDNode));
4018 if (newnode)
4019 {
4020 int id;
4021 struct MinNode *mn;
4022
4023 if (IsListEmpty((struct List *)&data->wd_IDList))
4024 {
4025 newnode->id = 1;
4026 AddHead((struct List *)&data->wd_IDList,
4027 (struct Node *)&newnode->node);
4028 return (IPTR) 1;
4029 }
4030
4031 id = 1;
4032
4033 for (mn = data->wd_IDList.mlh_Head; mn->mln_Succ; mn = mn->mln_Succ)
4034 {
4035 struct IDNode *idn = (struct IDNode *)mn;
4036 if (id < idn->id)
4037 break;
4038 id++;
4039 }
4040 newnode->id = id;
4041 Insert((struct List *)&data->wd_IDList,
4042 (struct Node *)&newnode->node, (struct Node *)mn);
4043 return (IPTR) id;
4044 }
4045
4046 return 0;
4047 }
4048
4049 /**************************************************************************
4050 MUIM_FreeGadgetID
4051 **************************************************************************/
4052 IPTR Window__MUIM_FreeGadgetID(struct IClass *cl, Object *obj,
4053 struct MUIP_Window_FreeGadgetID *msg)
4054 {
4055 struct MUI_WindowData *data = INST_DATA(cl, obj);
4056 struct MinNode *mn;
4057
4058 for (mn = data->wd_IDList.mlh_Head; mn->mln_Succ; mn = mn->mln_Succ)
4059 {
4060 struct IDNode *idn = (struct IDNode *)mn;
4061 if (msg->gadgetid == idn->id)
4062 {
4063 Remove((struct Node *)idn);
4064 FreePooled(data->wd_MemoryPool, idn, sizeof(struct IDNode));
4065 return 0;
4066 }
4067 }
4068
4069 return 0;
4070 }
4071
4072
4073 /**************************************************************************
4074 MUIM_Window_GetMenuCheck
4075 **************************************************************************/
4076 IPTR Window__MUIM_GetMenuCheck(struct IClass *cl, Object *obj,
4077 struct MUIP_Window_GetMenuCheck *msg)
4078 {
4079 IPTR stat = 0;
4080 struct MUI_WindowData *data = INST_DATA(cl, obj);
4081 Object *item;
4082 Object *strip = data->wd_ChildMenustrip;
4083 if (!strip)
4084 strip = data->wd_Menustrip;
4085 if (!strip)
4086 return 0;
4087 if (!(item = (Object *) DoMethod(strip, MUIM_FindUData, msg->MenuID)))
4088 return 0;
4089 get(item, MUIA_Menuitem_Checked, &stat);
4090 return stat;
4091 }
4092
4093 /**************************************************************************
4094 MUIM_Window_SetMenuCheck
4095 **************************************************************************/
4096 IPTR Window__MUIM_SetMenuCheck(struct IClass *cl, Object *obj,
4097 struct MUIP_Window_SetMenuCheck *msg)
4098 {
4099 struct MUI_WindowData *data = INST_DATA(cl, obj);
4100 Object *item;
4101 Object *strip = data->wd_ChildMenustrip;
4102 if (!strip)
4103 strip = data->wd_Menustrip;
4104 if (!strip)
4105 return 0;
4106 if (!(item = (Object *) DoMethod(strip, MUIM_FindUData, msg->MenuID)))
4107 return 0;
4108 set(item, MUIA_Menuitem_Checked, msg->stat);
4109 return 0;
4110 }
4111
4112 /**************************************************************************
4113 MUIM_Window_GetMenuState
4114 **************************************************************************/
4115 IPTR Window__MUIM_GetMenuState(struct IClass *cl, Object *obj,
4116 struct MUIP_Window_GetMenuState *msg)
4117 {
4118 IPTR stat = 0;
4119 struct MUI_WindowData *data = INST_DATA(cl, obj);
4120 Object *item;
4121 Object *strip = data->wd_ChildMenustrip;
4122 if (!strip)
4123 strip = data->wd_Menustrip;
4124 if (!strip)
4125 return 0;
4126 if (!(item = (Object *) DoMethod(strip, MUIM_FindUData, msg->MenuID)))
4127 return 0;
4128 get(item, MUIA_Menuitem_Enabled, &stat);
4129 return stat;
4130 }
4131
4132 /**************************************************************************
4133 MUIM_Window_SetMenuState
4134 **************************************************************************/
4135 IPTR Window__MUIM_SetMenuState(struct IClass *cl, Object *obj,
4136 struct MUIP_Window_SetMenuState *msg)
4137 {
4138 struct MUI_WindowData *data = INST_DATA(cl, obj);
4139 Object *item;
4140 Object *strip = data->wd_ChildMenustrip;
4141 if (!strip)
4142 strip = data->wd_Menustrip;
4143 if (!strip)
4144 return 0;
4145 if (!(item = (Object *) DoMethod(strip, MUIM_FindUData, msg->MenuID)))
4146 return 0;
4147 set(item, MUIA_Menuitem_Enabled, msg->stat);
4148 return 0;
4149 }
4150
4151 /**************************************************************************
4152 MUIM_Window_DrawBackground
4153 **************************************************************************/
4154 IPTR Window__MUIM_DrawBackground(struct IClass *cl, Object *obj,
4155 struct MUIP_Window_DrawBackground *msg)
4156 {
4157 struct MUI_WindowData *data = INST_DATA(cl, obj);
4158 if (!(data->wd_RenderInfo.mri_Window)) /* not between show/hide */
4159 return FALSE;
4160
4161 // D(bug("%d:zune_imspec_draw(%p) l=%d t=%d w=%d h=%d xo=%d yo=%d\n",
4162 // __LINE__, data->wd_Background, msg->left, msg->top, msg->width,
4163 // msg->height, msg->xoffset, msg->yoffset));
4164 zune_imspec_draw(data->wd_Background, &data->wd_RenderInfo,
4165 msg->left, msg->top, msg->width, msg->height,
4166 msg->xoffset, msg->yoffset, 0);
4167 return 0;
4168 }
4169
4170 /**************************************************************************
4171 MUIM_Window_ToFront
4172 **************************************************************************/
4173 IPTR Window__MUIM_ToFront(struct IClass *cl, Object *obj, Msg msg)
4174 {
4175 struct MUI_WindowData *data = INST_DATA(cl, obj);
4176 if (!(data->wd_RenderInfo.mri_Window)) /* not between show/hide */
4177 return 0;
4178
4179 WindowToFront(data->wd_RenderInfo.mri_Window);
4180 return 1;
4181 }
4182
4183 /**************************************************************************
4184 MUIM_Window_ToBack
4185 **************************************************************************/
4186 IPTR Window__MUIM_ToBack(struct IClass *cl, Object *obj, Msg msg)
4187 {
4188 struct MUI_WindowData *data = INST_DATA(cl, obj);
4189 if (!(data->wd_RenderInfo.mri_Window)) /* not between show/hide */
4190 return 0;
4191
4192 WindowToBack(data->wd_RenderInfo.mri_Window);
4193 return 1;
4194 }
4195
4196 /**************************************************************************
4197 MUIM_Window_ScreenToBack
4198 **************************************************************************/
4199 IPTR Window__MUIM_ScreenToBack(struct IClass *cl, Object *obj, Msg msg)
4200 {
4201 struct MUI_WindowData *data = INST_DATA(cl, obj);
4202 if (!(data->wd_RenderInfo.mri_Window)) /* not between show/hide */
4203 return 0;
4204
4205 ScreenToBack(data->wd_RenderInfo.mri_Screen);
4206 return 1;
4207 }
4208
4209 /**************************************************************************
4210 MUIM_Window_ScreenToFront
4211 **************************************************************************/
4212 IPTR Window__MUIM_ScreenToFront(struct IClass *cl, Object *obj, Msg msg)
4213 {
4214 struct MUI_WindowData *data = INST_DATA(cl, obj);
4215 if (!(data->wd_RenderInfo.mri_Window)) /* not between show/hide */
4216 return 0;
4217
4218 ScreenToFront(data->wd_RenderInfo.mri_Screen);
4219 return 1;
4220 }
4221
4222 /**************************************************************************
4223 MUIM_Window_ActionIconify
4224 **************************************************************************/
4225 IPTR Window__MUIM_ActionIconify(struct IClass *cl, Object *obj, Msg msg)
4226 {
4227 set(_app(obj), MUIA_Application_Iconified, TRUE);
4228
4229 return TRUE;
4230 }
4231
4232
4233 /* Loads ENV: prefs, add a Window_ID chunk in the MUIW chunk, if no MUIW chunk
4234 * then create it at the same level as MUIC chunk, save prefs.
4235 * Do the same for ENVARC:
4236 * MUIW chunk layout:
4237 * 'MUIW'
4238 * 00 00 00 30 (chunk length for a single window, 0x30L big endian)
4239 * 'this window ID'
4240 * 00 00 00 28
4241 * xx xx yy yy (X, Y)
4242 * ww ww hh hh (Width, Height)
4243 * ax ax ay ay (AltX, AltY)
4244 * aw aw ah ah (AltWidth, AltHeight)
4245 * 00 00 00 00 (???)
4246 * 00 00 00 00
4247 * 00 00 00 00
4248 * 00 00 00 00
4249 * 00 01 00 00
4250 * 00 00 00 00
4251 */
4252 static void RememberWindowPosition(Object *winobj, ULONG id)
4253 {
4254 if (!id)
4255 return;
4256 }
4257
4258 /* Loads ENV: prefs, remove our Window_ID chunk from the MUIW chunk,
4259 * save prefs.
4260 * Do the same for ENVARC:
4261 * This function shouldn't really be in window.c, but rather in a file dealing
4262 * with prefs file stuff.
4263 */
4264 static void ForgetWindowPosition(Object *winobj, ULONG id)
4265 {
4266 if (!id)
4267 return;
4268 }
4269
4270 /**************************************************************************
4271 MUIM_Window_Snapshot
4272 **************************************************************************/
4273 IPTR Window__MUIM_Snapshot(struct IClass *cl, Object *obj,
4274 struct MUIP_Window_Snapshot *msg)
4275 {
4276 struct MUI_WindowData *data = INST_DATA(cl, obj);
4277 struct windowpos winp;
4278 struct Window *w;
4279
4280 winp.id = data->wd_ID;
4281 w = data->wd_RenderInfo.mri_Window;
4282 if (w)
4283 {
4284 winp.x1 = w->LeftEdge;
4285 winp.y1 = w->TopEdge;
4286 winp.w1 = w->GZZWidth;
4287 winp.h1 = w->GZZHeight;
4288 winp.x2 = 0;
4289 winp.x2 = 0;
4290 winp.w2 = 0;
4291 winp.h2 = 0; //to do save alt dims
4292
4293 set(_app(obj), MUIA_Application_SetWinPos, &winp);
4294 }
4295
4296 if (msg->flags)
4297 RememberWindowPosition(obj, data->wd_ID);
4298 else
4299 ForgetWindowPosition(obj, data->wd_ID);
4300 return 1;
4301 }
4302
4303 /**************************************************************************
4304 MUIM_Window_UpdateMenu
4305 **************************************************************************/
4306 IPTR Window__MUIM_UpdateMenu(struct IClass *cl, Object *obj, Msg msg)
4307 {
4308 struct MUI_WindowData *data = INST_DATA(cl, obj);
4309
4310 struct Menu *menu = NULL;
4311 struct NewMenu *newmenu = NULL;
4312 APTR visinfo = NULL;
4313 struct Window *win = NULL;
4314
4315 if (data->wd_Menustrip) // only open windows can have a menustrip
4316 {
4317 if ((visinfo =
4318 GetVisualInfoA(data->wd_RenderInfo.mri_Screen, NULL)))
4319 {
4320 win = data->wd_RenderInfo.mri_Window;
4321 ClearMenuStrip(win);
4322 if (data->wd_Menu)
4323 {
4324 FreeMenus(data->wd_Menu);
4325 data->wd_Menu = NULL;
4326 }
4327
4328 get(data->wd_Menustrip, MUIA_Menuitem_NewMenu, &newmenu);
4329 if (newmenu)
4330 {
4331 if ((menu = CreateMenusA(newmenu, NULL)))
4332 {
4333 struct TagItem tags[] = {
4334 {GTMN_NewLookMenus, TRUE},
4335 {TAG_DONE, 0}
4336 };
4337 LayoutMenusA(menu, visinfo, tags);
4338 data->wd_Menu = menu;
4339 SetMenuStrip(win, menu);
4340 }
4341 }
4342 FreeVisualInfo(visinfo);
4343 }
4344 }
4345
4346 return 1;
4347 }
4348
4349 /**************************************************************************
4350 MUIM_Export : to export an object's "contents" to a dataspace object.
4351 **************************************************************************/
4352 static IPTR Window__MUIM_Export(struct IClass *cl, Object *obj,
4353 struct MUIP_Export *msg)
4354 {
4355 struct MUI_WindowData *data = INST_DATA(cl, obj);
4356 DoMethodA(data->wd_RootObject, (Msg) msg);
4357 return 0;
4358 }
4359
4360
4361 /**************************************************************************
4362 MUIM_Import : to import an object's "contents" from a dataspace object.
4363 **************************************************************************/
4364 static IPTR Window__MUIM_Import(struct IClass *cl, Object *obj,
4365 struct MUIP_Import *msg)
4366 {
4367 struct MUI_WindowData *data = INST_DATA(cl, obj);
4368 DoMethodA(data->wd_RootObject, (Msg) msg);
4369 return 0;
4370 }
4371
4372 BOOPSI_DISPATCHER(IPTR, Window_Dispatcher, cl, obj, msg)
4373 {
4374 switch (msg->MethodID)
4375 {
4376 case OM_NEW:
4377 return Window__OM_NEW(cl, obj, (struct opSet *)msg);
4378 case OM_DISPOSE:
4379 return Window__OM_DISPOSE(cl, obj, msg);
4380 case OM_SET:
4381 return Window__OM_SET(cl, obj, (struct opSet *)msg);
4382 case OM_GET:
4383 return Window__OM_GET(cl, obj, (struct opGet *)msg);
4384 case MUIM_FindUData:
4385 return Window__MUIM_FindUData(cl, obj,
4386 (struct MUIP_FindUData *)msg);
4387 case MUIM_GetUData:
4388 return Window__MUIM_GetUData(cl, obj, (struct MUIP_GetUData *)msg);
4389 case MUIM_SetUData:
4390 return Window__MUIM_SetUData(cl, obj, (struct MUIP_SetUData *)msg);
4391 case MUIM_SetUDataOnce:
4392 return Window__MUIM_SetUDataOnce(cl, obj,
4393 (struct MUIP_SetUDataOnce *)msg);
4394 case MUIM_Window_AddEventHandler:
4395 return Window__MUIM_AddEventHandler(cl, obj, (APTR) msg);
4396 case MUIM_Window_RemEventHandler:
4397 return Window__MUIM_RemEventHandler(cl, obj, (APTR) msg);
4398 case MUIM_ConnectParent:
4399 return Window__MUIM_ConnectParent(cl, obj, (APTR) msg);
4400 case MUIM_DisconnectParent:
4401 return Window__MUIM_DisconnectParent(cl, obj, (APTR) msg);
4402 case MUIM_Window_RecalcDisplay:
4403 return Window__MUIM_RecalcDisplay(cl, obj, (APTR) msg);
4404 case MUIM_Window_Setup:
4405 return Window__MUIM_Setup(cl, obj, (APTR) msg);
4406 case MUIM_Window_Cleanup:
4407 return Window__MUIM_Cleanup(cl, obj, (APTR) msg);
4408 case MUIM_Window_AddControlCharHandler:
4409 return Window__MUIM_AddControlCharHandler(cl, obj, (APTR) msg);
4410 case MUIM_Window_RemControlCharHandler:
4411 return Window__MUIM_RemControlCharHandler(cl, obj, (APTR) msg);
4412 case MUIM_Window_DragObject:
4413 return Window__MUIM_DragObject(cl, obj, (APTR) msg);
4414 case MUIM_Window_AllocGadgetID:
4415 return Window__MUIM_AllocGadgetID(cl, obj, (APTR) msg);
4416 case MUIM_Window_FreeGadgetID:
4417 return Window__MUIM_FreeGadgetID(cl, obj, (APTR) msg);
4418 case MUIM_Window_GetMenuCheck:
4419 return Window__MUIM_GetMenuCheck(cl, obj, (APTR) msg);
4420 case MUIM_Window_SetMenuCheck:
4421 return Window__MUIM_SetMenuCheck(cl, obj, (APTR) msg);
4422 case MUIM_Window_GetMenuState:
4423 return Window__MUIM_GetMenuState(cl, obj, (APTR) msg);
4424 case MUIM_Window_SetMenuState:
4425 return Window__MUIM_SetMenuState(cl, obj, (APTR) msg);
4426 case MUIM_Window_DrawBackground:
4427 return Window__MUIM_DrawBackground(cl, obj, (APTR) msg);
4428 case MUIM_Window_ToFront:
4429 return Window__MUIM_ToFront(cl, obj, (APTR) msg);
4430 case MUIM_Window_ToBack:
4431 return Window__MUIM_ToBack(cl, obj, (APTR) msg);
4432 case MUIM_Window_ScreenToFront:
4433 return Window__MUIM_ScreenToFront(cl, obj, (APTR) msg);
4434 case MUIM_Window_ScreenToBack:
4435 return Window__MUIM_ScreenToBack(cl, obj, (APTR) msg);
4436 case MUIM_Window_ActionIconify:
4437 return Window__MUIM_ActionIconify(cl, obj, (APTR) msg);
4438 case MUIM_Window_Snapshot:
4439 return Window__MUIM_Snapshot(cl, obj, (APTR) msg);
4440 case MUIM_Window_UpdateMenu:
4441 return Window__MUIM_UpdateMenu(cl, obj, (APTR) msg);
4442 case MUIM_Export:
4443 return Window__MUIM_Export(cl, obj, (APTR) msg);
4444 case MUIM_Import:
4445 return Window__MUIM_Import(cl, obj, (APTR) msg);
4446 }
4447
4448 return DoSuperMethodA(cl, obj, msg);
4449 }
4450 BOOPSI_DISPATCHER_END
4451
4452 /*
4453 * Class descriptor.
4454 */
4455 const struct __MUIBuiltinClass _MUI_Window_desc =
4456 {
4457 MUIC_Window,
4458 MUIC_Notify,
4459 sizeof(struct MUI_WindowData),
4460 (void *) Window_Dispatcher
4461 };
Mirror of AROS' svn.