?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update experimental gcc 6 patch to gcc 6.1.0 release
[AROS.git] / workbench / libs / muimaster / classes / group.c
blob35b436a819608f1783783b1df7e3c9a785423acc
1 /*
2 Copyright 1999, David Le Corfec.
3 Copyright 2002-2015, The AROS Development Team.
4 All rights reserved.
5
6 $Id$
7 */
8
9 #include <exec/types.h>
10
11 #include <clib/alib_protos.h>
12 #include <proto/exec.h>
13 #include <proto/intuition.h>
14 #include <proto/utility.h>
15 #include <proto/graphics.h>
16 #include <proto/muimaster.h>
17
18 extern struct Library *MUIMasterBase;
19
20 #include "muimaster_intern.h"
21 #include "mui.h"
22 #include "support.h"
23 #include "prefs.h"
24
25 /* #define MYDEBUG 1 */
26 #include "debug.h"
27
28 #define ROUND(x) ((int)(x + 0.5))
29 #define IS_HIDDEN(obj) (! (_flags(obj) & MADF_SHOWME) \
30 || (_flags(obj) & MADF_BORDERGADGET))
31
32 /* Attributes filtered out in OM_SET, before OM_SET gets passed to children.
33 Tested with MUI under UAE/AOS.
34
35 notifyclass:
36
37 MUIA_HelpLine
38 MUIA_HelpNode
39 MUIA_ObjectID
40 MUIA_UserData
41
42 areaclass:
43
44 MUIA_ContextMenu
45 MUIA_ContextMenuTrigger
46 MUIA_ControlChar
47 MUIA_CycleChain
48 MUIA_Draggable
49 MUIA_FillArea
50 MUIA_Frame
51 MUIA_FrameTitle
52 MUIA_HorizWeight
53 MUIA_Pressed
54 MUIA_Selected
55 MUIA_ShortHelp
56 MUIA_ShowMe
57 MUIA_VertWeight
58 MUIA_Weight
59
60 */
61
62 /* Private attribute/method definitions */
63 #define MUIM_Group_Insert (MUIB_MUI|0x00424d34) /* MUI: V20 */
64 struct MUIP_Group_Insert
65 {
66 STACKED ULONG MethodID;
67 STACKED Object *obj;
68 STACKED Object *pred;
69 };
70
71 #define MUIA_Group_ChildCount 0x80420322 /* MUI: V20 isg LONG */
72
73 struct layout2d_elem
74 {
75 WORD min;
76 WORD max;
77 WORD dim;
78 ULONG weight;
79 };
80
81
82 struct MUI_GroupData
83 {
84 Object *family;
85 struct Hook *layout_hook;
86 ULONG flags;
87 ULONG columns;
88 ULONG rows;
89 struct layout2d_elem *row_infos;
90 struct layout2d_elem *col_infos;
91 LONG active_page;
92 ULONG horiz_spacing;
93 ULONG vert_spacing;
94 ULONG num_children;
95 ULONG num_visible_children; /* for horiz/vert group only */
96 ULONG horiz_weight_sum;
97 ULONG vert_weight_sum;
98 ULONG samesize_maxmin_horiz;
99 ULONG samesize_maxmin_vert;
100 ULONG update; /* for MUI_Redraw() 1 - do not redraw the frame
101 * 2 - the virtual pos has changed */
102 struct MUI_EventHandlerNode ehn;
103 LONG virt_offx, virt_offy; /* diplay offsets */
104 LONG old_virt_offx, old_virt_offy; /* Saved virtual positions,
105 * used for update == 2 */
106 LONG virt_mwidth, virt_mheight; /* The complete width */
107 LONG saved_minwidth, saved_minheight;
108 LONG dont_forward_get; /* Set temporarily to 1 so that the get method
109 * is not forwarded */
110 LONG dont_forward_methods; /* Set temporarily to 1, meaning that the
111 * methods are not forwarded to the group's
112 * children */
113 /* MUI4 group with tabs */
114 Object *titlegroup;
115 };
116
117 /* Note:
118 * The MUI4 feature of group with tabs is implemented based on behaviour of
119 * one application. What this application codes suggest it seems that passing
120 * MUIV_Frame_Register together with MUIA_Group_PageMode, TRUE activates this
121 * mode.
122 * In such mode, the first passed group is used to register tab "titles" and
123 * is always visible. The selection of object in this group selects the
124 * matching (by position) group to be displayed
125 */
126
127 #define GROUP_HORIZ (1<<1)
128 #define GROUP_SAME_WIDTH (1<<2)
129 #define GROUP_SAME_HEIGHT (1<<3)
130 #define GROUP_CHANGING (1<<4)
131 #define GROUP_PAGEMODE (1<<5)
132 #define GROUP_VIRTUAL (1<<6)
133 #define GROUP_HSPACING (1<<7)
134 #define GROUP_VSPACING (1<<8)
135 #define GROUP_CHANGED (1<<9)
136
137
138 /* During minmax calculations objects with a weight of 0 shall
139 be treated like they had identical min/def/max size, ie. fixed size.
140
141 During layout objects with 0 weight must be treated like fixed-sized
142 too, but for hgroups only in x direction, and for vgroups only in
143 y direction. I think ... */
144
145 #define w0_defwidth(x) (_hweight(x) ? _defwidth(x) : _minwidth(x))
146 #define w0_maxwidth(x) (_hweight(x) ? _maxwidth(x) : _minwidth(x))
147
148 #define w0_defheight(x) (_vweight(x) ? _defheight(x) : _minheight(x))
149 #define w0_maxheight(x) (_vweight(x) ? _maxheight(x) : _minheight(x))
150
151 static const int __version = 1;
152 static const int __revision = 1;
153
154 IPTR Group__MUIM_Show(struct IClass *cl, Object *obj,
155 struct MUIP_Show *msg);
156 IPTR Group__MUIM_Hide(struct IClass *cl, Object *obj,
157 struct MUIP_Hide *msg);
158
159 /*****************************************************************************/
160 /*****************************************************************************/
161
162
163 static ULONG Group_DispatchMsg(struct IClass *cl, Object *obj, Msg msg);
164
165 static void change_active_page(struct IClass *cl, Object *obj, LONG page)
166 {
167 struct MUI_GroupData *data = INST_DATA(cl, obj);
168 LONG newpage, num_children = data->num_children;
169
170 if (!(data->flags & GROUP_PAGEMODE))
171 return;
172
173 if (data->titlegroup != NULL)
174 num_children--;
175
176 switch (page)
177 {
178 case MUIV_Group_ActivePage_First:
179 newpage = 0;
180 break;
181 case MUIV_Group_ActivePage_Last:
182 newpage = num_children - 1;
183 break;
184 case MUIV_Group_ActivePage_Prev:
185 newpage = data->active_page - 1;
186 if (newpage == -1)
187 newpage = num_children - 1;
188 break;
189 case MUIV_Group_ActivePage_Next:
190 case MUIV_Group_ActivePage_Advance:
191 newpage = (data->active_page + 1) % num_children;
192 break;
193 default:
194 newpage = page;
195 break;
196 }
197
198 if (newpage != data->active_page)
199 {
200 if (_flags(obj) & MADF_CANDRAW)
201 Group__MUIM_Hide(cl, obj, NULL);
202
203 data->active_page = newpage;
204
205 if (_flags(obj) & MADF_CANDRAW)
206 {
207 DoMethod(obj, MUIM_Layout);
208 Group__MUIM_Show(cl, obj, NULL);
209 data->update = 1;
210 MUI_Redraw(obj, MADF_DRAWUPDATE);
211 }
212
213 if (data->titlegroup)
214 set(data->titlegroup, MUIA_Group_ActivePage, newpage);
215 }
216 }
217
218 /**************************************************************************
219 Returns the number of visible children. Visible children are all children
220 that have MADF_SHOWME and not MADF_BORDERGADGET set.
221 **************************************************************************/
222 static int Group_GetNumVisibleChildren(struct MUI_GroupData *data,
223 struct MinList *children)
224 {
225 int num_visible_children = data->num_children;
226 Object *cstate;
227 Object *child;
228
229 /* As there can be invisible children we have to subtract those from
230 * the total number of children */
231 cstate = (Object *) children->mlh_Head;
232 while ((child = NextObject(&cstate)))
233 {
234 if (IS_HIDDEN(child))
235 num_visible_children--;
236 }
237 return num_visible_children;
238 }
239
240 /**************************************************************************
241 Handles insertion of objects - works based on fact that IDs of all methods
242 that use it are the same for Group and Family and that struct share obj at
243 same offset.
244 **************************************************************************/
245 struct MUIP_StructWithObj
246 {
247 STACKED ULONG MethodID;
248 STACKED Object *obj;
249 };
250
251 static IPTR Group__MUIM_AddObject(struct IClass *cl, Object *obj, Msg msg)
252 {
253 struct MUI_GroupData *data = INST_DATA(cl, obj);
254 struct MUIP_StructWithObj *msgint = (struct MUIP_StructWithObj *)msg;
255
256 DoMethodA(data->family, (Msg) msg);
257 data->num_children++;
258 if ((data->flags & GROUP_CHANGING) != 0)
259 data->flags |= GROUP_CHANGED;
260
261 /* if we are in an application tree, propagate pointers */
262 if (muiNotifyData(obj)->mnd_GlobalInfo)
263 {
264 /* Only children of groups can have parents */
265
266 if ((_flags(obj) & MADF_INVIRTUALGROUP)
267 || (data->flags & GROUP_VIRTUAL))
268 {
269 _flags(msgint->obj) |= MADF_INVIRTUALGROUP;
270 }
271
272 DoMethod(msgint->obj, MUIM_ConnectParent, (IPTR) obj);
273 }
274
275 /* Ensure new children are disabled if their parent is */
276 if (XGET(obj, MUIA_Disabled))
277 nnset(obj, MUIA_Disabled, TRUE);
278
279 /* Some apps (Odyssey) expect _parent() will work before group tree is
280 * added to application tree */
281 muiNotifyData(msgint->obj)->mnd_ParentObject = obj;
282
283 if (_flags(obj) & MADF_SETUP)
284 {
285 DoSetupMethod(msgint->obj, muiRenderInfo(obj));
286 }
287 /* if (_flags(obj) & MADF_CANDRAW) */
288 /* DoShowMethod(msg->opam_Object); */
289
290 return TRUE;
291 }
292
293 /**************************************************************************
294 OM_NEW - Constructor
295 **************************************************************************/
296 IPTR Group__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
297 {
298 struct MUI_GroupData *data;
299 struct TagItem *tags, *tag;
300 BOOL bad_children = FALSE;
301 IPTR disabled = FALSE;
302 IPTR frame = MUIV_Frame_None;
303
304 D(bug("[group.mui] OM_NEW, object 0x%p\n", obj));
305
306 obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
307 if (!obj)
308 return 0;
309
310 /* Initial local instance data */
311 data = INST_DATA(cl, obj);
312
313 data->family = MUI_NewObjectA(MUIC_Family, NULL);
314 if (!data->family)
315 {
316 CoerceMethod(cl, obj, OM_DISPOSE);
317 return 0;
318 }
319
320 data->horiz_spacing = -1;
321 data->vert_spacing = -1;
322 data->columns = 1;
323 data->rows = 1;
324 data->active_page = 0;
325 get(obj, MUIA_Frame, &frame);
326
327 /* parse initial taglist */
328 for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
329 {
330 switch (tag->ti_Tag)
331 {
332 case MUIA_Group_Child:
333 D(bug("[group.mui] Adding child 0x%p\n", tag->ti_Data));
334 if (tag->ti_Data)
335 {
336 DoMethod(obj, OM_ADDMEMBER, tag->ti_Data);
337 /* Set first child as group title */
338 if ((frame == MUIV_Frame_Register)
339 && (data->titlegroup == NULL))
340 data->titlegroup = (Object *) tag->ti_Data;
341 }
342 else
343 bad_children = TRUE;
344 break;
345
346 case MUIA_Group_ActivePage:
347 change_active_page(cl, obj, (LONG) tag->ti_Data);
348 break;
349
350 case MUIA_Group_Columns:
351 data->columns = (tag->ti_Data) > 1 ? tag->ti_Data : 1;
352 data->rows = 0;
353 break;
354
355 case MUIA_Group_Horiz:
356 _handle_bool_tag(data->flags, tag->ti_Data, GROUP_HORIZ);
357 break;
358
359 case MUIA_Group_HorizSpacing:
360 data->flags |= GROUP_HSPACING;
361 data->horiz_spacing = tag->ti_Data;
362 break;
363
364 case MUIA_Group_LayoutHook:
365 data->layout_hook = (struct Hook *)tag->ti_Data;
366 break;
367
368 case MUIA_Group_PageMode:
369 _handle_bool_tag(data->flags, tag->ti_Data, GROUP_PAGEMODE);
370 break;
371
372 case MUIA_Group_Rows:
373 data->rows = MAX((ULONG) tag->ti_Data, 1);
374 data->columns = 0;
375 break;
376
377 case MUIA_Group_SameHeight:
378 _handle_bool_tag(data->flags, tag->ti_Data, GROUP_SAME_HEIGHT);
379 break;
380
381 case MUIA_Group_SameSize:
382 _handle_bool_tag(data->flags, tag->ti_Data, GROUP_SAME_HEIGHT);
383 _handle_bool_tag(data->flags, tag->ti_Data, GROUP_SAME_WIDTH);
384 break;
385
386 case MUIA_Group_SameWidth:
387 _handle_bool_tag(data->flags, tag->ti_Data, GROUP_SAME_WIDTH);
388 break;
389
390 case MUIA_Group_Spacing:
391 data->flags |= (GROUP_HSPACING | GROUP_VSPACING);
392 data->horiz_spacing = tag->ti_Data;
393 data->vert_spacing = tag->ti_Data;
394 break;
395
396 case MUIA_Group_VertSpacing:
397 data->flags |= GROUP_VSPACING;
398 data->vert_spacing = tag->ti_Data;
399 break;
400
401 case MUIA_Group_Virtual:
402 _handle_bool_tag(data->flags, tag->ti_Data, GROUP_VIRTUAL);
403 break;
404 }
405 }
406
407 if (bad_children)
408 {
409 CoerceMethod(cl, obj, OM_DISPOSE);
410 return 0;
411 }
412
413 /* D(bug("Group_New(0x%lx)\n",obj)); */
414
415 if (data->flags & GROUP_VIRTUAL)
416 {
417 /* This is used by MUI_Render() to determine if group is virtual.
418 * It then installs a clip region.
419 * Also MUI_Layout() uses this. Probably for speed up reason */
420 _flags(obj) |= MADF_ISVIRTUALGROUP;
421 }
422
423 /* will forward MUIA_Disabled to children */
424 get(obj, MUIA_Disabled, &disabled);
425 if (disabled)
426 {
427 set(obj, MUIA_Disabled, TRUE);
428 }
429
430 /* This is only used for virtual groups */
431 data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS; /* Will be filled on demand */
432 data->ehn.ehn_Priority = 10; /* Will hear the click before all
433 * other normal objects */
434 data->ehn.ehn_Flags = 0;
435 data->ehn.ehn_Object = obj;
436 data->ehn.ehn_Class = cl;
437 return (IPTR) obj;
438 }
439
440 /**************************************************************************
441 OM_DISPOSE
442 **************************************************************************/
443 IPTR Group__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
444 {
445 struct MUI_GroupData *data = INST_DATA(cl, obj);
446
447 if (data->row_infos != NULL)
448 mui_free(data->row_infos);
449 if (data->col_infos != NULL)
450 mui_free(data->col_infos);
451 if (data->family != NULL)
452 MUI_DisposeObject(data->family);
453 return DoSuperMethodA(cl, obj, msg);
454 }
455
456 /**************************************************************************
457 OM_SET
458 **************************************************************************/
459 IPTR Group__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
460 {
461 struct MUI_GroupData *data = INST_DATA(cl, obj);
462 struct TagItem *tags = msg->ops_AttrList;
463 struct TagItem *tag;
464 BOOL forward = TRUE;
465 BOOL need_recalc = FALSE;
466 IPTR retval;
467
468 int virt_offx = data->virt_offx, virt_offy = data->virt_offy;
469
470 /* There are many ways to find out what tag items provided by set()
471 ** we do know. The best way should be using NextTagItem() and simply
472 ** browsing through the list.
473 */
474
475 /* Parse group attributes before calling DoSuperMethodA(),
476 ** otherwise if an app for example sets up a notification
477 ** on MUIA_Group_ActivePage which calls a hook, and then
478 ** the hook function calls get(obj, MUIA_Group_ActivePage),
479 ** it would get returned the old active page instead of the new
480 ** active page
481 */
482
483 while ((tag = NextTagItem(&tags)) != NULL)
484 {
485 switch (tag->ti_Tag)
486 {
487 case MUIA_Group_Columns:
488 data->columns = MAX((ULONG) tag->ti_Data, 1);
489 data->rows = 0;
490 need_recalc = TRUE;
491 break;
492 case MUIA_Group_ActivePage:
493 change_active_page(cl, obj, (LONG) tag->ti_Data);
494 break;
495 case MUIA_Group_Forward:
496 forward = tag->ti_Data;
497 break;
498 case MUIA_Group_HorizSpacing:
499 data->flags |= GROUP_HSPACING;
500 data->horiz_spacing = tag->ti_Data;
501 break;
502 case MUIA_Group_Rows:
503 data->rows = MAX((ULONG) tag->ti_Data, 1);
504 data->columns = 0;
505 need_recalc = TRUE;
506 break;
507 case MUIA_Group_Spacing:
508 data->flags |= (GROUP_HSPACING | GROUP_VSPACING);
509 data->horiz_spacing = tag->ti_Data;
510 data->vert_spacing = tag->ti_Data;
511 break;
512 case MUIA_Group_VertSpacing:
513 data->flags |= GROUP_VSPACING;
514 data->vert_spacing = tag->ti_Data;
515 break;
516 case MUIA_Virtgroup_Left:
517 //kprintf("set virtgroup_left: %d\n", tag->ti_Data);
518 virt_offx = tag->ti_Data;
519 break;
520
521 case MUIA_Group_LayoutHook:
522 /*
523 [ach] Seems like MUI supports setting this attribute after
524 initialization, even though the documentation states
525 otherwise. At least some programs use it...
526 */
527 data->layout_hook = (struct Hook *)tag->ti_Data;
528 break;
529
530 case MUIA_Virtgroup_Top:
531 //kprintf("set virtgroup_top: %d\n", tag->ti_Data);
532 virt_offy = tag->ti_Data;
533 break;
534 }
535
536 }
537
538 if (muiRenderInfo(obj) && need_recalc)
539 DoMethod(_win(obj), MUIM_Window_RecalcDisplay, (IPTR) obj);
540
541 retval = DoSuperMethodA(cl, obj, (Msg) msg);
542
543 /* seems to be the documented behaviour, however it should be slow! */
544
545 if (forward)
546 {
547 /* Attributes which are to be filtered out, so that they are ignored
548 when OM_SET is passed to group's children */
549
550 tags = msg->ops_AttrList;
551 while ((tag = NextTagItem(&tags)) != NULL)
552 {
553 switch (tag->ti_Tag)
554 {
555 case MUIA_HelpLine:
556 case MUIA_HelpNode:
557 case MUIA_ObjectID:
558 case MUIA_UserData:
559
560 case MUIA_ContextMenu:
561 case MUIA_ContextMenuTrigger:
562 case MUIA_ControlChar:
563 case MUIA_CycleChain:
564 case MUIA_Draggable:
565 case MUIA_FillArea:
566 case MUIA_Group_ActivePage:
567 case MUIA_Frame:
568 case MUIA_FrameTitle:
569 case MUIA_HorizWeight:
570 case MUIA_Pressed:
571 case MUIA_ShortHelp:
572 case MUIA_ShowMe:
573 case MUIA_VertWeight:
574 case MUIA_Weight:
575 case MUIA_Virtgroup_Left:
576 case MUIA_Virtgroup_Top:
577 case MUIA_AppMessage:
578 case MUIA_Timer:
579 tag->ti_Tag = TAG_IGNORE;
580 break;
581 case MUIA_Selected:
582 /* D(bug("Group_Set(%p) MUIA_Selected forwarded\n", obj)); */
583 /* tag->ti_Tag = TAG_IGNORE; */
584 break;
585 }
586 }
587
588 Group_DispatchMsg(cl, obj, (Msg) msg);
589
590 }
591
592 if (virt_offx != data->virt_offx || virt_offy != data->virt_offy)
593 {
594 if (_flags(obj) & MADF_CANDRAW)
595 Group__MUIM_Hide(cl, obj, NULL);
596 data->virt_offx = virt_offx;
597 data->virt_offy = virt_offy;
598 /* Relayout ourselves. This will also relayout all the children */
599 DoMethod(obj, MUIM_Layout);
600 if (_flags(obj) & MADF_CANDRAW)
601 Group__MUIM_Show(cl, obj, NULL);
602 data->update = 2;
603 MUI_Redraw(obj, MADF_DRAWUPDATE);
604 }
605
606 return retval;
607 }
608
609
610 /**************************************************************************
611 OM_GET
612 **************************************************************************/
613 IPTR Group__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
614 {
615 /* small macro to simplify return value storage */
616 #define STORE *(msg->opg_Storage)
617
618 struct MUI_GroupData *data = INST_DATA(cl, obj);
619
620 switch (msg->opg_AttrID)
621 {
622 case MUIA_Version:
623 STORE = __version;
624 return 1;
625 case MUIA_Revision:
626 STORE = __revision;
627 return 1;
628 case MUIA_Group_ActivePage:
629 STORE = data->active_page;
630 return 1;
631 case MUIA_Group_ChildList:
632 return GetAttr(MUIA_Family_List, data->family, msg->opg_Storage);
633 case MUIA_Group_Horiz:
634 STORE = (data->flags & GROUP_HORIZ);
635 return 1;
636 case MUIA_Group_HorizSpacing:
637 STORE = data->horiz_spacing;
638 return 1;
639 case MUIA_Group_VertSpacing:
640 STORE = data->vert_spacing;
641 return 1;
642 case MUIA_Group_ChildCount:
643 STORE = data->num_children;
644 return 1;
645 case MUIA_Virtgroup_Left:
646 STORE = data->virt_offx;
647 return 1;
648 case MUIA_Virtgroup_Top:
649 STORE = data->virt_offy;
650 return 1;
651 case MUIA_Virtgroup_Width:
652 STORE = data->virt_mwidth;
653 return 1;
654 case MUIA_Virtgroup_Height:
655 STORE = data->virt_mheight;
656 return 1;
657 case MUIA_Virtgroup_MinWidth:
658 STORE = data->saved_minwidth;
659 return 1;
660 case MUIA_Virtgroup_MinHeight:
661 STORE = data->saved_minheight;
662 return 1;
663 }
664
665 /* our handler didn't understand the attribute, we simply pass
666 ** it to our superclass now
667 */
668 if (DoSuperMethodA(cl, obj, (Msg) msg))
669 return 1;
670
671 /* seems to be the documented behaviour, however it should be slow! */
672 if (!data->dont_forward_get && !data->dont_forward_methods)
673 {
674 Object *cstate;
675 Object *child;
676 struct MinList *ChildList = NULL;
677
678 get(data->family, MUIA_Family_List, &(ChildList));
679 cstate = (Object *) ChildList->mlh_Head;
680 while ((child = NextObject(&cstate)))
681 if (DoMethodA(child, (Msg) msg))
682 return 1;
683 }
684 return 0;
685 #undef STORE
686 }
687
688
689 /**************************************************************************
690 MUIM_AddTail
691 **************************************************************************/
692 IPTR Group__MUIM_AddTail(struct IClass *cl, Object *obj,
693 struct MUIP_Group_AddTail *msg)
694 {
695 return Group__MUIM_AddObject(cl, obj, (Msg) msg);
696 }
697
698 /**************************************************************************
699 MUIM_AddHead
700 **************************************************************************/
701 IPTR Group__MUIM_AddHead(struct IClass *cl, Object *obj,
702 struct MUIP_Group_AddHead *msg)
703 {
704 return Group__MUIM_AddObject(cl, obj, (Msg) msg);
705 }
706
707 /**************************************************************************
708 MUIM_Insert
709 **************************************************************************/
710 IPTR Group__MUIM_Insert(struct IClass *cl, Object *obj,
711 struct MUIP_Group_Insert *msg)
712 {
713 return Group__MUIM_AddObject(cl, obj, (Msg) msg);
714 }
715
716 /**************************************************************************
717 MUIM_Remove
718 **************************************************************************/
719 IPTR Group__MUIM_Remove(struct IClass *cl, Object *obj,
720 struct MUIP_Group_Remove *msg)
721 {
722 struct MUI_GroupData *data = INST_DATA(cl, obj);
723
724 if (_flags(obj) & MADF_CANDRAW)
725 DoHideMethod(msg->obj);
726 if (_flags(obj) & MADF_SETUP)
727 DoMethod(msg->obj, MUIM_Cleanup);
728 if (muiNotifyData(obj)->mnd_GlobalInfo)
729 {
730 DoMethod(msg->obj, MUIM_DisconnectParent);
731 muiNotifyData(msg->obj)->mnd_ParentObject = NULL;
732
733 _flags(msg->obj) &= ~MADF_INVIRTUALGROUP;
734 }
735
736 if ((data->flags & GROUP_CHANGING) != 0)
737 data->flags |= GROUP_CHANGED;
738 data->num_children--;
739 DoMethodA(data->family, (Msg) msg);
740
741 return TRUE;
742 }
743
744
745 /**************************************************************************
746 MUIM_ConnectParent
747 **************************************************************************/
748 IPTR Group__MUIM_ConnectParent(struct IClass *cl, Object *obj,
749 struct MUIP_ConnectParent *msg)
750 {
751 struct MUI_GroupData *data = INST_DATA(cl, obj);
752 Object *cstate;
753 Object *child;
754 struct MinList *ChildList = NULL;
755
756 DoSuperMethodA(cl, obj, (Msg) msg);
757
758 get(data->family, MUIA_Family_List, &(ChildList));
759 cstate = (Object *) ChildList->mlh_Head;
760 while ((child = NextObject(&cstate)))
761 {
762 if ((_flags(obj) & MADF_INVIRTUALGROUP)
763 || (data->flags & GROUP_VIRTUAL))
764 {
765 _flags(child) |= MADF_INVIRTUALGROUP;
766 }
767
768 /* Only children of groups can have parents */
769 muiNotifyData(child)->mnd_ParentObject = obj;
770
771 DoMethod(child, MUIM_ConnectParent, (IPTR) obj);
772 }
773 return TRUE;
774 }
775
776 /**************************************************************************
777 MUIM_DisconnectParent
778 **************************************************************************/
779 IPTR Group__MUIM_DisconnectParent(struct IClass *cl, Object *obj,
780 struct MUIP_ConnectParent *msg)
781 {
782 struct MUI_GroupData *data = INST_DATA(cl, obj);
783 Object *cstate;
784 Object *child;
785 struct MinList *ChildList = NULL;
786
787 get(data->family, MUIA_Family_List, &(ChildList));
788 cstate = (Object *) ChildList->mlh_Head;
789 while ((child = NextObject(&cstate)))
790 {
791 DoMethodA(child, (Msg) msg);
792 muiNotifyData(child)->mnd_ParentObject = NULL;
793 _flags(child) &= ~MADF_INVIRTUALGROUP;
794 }
795 DoSuperMethodA(cl, obj, (Msg) msg);
796 return TRUE;
797 }
798
799 /*
800 * Put group in exchange state
801 */
802 IPTR Group__MUIM_InitChange(struct IClass *cl, Object *obj,
803 struct MUIP_Group_InitChange *msg)
804 {
805 struct MUI_GroupData *data = INST_DATA(cl, obj);
806
807 data->flags &= ~GROUP_CHANGED;
808 data->flags |= GROUP_CHANGING;
809 return TRUE;
810 }
811
812
813 /*
814 * Will recalculate display after dynamic adding/removing
815 */
816 IPTR Group__MUIM_ExitChange(struct IClass *cl, Object *obj,
817 struct MUIP_Group_ExitChange *msg)
818 {
819 struct MUI_GroupData *data = INST_DATA(cl, obj);
820
821 data->flags &= ~GROUP_CHANGING;
822
823 #if 0
824 /* Code is invalid. ExitChange needs to re-layout each time (tested
825 * with MUI 3.8 and MUI 4.0 on m68k).
826 * This is temporary change until proper implementaion is in place. */
827 if (data->flags & GROUP_CHANGED)
828 #endif
829 {
830 data->flags &= ~GROUP_CHANGED;
831
832 if ((_flags(obj) & MADF_SETUP) && _win(obj))
833 {
834 Object *win = _win(obj);
835 Object *parent = obj;
836
837 /* CHECKME: Don't call RecalcDisplay if one of our parents is
838 in GROUP_CHANGING state to prevent crash with Zune prefs
839 program NListtree page because NList/NListtree when
840 killing tree images in MUIM_Cleanup uses InitChange/
841 ExitChange. Zune prefs program uses InitChange/ExitChange
842 when switching page -> nesting -> mess. */
843
844 while ((parent = _parent(parent)))
845 {
846 struct MUI_GroupData *pdata = INST_DATA(cl, parent);
847
848 if (parent == win)
849 break;
850
851 if (pdata->flags & GROUP_CHANGING)
852 {
853 return TRUE;
854 }
855
856 }
857
858 DoMethod(win, MUIM_Window_RecalcDisplay, (IPTR) obj);
859 }
860 }
861
862 return TRUE;
863 }
864
865
866 /*
867 * Will recalculate display after dynamic adding/removing
868 */
869 IPTR Group__MUIM_ExitChange2(struct IClass *cl, Object *obj,
870 struct MUIP_Group_ExitChange2 *msg)
871 {
872 struct MUI_GroupData *data = INST_DATA(cl, obj);
873
874 if (data->flags & GROUP_CHANGING)
875 {
876 data->flags &= ~(GROUP_CHANGING | GROUP_CHANGED);
877
878 if ((_flags(obj) & MADF_SETUP) && _win(obj))
879 {
880 Object *win = _win(obj);
881 Object *parent = obj;
882
883 /* CHECKME: Don't call RecalcDisplay if one of our parents is
884 in GROUP_CHANGING state to prevent crash with Zune prefs
885 program NListtree page because NList/NListtree when
886 killing tree images in MUIM_Cleanup uses InitChange/
887 ExitChange. Zune prefs program uses InitChange/ExitChange
888 when switching page -> nesting -> mess. */
889
890 while ((parent = _parent(parent)))
891 {
892 struct MUI_GroupData *pdata = INST_DATA(cl, parent);
893
894 if (parent == win)
895 break;
896
897 if (pdata->flags & GROUP_CHANGING)
898 {
899 return TRUE;
900 }
901
902 }
903
904 DoMethod(win, MUIM_Window_RecalcDisplay, (IPTR) obj);
905 }
906 }
907
908 return TRUE;
909 }
910
911
912 /*
913 * Sort the family
914 */
915 IPTR Group__MUIM_Sort(struct IClass *cl, Object *obj,
916 struct MUIP_Group_Sort *msg)
917 {
918 struct MUI_GroupData *data = INST_DATA(cl, obj);
919
920 /* modify message */
921 msg->MethodID = MUIM_Family_Sort;
922
923 DoMethodA(data->family, (APTR) msg);
924
925 /* restore original message */
926 msg->MethodID = MUIM_Group_Sort;
927 return TRUE;
928 }
929
930 /**************************************************************************
931 MUIM_Group_DoMethodNoForward
932
933 Executes the given method but does not forward it to the children
934 **************************************************************************/
935 IPTR Group__MUIM_DoMethodNoForward(struct IClass *cl, Object *obj,
936 struct MUIP_Group_DoMethodNoForward *msg)
937 {
938 struct MUI_GroupData *data = INST_DATA(cl, obj);
939 IPTR rc;
940 data->dont_forward_methods = 1; /* disable forwarding */
941 rc = DoMethodA(obj, (Msg) & msg->DoMethodID);
942 /* Probably doesn't work correctly on AROS? */
943
944 data->dont_forward_methods = 0;
945 return rc;
946 }
947
948 /*
949 * Propagate a method to group children.
950 */
951 static ULONG Group_DispatchMsg(struct IClass *cl, Object *obj, Msg msg)
952 {
953 struct MUI_GroupData *data = INST_DATA(cl, obj);
954 Object *cstate;
955 Object *child;
956 struct MinList *ChildList = NULL;
957
958 if (data->dont_forward_methods)
959 return TRUE;
960
961 get(data->family, MUIA_Family_List, &(ChildList));
962 cstate = (Object *) ChildList->mlh_Head;
963 while ((child = NextObject(&cstate)))
964 {
965 DoMethodA(child, (Msg) msg);
966 }
967 return TRUE;
968 }
969
970
971 /**************************************************************************
972 MUIM_Setup
973 **************************************************************************/
974 IPTR Group__MUIM_Setup(struct IClass *cl, Object *obj,
975 struct MUIP_Setup *msg)
976 {
977 struct MUI_GroupData *data = INST_DATA(cl, obj);
978 Object *cstate;
979 Object *cstate_copy;
980 Object *child;
981 Object *childFailed;
982 struct MinList *ChildList = NULL;
983
984 if (!DoSuperMethodA(cl, obj, (Msg) msg))
985 return FALSE;
986
987 ASSERT_VALID_PTR(muiGlobalInfo(obj));
988
989 if (!(data->flags & GROUP_HSPACING))
990 data->horiz_spacing = muiGlobalInfo(obj)->mgi_Prefs->group_hspacing;
991 if (!(data->flags & GROUP_VSPACING))
992 data->vert_spacing = muiGlobalInfo(obj)->mgi_Prefs->group_vspacing;
993 get(data->family, MUIA_Family_List, &(ChildList));
994 cstate = cstate_copy = (Object *) ChildList->mlh_Head;
995 while ((child = NextObject(&cstate)))
996 {
997 #if 0 /* SHOWME affects only show/hide */
998 if (!(_flags(child) & MADF_SHOWME))
999 continue;
1000 #endif
1001
1002 if (!DoSetupMethod(child, msg->RenderInfo))
1003 {
1004 /* Send MUIM_Cleanup to all objects that received MUIM_Setup.
1005 */
1006 childFailed = child;
1007 cstate = cstate_copy;
1008 while ((child = NextObject(&cstate)) && (child != childFailed))
1009 {
1010 #if 0 /* SHOWME affects only show/hide */
1011 if (!(_flags(child) & MADF_SHOWME))
1012 continue;
1013 #endif
1014 DoMethod(child, MUIM_Cleanup);
1015 }
1016 return FALSE;
1017 }
1018 }
1019
1020 if (data->flags & GROUP_VIRTUAL)
1021 {
1022 DoMethod(_win(obj), MUIM_Window_AddEventHandler,
1023 (IPTR) & data->ehn);
1024 }
1025
1026 return TRUE;
1027 }
1028
1029
1030 /**************************************************************************
1031 MUIM_Cleanup
1032 **************************************************************************/
1033 IPTR Group__MUIM_Cleanup(struct IClass *cl, Object *obj, Msg msg)
1034 {
1035 struct MUI_GroupData *data = INST_DATA(cl, obj);
1036 Object *cstate;
1037 Object *child;
1038 struct MinList *ChildList = NULL;
1039
1040 if (data->flags & GROUP_VIRTUAL)
1041 {
1042 DoMethod(_win(obj), MUIM_Window_RemEventHandler,
1043 (IPTR) & data->ehn);
1044 }
1045
1046 get(data->family, MUIA_Family_List, &(ChildList));
1047 cstate = (Object *) ChildList->mlh_Head;
1048 while ((child = NextObject(&cstate)))
1049 {
1050 #if 0 /* SHOWME affects only show/hide */
1051 if (!(_flags(child) & MADF_SHOWME))
1052 continue;
1053 #endif
1054 DoMethodA(child, (Msg) msg);
1055 }
1056 return DoSuperMethodA(cl, obj, (Msg) msg);
1057 }
1058
1059 static struct Region *group_children_clip_region(struct IClass *cl,
1060 Object *obj)
1061 {
1062 struct Region *region = NULL;
1063
1064 region = NewRegion();
1065 if (region)
1066 {
1067 struct MUI_GroupData *data = INST_DATA(cl, obj);
1068 struct Rectangle rect;
1069 LONG page = -1;
1070 struct MinList *ChildList = NULL;
1071 Object *cstate;
1072 Object *child;
1073
1074 rect.MinX = _left(obj);
1075 rect.MinY = _top(obj);
1076 rect.MaxX = _right(obj);
1077 rect.MaxY = _bottom(obj);
1078
1079 OrRectRegion(region, &rect);
1080 get(data->family, MUIA_Family_List, &ChildList);
1081 cstate = (Object *) ChildList->mlh_Head;
1082 while ((child = NextObject(&cstate)))
1083 {
1084 if (child != data->titlegroup)
1085 ++page;
1086
1087 if ((data->flags & GROUP_PAGEMODE) && (page != data->active_page)
1088 && (child != data->titlegroup))
1089 continue;
1090
1091 if ((muiAreaData(child)->mad_Flags & MADF_CANDRAW)
1092 && (_width(child) > 0) && (_height(child) > 0))
1093 {
1094 rect.MinX = MAX(_left(child), _mleft(obj));
1095 rect.MinY = MAX(_top(child), _mtop(obj));
1096 rect.MaxX = MIN(_right(child), _mright(obj));
1097 rect.MaxY = MIN(_bottom(child), _mbottom(obj));
1098
1099 if ((rect.MaxX >= rect.MinX) && (rect.MaxY >= rect.MinY))
1100 {
1101 ClearRectRegion(region, &rect);
1102 }
1103 }
1104 }
1105 }
1106
1107 return region;
1108 }
1109
1110 /**************************************************************************
1111 MUIM_Draw - draw the group
1112 **************************************************************************/
1113 IPTR Group__MUIM_Draw(struct IClass *cl, Object *obj,
1114 struct MUIP_Draw *msg)
1115 {
1116 struct MUI_GroupData *data = INST_DATA(cl, obj);
1117 Object *cstate;
1118 Object *child;
1119 struct MinList *ChildList = NULL;
1120 struct Rectangle group_rect; /* child_rect; */
1121 int page;
1122 struct Region *region = NULL;
1123 APTR clip = (APTR) - 1;
1124
1125 if (data->flags & GROUP_CHANGING)
1126 return FALSE;
1127
1128 if (muiGlobalInfo(obj)->mgi_Prefs->window_redraw
1129 == WINDOW_REDRAW_WITHOUT_CLEAR)
1130 {
1131 struct Region *r = group_children_clip_region(cl, obj);
1132 APTR c = (APTR)-1;
1133 if (r)
1134 c = MUI_AddClipRegion(muiRenderInfo(obj), r);
1135
1136 DoSuperMethodA(cl, obj, (Msg) msg);
1137
1138 if (r)
1139 MUI_RemoveClipRegion(muiRenderInfo(obj), c);
1140 }
1141 else
1142 {
1143 DoSuperMethodA(cl, obj, (Msg) msg);
1144 }
1145
1146 if ((msg->flags & MADF_DRAWUPDATE) && data->update == 1)
1147 {
1148 struct Region *r = NULL;
1149 APTR c = (APTR)-1;
1150
1151 if (muiGlobalInfo(obj)->mgi_Prefs->window_redraw
1152 == WINDOW_REDRAW_WITHOUT_CLEAR)
1153 r = group_children_clip_region(cl, obj);
1154
1155 if (r)
1156 c = MUI_AddClipRegion(muiRenderInfo(obj), r);
1157
1158 /*
1159 * update is set when changing active page of a page group
1160 * need to redraw background ourself
1161 */
1162 DoMethod(obj, MUIM_DrawBackground,
1163 _mleft(obj), _mtop(obj), _mwidth(obj), _mheight(obj),
1164 _mleft(obj), _mtop(obj), 0);
1165
1166 if (r)
1167 MUI_RemoveClipRegion(muiRenderInfo(obj), c);
1168 }
1169 else
1170 {
1171 if ((msg->flags & MADF_DRAWUPDATE) && data->update == 2)
1172 {
1173 LONG left, top, right, bottom;
1174 LONG diff_virt_offx = data->virt_offx - data->old_virt_offx;
1175 LONG diff_virt_offy = data->virt_offy - data->old_virt_offy;
1176 struct Rectangle rect;
1177 struct Rectangle *clip_rect = &muiRenderInfo(obj)->mri_ClipRect;
1178
1179 data->update = 0;
1180
1181 if (!diff_virt_offx && !diff_virt_offy)
1182 {
1183 return 1;
1184 }
1185
1186 /* sba: I don't know how MUI handle this but ScrollRasterBF() made problems when scrolling
1187 ** a (partly visible) virtual groups in a virtual group, because e.g. _mtop() is then
1188 ** smaller than the region. ScrollRasterBF() on AmigaOS then marks the complete region
1189 ** as damaged. Using ScrollWindowRaster() solved that problem but it flickers then.
1190 ** To avoid this we prevent that the scroll area is out of the region bounds.
1191 ** The region bounds are setted in MUI_Redraw() but should probably should go in the
1192 ** MUI's clip functions
1193 */
1194
1195 left = MAX(_mleft(obj), clip_rect->MinX);
1196 top = MAX(_mtop(obj), clip_rect->MinY);
1197 right = MIN(_mright(obj), clip_rect->MaxX);
1198 bottom = MIN(_mbottom(obj), clip_rect->MaxY);
1199
1200 /* old code was
1201 ** ScrollRasterBF(_rp(obj), diff_virt_offx, diff_virt_offy, _mleft(obj), _mtop(obj), _mright(obj),_mbottom(obj));
1202 */
1203
1204 ScrollWindowRaster(_window(obj), diff_virt_offx, diff_virt_offy,
1205 left, top, right, bottom);
1206
1207 if ((region = NewRegion()))
1208 {
1209 if (diff_virt_offx)
1210 {
1211 rect.MinY = top;
1212 rect.MaxY = bottom;
1213
1214 if (diff_virt_offx > 0)
1215 {
1216 rect.MinX = right - diff_virt_offx + 1;
1217 if (rect.MinX < left)
1218 rect.MinX = left;
1219 rect.MaxX = right;
1220 }
1221 else
1222 {
1223 rect.MinX = left;
1224 rect.MaxX = left - diff_virt_offx - 1;
1225 if (rect.MaxX > right)
1226 rect.MaxX = right;
1227 }
1228
1229 if (rect.MinX <= rect.MaxX)
1230 {
1231 DoMethod(obj, MUIM_DrawBackground,
1232 rect.MinX, rect.MinY,
1233 rect.MaxX - rect.MinX + 1,
1234 rect.MaxY - rect.MinY + 1,
1235 rect.MinX, rect.MinY, 0);
1236
1237 OrRectRegion(region, &rect);
1238 }
1239 }
1240
1241 if (diff_virt_offy)
1242 {
1243 rect.MinX = left;
1244 rect.MaxX = right;
1245
1246 if (diff_virt_offy > 0)
1247 {
1248 rect.MinY = bottom - diff_virt_offy + 1;
1249 if (rect.MinY < top)
1250 rect.MinY = top;
1251 rect.MaxY = bottom;
1252 }
1253 else
1254 {
1255 rect.MinY = top;
1256 rect.MaxY = top - diff_virt_offy - 1;
1257 if (rect.MaxY > bottom)
1258 rect.MaxY = bottom;
1259 }
1260 if (rect.MinY <= rect.MaxY)
1261 {
1262 DoMethod(obj, MUIM_DrawBackground,
1263 rect.MinX, rect.MinY,
1264 rect.MaxX - rect.MinX + 1,
1265 rect.MaxY - rect.MinY + 1,
1266 rect.MinX, rect.MinY, 0);
1267
1268 OrRectRegion(region, &rect);
1269 }
1270 }
1271 }
1272
1273 }
1274 else
1275 {
1276 if (!(msg->flags & MADF_DRAWOBJECT)
1277 && !(msg->flags & MADF_DRAWALL))
1278 return TRUE;
1279 }
1280 }
1281
1282 if (data->flags & GROUP_VIRTUAL && !region)
1283 {
1284 /* Not really needed if MUI Draws all the objects, maybe that's
1285 * what DRAWALL is for??? */
1286 if ((region = NewRegion()))
1287 {
1288 struct Rectangle rect;
1289 rect.MinX = _mleft(obj);
1290 rect.MinY = _mtop(obj);
1291 rect.MaxX = _mright(obj);
1292 rect.MaxY = _mbottom(obj);
1293 OrRectRegion(region, &rect);
1294 }
1295 }
1296
1297 /* Add clipping region if we have one */
1298 if (region)
1299 clip = MUI_AddClipRegion(muiRenderInfo(obj), region);
1300
1301 group_rect = muiRenderInfo(obj)->mri_ClipRect;
1302 page = -1;
1303 get(data->family, MUIA_Family_List, &(ChildList));
1304 cstate = (Object *) ChildList->mlh_Head;
1305 while ((child = NextObject(&cstate)))
1306 {
1307 if (!(_flags(child) & MADF_SHOWME))
1308 continue;
1309
1310 if (child != data->titlegroup)
1311 ++page;
1312
1313 if ((data->flags & GROUP_PAGEMODE) && ((page != data->active_page)
1314 && (child != data->titlegroup)))
1315 {
1316 continue;
1317 }
1318
1319 if ((data->flags & GROUP_PAGEMODE) && (child == data->titlegroup)
1320 && (msg->flags & MADF_DRAWUPDATE) && (data->update == 1))
1321 {
1322 /* Do not issue a re-draw to title group during page switch.
1323 * The group will re-draw itself due to setting of
1324 * MUIA_Group_ActivePage attribute.
1325 */
1326 continue;
1327 }
1328
1329 MUI_Redraw(child, MADF_DRAWOBJECT);
1330 muiRenderInfo(obj)->mri_ClipRect = group_rect;
1331 }
1332
1333 if (data->flags & GROUP_VIRTUAL && region && clip != (APTR) - 1)
1334 {
1335 MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
1336 }
1337
1338 data->old_virt_offx = data->virt_offx;
1339 data->old_virt_offy = data->virt_offy;
1340 data->update = 0;
1341
1342 return TRUE;
1343 }
1344
1345
1346 #define END_MINMAX() \
1347 tmp.MaxHeight = MAX(tmp.MaxHeight, tmp.MinHeight); \
1348 tmp.MaxWidth = MAX(tmp.MaxWidth, tmp.MinWidth); \
1349 tmp.DefHeight = CLAMP(tmp.DefHeight, tmp.MinHeight, tmp.MaxHeight); \
1350 tmp.DefWidth = CLAMP(tmp.DefWidth, tmp.MinWidth, tmp.MaxWidth); \
1351 msg->MinMaxInfo->MinWidth += tmp.MinWidth; \
1352 msg->MinMaxInfo->MinHeight += tmp.MinHeight; \
1353 msg->MinMaxInfo->MaxWidth += tmp.MaxWidth; \
1354 msg->MinMaxInfo->MaxHeight += tmp.MaxHeight; \
1355 msg->MinMaxInfo->DefWidth += tmp.DefWidth; \
1356 msg->MinMaxInfo->DefHeight += tmp.DefHeight;
1357
1358 /*
1359 * MinMax calculation function. When this is called,
1360 * the children of your group have already been asked
1361 * about their min/max dimension so you can use their
1362 * dimensions to calculate yours.
1363 *
1364 * Notes:
1365 * - Init minwidth and maxwidth with size needed for total child spacing.
1366 * - 1st pass to find maximum minimum width, to set minwidth of each child
1367 * if they should have the same width (for a row of buttons ...)
1368 * - Adjust minwidth w/o making object bigger than their max size.
1369 */
1370 static void group_minmax_horiz(struct IClass *cl, Object *obj,
1371 struct MinList *children, struct MUIP_AskMinMax *msg)
1372 {
1373 struct MUI_GroupData *data = INST_DATA(cl, obj);
1374 Object *cstate;
1375 Object *child;
1376 struct MUI_MinMax tmp;
1377 WORD maxminwidth = 0;
1378 BOOL found_nonzero_vweight = FALSE;
1379
1380 tmp.MinHeight = 0;
1381 tmp.DefHeight = 0;
1382 tmp.MaxHeight = MUI_MAXMAX;
1383 if (data->num_visible_children > 0)
1384 {
1385 tmp.MinWidth = tmp.DefWidth = tmp.MaxWidth =
1386 (data->num_visible_children - 1) * data->horiz_spacing;
1387 }
1388 else
1389 {
1390 tmp.MinWidth = tmp.DefWidth = 0;
1391 tmp.MaxWidth = MUI_MAXMAX;
1392 }
1393
1394 if (data->flags & GROUP_SAME_WIDTH)
1395 {
1396 cstate = (Object *) children->mlh_Head;
1397 while ((child = NextObject(&cstate)))
1398 {
1399 if (IS_HIDDEN(child))
1400 continue;
1401 maxminwidth = MAX(maxminwidth, _minwidth(child));
1402 }
1403 }
1404
1405 data->samesize_maxmin_horiz = maxminwidth;
1406 /* D(bug("group_minmax_horiz(%p) : maxminwidth=%d\n", obj, maxminwidth)); */
1407
1408 data->horiz_weight_sum = 0;
1409 cstate = (Object *) children->mlh_Head;
1410 while ((child = NextObject(&cstate)))
1411 {
1412 WORD minwidth;
1413
1414 if (IS_HIDDEN(child))
1415 continue;
1416 if (data->flags & GROUP_SAME_WIDTH)
1417 {
1418 minwidth = MAX(maxminwidth, _minwidth(child));
1419 minwidth = MIN(minwidth, _maxwidth(child));
1420 }
1421 else
1422 minwidth = _minwidth(child);
1423 tmp.MinWidth += minwidth;
1424 tmp.DefWidth += w0_defwidth(child);
1425 tmp.MaxWidth += w0_maxwidth(child);
1426 tmp.MaxWidth = MIN(tmp.MaxWidth, MUI_MAXMAX);
1427 tmp.MinHeight = MAX(tmp.MinHeight, _minheight(child));
1428 tmp.DefHeight = MAX(tmp.DefHeight, _defheight(child));
1429 /*
1430 if all children have null weight then maxheight=minheight
1431 if all but some children have null weights, the maxheight
1432 is the min of all maxheights
1433 */
1434 tmp.MaxHeight = MIN(tmp.MaxHeight, _maxheight(child));
1435 data->horiz_weight_sum += _hweight(child);
1436 if (_vweight(child) > 0)
1437 {
1438 found_nonzero_vweight = TRUE;
1439 }
1440 }
1441 if (!found_nonzero_vweight)
1442 {
1443 tmp.MaxHeight = tmp.MinHeight;
1444 }
1445
1446 //if (data->flags & GROUP_VIRTUAL)
1447 //{
1448 //kprintf("# min %d x %d def %d x %d max %d x %d\n",
1449 // tmp.MinWidth, tmp.MinHeight,
1450 // tmp.DefWidth, tmp.DefHeight,
1451 // tmp.MaxWidth, tmp.MaxHeight);
1452 //}
1453
1454 END_MINMAX();
1455 }
1456
1457 /* minmax calculation for vertical groups (see group_minmax_horiz)
1458 */
1459 static void group_minmax_vert(struct IClass *cl, Object *obj,
1460 struct MinList *children, struct MUIP_AskMinMax *msg)
1461 {
1462 struct MUI_GroupData *data = INST_DATA(cl, obj);
1463 Object *cstate;
1464 Object *child;
1465 struct MUI_MinMax tmp;
1466 WORD maxminheight = 0;
1467 BOOL found_nonzero_hweight = FALSE;
1468
1469 tmp.MinWidth = 0;
1470 tmp.DefWidth = 0;
1471 tmp.MaxWidth = MUI_MAXMAX;
1472 if (data->num_visible_children > 0)
1473 {
1474 tmp.MinHeight = tmp.DefHeight = tmp.MaxHeight =
1475 (data->num_visible_children - 1) * data->vert_spacing;
1476 }
1477 else
1478 {
1479 tmp.MinHeight = tmp.DefHeight = 0;
1480 tmp.MaxHeight = MUI_MAXMAX;
1481 }
1482
1483 if (data->flags & GROUP_SAME_HEIGHT)
1484 {
1485 cstate = (Object *) children->mlh_Head;
1486 while ((child = NextObject(&cstate)))
1487 {
1488 if (IS_HIDDEN(child))
1489 continue;
1490 maxminheight = MAX(maxminheight, _minheight(child));
1491 }
1492 }
1493
1494 data->samesize_maxmin_vert = maxminheight;
1495 data->vert_weight_sum = 0;
1496 cstate = (Object *) children->mlh_Head;
1497 while ((child = NextObject(&cstate)))
1498 {
1499 if (IS_HIDDEN(child))
1500 continue;
1501
1502 if (data->flags & GROUP_SAME_HEIGHT)
1503 _minheight(child) = MIN(maxminheight, w0_maxheight(child));
1504 tmp.MinHeight += _minheight(child);
1505 tmp.DefHeight += w0_defheight(child);
1506 tmp.MaxHeight += w0_maxheight(child);
1507 tmp.MaxHeight = MIN(tmp.MaxHeight, MUI_MAXMAX);
1508 tmp.MinWidth = MAX(tmp.MinWidth, _minwidth(child));
1509 tmp.DefWidth = MAX(tmp.DefWidth, _defwidth(child));
1510 tmp.MaxWidth = MIN(tmp.MaxWidth, _maxwidth(child));
1511 data->vert_weight_sum += _vweight(child);
1512 if (_hweight(child) > 0)
1513 {
1514 found_nonzero_hweight = TRUE;
1515 }
1516 }
1517 if (!found_nonzero_hweight)
1518 {
1519 tmp.MaxWidth = tmp.MinWidth;
1520 }
1521
1522 END_MINMAX();
1523 }
1524
1525
1526 static void
1527 minmax_2d_rows_pass(struct MUI_GroupData *data, struct MinList *children,
1528 struct MUI_MinMax *req, WORD maxmin_height, WORD maxdef_height)
1529 {
1530 int i, j;
1531 Object *cstate;
1532 Object *child;
1533
1534 /* do not rewind after the while, to process line by line */
1535 cstate = (Object *) children->mlh_Head;
1536 /* for each row */
1537 for (i = 0; i < data->rows; i++)
1538 {
1539 /* calculate min and max height of this row */
1540 int min_h = 0, def_h = 0, max_h = MUI_MAXMAX;
1541 BOOL found_nonzero_vweight = FALSE;
1542
1543 data->row_infos[i].weight = 0;
1544
1545 j = 0;
1546 while ((child = NextObject(&cstate)))
1547 {
1548 if (IS_HIDDEN(child))
1549 continue;
1550 if (data->flags & GROUP_SAME_HEIGHT)
1551 {
1552 _minheight(child) = MIN(maxmin_height, w0_maxheight(child));
1553 _defheight(child) = MIN(maxdef_height, w0_maxheight(child));
1554 }
1555 min_h = MAX(min_h, _minheight(child));
1556 def_h = MAX(def_h, w0_defheight(child));
1557 max_h = MIN(max_h, _maxheight(child));
1558 if (_vweight(child) > 0)
1559 {
1560 found_nonzero_vweight = TRUE;
1561 data->row_infos[i].weight += _vweight(child);
1562 }
1563 ++j;
1564 if ((j % data->columns) == 0)
1565 break;
1566 }
1567 if (!found_nonzero_vweight)
1568 max_h = min_h;
1569 else
1570 max_h = MAX(max_h, min_h);
1571 /* D(bug("row %d : min_h=%d max_h=%d\n", i, min_h, max_h)); */
1572
1573 data->row_infos[i].min = min_h;
1574 data->row_infos[i].max = max_h;
1575 data->vert_weight_sum += data->row_infos[i].weight;
1576
1577 req->MinHeight += min_h;
1578 req->DefHeight += def_h;
1579 req->MaxHeight += max_h;
1580 if (req->MaxHeight > MUI_MAXMAX)
1581 req->MaxHeight = MUI_MAXMAX;
1582 }
1583 }
1584
1585
1586 static void
1587 minmax_2d_columns_pass(struct MUI_GroupData *data, struct MinList *children,
1588 struct MUI_MinMax *req, WORD maxmin_width, WORD maxdef_width)
1589 {
1590 int i, j;
1591 Object *cstate;
1592 Object *child;
1593
1594 for (i = 0; i < data->columns; i++)
1595 {
1596 /* calculate min and max width of this column */
1597 int min_w = 0, def_w = 0, max_w = MUI_MAXMAX;
1598 BOOL found_nonzero_hweight = FALSE;
1599
1600 data->col_infos[i].weight = 0;
1601
1602 j = 0;
1603 /* process all children to get children on a column */
1604 cstate = (Object *) children->mlh_Head;
1605 while ((child = NextObject(&cstate)))
1606 {
1607 if (IS_HIDDEN(child))
1608 continue;
1609 ++j;
1610 if (((j - 1) % data->columns) != i)
1611 continue;
1612 if (data->flags & GROUP_SAME_WIDTH)
1613 {
1614 _minwidth(child) = MIN(maxmin_width, w0_maxwidth(child));
1615 _defwidth(child) = MIN(maxdef_width, w0_maxwidth(child));
1616 }
1617 min_w = MAX(min_w, _minwidth(child));
1618 def_w = MAX(def_w, w0_defwidth(child));
1619
1620 /* this handles the case of null weight children, which limit
1621 * the max size if they're alone, but not if they are with
1622 * non-null weight obj
1623 */
1624 max_w = MIN(max_w, _maxwidth(child));
1625 if (_hweight(child) > 0)
1626 {
1627 found_nonzero_hweight = TRUE;
1628 data->col_infos[i].weight += _hweight(child);
1629 }
1630 }
1631 if (!found_nonzero_hweight)
1632 max_w = min_w;
1633 else
1634 max_w = MAX(max_w, min_w);
1635 /* D(bug("col %d : min_w=%d max_w=%d\n", i, min_w, max_w)); */
1636
1637 data->col_infos[i].min = min_w;
1638 data->col_infos[i].max = max_w;
1639 data->horiz_weight_sum += data->col_infos[i].weight;
1640
1641 req->MinWidth += min_w;
1642 req->DefWidth += def_w;
1643 req->MaxWidth += max_w;
1644 if (req->MaxWidth > MUI_MAXMAX)
1645 req->MaxWidth = MUI_MAXMAX;
1646 }
1647 }
1648
1649 static void
1650 group_minmax_2d(struct IClass *cl, Object *obj,
1651 struct MinList *children, struct MUIP_AskMinMax *msg)
1652 {
1653 struct MUI_GroupData *data = INST_DATA(cl, obj);
1654 Object *cstate;
1655 Object *child;
1656 struct MUI_MinMax tmp;
1657 WORD maxmin_width;
1658 WORD maxmin_height;
1659 WORD maxdef_width;
1660 WORD maxdef_height;
1661
1662 if (!data->columns)
1663 {
1664 if (data->num_children % data->rows)
1665 {
1666 data->columns = 1;
1667 data->rows = data->num_children;
1668 }
1669 else
1670 data->columns = data->num_children / data->rows;
1671 }
1672 else
1673 {
1674 if (data->num_children % data->columns)
1675 {
1676 data->rows = 1;
1677 data->columns = data->num_children;
1678 }
1679 else
1680 data->rows = data->num_children / data->columns;
1681 }
1682
1683 if (data->columns < 1)
1684 data->columns = 1;
1685 if (data->rows < 1)
1686 data->rows = 1;
1687
1688 if (data->row_infos != NULL)
1689 mui_free(data->row_infos);
1690
1691 data->row_infos = mui_alloc(data->rows * sizeof(struct layout2d_elem));
1692 if (NULL == data->row_infos)
1693 return;
1694
1695 if (data->col_infos != NULL)
1696 mui_free(data->col_infos);
1697
1698 data->col_infos =
1699 mui_alloc(data->columns * sizeof(struct layout2d_elem));
1700 if (NULL == data->col_infos)
1701 return;
1702
1703 data->horiz_weight_sum = 0;
1704 data->vert_weight_sum = 0;
1705
1706 tmp.MinHeight = tmp.DefHeight = tmp.MaxHeight =
1707 (data->rows - 1) * data->vert_spacing;
1708 tmp.MinWidth = tmp.DefWidth = tmp.MaxWidth =
1709 (data->columns - 1) * data->horiz_spacing;
1710 /* get minimum dims if same dims for all children are needed */
1711 maxmin_width = 0;
1712 maxmin_height = 0;
1713 maxdef_width = 0;
1714 maxdef_height = 0;
1715
1716 if ((data->flags & GROUP_SAME_WIDTH)
1717 || (data->flags & GROUP_SAME_HEIGHT))
1718 {
1719 cstate = (Object *) children->mlh_Head;
1720 while ((child = NextObject(&cstate)))
1721 {
1722 if (!(_flags(child) & MADF_SHOWME))
1723 continue;
1724 maxmin_width = MAX(maxmin_width, _minwidth(child));
1725 maxmin_height = MAX(maxmin_height, _minheight(child));
1726 maxdef_width = MAX(maxdef_width, w0_defwidth(child));
1727 maxdef_height = MAX(maxdef_height, w0_defheight(child));
1728 }
1729 /* g_print("2d group: mminw=%d mminh=%d\n", */
1730 /* maxmin_width, maxmin_height); */
1731 }
1732 if (data->flags & GROUP_SAME_HEIGHT)
1733 data->samesize_maxmin_vert = maxmin_height;
1734 else
1735 data->samesize_maxmin_vert = 0;
1736
1737 if (data->flags & GROUP_SAME_WIDTH)
1738 data->samesize_maxmin_horiz = maxmin_width;
1739 else
1740 data->samesize_maxmin_horiz = 0;
1741
1742 minmax_2d_rows_pass(data, children, &tmp, maxmin_height, maxdef_height);
1743 minmax_2d_columns_pass(data, children, &tmp, maxmin_width,
1744 maxdef_width);
1745
1746 END_MINMAX();
1747 }
1748
1749
1750 static void
1751 group_minmax_pagemode(struct IClass *cl, Object *obj,
1752 struct MinList *children, struct MUIP_AskMinMax *msg)
1753 {
1754 Object *cstate;
1755 Object *child;
1756 struct MUI_GroupData *data = INST_DATA(cl, obj);
1757 struct MUI_MinMax tmp = { 0, 0, MUI_MAXMAX, MUI_MAXMAX, 0, 0 };
1758
1759 cstate = (Object *) children->mlh_Head;
1760
1761 D(bug("minmax_pagemode(%lx)\n", obj, tmp.DefWidth));
1762
1763 while ((child = NextObject(&cstate)))
1764 {
1765 if (!(_flags(child) & MADF_SHOWME))
1766 continue;
1767
1768 if (child == data->titlegroup)
1769 continue;
1770
1771 tmp.MinHeight = MAX(tmp.MinHeight, _minheight(child));
1772 D(bug("minmax_pagemode(%p) minh child = %d tmpmin=%d\n", obj,
1773 _minheight(child), tmp.MinHeight));
1774 tmp.MinWidth = MAX(tmp.MinWidth, _minwidth(child));
1775 tmp.MaxHeight = MIN(tmp.MaxHeight, w0_maxheight(child));
1776 tmp.MaxWidth = MIN(tmp.MaxWidth, w0_maxwidth(child));
1777 tmp.DefHeight = MAX(tmp.DefHeight,
1778 ((w0_defheight(child) <
1779 MUI_MAXMAX) ? w0_defheight(child) : tmp.DefHeight));
1780 tmp.DefWidth =
1781 MAX(tmp.DefWidth,
1782 ((w0_defwidth(child) <
1783 MUI_MAXMAX) ? w0_defwidth(child) : tmp.DefWidth));
1784 D(bug("minmax_pagemode(%lx) defw = %ld\n", obj, tmp.DefWidth));
1785 }
1786
1787 if (data->titlegroup)
1788 {
1789 tmp.MinHeight += _minheight(data->titlegroup);
1790 tmp.MaxHeight += w0_maxheight(data->titlegroup);
1791 tmp.DefHeight += w0_defheight(data->titlegroup);
1792 }
1793
1794 END_MINMAX();
1795 }
1796
1797 /**************************************************************************
1798 MUIM_AskMinMax : ask children about min/max sizes, then
1799 either call a hook, or the builtin method, to calculate our minmax
1800 **************************************************************************/
1801 IPTR Group__MUIM_AskMinMax(struct IClass *cl, Object *obj,
1802 struct MUIP_AskMinMax *msg)
1803 {
1804 struct MUI_GroupData *data = INST_DATA(cl, obj);
1805 struct MUI_LayoutMsg lm;
1806 struct MUIP_AskMinMax childMsg;
1807 struct MUI_MinMax childMinMax;
1808 Object *cstate;
1809 Object *child;
1810 LONG super_minwidth, super_minheight;
1811
1812 /*
1813 * let our superclass first fill in its size with frame, inner spc etc ...
1814 */
1815 DoSuperMethodA(cl, obj, (Msg) msg);
1816 super_minwidth = msg->MinMaxInfo->MinWidth;
1817 super_minheight = msg->MinMaxInfo->MinHeight;
1818
1819 /*
1820 * Ask children
1821 */
1822 childMsg.MethodID = msg->MethodID;
1823 childMsg.MinMaxInfo = &childMinMax;
1824 get(data->family, MUIA_Family_List, &(lm.lm_Children));
1825
1826 cstate = (Object *) lm.lm_Children->mlh_Head;
1827
1828 while ((child = NextObject(&cstate)))
1829 {
1830 if (!(_flags(child) & MADF_SHOWME))
1831 /* BORDERGADGETs should handle this itself */
1832 continue;
1833 /* Ask child */
1834 DoMethodA(child, (Msg) & childMsg);
1835 /* D(bug("*** group %lx, child %lx min=%ld,%ld\n", */
1836 /* obj, child, childMinMax.MinWidth, childMinMax.MinHeight)); */
1837 __area_finish_minmax(child, childMsg.MinMaxInfo);
1838 }
1839
1840 /*
1841 * Use children infos to calculate group size
1842 */
1843 if (data->flags & GROUP_PAGEMODE)
1844 {
1845 D(bug("minmax_pagemode(%p) minh initial = %d\n", obj,
1846 msg->MinMaxInfo->MinHeight));
1847 group_minmax_pagemode(cl, obj, lm.lm_Children, msg);
1848 D(bug("minmax_pagemode(%p) minh = %d\n", obj,
1849 msg->MinMaxInfo->MinHeight));
1850 }
1851 else if (data->layout_hook)
1852 {
1853 lm.lm_Type = MUILM_MINMAX;
1854 CallHookPkt(data->layout_hook, obj, &lm);
1855
1856 if (lm.lm_MinMax.MaxHeight < lm.lm_MinMax.MinHeight)
1857 lm.lm_MinMax.MaxHeight = lm.lm_MinMax.MinHeight;
1858 if (lm.lm_MinMax.DefHeight < lm.lm_MinMax.MinHeight)
1859 lm.lm_MinMax.DefHeight = lm.lm_MinMax.MinHeight;
1860 if (lm.lm_MinMax.MaxWidth < lm.lm_MinMax.MinWidth)
1861 lm.lm_MinMax.MaxWidth = lm.lm_MinMax.MinWidth;
1862 if (lm.lm_MinMax.DefWidth < lm.lm_MinMax.MinWidth)
1863 lm.lm_MinMax.DefWidth = lm.lm_MinMax.MinWidth;
1864
1865 //kprintf("### min %d x %d def %d x %d max %d x %d\n",
1866 // msg->MinMaxInfo->MinWidth,
1867 // msg->MinMaxInfo->MinHeight,
1868 // msg->MinMaxInfo->DefWidth,
1869 // msg->MinMaxInfo->DefHeight,
1870 // msg->MinMaxInfo->MaxWidth,
1871 // msg->MinMaxInfo->MaxHeight);
1872
1873 msg->MinMaxInfo->MinWidth += lm.lm_MinMax.MinWidth;
1874 msg->MinMaxInfo->MinHeight += lm.lm_MinMax.MinHeight;
1875 msg->MinMaxInfo->MaxWidth += lm.lm_MinMax.MaxWidth;
1876 if (msg->MinMaxInfo->MaxWidth > MUI_MAXMAX)
1877 msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
1878 msg->MinMaxInfo->MaxHeight += lm.lm_MinMax.MaxHeight;
1879 if (msg->MinMaxInfo->MaxHeight > MUI_MAXMAX)
1880 msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
1881 msg->MinMaxInfo->DefWidth += lm.lm_MinMax.DefWidth;
1882 msg->MinMaxInfo->DefHeight += lm.lm_MinMax.DefHeight;
1883
1884 //kprintf("#### min %d x %d def %d x %d max %d x %d\n",
1885 // msg->MinMaxInfo->MinWidth,
1886 // msg->MinMaxInfo->MinHeight,
1887 // msg->MinMaxInfo->DefWidth,
1888 // msg->MinMaxInfo->DefHeight,
1889 // msg->MinMaxInfo->MaxWidth,
1890 // msg->MinMaxInfo->MaxHeight);
1891
1892 }
1893 else
1894 {
1895 if ((data->rows == 1) && (data->columns == 1))
1896 {
1897 data->num_visible_children =
1898 Group_GetNumVisibleChildren(data, lm.lm_Children);
1899 if (data->flags & GROUP_HORIZ)
1900 group_minmax_horiz(cl, obj, lm.lm_Children, msg);
1901 else
1902 group_minmax_vert(cl, obj, lm.lm_Children, msg);
1903 }
1904 else
1905 {
1906 group_minmax_2d(cl, obj, lm.lm_Children, msg);
1907 }
1908 }
1909
1910 if (data->flags & GROUP_VIRTUAL)
1911 {
1912 data->saved_minwidth = msg->MinMaxInfo->MinWidth;
1913 data->saved_minheight = msg->MinMaxInfo->MinHeight;
1914 msg->MinMaxInfo->MinWidth = super_minwidth + 2;
1915 msg->MinMaxInfo->MinHeight = super_minheight + 2;
1916
1917 //kprintf("## min %d x %d def %d x %d max %d x %d\n",
1918 // msg->MinMaxInfo->MinWidth,
1919 // msg->MinMaxInfo->MinHeight,
1920 // msg->MinMaxInfo->DefWidth,
1921 // msg->MinMaxInfo->DefHeight,
1922 // msg->MinMaxInfo->MaxWidth,
1923 // msg->MinMaxInfo->MaxHeight);
1924
1925 }
1926
1927 return 0;
1928 }
1929
1930
1931
1932 // enforce minmax constraint, but also update total growable/shrinkable weights
1933 // while we're at it
1934 static void Layout1D_minmax_constraint(WORD *sizep, WORD minsize,
1935 WORD maxsize, WORD *remainp, WORD *sizegrowp, WORD *sizeshrinkp,
1936 ULONG *weightgrowp, ULONG *weightshrinkp, UWORD weight, WORD samesize)
1937 {
1938 WORD size = *sizep, remain = *remainp,
1939 sizegrow = *sizegrowp, sizeshrink = *sizeshrinkp;
1940 ULONG weightgrow = *weightgrowp, weightshrink = *weightshrinkp;
1941
1942 /* D(bug("L1D_minmax_c size=%d min=%d max=%d w=%d ss=%d\n", */
1943 /* size, minsize, maxsize, */
1944 /* weight, samesize)); */
1945
1946 if ((samesize > 0) && (weight == 0))
1947 {
1948 remain += size - samesize;
1949 size = samesize;
1950 sizeshrink -= size;
1951 sizegrow -= size;
1952 }
1953
1954 if (size <= minsize) // too little
1955 {
1956 remain += size - minsize;
1957 size = minsize;
1958 sizeshrink -= size;
1959 if (size == maxsize)
1960 sizegrow -= size;
1961 }
1962 else if (size >= maxsize) // too big
1963 {
1964 remain += size - maxsize;
1965 size = maxsize;
1966 sizegrow -= size;
1967 }
1968
1969 if (!((samesize > 0) && (weight == 0)))
1970 {
1971 if (size < maxsize)
1972 weightgrow += weight;
1973 if (size > minsize)
1974 weightshrink += weight;
1975 }
1976
1977 *sizep = size;
1978 *remainp = remain;
1979 *sizegrowp = sizegrow;
1980 *sizeshrinkp = sizeshrink;
1981 *weightgrowp = weightgrow;
1982 *weightshrinkp = weightshrink;
1983 }
1984
1985
1986 // redistribute excess size to growable child, or reduce size of a shrinkable
1987 // child
1988 static void Layout1D_redistribution(WORD *sizep, WORD minsize,
1989 WORD maxsize, WORD *remainp, WORD *sizegrowp, WORD *sizeshrinkp,
1990 ULONG *weightgrowp, ULONG *weightshrinkp, UWORD weight)
1991 {
1992 WORD size = *sizep, remain = *remainp,
1993 sizegrow = *sizegrowp, sizeshrink = *sizeshrinkp;
1994 ULONG weightgrow = *weightgrowp, weightshrink = *weightshrinkp;
1995
1996 if (weight == 0)
1997 return;
1998
1999 if ((remain > 0) && (size < maxsize))
2000 {
2001 LONG newsize;
2002
2003 newsize = (sizegrow * weight + weightgrow / 2) / weightgrow;
2004
2005 /* D(bug("newsize=%ld == size_growa=%ld * w=%ld / weight_grow=%d\n", */
2006 /* newsize, sizegrow, weight, weightgrow)); */
2007
2008 /* take care of off-by-1 errors that may toggle remainder sign
2009 * by ensuring convergence to 0
2010 */
2011 if (remain - newsize + size < 0)
2012 {
2013 /* D(bug("adding remainder=%d => size = %d\n", */
2014 /* remain, size + remain)); */
2015 size += remain;
2016 remain = 0;
2017 }
2018 else
2019 {
2020 remain -= newsize - size;
2021 size = newsize;
2022 sizegrow -= size;
2023 weightgrow -= weight;
2024 }
2025 }
2026 else if ((remain < 0) && (size > minsize))
2027 {
2028 LONG newsize;
2029
2030 newsize = (sizeshrink * weight + weightshrink / 2) / weightshrink;
2031
2032 /* D(bug("newsize=%ld == size_shrinkables=%ld * w=%ld " */
2033 /* "/ weight_shrinkables=%d\n", */
2034 /* newsize, sizeshrink, weight, weightshrink)); */
2035
2036 if (remain - newsize + size > 0)
2037 {
2038 /* D(bug("adding remainder=%d => size = %d\n", */
2039 /* remain, size + remain)); */
2040 size += remain;
2041 remain = 0;
2042 }
2043 else
2044 {
2045 remain -= newsize - size;
2046 size = newsize;
2047 sizeshrink -= size;
2048 weightshrink -= weight;
2049 }
2050 }
2051
2052 *sizep = size;
2053 *remainp = remain;
2054 *sizegrowp = sizegrow;
2055 *sizeshrinkp = sizeshrink;
2056 *weightgrowp = weightgrow;
2057 *weightshrinkp = weightshrink;
2058 }
2059
2060
2061 // 2 passes at most, less on average (0.5 or 1.5), each does
2062 // - a minmax clamping, evenutally adding to a remainder
2063 // (remainder = missing (underflow) or remaining (overflow) space compared
2064 // to ideal sizes where children fill the whole group)
2065 // - a redistribution of the remainder, by growing (pos. remainder) or
2066 // shrinking (neg. remainder) children able to support it.
2067 //
2068 // Occasionnaly the first time the redistribution is done, the minmax
2069 // constraint can be broken, thus the extra pass to check and eventually
2070 // redistribute. The second redistribution never breaks minmax constraint
2071 // (there should be a mathematical proof, but feel free to prove me wrong
2072 // with an example)
2073 static void Layout1D_minmax_constraints_and_redistrib(struct MinList
2074 *children, WORD total_size, WORD remainder, WORD samesize,
2075 BOOL group_horiz)
2076 {
2077 Object *cstate;
2078 Object *child;
2079 int i;
2080
2081 for (i = 0; i < 2; i++)
2082 {
2083 WORD size_growables = total_size;
2084 WORD size_shrinkables = total_size;
2085 ULONG weight_growables = 0;
2086 ULONG weight_shrinkables = 0;
2087
2088 /* D(bug("start : rem=%ld, A=%ld, size_growables=%ld, " */
2089 /* "size_shrinkables=%ld\n", */
2090 /* remainder, total_size, size_growables, size_shrinkables)); */
2091
2092 // minmax constraints
2093 cstate = (Object *) children->mlh_Head;
2094 while ((child = NextObject(&cstate)))
2095 {
2096 /* WORD old_size; */
2097
2098 if (IS_HIDDEN(child))
2099 continue;
2100
2101 if (group_horiz)
2102 {
2103 /* old_size = _width(child); */
2104
2105 Layout1D_minmax_constraint(&_width(child), _minwidth(child),
2106 _maxwidth(child), &remainder, &size_growables,
2107 &size_shrinkables, &weight_growables,
2108 &weight_shrinkables, _hweight(child), samesize);
2109
2110 /* D(bug("loop1 on %p : width=%d was %d, rem=%d, A=%d, " */
2111 /* "sizegrow=%d, sizeshrink=%d w=%d min=%d max=%d\n", */
2112 /* child, _width(child), old_size, remainder, total_size, */
2113 /* size_growables, size_shrinkables, _hweight(child), */
2114 /* _minwidth(child), _maxwidth(child))); */
2115 }
2116 else // ! group_horiz
2117 {
2118 /* old_size = _height(child); */
2119
2120 Layout1D_minmax_constraint(&_height(child),
2121 _minheight(child), _maxheight(child), &remainder,
2122 &size_growables, &size_shrinkables, &weight_growables,
2123 &weight_shrinkables, _vweight(child), samesize);
2124
2125 /* D(bug("loop1 on %p : h=%ld was %d, rem=%d, A=%d, " */
2126 /* "sizegrow=%d, sizeshrink=%d w=%d min=%d max=%d\n", */
2127 /* child, _height(child), old_size, remainder, total_size,*/
2128 /* size_growables, size_shrinkables, _vweight(child), */
2129 /* _minheight(child), _maxheight(child))); */
2130 } // if (group_horiz)
2131 } // while child, minmax constraints
2132
2133 // mid-pass break
2134 if (remainder == 0)
2135 break;
2136
2137 /* D(bug("mid : rem=%d, A=%d, size_grow=%d, size_shrink=%d, " */
2138 /* "wg=%ld, ws=%ld\n", remainder, total_size, size_growables, */
2139 /* size_shrinkables, weight_growables, weight_shrinkables)); */
2140
2141 // distribute remaining space to possible candidates
2142 cstate = (Object *) children->mlh_Head;
2143 while (((child = NextObject(&cstate)) != NULL) && (remainder != 0))
2144 {
2145 /* WORD old_size; */
2146
2147 if (IS_HIDDEN(child))
2148 continue;
2149
2150 if (group_horiz)
2151 {
2152 /* old_size = _width(child); */
2153
2154 Layout1D_redistribution(&_width(child), _minwidth(child),
2155 _maxwidth(child), &remainder, &size_growables,
2156 &size_shrinkables, &weight_growables,
2157 &weight_shrinkables, _hweight(child));
2158
2159 /* D(bug("loop2 on %p : h=%d was %d, rem=%d, A=%d, " */
2160 /* "size_grow=%d, size_shrink=%d\n", child, */
2161 /* _width(child), old_size, remainder, total_size, */
2162 /* size_growables, size_shrinkables)); */
2163 }
2164 else // ! group_horiz
2165 {
2166 /* old_size = _height(child); */
2167
2168 Layout1D_redistribution(&_height(child), _minheight(child),
2169 _maxheight(child), &remainder, &size_growables,
2170 &size_shrinkables, &weight_growables,
2171 &weight_shrinkables, _vweight(child));
2172
2173 /* D(bug("loop2 on %p : h=%d was %d, rem=%d, A=%d, " */
2174 /* "size_grow=%d, size_shrink=%d\n", child, */
2175 /* _height(child), old_size, remainder, total_size, */
2176 /* size_growables, size_shrinkables)); */
2177 } // if (group_horiz)
2178
2179 } // while child, redistribution
2180
2181 /* if (remainder != 0) */
2182 /* { */
2183 /* D(bug("end : rem=%ld, A=%ld, size_grow=%ld, size_shrink=%ld\n", */
2184 /* remainder, total_size, size_growables, size_shrinkables)); */
2185 /* } */
2186 // dont break here if remainder == 0, some minmax constraints
2187 // may not be respected
2188 } // end for
2189
2190 // to easily spot layout bugs, nothing like a (division by zero) exception
2191 /* if (remainder != 0) */
2192 /* { */
2193 /* ASSERT(remainder != 0); */
2194 /* D(bug("gonna crash, remainder = %d\n", remainder)); */
2195 /* remainder /= 0; */
2196 /* } */
2197
2198 }
2199
2200 static void Layout1D_weight_constraint(WORD *total_sizep,
2201 WORD *total_init_sizep,
2202 ULONG *total_weightp, WORD *sizep, UWORD weight, WORD minsize)
2203 {
2204 if (*total_weightp > 0)
2205 *sizep = (*total_sizep * weight + *total_weightp / 2)
2206 / *total_weightp;
2207 else
2208 *sizep = minsize;
2209
2210 *total_weightp -= weight;
2211 *total_sizep -= *sizep;
2212 *total_init_sizep += *sizep;
2213 }
2214
2215
2216 static void group_layout_vert(struct IClass *cl, Object *obj,
2217 struct MinList *children)
2218 {
2219 struct MUI_GroupData *data = INST_DATA(cl, obj);
2220 Object *cstate;
2221 Object *child;
2222 ULONG total_weight;
2223 WORD remainder; /* must converge to 0 to successfully end layout */
2224 WORD total_size;
2225 WORD total_size_backup;
2226 WORD total_init_size; /* total size of the ideally sized children */
2227 WORD width;
2228 WORD left = 0;
2229 WORD top = 0;
2230 WORD layout_width;
2231 WORD layout_height;
2232
2233 //kprintf("group_layout_vert: virtoff = %d,%d\n",
2234 // data->virt_offx, data->virt_offy);
2235
2236 if (data->flags & GROUP_VIRTUAL)
2237 {
2238 data->virt_mwidth =
2239 CLAMP(_mwidth(obj), data->saved_minwidth - _subwidth(obj),
2240 _maxwidth(obj) - _subwidth(obj));
2241 data->virt_mheight =
2242 CLAMP(_mheight(obj), data->saved_minheight - _subheight(obj),
2243 _maxheight(obj) - _subheight(obj));
2244
2245 layout_width = data->virt_mwidth;
2246 layout_height = data->virt_mheight;
2247 }
2248 else
2249 {
2250 layout_width = _mwidth(obj);
2251 layout_height = _mheight(obj);
2252 }
2253
2254 total_weight = data->vert_weight_sum;
2255 total_init_size = 0;
2256 total_size =
2257 layout_height - (data->num_visible_children -
2258 1) * data->vert_spacing;
2259 total_size_backup = total_size;
2260
2261 /* D(bug("\nvert layout for %p, A=%d W=%ld\n", */
2262 /* obj, total_size, total_weight)); */
2263
2264 // weight constraints
2265 // calculate ideal size for each object, and total ideal size
2266 cstate = (Object *) children->mlh_Head;
2267 while ((child = NextObject(&cstate)))
2268 {
2269 if (IS_HIDDEN(child))
2270 continue;
2271
2272 Layout1D_weight_constraint(&total_size, &total_init_size,
2273 &total_weight, &_height(child), _vweight(child),
2274 _minheight(child));
2275 /* D(bug("child %p : ideal=%d w=%ld\n", */
2276 /* child, _height(child), _vweight(child))); */
2277 } // while child, weight constraints
2278
2279 total_size = total_size_backup;
2280 remainder = total_size - total_init_size;
2281
2282 if (data->flags & GROUP_VIRTUAL)
2283 {
2284 /* This is also true for non virtual groups, but if this would be the
2285 ** case then there is a bug in the layout function
2286 */
2287 if (total_size < 0)
2288 total_size = 0;
2289 }
2290
2291 Layout1D_minmax_constraints_and_redistrib(children,
2292 total_size,
2293 remainder,
2294 (data->flags & GROUP_SAME_HEIGHT) ? data->samesize_maxmin_vert : 0,
2295 FALSE);
2296
2297 // do the layout
2298 cstate = (Object *) children->mlh_Head;
2299 while ((child = NextObject(&cstate)))
2300 {
2301 if (IS_HIDDEN(child))
2302 continue;
2303
2304 width = MIN(_maxwidth(child), layout_width);
2305 width = MAX(width, _minwidth(child));
2306 left = (layout_width - width) / 2;
2307
2308 /* D(bug("child %p -> layout %d x %d\n", */
2309 /* child, width, _height(child))); */
2310 if (!MUI_Layout(child, left, top, width, _height(child), 0))
2311 return;
2312 top += data->vert_spacing + _height(child);
2313 }
2314
2315 }
2316
2317
2318 static void group_layout_horiz(struct IClass *cl, Object *obj,
2319 struct MinList *children)
2320 {
2321 struct MUI_GroupData *data = INST_DATA(cl, obj);
2322 Object *cstate;
2323 Object *child;
2324 ULONG total_weight;
2325 WORD remainder; /* must converge to 0 to succesfully end layout */
2326 WORD total_size;
2327 WORD total_size_backup;
2328 WORD total_init_size; /* total size of the ideally sized children */
2329 WORD height;
2330 WORD top = 0;
2331 WORD left = 0;
2332 WORD layout_width;
2333 WORD layout_height;
2334
2335 //kprintf("group_layout_horiz: virtoff = %d,%d\n",
2336 // data->virt_offx, data->virt_offy);
2337
2338 if (data->flags & GROUP_VIRTUAL)
2339 {
2340 data->virt_mwidth =
2341 CLAMP(_mwidth(obj), data->saved_minwidth - _subwidth(obj),
2342 _maxwidth(obj) - _subwidth(obj));
2343 data->virt_mheight =
2344 CLAMP(_mheight(obj), data->saved_minheight - _subheight(obj),
2345 _maxheight(obj) - _subheight(obj));
2346
2347 layout_width = data->virt_mwidth;
2348 layout_height = data->virt_mheight;
2349
2350 //kprintf("group_layout_horiz: layoutsize %d x %d "
2351 // " virtsize %d x %d msize %d x %d\n",
2352 // layout_width, layout_height, data->virt_mwidth,
2353 // data->virt_mheight,
2354 // _mwidth(obj), _mheight(obj));
2355 }
2356 else
2357 {
2358 layout_width = _mwidth(obj);
2359 layout_height = _mheight(obj);
2360 }
2361
2362 total_weight = data->horiz_weight_sum;
2363 total_init_size = 0;
2364 total_size =
2365 layout_width - (data->num_visible_children -
2366 1) * data->horiz_spacing;
2367 total_size_backup = total_size;
2368
2369 /* D(bug("\nhoriz layout for %p, A=%d W=%ld\n", */
2370 /* obj, total_size, total_weight)); */
2371
2372 // weight constraints
2373 // calculate ideal size for each object, and total ideal size
2374 cstate = (Object *) children->mlh_Head;
2375 while ((child = NextObject(&cstate)))
2376 {
2377 if (IS_HIDDEN(child))
2378 continue;
2379
2380 Layout1D_weight_constraint(&total_size, &total_init_size,
2381 &total_weight, &_width(child), _hweight(child),
2382 _minwidth(child));
2383 /* D(bug("child %p : ideal=%d w=%ld\n", */
2384 /* child, _width(child), _hweight(child))); */
2385 } // while child, weight constraints
2386
2387 total_size = total_size_backup;
2388 if (data->horiz_weight_sum > 0)
2389 remainder = total_size - total_init_size;
2390 else
2391 remainder = 0;
2392
2393 if (data->flags & GROUP_VIRTUAL)
2394 {
2395 /* This is also true for non virtual groups, but if this would be the
2396 ** case then there is a bug in the layout function
2397 */
2398 if (total_size < 0)
2399 total_size = 0;
2400 }
2401
2402 Layout1D_minmax_constraints_and_redistrib(children,
2403 total_size,
2404 remainder,
2405 (data->flags & GROUP_SAME_WIDTH) ? data->samesize_maxmin_horiz : 0,
2406 TRUE);
2407
2408 // do the layout
2409 cstate = (Object *) children->mlh_Head;
2410 while ((child = NextObject(&cstate)))
2411 {
2412 if (IS_HIDDEN(child))
2413 continue;
2414
2415 height = MIN(_maxheight(child), layout_height);
2416 height = MAX(height, _minheight(child));
2417 top = (layout_height - height) / 2;
2418
2419 /* D(bug("child %p -> layout %d x %d\n", */
2420 /* child, _width(child), height)); */
2421 if (!MUI_Layout(child, left, top, _width(child), height, 0))
2422 return;
2423 left += data->horiz_spacing + _width(child);
2424 }
2425
2426 }
2427
2428
2429 static void Layout2D_weight_constraint(struct MUI_GroupData *data,
2430 struct layout2d_elem *row_infos,
2431 struct layout2d_elem *col_infos,
2432 WORD total_size_height, WORD total_size_width,
2433 WORD *total_init_height, WORD *total_init_width)
2434 {
2435 int i;
2436 ULONG total_weight_vert = data->vert_weight_sum;
2437 ULONG total_weight_horiz = data->horiz_weight_sum;
2438
2439 *total_init_height = 0;
2440 *total_init_width = 0;
2441
2442 /* calc row heights */
2443 for (i = 0; i < data->rows; i++)
2444 {
2445 if (total_weight_vert > 0)
2446 row_infos[i].dim =
2447 (total_size_height * row_infos[i].weight +
2448 total_weight_vert / 2) / total_weight_vert;
2449 else
2450 row_infos[i].dim = row_infos[i].min;
2451
2452 /* D(bug("l2 row %d : ideal = %d with w=%d, A=%d, W=%d\n", */
2453 /* i, row_infos[i].dim, */
2454 /* row_infos[i].weight, total_size_height, total_weight_vert)); */
2455
2456 total_weight_vert -= row_infos[i].weight;
2457 total_size_height -= row_infos[i].dim;
2458 *total_init_height += row_infos[i].dim;
2459 }
2460
2461 /* calc columns widths */
2462 for (i = 0; i < data->columns; i++)
2463 {
2464 if (total_weight_horiz)
2465 col_infos[i].dim =
2466 (total_size_width * col_infos[i].weight +
2467 total_weight_horiz / 2) / total_weight_horiz;
2468 else
2469 col_infos[i].dim = col_infos[i].min;
2470
2471 /* D(bug("l2 col %d : ideal = %d with w=%d, A=%d, W=%d\n", */
2472 /* i, col_infos[i].dim, */
2473 /* col_infos[i].weight, total_size_width, total_weight_horiz)); */
2474
2475 total_weight_horiz -= col_infos[i].weight;
2476 total_size_width -= col_infos[i].dim;
2477 *total_init_width += col_infos[i].dim;
2478 }
2479 }
2480
2481
2482
2483 static void Layout2D_minmax_constraints_and_redistrib(struct layout2d_elem
2484 *infos, WORD nitems, WORD total_size, WORD samesize, WORD remainder)
2485 {
2486 int j;
2487
2488 /* D(bug("L2D mc&r n=%d A=%d ss=%d rem=%d\n", */
2489 /* nitems, total_size, samesize, remainder)); */
2490
2491 for (j = 0; j < 2; j++)
2492 {
2493 WORD size_growables = total_size;
2494 WORD size_shrinkables = total_size;
2495 ULONG weight_growables = 0;
2496 ULONG weight_shrinkables = 0;
2497 /* WORD old_size; */
2498 int i;
2499
2500 // minmax constraints
2501 for (i = 0; i < nitems; i++)
2502 {
2503 /* old_size = infos[i].dim; */
2504
2505 /* D(bug("bef loop1 on %d : size=%d, rem=%d, A=%d, " */
2506 /* "sizegrow=%d, sizeshrink=%d w=%d min=%d max=%d\n", */
2507 /* i, infos[i].dim, remainder, total_size, */
2508 /* size_growables, size_shrinkables, infos[i].weight, */
2509 /* infos[i].min, infos[i].max)); */
2510
2511 Layout1D_minmax_constraint(&infos[i].dim, infos[i].min,
2512 infos[i].max, &remainder, &size_growables,
2513 &size_shrinkables, &weight_growables, &weight_shrinkables,
2514 infos[i].weight, samesize);
2515
2516 /* D(bug("loop1 on %d : size=%d was %d, rem=%d, A=%d, " */
2517 /* "sizegrow=%d, sizeshrink=%d w=%d min=%d max=%d\n", */
2518 /* i, infos[i].dim, old_size, remainder, total_size, */
2519 /* size_growables, size_shrinkables, infos[i].weight, */
2520 /* infos[i].min, infos[i].max)); */
2521 }
2522
2523 if (remainder == 0)
2524 break;
2525
2526 for (i = 0; i < nitems; i++)
2527 {
2528 /* old_size = infos[i].dim; */
2529
2530 /* D(bug("bef loop2 on %d : size=%d, rem=%d, A=%d, " */
2531 /* "size_grow=%d, size_shrink=%d\n", i, */
2532 /* infos[i].dim, remainder, total_size, */
2533 /* size_growables, size_shrinkables)); */
2534
2535 Layout1D_redistribution(&infos[i].dim, infos[i].min,
2536 infos[i].max, &remainder, &size_growables,
2537 &size_shrinkables, &weight_growables, &weight_shrinkables,
2538 infos[i].weight);
2539
2540 /* D(bug("loop2 on %d : size=%d was %d, rem=%d, A=%d, " */
2541 /* "size_grow=%d, size_shrink=%d\n", i, */
2542 /* infos[i].dim, old_size, remainder, total_size, */
2543 /* size_growables, size_shrinkables)); */
2544 }
2545 }
2546 }
2547
2548 static void
2549 layout_2d_distribute_space(struct MUI_GroupData *data,
2550 struct layout2d_elem *row_infos,
2551 struct layout2d_elem *col_infos,
2552 struct MinList *children, LONG left_start, LONG top_start)
2553 {
2554 Object *cstate;
2555 Object *child;
2556 LONG left;
2557 LONG top;
2558 LONG col_width;
2559 LONG row_height;
2560 int i, j;
2561
2562 /*
2563 * pass 2 : distribute space
2564 */
2565 cstate = (Object *) children->mlh_Head;
2566 top = top_start;
2567 /* for each row */
2568 for (i = 0; i < data->rows; i++)
2569 {
2570 /* left start for child layout in this row */
2571 left = left_start;
2572
2573 /* max height for children in this row */
2574 row_height = row_infos[i].dim;
2575 j = 0;
2576 /* for each column */
2577 while ((child = NextObject(&cstate)))
2578 {
2579 LONG cleft;
2580 LONG ctop;
2581 LONG cwidth;
2582 LONG cheight;
2583
2584 if (IS_HIDDEN(child))
2585 continue;
2586 /* max width for children in this column */
2587 col_width = col_infos[j].dim;
2588
2589 /* center child if col width is bigger than child maxwidth */
2590 cwidth = MIN(_maxwidth(child), col_width);
2591 cwidth = MAX(cwidth, _minwidth(child));
2592 cleft = left + (col_width - cwidth) / 2;
2593
2594 /* center child if row height is bigger than child maxheight */
2595 cheight = MIN(_maxheight(child), row_height);
2596 cheight = MAX(cheight, _minheight(child));
2597 ctop = top + (row_height - cheight) / 2;
2598
2599 /* g_print("layout %d %d %d %d\n", cleft, ctop, cwidth, cheight); */
2600 /* D(bug("2DL/child %p -> layout %d x %d\n", */
2601 /* child, cwidth, cheight)); */
2602 if (!MUI_Layout(child, cleft, ctop, cwidth, cheight, 0))
2603 return;
2604
2605 left += data->horiz_spacing + col_width;
2606
2607 ++j;
2608 if ((j % data->columns) == 0)
2609 break;
2610 }
2611
2612 top += data->vert_spacing + row_height;
2613 }
2614
2615 }
2616
2617
2618 /*
2619 * all children in the same row have the same maximum height
2620 * all children in the same column have the same maximum height
2621 * if a child maximum size is smaller than the biggest minimum size,
2622 * the chid will be centered in the remaining space.
2623 *
2624 * for each row, determine its height allocation
2625 * weight ? the vertical weight of a row, if no fixed-height child
2626 * in the row, is the sum of all vertical weights of children
2627 * all row members will have the same height
2628 *
2629 * for each column, determine its width allocation
2630 * all column members will have the same width
2631 */
2632 /* Write a proper hook function */
2633 static void
2634 group_layout_2d(struct IClass *cl, Object *obj, struct MinList *children)
2635 {
2636 struct MUI_GroupData *data = INST_DATA(cl, obj);
2637 WORD left_start = 0;
2638 WORD top_start = 0;
2639 WORD total_size_height =
2640 _mheight(obj) - (data->rows - 1) * data->vert_spacing;
2641 WORD total_size_width =
2642 _mwidth(obj) - (data->columns - 1) * data->horiz_spacing;
2643 WORD total_init_height;
2644 WORD total_init_width;
2645 WORD remainder_height;
2646 WORD remainder_width;
2647 WORD layout_width;
2648 WORD layout_height;
2649
2650 if (data->rows == 0 || data->columns == 0)
2651 return;
2652 if (data->num_children % data->rows
2653 || data->num_children % data->columns)
2654 return;
2655 if (data->row_infos == NULL || data->col_infos == NULL)
2656 return;
2657
2658 //kprintf("group_layout_horiz: virtoff = %d,%d\n",
2659 // data->virt_offx, data->virt_offy);
2660
2661 if (data->flags & GROUP_VIRTUAL)
2662 {
2663 data->virt_mwidth =
2664 CLAMP(_mwidth(obj), data->saved_minwidth - _subwidth(obj),
2665 _maxwidth(obj) - _subwidth(obj));
2666 data->virt_mheight =
2667 CLAMP(_mheight(obj), data->saved_minheight - _subheight(obj),
2668 _maxheight(obj) - _subheight(obj));
2669
2670 layout_width = data->virt_mwidth;
2671 layout_height = data->virt_mheight;
2672 }
2673 else
2674 {
2675 layout_width = _mwidth(obj);
2676 layout_height = _mheight(obj);
2677 }
2678
2679 total_size_height =
2680 layout_height - (data->rows - 1) * data->vert_spacing;
2681 total_size_width =
2682 layout_width - (data->columns - 1) * data->horiz_spacing;
2683
2684 // fix left/top ?
2685
2686 // weight constraints
2687 Layout2D_weight_constraint(data, data->row_infos, data->col_infos,
2688 total_size_height, total_size_width,
2689 &total_init_height, &total_init_width);
2690
2691 remainder_height = total_size_height - total_init_height;
2692 remainder_width = total_size_width - total_init_width;
2693
2694 Layout2D_minmax_constraints_and_redistrib(data->row_infos,
2695 data->rows, total_size_height,
2696 /* (data->flags & GROUP_SAME_HEIGHT) ? data->samesize_maxmin_vert : 0, */
2697 0, remainder_height);
2698
2699 Layout2D_minmax_constraints_and_redistrib(data->col_infos,
2700 data->columns, total_size_width,
2701 /* (data->flags & GROUP_SAME_WIDTH) ? data->samesize_maxmin_horiz : 0, */
2702 0, remainder_width);
2703
2704 layout_2d_distribute_space(data, data->row_infos, data->col_infos,
2705 children, left_start, top_start);
2706 }
2707
2708
2709 /* Write a proper hook function */
2710 static void group_layout_pagemode(struct IClass *cl, Object *obj,
2711 struct MinList *children)
2712 {
2713 struct MUI_GroupData *data = INST_DATA(cl, obj);
2714 Object *cstate;
2715 Object *child;
2716 WORD layout_width;
2717 WORD layout_height;
2718 int w, h, yoffset = 0;
2719
2720 if (data->flags & GROUP_VIRTUAL)
2721 {
2722 data->virt_mwidth =
2723 CLAMP(_mwidth(obj), data->saved_minwidth - _subwidth(obj),
2724 _maxwidth(obj) - _subwidth(obj));
2725 data->virt_mheight =
2726 CLAMP(_mheight(obj), data->saved_minheight - _subheight(obj),
2727 _maxheight(obj) - _subheight(obj));
2728
2729 layout_width = data->virt_mwidth;
2730 layout_height = data->virt_mheight;
2731 }
2732 else
2733 {
2734 layout_width = _mwidth(obj);
2735 layout_height = _mheight(obj);
2736 }
2737
2738 if (data->titlegroup)
2739 {
2740 yoffset = _minheight(data->titlegroup);
2741 layout_height -= yoffset;
2742 }
2743
2744 cstate = (Object *) children->mlh_Head;
2745 while ((child = NextObject(&cstate)))
2746 {
2747 w = MIN(layout_width, _maxwidth(child));
2748 h = MIN(layout_height, _maxheight(child));
2749
2750 if (child == data->titlegroup)
2751 {
2752 MUI_Layout(child, (layout_width - w) / 2, 0, w, yoffset, 0);
2753 }
2754 else
2755 {
2756 D(bug("PM/child %p -> layout %d x %d\n", child, w, h));
2757 MUI_Layout(child, (layout_width - w) / 2,
2758 yoffset + (layout_height - h) / 2, w, h, 0);
2759 }
2760 }
2761 }
2762
2763
2764 /**************************************************************************
2765 MUIM_Layout
2766 Either use a given layout hook, or the builtin method.
2767 **************************************************************************/
2768 IPTR Group__MUIM_Layout(struct IClass *cl, Object *obj,
2769 struct MUIP_Layout *msg)
2770 {
2771 struct MUI_GroupData *data = INST_DATA(cl, obj);
2772 struct MUI_LayoutMsg lm = { 0 };
2773
2774 get(data->family, MUIA_Family_List, &(lm.lm_Children));
2775 if (data->flags & GROUP_PAGEMODE)
2776 {
2777 group_layout_pagemode(cl, obj, lm.lm_Children);
2778 }
2779 else if (data->layout_hook)
2780 {
2781 lm.lm_Type = MUILM_LAYOUT;
2782 lm.lm_Layout.Width = _mwidth(obj);
2783 lm.lm_Layout.Height = _mheight(obj);
2784
2785 CallHookPkt(data->layout_hook, obj, &lm);
2786
2787 if (data->flags & GROUP_VIRTUAL)
2788 {
2789 data->virt_mwidth = lm.lm_Layout.Width;
2790 data->virt_mheight = lm.lm_Layout.Height;
2791 }
2792 }
2793 else
2794 {
2795 if ((data->rows == 1) && (data->columns == 1))
2796 {
2797 if (data->flags & GROUP_HORIZ)
2798 group_layout_horiz(cl, obj, lm.lm_Children);
2799 else
2800 group_layout_vert(cl, obj, lm.lm_Children);
2801 }
2802 else
2803 group_layout_2d(cl, obj, lm.lm_Children);
2804 }
2805
2806 if (data->flags & GROUP_VIRTUAL)
2807 {
2808 WORD new_virt_offx, new_virt_offy;
2809
2810 new_virt_offx = data->virt_offx;
2811 new_virt_offy = data->virt_offy;
2812
2813 if (new_virt_offx + _mwidth(obj) > data->virt_mwidth)
2814 {
2815 new_virt_offx = data->virt_mwidth - _mwidth(obj);
2816 }
2817 if (new_virt_offx < 0)
2818 new_virt_offx = 0;
2819
2820 if (new_virt_offy + _mheight(obj) > data->virt_mheight)
2821 {
2822 new_virt_offy = data->virt_mheight - _mheight(obj);
2823 }
2824 if (new_virt_offy < 0)
2825 new_virt_offy = 0;
2826
2827 if (new_virt_offx != data->virt_offx)
2828 {
2829 nfset(obj, MUIA_Virtgroup_Left, new_virt_offx);
2830 }
2831
2832 if (new_virt_offy != data->virt_offy)
2833 {
2834 nfset(obj, MUIA_Virtgroup_Top, new_virt_offy);
2835 }
2836
2837 }
2838
2839 return 0;
2840 }
2841
2842 /**************************************************************************
2843 MUIM_Show
2844 **************************************************************************/
2845 IPTR Group__MUIM_Show(struct IClass *cl, Object *obj,
2846 struct MUIP_Show *msg)
2847 {
2848 struct MUI_GroupData *data = INST_DATA(cl, obj);
2849 Object *cstate;
2850 Object *child;
2851 struct MinList *ChildList = NULL;
2852
2853 /* If msg is NULL, we won't want that the super method actually gets
2854 * this call */
2855 if (msg)
2856 DoSuperMethodA(cl, obj, (Msg) msg);
2857
2858 get(data->family, MUIA_Family_List, &(ChildList));
2859 cstate = (Object *) ChildList->mlh_Head;
2860
2861 if (data->flags & GROUP_PAGEMODE)
2862 {
2863 int page = 0;
2864 while ((child = NextObject(&cstate)))
2865 {
2866 if (child == data->titlegroup)
2867 {
2868 DoShowMethod(child);
2869 continue; /* Title group is not counted as page */
2870 }
2871
2872 if (page == data->active_page)
2873 {
2874 DoShowMethod(child);
2875 break;
2876 }
2877 page++;
2878 }
2879 }
2880 else
2881 {
2882 while ((child = NextObject(&cstate)))
2883 {
2884 if (!(data->flags & GROUP_VIRTUAL) ||
2885 IsObjectVisible(child, MUIMasterBase))
2886 {
2887 if (_flags(child) & MADF_SHOWME)
2888 DoShowMethod(child);
2889 }
2890 }
2891 }
2892 return TRUE;
2893 }
2894
2895 /**************************************************************************
2896 MUIM_Hide
2897 **************************************************************************/
2898 IPTR Group__MUIM_Hide(struct IClass *cl, Object *obj,
2899 struct MUIP_Hide *msg)
2900 {
2901 struct MUI_GroupData *data = INST_DATA(cl, obj);
2902 Object *cstate;
2903 Object *child;
2904 struct MinList *ChildList = NULL;
2905
2906 get(data->family, MUIA_Family_List, &(ChildList));
2907 cstate = (Object *) ChildList->mlh_Head;
2908
2909 if (data->flags & GROUP_PAGEMODE)
2910 {
2911 int page = 0;
2912 while ((child = NextObject(&cstate)))
2913 {
2914 if (child == data->titlegroup)
2915 {
2916 DoHideMethod(child);
2917 continue; /* Title group is not counted as page */
2918 }
2919
2920 if (page == data->active_page)
2921 {
2922 DoHideMethod(child);
2923 break;
2924 }
2925 page++;
2926 }
2927 }
2928 else
2929 {
2930 while ((child = NextObject(&cstate)))
2931 {
2932 if (_flags(child) & MADF_CANDRAW)
2933 DoHideMethod(child);
2934 }
2935 }
2936
2937 /* If msg is NULL, we won't want that the super method actually gets
2938 * this call */
2939 if (msg)
2940 return DoSuperMethodA(cl, obj, (Msg) msg);
2941 return 1;
2942 }
2943
2944 /*
2945 * MUIM_FindUData : tests if the MUIA_UserData of the object
2946 * contains the given <udata> and returns the object pointer in this case.
2947 */
2948 IPTR Group__MUIM_FindUData(struct IClass *cl, Object *obj,
2949 struct MUIP_FindUData *msg)
2950 {
2951 struct MUI_GroupData *data = INST_DATA(cl, obj);
2952
2953 if (muiNotifyData(obj)->mnd_UserData == msg->udata)
2954 return (IPTR) obj;
2955
2956 return DoMethodA(data->family, (Msg) msg);
2957 }
2958
2959
2960 /*
2961 * MUIM_GetUData : This method tests if the MUIA_UserData of the object
2962 * contains the given <udata> and gets <attr> to <storage> for itself
2963 * in this case.
2964 */
2965 IPTR Group__MUIM_GetUData(struct IClass *cl, Object *obj,
2966 struct MUIP_GetUData *msg)
2967 {
2968 struct MUI_GroupData *data = INST_DATA(cl, obj);
2969
2970 if (muiNotifyData(obj)->mnd_UserData == msg->udata)
2971 {
2972 get(obj, msg->attr, msg->storage);
2973 return TRUE;
2974 }
2975
2976 return DoMethodA(data->family, (Msg) msg);
2977 }
2978
2979
2980 /*
2981 * MUIM_SetUData : This method tests if the MUIA_UserData of the object
2982 * contains the given <udata> and sets <attr> to <val> for itself in this case.
2983 */
2984 IPTR Group__MUIM_SetUData(struct IClass *cl, Object *obj,
2985 struct MUIP_SetUData *msg)
2986 {
2987 struct MUI_GroupData *data = INST_DATA(cl, obj);
2988
2989 if (muiNotifyData(obj)->mnd_UserData == msg->udata)
2990 set(obj, msg->attr, msg->val);
2991
2992 DoMethodA(data->family, (Msg) msg);
2993 return TRUE;
2994 }
2995
2996
2997 /*
2998 * MUIM_SetUDataOnce : This method tests if the MUIA_UserData of the object
2999 * contains the given <udata> and sets <attr> to <val> for itself in this case.
3000 * Stop after the first udata found.
3001 */
3002 IPTR Group__MUIM_SetUDataOnce(struct IClass *cl, Object *obj,
3003 struct MUIP_SetUData *msg)
3004 {
3005 struct MUI_GroupData *data = INST_DATA(cl, obj);
3006
3007 if (muiNotifyData(obj)->mnd_UserData == msg->udata)
3008 {
3009 set(obj, msg->attr, msg->val);
3010 return TRUE;
3011 }
3012 return DoMethodA(data->family, (Msg) msg);
3013 }
3014
3015 /**************************************************************************
3016 MUIM_DragQueryExtented
3017 **************************************************************************/
3018 IPTR Group__MUIM_DragQueryExtended(struct IClass *cl, Object *obj,
3019 struct MUIP_DragQueryExtended *msg)
3020 {
3021 struct MUI_GroupData *data = INST_DATA(cl, obj);
3022 Object *cstate;
3023 Object *child;
3024 Object *found_obj;
3025 struct MinList *ChildList = NULL;
3026
3027 get(data->family, MUIA_Family_List, &(ChildList));
3028 cstate = (Object *) ChildList->mlh_Head;
3029 while ((child = NextObject(&cstate)))
3030 {
3031 if (!(_flags(child) & MADF_CANDRAW))
3032 continue;
3033
3034 if ((found_obj = (Object *) DoMethodA(child, (Msg) msg)))
3035 return (IPTR) found_obj;
3036 }
3037 return DoSuperMethodA(cl, obj, (Msg) msg);
3038 }
3039
3040 /**************************************************************************
3041 MUIM_HandleEvent
3042 **************************************************************************/
3043 IPTR Group__MUIM_HandleEvent(struct IClass *cl, Object *obj,
3044 struct MUIP_HandleEvent *msg)
3045 {
3046 struct MUI_GroupData *data = INST_DATA(cl, obj);
3047
3048 /* check this, otherwise a superclass who has IDCMP_MOUSEBUTTONS
3049 eventhandler might call DoSuperMethod, and this function gets
3050 called even when he have not added any eventhandler */
3051
3052 if ((data->flags & GROUP_VIRTUAL) && msg->imsg)
3053 {
3054 switch (msg->imsg->Class)
3055 {
3056 case IDCMP_MOUSEBUTTONS:
3057 /* For virtual groups */
3058 if (msg->imsg->Code == SELECTDOWN)
3059 {
3060 if (_between(_mleft(obj), msg->imsg->MouseX, _mright(obj))
3061 && _between(_mtop(obj), msg->imsg->MouseY,
3062 _mbottom(obj)))
3063 {
3064 DoMethod(_win(obj), MUIM_Window_RemEventHandler,
3065 (IPTR) & data->ehn);
3066 data->ehn.ehn_Events |= IDCMP_INTUITICKS;
3067 DoMethod(_win(obj), MUIM_Window_AddEventHandler,
3068 (IPTR) & data->ehn);
3069 }
3070 }
3071 else
3072 {
3073 if (data->ehn.ehn_Events & IDCMP_INTUITICKS)
3074 {
3075 DoMethod(_win(obj), MUIM_Window_RemEventHandler,
3076 (IPTR) & data->ehn);
3077 data->ehn.ehn_Events &= ~IDCMP_INTUITICKS;
3078 DoMethod(_win(obj), MUIM_Window_AddEventHandler,
3079 (IPTR) & data->ehn);
3080 }
3081 }
3082 break;
3083
3084 case IDCMP_INTUITICKS:
3085 if (!(data->ehn.ehn_Events & IDCMP_INTUITICKS))
3086 break;
3087
3088 if (!(_between(_mleft(obj), msg->imsg->MouseX, _mright(obj))
3089 && _between(_mtop(obj), msg->imsg->MouseY,
3090 _mbottom(obj))))
3091 {
3092 LONG new_virt_offx = data->virt_offx;
3093 LONG new_virt_offy = data->virt_offy;
3094
3095 if (msg->imsg->MouseX < _mleft(obj))
3096 {
3097 /* scroll left */
3098 if (new_virt_offx >= 4)
3099 new_virt_offx -= 4;
3100 else
3101 new_virt_offx = 0;
3102 }
3103 else if (msg->imsg->MouseX > _mright(obj))
3104 {
3105 /* scroll right */
3106 new_virt_offx += 4;
3107 if (new_virt_offx > data->virt_mwidth - _mwidth(obj))
3108 new_virt_offx = data->virt_mwidth - _mwidth(obj);
3109 if (new_virt_offx < 0)
3110 new_virt_offx = 0;
3111 }
3112
3113 if (msg->imsg->MouseY < _mtop(obj))
3114 {
3115 /* scroll top */
3116 if (new_virt_offy >= 4)
3117 new_virt_offy -= 4;
3118 else
3119 new_virt_offy = 0;
3120 }
3121 else if (msg->imsg->MouseY > _mbottom(obj))
3122 {
3123 /* scroll bottom */
3124 new_virt_offy += 4;
3125 if (new_virt_offy > data->virt_mheight - _mheight(obj))
3126 new_virt_offy = data->virt_mheight - _mheight(obj);
3127 if (new_virt_offy < 0)
3128 new_virt_offy = 0;
3129 }
3130
3131 if (new_virt_offx != data->virt_offx
3132 || new_virt_offy != data->virt_offy)
3133 {
3134 SetAttrs(obj,
3135 MUIA_Virtgroup_Left, new_virt_offx,
3136 MUIA_Virtgroup_Top, new_virt_offy,
3137 MUIA_Group_Forward, FALSE, TAG_DONE);
3138 }
3139 }
3140 break;
3141 }
3142 }
3143
3144 return 0;
3145 }
3146
3147 /**************************************************************************
3148 MUIM_DrawBackground
3149 **************************************************************************/
3150 IPTR Group__MUIM_DrawBackground(struct IClass *cl, Object *obj,
3151 struct MUIP_DrawBackground *msg)
3152 {
3153 struct MUI_GroupData *data = INST_DATA(cl, obj);
3154
3155 if (data->flags & GROUP_VIRTUAL)
3156 {
3157 struct MUIP_DrawBackground msg2 = *msg;
3158
3159 msg2.xoffset += data->virt_offx;
3160 msg2.yoffset += data->virt_offy;
3161
3162 return DoSuperMethodA(cl, obj, (Msg) & msg2);
3163 }
3164
3165 return DoSuperMethodA(cl, obj, (Msg) msg);
3166 }
3167
3168 /**************************************************************************
3169 MUIM_FindAreaObject
3170 Find the given object or return NULL
3171 **************************************************************************/
3172 IPTR Group__MUIM_FindAreaObject(struct IClass *cl, Object *obj,
3173 struct MUIP_FindAreaObject *msg)
3174 {
3175 struct MUI_GroupData *data = INST_DATA(cl, obj);
3176 Object *cstate;
3177 Object *child;
3178 struct MinList *ChildList = NULL;
3179
3180 // it's me ?
3181 if (msg->obj == obj)
3182 return (IPTR) obj;
3183
3184 // it's one of my children ?
3185 get(data->family, MUIA_Family_List, &(ChildList));
3186 cstate = (Object *) ChildList->mlh_Head;
3187 while ((child = NextObject(&cstate)))
3188 {
3189 if (msg->obj == child)
3190 return (IPTR) child;
3191 }
3192
3193 // let the children find it
3194 get(data->family, MUIA_Family_List, &(ChildList));
3195 cstate = (Object *) ChildList->mlh_Head;
3196 while ((child = NextObject(&cstate)))
3197 {
3198 Object *res = (Object *) DoMethodA(child, (Msg) msg);
3199 if (res != NULL)
3200 return (IPTR) res;
3201 }
3202
3203 return (IPTR) NULL;
3204 }
3205
3206 /**************************************************************************
3207 MUIM_Export : to export an object's "contents" to a dataspace object.
3208 **************************************************************************/
3209 static IPTR Group__MUIM_Export(struct IClass *cl, Object *obj,
3210 struct MUIP_Export *msg)
3211 {
3212 struct MUI_GroupData *data = INST_DATA(cl, obj);
3213 Object *cstate;
3214 Object *child;
3215 struct MinList *ChildList = NULL;
3216
3217 get(data->family, MUIA_Family_List, &(ChildList));
3218 if (!ChildList)
3219 return 0;
3220
3221 cstate = (Object *) ChildList->mlh_Head;
3222 while ((child = NextObject(&cstate)))
3223 {
3224 DoMethodA(child, (Msg) msg);
3225 }
3226
3227 return 0;
3228 }
3229
3230
3231 /**************************************************************************
3232 MUIM_Import : to import an object's "contents" from a dataspace object.
3233 **************************************************************************/
3234 static IPTR Group__MUIM_Import(struct IClass *cl, Object *obj,
3235 struct MUIP_Import *msg)
3236 {
3237 struct MUI_GroupData *data = INST_DATA(cl, obj);
3238 Object *cstate;
3239 Object *child;
3240 struct MinList *ChildList = NULL;
3241
3242 get(data->family, MUIA_Family_List, &(ChildList));
3243 if (!ChildList)
3244 return 0;
3245
3246 cstate = (Object *) ChildList->mlh_Head;
3247 while ((child = NextObject(&cstate)))
3248 {
3249 DoMethodA(child, (Msg) msg);
3250 }
3251
3252 return 0;
3253 }
3254
3255 /**************************************************************************
3256 MUIM_Notify - disabled now because previous Zune versions had a OM_GET
3257 check in MUIM_Notify which is no longer the case
3258 **************************************************************************/
3259 #if 0
3260 STATIC IPTR Group_Notify(struct IClass *cl, Object *obj,
3261 struct MUIP_Notify *msg)
3262 {
3263 struct MUI_GroupData *data = INST_DATA(cl, obj);
3264 Object *cstate;
3265 Object *child;
3266 struct MinList *ChildList;
3267
3268 /* Try at first if understand the message our self
3269 ** We disable the forwarding of the OM_GET message
3270 ** as the MUIM_Notify otherwise would "think" that
3271 ** the group class actually understands the attribute
3272 ** although a child does this only
3273 */
3274 data->dont_forward_get = 1;
3275 if (DoSuperMethodA(cl, obj, (Msg) msg))
3276 {
3277 data->dont_forward_get = 0;
3278 return 1;
3279 }
3280
3281 /* We ourselves didn't understand the notify tag so we try the
3282 * children now */
3283 data->dont_forward_get = 0;
3284
3285 get(data->family, MUIA_Family_List, (IPTR *) & (ChildList));
3286 cstate = (Object *) ChildList->mlh_Head;
3287 while ((child = NextObject(&cstate)))
3288 {
3289 if (DoMethodA(child, (Msg) msg))
3290 return 1;
3291 }
3292 return 0;
3293 }
3294 #endif
3295
3296 #if 1
3297 /* Notes about Group_Notify() and echo notification problem:
3298 It was discovered that MUI seems to have some special handling for group class
3299 which will drop notifications on the children which are found to not
3300 understand the attribute.
3301
3302 This is done by checking if an OM_GET on the child returns TRUE.
3303 There's a little problem here because it is not known how big the storage
3304 needed for the attribute in question will be. Almost no class uses anything
3305 bigger than one IPTR. For "big" attributes those return a pointer to the data,
3306 not the data itself. Unfortuntely there are some exceptions like colorwheel
3307 class which does not return a pointer, but the data itself. So it's not
3308 enough to use one single IPTR variable (4 Bytes on 32bit machines, 8 bytes
3309 on 64 bit machines) to store the result of the test-OM_Get.
3310
3311 There is no general way to query the size needed so if one wants to change
3312 Zune to work like MUI one needs to choose a size which one hopes will be
3313 big enough to hold all possible attributes of all classes, old, present
3314 and future ones.
3315 */
3316 STATIC IPTR Group_Notify(struct IClass *cl, Object *obj,
3317 struct MUIP_Notify *msg)
3318 {
3319 struct MUI_GroupData *data = INST_DATA(cl, obj);
3320 Object *cstate;
3321 Object *child;
3322 struct MinList *ChildList = NULL;
3323 IPTR attr[30];
3324
3325 data->dont_forward_get = 1;
3326
3327 if (GetAttr(msg->TrigAttr, obj, attr))
3328 {
3329 data->dont_forward_get = 0;
3330 return DoSuperMethodA(cl, obj, (Msg) msg);
3331 }
3332 data->dont_forward_get = 0;
3333
3334 get(data->family, MUIA_Family_List, &(ChildList));
3335 if (!ChildList)
3336 return TRUE;
3337
3338 cstate = (Object *) ChildList->mlh_Head;
3339 while ((child = NextObject(&cstate)))
3340 {
3341
3342 if (GetAttr(msg->TrigAttr, child, attr))
3343 {
3344 DoMethodA(child, (Msg) msg);
3345 /* No return here! */
3346 }
3347 }
3348 return TRUE;
3349 }
3350 #endif
3351
3352 BOOPSI_DISPATCHER(IPTR, Group_Dispatcher, cl, obj, msg)
3353 {
3354 switch (msg->MethodID)
3355 {
3356 case OM_NEW:
3357 return Group__OM_NEW(cl, obj, (struct opSet *)msg);
3358 case OM_DISPOSE:
3359 return Group__OM_DISPOSE(cl, obj, msg);
3360 case OM_SET:
3361 return Group__OM_SET(cl, obj, (struct opSet *)msg);
3362 case OM_GET:
3363 return Group__OM_GET(cl, obj, (struct opGet *)msg);
3364 case OM_ADDMEMBER: /* Fall through */
3365 case MUIM_Group_AddTail:
3366 return Group__MUIM_AddTail(cl, obj, (APTR) msg);
3367 case MUIM_Group_AddHead:
3368 return Group__MUIM_AddHead(cl, obj, (APTR) msg);
3369 case MUIM_Group_Insert:
3370 return Group__MUIM_Insert(cl, obj, (APTR) msg);
3371 case OM_REMMEMBER: /* Fall through */
3372 case MUIM_Group_Remove:
3373 return Group__MUIM_Remove(cl, obj, (APTR) msg);
3374 case MUIM_AskMinMax:
3375 return Group__MUIM_AskMinMax(cl, obj, (APTR) msg);
3376 case MUIM_Group_ExitChange:
3377 return Group__MUIM_ExitChange(cl, obj, (APTR) msg);
3378 case MUIM_Group_ExitChange2:
3379 return Group__MUIM_ExitChange2(cl, obj, (APTR) msg);
3380 case MUIM_Group_InitChange:
3381 return Group__MUIM_InitChange(cl, obj, (APTR) msg);
3382 case MUIM_Group_Sort:
3383 return Group__MUIM_Sort(cl, obj, (APTR) msg);
3384 case MUIM_Group_DoMethodNoForward:
3385 return Group__MUIM_DoMethodNoForward(cl, obj, (APTR) msg);
3386 case MUIM_ConnectParent:
3387 return Group__MUIM_ConnectParent(cl, obj, (APTR) msg);
3388 case MUIM_DisconnectParent:
3389 return Group__MUIM_DisconnectParent(cl, obj, (APTR) msg);
3390 case MUIM_Layout:
3391 return Group__MUIM_Layout(cl, obj, (APTR) msg);
3392 case MUIM_Setup:
3393 return Group__MUIM_Setup(cl, obj, (APTR) msg);
3394 case MUIM_Cleanup:
3395 return Group__MUIM_Cleanup(cl, obj, (APTR) msg);
3396 case MUIM_Draw:
3397 return Group__MUIM_Draw(cl, obj, (APTR) msg);
3398
3399 case MUIM_FindUData:
3400 return Group__MUIM_FindUData(cl, obj, (APTR) msg);
3401 case MUIM_GetUData:
3402 return Group__MUIM_GetUData(cl, obj, (APTR) msg);
3403 case MUIM_SetUData:
3404 return Group__MUIM_SetUData(cl, obj, (APTR) msg);
3405 case MUIM_SetUDataOnce:
3406 return Group__MUIM_SetUDataOnce(cl, obj, (APTR) msg);
3407 case MUIM_Show:
3408 return Group__MUIM_Show(cl, obj, (APTR) msg);
3409 case MUIM_Hide:
3410 return Group__MUIM_Hide(cl, obj, (APTR) msg);
3411 case MUIM_HandleEvent:
3412 return Group__MUIM_HandleEvent(cl, obj, (APTR) msg);
3413 case MUIM_DrawBackground:
3414 return Group__MUIM_DrawBackground(cl, obj, (APTR) msg);
3415 case MUIM_DragQueryExtended:
3416 return Group__MUIM_DragQueryExtended(cl, obj, (APTR) msg);
3417 case MUIM_FindAreaObject:
3418 return Group__MUIM_FindAreaObject(cl, obj, (APTR) msg);
3419 case MUIM_Export:
3420 return Group__MUIM_Export(cl, obj, (APTR) msg);
3421 case MUIM_Import:
3422 return Group__MUIM_Import(cl, obj, (APTR) msg);
3423
3424 //#if 0
3425 #if 1
3426 /* Disabled. See above */
3427 case MUIM_Notify:
3428 return Group_Notify(cl, obj, (APTR) msg);
3429 #endif
3430 case MUIM_Set:
3431 case MUIM_MultiSet:
3432 case MUIM_CallHook:
3433 case MUIM_DrawParentBackground:
3434 case MUIM_DragBegin:
3435 case MUIM_DragDrop:
3436 case MUIM_DragQuery:
3437 case MUIM_DragFinish:
3438 case MUIM_DoDrag:
3439 case MUIM_CreateDragImage:
3440 case MUIM_DeleteDragImage:
3441 case MUIM_GoActive:
3442 case MUIM_GoInactive:
3443 case MUIM_CreateBubble:
3444 case MUIM_DeleteBubble:
3445 case MUIM_CreateShortHelp:
3446 case MUIM_DeleteShortHelp:
3447 case OM_ADDTAIL:
3448 case OM_REMOVE:
3449 return DoSuperMethodA(cl, obj, (APTR) msg);
3450 /* Needs not to be forwarded? */
3451 }
3452
3453 /* sometimes you want to call a superclass method,
3454 * but not dispatching to child.
3455 * But what to do with list methods in a listview ?
3456 */
3457 Group_DispatchMsg(cl, obj, (APTR) msg);
3458
3459 return DoSuperMethodA(cl, obj, msg);
3460 }
3461 BOOPSI_DISPATCHER_END
3462
3463 /*
3464 * Class descriptor.
3465 */
3466 const struct __MUIBuiltinClass _MUI_Group_desc =
3467 {
3468 MUIC_Group,
3469 MUIC_Area,
3470 sizeof(struct MUI_GroupData),
3471 (void *) Group_Dispatcher
3472 };
Mirror of AROS' svn.