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