?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Tabs to spaces, more consistent formatting.
[AROS.git] / workbench / libs / muimaster / classes / balance.c
blob61493aca255f659a668ee238431974643e02861e
1 /*
2 Copyright © 2002-2006, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #include <string.h>
7 #include <stdlib.h>
8
9 #include <exec/types.h>
10
11 #include <clib/alib_protos.h>
12 #include <proto/intuition.h>
13 #include <proto/graphics.h>
14 #include <proto/utility.h>
15 #include <proto/exec.h>
16 #include <proto/muimaster.h>
17
18 #include "mui.h"
19 #include "muimaster_intern.h"
20 #include "support.h"
21 #include "prefs.h"
22 #include "balance_private.h"
23
24 /* #define MYDEBUG 0 */
25 #include "debug.h"
26
27 extern struct Library *MUIMasterBase;
28
29 /*
30 * [FirstBound .... <- balance -> .... SecondBound]
31 */
32
33
34 IPTR Balance__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
35 {
36 struct Balance_DATA *data;
37 struct TagItem *tags;
38 struct TagItem *tag;
39
40 obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
41
42 if (!obj)
43 return 0;
44
45 /* Initial local instance data */
46 data = INST_DATA(cl, obj);
47
48 /* parse initial taglist */
49
50 for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
51 {
52 switch (tag->ti_Tag)
53 {
54 case MUIA_Balance_Quiet:
55 break;
56 }
57 }
58
59 data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS;
60 data->ehn.ehn_Priority = 0;
61 data->ehn.ehn_Flags = 0;
62 data->ehn.ehn_Object = obj;
63 data->ehn.ehn_Class = cl;
64
65 D(bug("Balance_New(0x%lx)\n", obj));
66
67 return (IPTR) obj;
68 }
69
70 IPTR Balance__MUIM_Setup(struct IClass *cl, Object *obj,
71 struct MUIP_Setup *msg)
72 {
73 struct Balance_DATA *data = INST_DATA(cl, obj);
74
75 if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
76 return FALSE;
77
78 if (_parent(obj))
79 get(_parent(obj), MUIA_Group_Horiz, &data->horizgroup);
80
81 DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR) & data->ehn);
82
83 return TRUE;
84 }
85
86 IPTR Balance__MUIM_Cleanup(struct IClass *cl, Object *obj,
87 struct MUIP_Cleanup *msg)
88 {
89 struct Balance_DATA *data = INST_DATA(cl, obj);
90
91 DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR) & data->ehn);
92
93 return DoSuperMethodA(cl, obj, (Msg) msg);
94 }
95
96 /**************************************************************************
97 MUIM_AskMinMax
98 **************************************************************************/
99 IPTR Balance__MUIM_AskMinMax(struct IClass *cl, Object *obj,
100 struct MUIP_AskMinMax *msg)
101 {
102 struct Balance_DATA *data = INST_DATA(cl, obj);
103
104 DoSuperMethodA(cl, obj, (Msg) msg);
105
106 if (data->horizgroup)
107 {
108 msg->MinMaxInfo->MinWidth += 3;
109 msg->MinMaxInfo->DefWidth = msg->MinMaxInfo->MinWidth;
110 msg->MinMaxInfo->MaxWidth = msg->MinMaxInfo->DefWidth;
111 msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
112 }
113 else
114 {
115 msg->MinMaxInfo->MinHeight += 3;
116 msg->MinMaxInfo->DefHeight = msg->MinMaxInfo->MinHeight;
117 msg->MinMaxInfo->MaxHeight = msg->MinMaxInfo->DefHeight;
118 msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
119 }
120
121 return TRUE;
122 }
123
124
125 IPTR Balance__MUIM_Draw(struct IClass *cl, Object *obj,
126 struct MUIP_Draw *msg)
127 {
128 struct Balance_DATA *data = INST_DATA(cl, obj);
129 LONG col1, col2;
130
131 DoSuperMethodA(cl, obj, (Msg) msg);
132
133 if (!(msg->flags & MADF_DRAWOBJECT))
134 return 0;
135
136 if (_mwidth(obj) < 1 || _mheight(obj) < 1)
137 return TRUE;
138
139 if (data->state == NOT_CLICKED)
140 {
141 col1 = MPEN_TEXT;
142 col2 = MPEN_SHINE;
143 }
144 else
145 {
146 col2 = MPEN_TEXT;
147 col1 = MPEN_SHINE;
148 }
149
150 if (data->horizgroup)
151 {
152 SetAPen(_rp(obj), _pens(obj)[col1]);
153 Move(_rp(obj), _mleft(obj), _mtop(obj));
154 Draw(_rp(obj), _mleft(obj), _mbottom(obj));
155 SetAPen(_rp(obj), _pens(obj)[MPEN_FILL]);
156 Move(_rp(obj), _mleft(obj) + 1, _mtop(obj));
157 Draw(_rp(obj), _mleft(obj) + 1, _mbottom(obj));
158 SetAPen(_rp(obj), _pens(obj)[col2]);
159 Move(_rp(obj), _mleft(obj) + 2, _mtop(obj));
160 Draw(_rp(obj), _mleft(obj) + 2, _mbottom(obj));
161 }
162 else
163 {
164 SetAPen(_rp(obj), _pens(obj)[col1]);
165 Move(_rp(obj), _mleft(obj), _mtop(obj));
166 Draw(_rp(obj), _mright(obj), _mtop(obj));
167 SetAPen(_rp(obj), _pens(obj)[MPEN_FILL]);
168 Move(_rp(obj), _mleft(obj), _mtop(obj) + 1);
169 Draw(_rp(obj), _mright(obj), _mtop(obj) + 1);
170 SetAPen(_rp(obj), _pens(obj)[col2]);
171 Move(_rp(obj), _mleft(obj), _mtop(obj) + 2);
172 Draw(_rp(obj), _mright(obj), _mtop(obj) + 2);
173 }
174
175 return TRUE;
176 }
177
178 static void draw_object_frame(Object *obj, Object *o, BOOL fixed)
179 {
180 SetAPen(_rp(obj), _pens(obj)[MPEN_TEXT]);
181 Move(_rp(obj), _left(o), _top(o));
182 Draw(_rp(obj), _left(o), _bottom(o));
183 Draw(_rp(obj), _right(o), _bottom(o));
184 Draw(_rp(obj), _right(o), _top(o));
185 Draw(_rp(obj), _left(o), _top(o));
186 if (!fixed)
187 {
188 Draw(_rp(obj), _right(o), _bottom(o));
189 Move(_rp(obj), _right(o), _top(o));
190 Draw(_rp(obj), _left(o), _bottom(o));
191 }
192 }
193
194 static LONG get_first_bound(struct Balance_DATA *data, Object *obj)
195 {
196 ULONG spacing = 0;
197
198 if (data->horizgroup)
199 {
200 get(_parent(obj), MUIA_Group_HorizSpacing, &spacing);
201 return _left(obj) + _minwidth(obj) + _subwidth(obj) + spacing;
202 }
203 else
204 {
205 get(_parent(obj), MUIA_Group_VertSpacing, &spacing);
206 return _top(obj) + _minheight(obj) + _subheight(obj) + spacing;
207 }
208 }
209
210 static LONG get_second_bound(struct Balance_DATA *data, Object *obj)
211 {
212 ULONG spacing = 0;
213
214 if (data->horizgroup)
215 {
216 get(_parent(obj), MUIA_Group_HorizSpacing, &spacing);
217 return _right(obj) - _minwidth(obj) - _subwidth(obj) - spacing;
218 }
219 else
220 {
221 get(_parent(obj), MUIA_Group_VertSpacing, &spacing);
222 return _bottom(obj) - _minheight(obj) - _subheight(obj) - spacing;
223 }
224 }
225
226
227 static LONG get_first_bound_multi(struct Balance_DATA *data, Object *obj)
228 {
229 if (data->horizgroup)
230 {
231 return _mleft(_parent(obj));
232 }
233 else
234 {
235 return _mtop(_parent(obj));
236 }
237 }
238
239 static LONG get_second_bound_multi(struct Balance_DATA *data, Object *obj)
240 {
241 if (data->horizgroup)
242 {
243 return _mright(_parent(obj));
244 }
245 else
246 {
247 return _mbottom(_parent(obj));
248 }
249 }
250
251 static BOOL is_fixed_size(struct Balance_DATA *data, Object *obj)
252 {
253 if (data->horizgroup)
254 {
255 return (_minwidth(obj) == _maxwidth(obj));
256 }
257 else
258 {
259 return (_minheight(obj) == _maxheight(obj));
260 }
261 }
262
263
264 static ULONG get_total_weight_2(struct Balance_DATA *data, Object *objA,
265 Object *objB)
266 {
267 if (data->horizgroup)
268 {
269 return _hweight(objA) + _hweight(objB);
270 }
271 else
272 {
273 return _vweight(objA) + _vweight(objB);
274 }
275 }
276
277
278 static void set_weight_2(struct Balance_DATA *data, WORD current)
279 {
280 LONG weightB;
281 LONG weightA;
282
283 if (current >= data->second_bound)
284 {
285 weightB = 0;
286 weightA = data->total_weight;
287 D(bug("weightB = 0\n"));
288 }
289 else if (current <= data->first_bound)
290 {
291 weightA = 0;
292 weightB = data->total_weight;
293 D(bug("weightA = 0\n"));
294 }
295 else
296 {
297 D(bug("L=%ld, mid=%ld, R=%ld || M=%d\n",
298 data->first_bound, data->clickpos, data->second_bound,
299 current));
300 weightA = (current - data->first_bound + 1) * data->total_weight
301 / (data->second_bound - data->first_bound + 1);
302
303 D(bug("found wA = %ld\n", weightA));
304 if (weightA > data->total_weight)
305 {
306 D(bug("*** weightA > data->total_weight\n"));
307 weightA = data->total_weight;
308 }
309 weightB = data->total_weight - weightA;
310 }
311
312 if (data->horizgroup)
313 {
314 _hweight(data->obj_before) = weightA;
315 _hweight(data->obj_after) = weightB;
316 }
317 else
318 {
319 _vweight(data->obj_before) = weightA;
320 _vweight(data->obj_after) = weightB;
321 }
322 }
323
324
325 static void recalc_weights_neighbours(struct IClass *cl, Object *obj,
326 WORD mouse)
327 {
328 struct Balance_DATA *data = INST_DATA(cl, obj);
329
330 if ((data->total_weight == -1) || (data->first_bound == -1)
331 || (data->second_bound == -1))
332 {
333 Object *sibling;
334 Object *object_state;
335
336 object_state = (Object *) data->objs->lh_Head;
337 while ((sibling = NextObject(&object_state)))
338 {
339 if (!(_flags(sibling) & MADF_SHOWME))
340 continue;
341 /* D(bug("sibling %lx\n", sibling)); */
342 if (sibling == obj)
343 {
344 while ((sibling = NextObject(&object_state)))
345 {
346 if (!(_flags(sibling) & MADF_SHOWME))
347 continue;
348 data->obj_after = sibling;
349 break;
350 }
351 break;
352 }
353 data->obj_before = sibling;
354 }
355 if (!(data->obj_before && data->obj_after))
356 {
357 D(bug
358 ("Balance(%0xlx): missing siblings; before=%lx, after=%lx\n",
359 obj, data->obj_before, data->obj_after));
360 return;
361 }
362 if (data->total_weight == -1)
363 data->total_weight =
364 get_total_weight_2(data, data->obj_before, data->obj_after);
365 if (data->first_bound == -1)
366 data->first_bound = get_first_bound(data, data->obj_before);
367 if (data->second_bound == -1)
368 data->second_bound = get_second_bound(data, data->obj_after);
369 }
370
371 set_weight_2(data, mouse);
372 }
373
374 static LONG get_weight(struct Balance_DATA *data, Object *obj)
375 {
376 if (data->horizgroup)
377 {
378 return _hweight(obj);
379 }
380 else
381 {
382 return _vweight(obj);
383 }
384 }
385
386 static void set_weight(struct Balance_DATA *data, Object *obj, LONG w)
387 {
388 if (data->horizgroup)
389 {
390 _hweight(obj) = w;
391 }
392 else
393 {
394 _vweight(obj) = w;
395 }
396 }
397
398 static LONG get_size(struct Balance_DATA *data, Object *obj)
399 {
400 if (data->horizgroup)
401 {
402 return _width(obj);
403 }
404 else
405 {
406 return _height(obj);
407 }
408 }
409
410 #if 0
411 static void set_interpolated_weight(struct Balance_DATA *data, Object *obj,
412 LONG oldw, LONG neww)
413 {
414 if (data->horizgroup)
415 {
416 if (oldw)
417 _hweight(obj) = _hweight(obj) * neww / oldw;
418 else
419 _hweight(obj) = 0;
420 }
421 else
422 {
423 if (oldw)
424 _vweight(obj) = _vweight(obj) * neww / oldw;
425 else
426 _vweight(obj) = 0;
427 }
428
429 }
430 #endif
431
432 static void set_weight_all(struct Balance_DATA *data, Object *obj,
433 WORD current)
434 {
435 LONG weightB;
436 LONG weightA;
437 LONG ldelta, rdelta, lwbygad, rwbygad, lbonus, rbonus, lneg, rneg,
438 lzero, rzero, count;
439 int lfirst, rfirst;
440
441 {
442 if (data->lsize && data->rsize)
443 {
444 weightA = data->lsum
445 + ((current - data->clickpos)
446 * ((data->lsum / (double)data->lsize) +
447 (data->rsum / (double)data->rsize)) / 2.0);
448 }
449 else
450 weightA = data->lsum;
451
452 if (weightA > data->total_weight)
453 {
454 D(bug("*** weightA > data->total_weight\n"));
455 weightA = data->total_weight;
456 }
457 if (weightA < 0)
458 {
459 D(bug("*** weightA < 0n"));
460 weightA = 0;
461 }
462 weightB = data->total_weight - weightA;
463 D(bug("normal : weights = %ld/%ld\n", weightA, weightB));
464 }
465
466 ldelta = weightA - data->oldWeightA;
467 rdelta = weightB - data->oldWeightB;
468 lwbygad = ldelta / data->lsiblings;
469 rwbygad = rdelta / data->rsiblings;
470 lbonus = ldelta % data->lsiblings;
471 if (lbonus < 0)
472 lbonus = -lbonus;
473 rbonus = rdelta % data->rsiblings;
474 if (rbonus < 0)
475 rbonus = -rbonus;
476 lfirst = (int)((double)data->lsiblings * rand() / (RAND_MAX + 1.0));
477 rfirst = (int)((double)data->rsiblings * rand() / (RAND_MAX + 1.0));
478
479 count = 0;
480 do
481 {
482 Object *sibling;
483 Object *object_state;
484 WORD left = data->lsiblings;
485
486 D(bug("delta=%ld/%ld; wbygad=%ld/%ld; bonus=%ld/%ld; first=%d/%d\n",
487 ldelta, rdelta, lwbygad, rwbygad, lbonus, rbonus, lfirst,
488 rfirst));
489
490 if (count++ == 4)
491 {
492 D(bug("avoiding deadloop\n"));
493 break;
494 }
495 lneg = 0;
496 rneg = 0;
497 lzero = 0;
498 rzero = 0;
499
500 /* D(bug("left weight : from %d to %d\n", data->lsum, weightA)); */
501 /* D(bug("right weight : from %d to %d\n", data->rsum, weightB)); */
502 object_state = (Object *) data->objs->lh_Head;
503 while ((sibling = NextObject(&object_state)))
504 {
505 if (!(_flags(sibling) & MADF_SHOWME))
506 continue;
507 if (is_fixed_size(data, sibling))
508 continue;
509
510 /* D(bug(" B %d\n", left)); */
511 if (left > 0)
512 {
513 WORD w1, w2;
514 w1 = get_weight(data, sibling);
515 w2 = w1;
516 if (w2 || (count < 2))
517 {
518 w2 += lwbygad;
519 if ((lfirst-- <= 0) && lbonus-- > 0)
520 w2 += ((ldelta > 0) ? 1 : -1);
521 if (w2 < 0)
522 {
523 lzero++;
524 lneg += w2;
525 w2 = 0;
526 }
527 set_weight(data, sibling, w2);
528 /* D(bug(" w (left) from %d to %d (%ld -> %ld)\n",
529 * w1, w2, data->oldWeightA, weightA)); */
530 }
531 }
532 else
533 {
534 WORD w1, w2;
535 w1 = get_weight(data, sibling);
536 w2 = w1;
537 if (w2 || (count < 2))
538 {
539 w2 += rwbygad;
540 if ((rfirst-- <= 0) && rbonus-- > 0)
541 w2 += ((rdelta > 0) ? 1 : -1);
542 if (w2 < 0)
543 {
544 rzero++;
545 rneg += w2;
546 w2 = 0;
547 }
548 set_weight(data, sibling, w2);
549 /* D(bug(" w (right) from %d to %d (%ld -> %ld)\n",
550 * w1, w2, data->oldWeightB, weightB)); */
551 }
552 }
553 left--;
554 }
555 if (lzero == data->lsiblings)
556 break;
557 if (rzero == data->rsiblings)
558 break;
559
560 lwbygad = lneg / (data->lsiblings - lzero);
561 lbonus = -(lneg % (data->lsiblings - lzero)) + lbonus;
562 rwbygad = rneg / (data->rsiblings - rzero);
563 rbonus = -(rneg % (data->rsiblings - rzero)) + rbonus;
564 }
565 while (lneg || rneg || (lbonus > 0) || (rbonus > 0));
566
567 data->oldWeightA = weightA;
568 data->oldWeightB = weightB;
569 }
570
571
572 static void recalc_weights_all(struct IClass *cl, Object *obj, WORD mouse)
573 {
574 struct Balance_DATA *data = INST_DATA(cl, obj);
575 Object *first = NULL;
576 Object *last = NULL;
577
578 D(bug("recalc_weights_all\n"));
579
580 if ((data->total_weight == -1) || (data->lsiblings == -1)
581 || (data->rsiblings == -1) || (data->first_bound == -1)
582 || (data->second_bound == -1))
583 {
584 Object *sibling;
585 Object *object_state;
586 Object *next;
587 BOOL mid = FALSE;
588
589 data->lsum = 0;
590 data->rsum = 0;
591 data->lsize = 0;
592 data->rsize = 0;
593
594 object_state = (Object *) data->objs->lh_Head;
595 for (next = NextObject(&object_state); next;
596 next = NextObject(&object_state))
597 {
598 sibling = next;
599 if (!(_flags(sibling) & MADF_SHOWME))
600 continue;
601
602 if (sibling == obj)
603 {
604 mid = TRUE;
605 data->rsiblings = 0;
606 continue;
607 }
608
609 if (is_fixed_size(data, sibling))
610 continue;
611
612 if (!first)
613 {
614 first = sibling;
615 data->lsiblings = 1;
616 data->lsum += get_weight(data, sibling);
617 data->lsize += get_size(data, sibling);
618 }
619 else
620 {
621 if (!mid)
622 {
623 data->lsiblings++;
624 data->lsum += get_weight(data, sibling);
625 data->lsize += get_size(data, sibling);
626 }
627 else
628 {
629 data->rsiblings++;
630 data->rsum += get_weight(data, sibling);
631 data->rsize += get_size(data, sibling);
632 last = sibling;
633 }
634 }
635 }
636
637 if (!first || !mid || !last)
638 return;
639 if (data->total_weight == -1)
640 data->total_weight = data->lsum + data->rsum;
641
642 if (data->first_bound == -1)
643 data->first_bound = get_first_bound_multi(data, first);
644
645 if (data->second_bound == -1)
646 data->second_bound = get_second_bound_multi(data, last);
647
648 data->oldWeightA = data->lsum;
649 data->oldWeightB = data->rsum;
650 }
651 D(bug("Total Weight = %ld, left = %ld, right = %ld\n",
652 data->total_weight, data->lsum, data->rsum));
653 D(bug("bound 1 = %ld, bound 2 = %ld\n", data->first_bound,
654 data->second_bound));
655 set_weight_all(data, obj, mouse);
656 }
657
658
659 static void handle_move(struct IClass *cl, Object *obj, WORD mouse)
660 {
661 struct Balance_DATA *data = INST_DATA(cl, obj);
662
663 if (data->state == CLICKED)
664 recalc_weights_all(cl, obj, mouse);
665 else if (data->state == SHIFT_CLICKED)
666 recalc_weights_neighbours(cl, obj, mouse);
667 else
668 return;
669
670 /* full drawing, or sketch */
671 if (muiGlobalInfo(obj)->mgi_Prefs->balancing_look ==
672 BALANCING_SHOW_OBJECTS)
673 {
674 DoMethod(_parent(obj), MUIM_Hide);
675
676 /* relayout with new weights */
677 DoMethod(_parent(obj), MUIM_Layout);
678
679 DoMethod(_parent(obj), MUIM_Show);
680
681 MUI_Redraw(_parent(obj), MADF_DRAWALL);
682 }
683 else
684 {
685 Object *sibling;
686 Object *object_state;
687
688 DoMethod(_parent(obj), MUIM_DrawBackground, _mleft(_parent(obj)),
689 _mtop(_parent(obj)), _mwidth(_parent(obj)),
690 _mheight(_parent(obj)), 0, 0, 0);
691
692 /* relayout with new weights */
693 DoMethod(_parent(obj), MUIM_Layout);
694
695 DoMethod(obj, MADF_DRAWOBJECT);
696
697 /* for each child, draw a black frame */
698 object_state = (Object *) data->objs->lh_Head;
699 while ((sibling = NextObject(&object_state)))
700 {
701 if ((!(_flags(sibling) & MADF_SHOWME)) && (obj != sibling))
702 continue;
703 /* D(bug("sibling %lx\n", sibling)); */
704
705 draw_object_frame(obj, sibling, is_fixed_size(data, sibling));
706 }
707 }
708 }
709
710
711 /**************************************************************************
712 MUIM_HandleEvent
713 **************************************************************************/
714 IPTR Balance__MUIM_HandleEvent(struct IClass *cl, Object *obj,
715 struct MUIP_HandleEvent *msg)
716 {
717 struct Balance_DATA *data = INST_DATA(cl, obj);
718
719 if (msg->imsg)
720 {
721 switch (msg->imsg->Class)
722 {
723 case IDCMP_MOUSEBUTTONS:
724 if (msg->imsg->Code == SELECTDOWN)
725 {
726 if (_isinobject(msg->imsg->MouseX, msg->imsg->MouseY))
727 {
728 get(_parent(obj), MUIA_Group_ChildList, &data->objs);
729 data->clickpos =
730 data->horizgroup ? msg->imsg->MouseX : msg->imsg->
731 MouseY;
732 data->lastpos = data->clickpos;
733 DoMethod(_win(obj), MUIM_Window_RemEventHandler,
734 (IPTR) & data->ehn);
735 data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
736 DoMethod(_win(obj), MUIM_Window_AddEventHandler,
737 (IPTR) & data->ehn);
738 if (msg->imsg->
739 Qualifier & (IEQUALIFIER_LSHIFT |
740 IEQUALIFIER_RSHIFT))
741 {
742 data->state = SHIFT_CLICKED;
743 data->obj_before = NULL;
744 data->obj_after = NULL;
745 }
746 else
747 {
748 data->state = CLICKED;
749 data->lsiblings = -1;
750 data->rsiblings = -1;
751 }
752 data->total_weight = -1;
753 data->first_bound = -1;
754 data->second_bound = -1;
755 srand(1);
756 MUI_Redraw(obj, MADF_DRAWOBJECT);
757 }
758 }
759 else /* msg->imsg->Code != SELECTDOWN */
760 {
761 if (data->state != NOT_CLICKED)
762 {
763 DoMethod(_win(obj), MUIM_Window_RemEventHandler,
764 (IPTR) & data->ehn);
765 data->ehn.ehn_Events &= ~IDCMP_MOUSEMOVE;
766 DoMethod(_win(obj), MUIM_Window_AddEventHandler,
767 (IPTR) & data->ehn);
768 data->state = NOT_CLICKED;
769 if (data->total_weight != -1)
770 {
771 DoMethod(_parent(obj), MUIM_Hide);
772
773 /* relayout with new weights */
774 DoMethod(_parent(obj), MUIM_Layout);
775
776 DoMethod(_parent(obj), MUIM_Show);
777 MUI_Redraw(_parent(obj), MADF_DRAWOBJECT);
778 }
779 else
780 MUI_Redraw(obj, MADF_DRAWALL);
781 }
782 }
783 break;
784
785 case IDCMP_MOUSEMOVE:
786 {
787 if ((data->horizgroup)
788 && (msg->imsg->MouseX == data->lastpos))
789 break;
790 if ((!data->horizgroup)
791 && (msg->imsg->MouseY == data->lastpos))
792 break;
793 data->lazy ^= 1;
794 if (data->lazy)
795 break;
796
797 DoMethod(_win(obj), MUIM_Window_RemEventHandler,
798 (IPTR) & data->ehn);
799
800 if (data->horizgroup)
801 {
802 handle_move(cl, obj, msg->imsg->MouseX);
803 data->lastpos = msg->imsg->MouseX;
804 }
805 else
806 {
807 handle_move(cl, obj, msg->imsg->MouseY);
808 data->lastpos = msg->imsg->MouseY;
809 }
810
811 data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
812 DoMethod(_win(obj), MUIM_Window_AddEventHandler,
813 (IPTR) & data->ehn);
814 }
815 break;
816 }
817 }
818
819 return 0;
820 }
821
822 #if ZUNE_BUILTIN_BALANCE
823 BOOPSI_DISPATCHER(IPTR, Balance_Dispatcher, cl, obj, msg)
824 {
825 switch (msg->MethodID)
826 {
827 case OM_NEW:
828 return Balance__OM_NEW(cl, obj, (struct opSet *)msg);
829 case MUIM_Setup:
830 return Balance__MUIM_Setup(cl, obj, (APTR) msg);
831 case MUIM_Cleanup:
832 return Balance__MUIM_Cleanup(cl, obj, (APTR) msg);
833 case MUIM_AskMinMax:
834 return Balance__MUIM_AskMinMax(cl, obj, (APTR) msg);
835 case MUIM_Draw:
836 return Balance__MUIM_Draw(cl, obj, (APTR) msg);
837 case MUIM_HandleEvent:
838 return Balance__MUIM_HandleEvent(cl, obj, (APTR) msg);
839 default:
840 return DoSuperMethodA(cl, obj, msg);
841 }
842 }
843 BOOPSI_DISPATCHER_END const struct __MUIBuiltinClass _MUI_Balance_desc =
844 {
845 MUIC_Balance,
846 MUIC_Area,
847 sizeof(struct Balance_DATA),
848 (void *)Balance_Dispatcher
849 };
850 #endif
Mirror of AROS' svn.