?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update experimental gcc 6 patch to gcc 6.1.0 release
[AROS.git] / workbench / libs / muimaster / classes / title.c
blob7d434a2b5b0f981875200a4fb23b45ffa4f6f363
1 /*
2 Copyright © 2012-2015, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #define MUIMASTER_YES_INLINE_STDARG
7
8 #include <clib/alib_protos.h>
9 #include <proto/intuition.h>
10 #include <proto/muimaster.h>
11 #include <proto/graphics.h>
12 #include <proto/utility.h>
13
14 #include "mui.h"
15 #include "muimaster_intern.h"
16 #include "support.h"
17 #include "support_classes.h"
18 #include "title_private.h"
19
20 /* #define MYDEBUG 1 */
21 #include "debug.h"
22
23 extern struct Library *MUIMasterBase;
24
25 /* Note: Code taken from OWB's tabs handling */
26
27 #define MUIB_Tabs (TAG_USER | 0x10000000)
28 #define MUIV_Tabs_Top (MUIB_Tabs | 0x00000000)
29 #define MUIV_Tabs_Left (MUIB_Tabs | 0x00000001)
30
31 #define _isinobj(x,y,obj) (_between(_left(obj),(x),_right (obj)) \
32 && _between(_top(obj) ,(y),_bottom(obj)))
33
34 #define VERT_PADDING (4)
35 #define HORIZ_PADDING (4)
36
37 ULONG Tabs_Layout_Function(struct Hook *hook, Object *obj,
38 struct MUI_LayoutMsg *lm)
39 {
40 struct Title_DATA *data = (struct Title_DATA *)hook->h_Data;
41 switch (lm->lm_Type)
42 {
43 case MUILM_MINMAX:
44 {
45 Object *cstate = (Object *) lm->lm_Children->mlh_Head;
46 Object *child;
47
48 WORD maxminwidth = 0;
49 WORD maxminheight = 0;
50 WORD mintotalwidth = 0;
51 WORD mintotalheight = 0;
52 LONG number_of_children = 0;
53
54 /* find out biggest widths & heights of our children */
55
56 while ((child = NextObject(&cstate)))
57 {
58 if (maxminwidth < MUI_MAXMAX
59 && _minwidth(child) > maxminwidth)
60 maxminwidth = _minwidth(child);
61
62 if (maxminheight < MUI_MAXMAX
63 && _minheight(child) > maxminheight)
64 maxminheight = _minheight(child);
65
66 mintotalheight += _minheight(child);
67
68 number_of_children++;
69 }
70
71 if (data->location == MUIV_Tabs_Top)
72 {
73 WORD horiz_spacing = XGET(obj, MUIA_Group_HorizSpacing);
74
75 mintotalwidth = (number_of_children * maxminwidth) +
76 ((number_of_children - 1) * horiz_spacing) + horiz_spacing;
77
78 lm->lm_MinMax.MinWidth = lm->lm_MinMax.DefWidth = mintotalwidth;
79 lm->lm_MinMax.MaxWidth = MUI_MAXMAX;
80
81 lm->lm_MinMax.MinHeight =
82 lm->lm_MinMax.MaxHeight =
83 lm->lm_MinMax.DefHeight = maxminheight + (VERT_PADDING * 2);
84 }
85 else if (data->location == MUIV_Tabs_Left)
86 {
87 mintotalheight +=
88 (number_of_children - 1) * XGET(obj,
89 MUIA_Group_VertSpacing);
90 lm->lm_MinMax.MinWidth = lm->lm_MinMax.DefWidth =
91 maxminwidth;
92 lm->lm_MinMax.MinHeight = lm->lm_MinMax.DefHeight =
93 mintotalheight;
94 lm->lm_MinMax.MaxWidth = lm->lm_MinMax.DefWidth =
95 maxminwidth;
96 lm->lm_MinMax.MaxHeight = MUI_MAXMAX;
97 }
98
99 return 0;
100 }
101 case MUILM_LAYOUT:
102 {
103 APTR cstate;
104 Object *child;
105 LONG number_of_children = 0;
106
107 cstate = lm->lm_Children->mlh_Head;
108 while ((child = NextObject(&cstate)))
109 {
110 number_of_children++;
111 }
112
113 if (data->location == MUIV_Tabs_Top)
114 {
115 WORD horiz_spacing = XGET(obj, MUIA_Group_HorizSpacing);
116 WORD childwidth =
117 (lm->lm_Layout.Width - ((number_of_children - 1) * horiz_spacing) - horiz_spacing)
118 / number_of_children;
119
120 WORD leftovers = lm->lm_Layout.Width -
121 ((number_of_children - 1) * horiz_spacing) - horiz_spacing -
122 (number_of_children * childwidth);
123
124 WORD left = horiz_spacing / 2;
125 WORD cheight = _height(obj) - (VERT_PADDING * 2);
126
127 cstate = lm->lm_Children->mlh_Head;
128 while ((child = NextObject(&cstate)))
129 {
130 WORD cwidth = childwidth;
131
132 if (leftovers-- > 0)
133 cwidth++;
134 if (!MUI_Layout(child, left + HORIZ_PADDING, VERT_PADDING, cwidth - (HORIZ_PADDING * 2), cheight , 0))
135 return (FALSE);
136
137 left += cwidth + horiz_spacing;
138 }
139 }
140 else if (data->location == MUIV_Tabs_Left)
141 {
142 WORD vert_spacing = XGET(obj, MUIA_Group_VertSpacing);
143 WORD top = 0;
144 cstate = lm->lm_Children->mlh_Head;
145 while ((child = NextObject(&cstate)))
146 {
147 WORD cheight = _minheight(child);
148
149 if (!MUI_Layout(child, 0, top, lm->lm_Layout.Width,
150 cheight, 0))
151 return (FALSE);
152
153 top += cheight + vert_spacing;
154 }
155 }
156 else
157 return FALSE;
158
159 return TRUE;
160 }
161 }
162
163 return TRUE;
164 }
165
166 IPTR Title__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
167 {
168 struct Title_DATA *data = NULL;
169 struct Hook *layout_hook;
170
171 /* Lay tabs horizontally by default */
172 LONG location = MUIV_Tabs_Top;
173
174 layout_hook = AllocVec(sizeof(struct Hook), MEMF_ANY | MEMF_CLEAR);
175 if (!layout_hook)
176 return (IPTR) NULL;
177
178 layout_hook->h_Entry = HookEntry;
179 layout_hook->h_SubEntry = (HOOKFUNC) Tabs_Layout_Function;
180
181 obj = (Object *) DoSuperNewTags
182 (cl, obj, NULL,
183 MUIA_Group_Horiz, TRUE,
184 MUIA_Group_LayoutHook, (IPTR) layout_hook,
185 MUIA_ShowSelState, FALSE, TAG_MORE, (IPTR) msg->ops_AttrList);
186 if (!obj)
187 return FALSE;
188
189 data = INST_DATA(cl, obj);
190
191 layout_hook->h_Data = data;
192 data->layout_hook = layout_hook;
193 data->location = location;
194 data->activetab = 0;
195 data->oldactivetab = 0;
196
197 /* We need tab events to be processed after all objects contained in tabs
198 like for example close button, hence the low priority value */
199 data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS;
200 data->ehn.ehn_Priority = -7;
201 data->ehn.ehn_Flags = 0;
202 data->ehn.ehn_Object = obj;
203 data->ehn.ehn_Class = cl;
204
205 D(bug("muimaster.library/title.c: Title Object created at 0x%lx\n",
206 obj));
207
208 return (IPTR) obj;
209 }
210
211 IPTR Title__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
212 {
213 struct Title_DATA *data = INST_DATA(cl, obj);
214 FreeVec(data->layout_hook);
215
216 return DoSuperMethodA(cl, obj, msg);
217 }
218
219 IPTR Title__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
220 {
221 struct Title_DATA *data = INST_DATA(cl, obj);
222 struct TagItem *tags = msg->ops_AttrList;
223 struct TagItem *tag;
224
225 while ((tag = NextTagItem(&tags)) != NULL)
226 {
227 switch (tag->ti_Tag)
228 {
229 case MUIA_Group_ActivePage:
230 {
231 if (data->activetab != tag->ti_Data)
232 {
233 data->oldactivetab = data->activetab;
234 data->activetab = tag->ti_Data;
235 MUI_Redraw(obj, MADF_DRAWUPDATE);
236 set(_parent(obj), MUIA_Group_ActivePage,
237 data->activetab);
238 }
239 break;
240 }
241 }
242 }
243
244 return DoSuperMethodA(cl, obj, (Msg) msg);
245 }
246
247 /* MUIM_Draw helpers */
248
249 /* Similar like in Register class */
250 static void DrawTopTab(Object *obj, struct Title_DATA *data, BOOL active,
251 WORD x1, WORD y1, WORD x2, WORD y2)
252 {
253 /* Correct for padding */
254 x1 -= HORIZ_PADDING;
255 y1 -= VERT_PADDING;
256 x2 += HORIZ_PADDING;
257 y2 += 1;
258
259 /* Fill the padding area */
260 DoMethod(obj, MUIM_DrawBackground, x1 , y1, x2 - x1, VERT_PADDING, 0, 0, 0);
261 DoMethod(obj, MUIM_DrawBackground, x1 , y1, HORIZ_PADDING, y2 - y1, 0, 0, 0);
262 DoMethod(obj, MUIM_DrawBackground, x2 - VERT_PADDING + 1, y1, HORIZ_PADDING, y2 - y1, 0, 0, 0);
263 DoMethod(obj, MUIM_DrawBackground, x1, y2, x2 - x1, 1, 0, 0, 0);
264
265 if (!active)
266 {
267 /* Clear the rounded edges of an inactive tab with default
268 * background */
269
270 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x1, (IPTR) y1,
271 (IPTR) 1, (IPTR) 3, (IPTR) x1, (IPTR) y1, (IPTR) 0);
272 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x1 + 1, (IPTR) y1,
273 (IPTR) 1, (IPTR) 2, (IPTR) x1 + 1, (IPTR) y1, (IPTR) 0);
274 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x1 + 2, (IPTR) y1,
275 (IPTR) 1, (IPTR) 1, (IPTR) x1 + 2, (IPTR) y1, (IPTR) 0);
276 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x2 - 3, (IPTR) y1,
277 (IPTR) 3, (IPTR) 1, (IPTR) x2 - 3, (IPTR) y1, (IPTR) 0);
278 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x2 - 1, (IPTR) y1,
279 (IPTR) 1, (IPTR) 2, (IPTR) x2 - 1, (IPTR) y1, (IPTR) 0);
280 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x2, (IPTR) y1,
281 (IPTR) 1, (IPTR) 3, (IPTR) x2, (IPTR) y1, (IPTR) 0);
282 }
283
284 /* top horiz bar */
285 SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
286 RectFill(_rp(obj), x1 + 4, y1, x2 - 4, y1);
287
288 /* left vert bar */
289 RectFill(_rp(obj), x1, y1 + 4, x1, y2 - (active ? 2 : 1));
290 WritePixel(_rp(obj), x1 + 1, y1 + 3);
291 WritePixel(_rp(obj), x1 + 1, y1 + 2);
292 WritePixel(_rp(obj), x1 + 2, y1 + 1);
293 WritePixel(_rp(obj), x1 + 3, y1 + 1);
294 SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHINE]);
295 WritePixel(_rp(obj), x1 + 3, y1);
296 WritePixel(_rp(obj), x1 + 4, y1 + 1);
297 WritePixel(_rp(obj), x1 + 2, y1 + 2);
298 WritePixel(_rp(obj), x1 + 3, y1 + 2);
299 WritePixel(_rp(obj), x1 + 2, y1 + 3);
300 WritePixel(_rp(obj), x1, y1 + 3);
301 WritePixel(_rp(obj), x1 + 1, y1 + 4);
302
303 if (active)
304 {
305 /* bottom horiz bar */
306 SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
307 WritePixel(_rp(obj), x1, y2 - 1);
308 WritePixel(_rp(obj), x1, y2);
309
310 SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
311 WritePixel(_rp(obj), x2, y2 - 1);
312 WritePixel(_rp(obj), x2, y2);
313 }
314 else
315 {
316 SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
317 RectFill(_rp(obj), x1, y2, x2, y2);
318 }
319
320 /* right vert bar */
321 SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
322 WritePixel(_rp(obj), x2 - 1, y1 + 2);
323 RectFill(_rp(obj), x2, y1 + 4, x2, y2 - (active ? 2 : 1));
324 SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHADOW]);
325 WritePixel(_rp(obj), x2 - 2, y1 + 1);
326 WritePixel(_rp(obj), x2 - 1, y1 + 3);
327 WritePixel(_rp(obj), x2, y1 + 3);
328 SetAPen(_rp(obj), _pens(obj)[MPEN_BACKGROUND]);
329 WritePixel(_rp(obj), x2 - 3, y1 + 1);
330 }
331
332 /* Like above, just symetrically flipped */
333 static void DrawLeftTab(Object *obj, struct Title_DATA *data, BOOL active,
334 WORD x1, WORD y1, WORD x2, WORD y2)
335 {
336 if (!active)
337 {
338 /* Clear the rounded edges of an inactive tab with default
339 * background */
340
341 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x1, (IPTR) y1,
342 (IPTR) 3, (IPTR) 1, (IPTR) x1, (IPTR) y1, (IPTR) 0);
343 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x1, (IPTR) y1 + 1,
344 (IPTR) 2, (IPTR) 1, (IPTR) x1, (IPTR) y1 + 1, (IPTR) 0);
345 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x1, (IPTR) y1 + 2,
346 (IPTR) 1, (IPTR) 1, (IPTR) x1, (IPTR) y1 + 2, (IPTR) 0);
347 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x1, (IPTR) y2 - 2,
348 (IPTR) 1, (IPTR) 1, (IPTR) x1, (IPTR) y2 - 2, (IPTR) 0);
349 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x1, (IPTR) y2 - 1,
350 (IPTR) 2, (IPTR) 1, (IPTR) x1, (IPTR) y2 - 1, (IPTR) 0);
351 DoMethod(obj, MUIM_DrawParentBackground, (IPTR) x1, (IPTR) y2,
352 (IPTR) 3, (IPTR) 1, (IPTR) x1, (IPTR) y2, (IPTR) 0);
353
354 }
355
356 /* left vert bar */
357 SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
358 RectFill(_rp(obj), x1, y1 + 4, x1, y2 - 4);
359
360 /* top horiz bar */
361 RectFill(_rp(obj), x1 + 4, y1, x2 - (active ? 2 : 1), y1);
362 WritePixel(_rp(obj), x1 + 1, y1 + 3);
363 WritePixel(_rp(obj), x1 + 1, y1 + 2);
364 WritePixel(_rp(obj), x1 + 2, y1 + 1);
365 WritePixel(_rp(obj), x1 + 3, y1 + 1);
366 SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHINE]);
367 WritePixel(_rp(obj), x1 + 3, y1);
368 WritePixel(_rp(obj), x1 + 4, y1 + 1);
369 WritePixel(_rp(obj), x1 + 2, y1 + 2);
370 WritePixel(_rp(obj), x1 + 3, y1 + 2);
371 WritePixel(_rp(obj), x1 + 2, y1 + 3);
372 WritePixel(_rp(obj), x1, y1 + 3);
373 WritePixel(_rp(obj), x1 + 1, y1 + 4);
374
375 if (active)
376 {
377 /* bottom horiz bar */
378 SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
379 WritePixel(_rp(obj), x2 - 1, y1);
380 WritePixel(_rp(obj), x2, y1);
381
382 SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
383 WritePixel(_rp(obj), x2 - 1, y2);
384 WritePixel(_rp(obj), x2, y2);
385 }
386 else
387 {
388 SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
389 RectFill(_rp(obj), x2, y1, x2, y2);
390 }
391
392 /* bottom horiz bar */
393 SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
394 WritePixel(_rp(obj), x1 + 2, y2 - 1);
395 RectFill(_rp(obj), x1 + 4, y2, x2 - (active ? 2 : 1), y2);
396 SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHADOW]);
397 WritePixel(_rp(obj), x1 + 1, y2 - 2);
398 WritePixel(_rp(obj), x1 + 3, y2 - 1);
399 WritePixel(_rp(obj), x1 + 3, y2);
400 SetAPen(_rp(obj), _pens(obj)[MPEN_BACKGROUND]);
401 WritePixel(_rp(obj), x1 + 1, y2 - 3);
402 }
403
404 /* Drawing code */
405 IPTR Tab__MUIM_Draw(Object *child, struct Title_DATA *data, BOOL active)
406 {
407 WORD x1 = _left(child);
408 WORD y1 = _top(child);
409 WORD x2 = _right(child);
410 WORD y2 = _bottom(child);
411
412 /* Setting of background (to a different value!) causes redraw of object. We use this "feature" */
413 if (active)
414 nnset(child, MUIA_Background, data->background);
415 else
416 nnset(child, MUIA_Background, MUII_BACKGROUND);
417
418 /* Draw tab frame */
419 if (data->location == MUIV_Tabs_Top)
420 DrawTopTab(child, data, active, x1, y1, x2, y2);
421 else if (data->location == MUIV_Tabs_Left)
422 DrawLeftTab(child, data, active, x1, y1, x2, y2);
423
424 return TRUE;
425 }
426 /* MUIM_Draw helpers */
427
428 IPTR Title__MUIM_Draw(struct IClass *cl, Object *obj,
429 struct MUIP_Draw *msg)
430 {
431 struct Title_DATA *data = INST_DATA(cl, obj);
432 struct List *children = NULL;
433 APTR cstate;
434 Object *child;
435 WORD horiz_spacing = XGET(obj, MUIA_Group_HorizSpacing);
436 WORD vert_spacing = XGET(obj, MUIA_Group_VertSpacing);
437 LONG tab = 0;
438
439 /* Draw all the children */
440 DoSuperMethodA(cl, obj, (Msg) msg);
441
442 if (!(msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE)))
443 return (0);
444
445
446 /* Now draw missing TabbedGroup border between the spaces */
447 get(obj, MUIA_Group_ChildList, &children);
448
449 cstate = children->lh_Head;
450
451 while ((child = NextObject(&cstate)))
452 {
453 if (tab == data->activetab)
454 Tab__MUIM_Draw(child, data, TRUE);
455 else if (tab == data->oldactivetab)
456 Tab__MUIM_Draw(child, data, FALSE);
457 else if (msg->flags & MADF_DRAWOBJECT)
458 Tab__MUIM_Draw(child, data, FALSE);
459
460 tab++;
461 }
462
463 cstate = children->lh_Head;
464 child = NextObject(&cstate);
465
466 SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
467 if (data->location == MUIV_Tabs_Top)
468 {
469 RectFill(_rp(obj), _left(obj), _bottom(child) + 1, _left(obj) + horiz_spacing / 2, _bottom(child) + 1);
470 RectFill(_rp(obj), _right(obj) - horiz_spacing / 2, _bottom(child) + 1, _right(obj), _bottom(child) + 1);
471
472 while (child && (child = NextObject(&cstate)))
473 {
474 RectFill(_rp(obj), _left(child) - horiz_spacing - HORIZ_PADDING, _bottom(child) + 1,
475 _left(child) - 1 - HORIZ_PADDING, _bottom(child) + 1);
476 }
477 }
478 else if (data->location == MUIV_Tabs_Left)
479 {
480 WORD lasty = -1;
481 while (child && (child = NextObject(&cstate)))
482 {
483 RectFill(_rp(obj), _right(child), _top(child) - vert_spacing,
484 _right(child), _top(child) - 1);
485 lasty = _bottom(child);
486 }
487 if (lasty > -1)
488 RectFill(_rp(obj), _right(obj), lasty + 1, _right(obj),
489 _bottom(obj));
490 }
491 else
492 return FALSE;
493
494 return TRUE;
495 }
496
497 IPTR Title__MUIM_Setup(struct IClass *cl, Object *obj,
498 struct MUIP_Setup *msg)
499 {
500 struct Title_DATA *data = INST_DATA(cl, obj);
501
502 if (!DoSuperMethodA(cl, obj, (Msg) msg))
503 return FALSE;
504
505 get(_parent(obj), MUIA_Background, &data->background);
506
507 DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR) & data->ehn);
508
509 return TRUE;
510 }
511
512 IPTR Title__MUIM_Cleanup(struct IClass *cl, Object *obj,
513 struct MUIP_Cleanup *msg)
514 {
515 struct Title_DATA *data = INST_DATA(cl, obj);
516
517 DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR) & data->ehn);
518
519 return DoSuperMethodA(cl, obj, (Msg) msg);
520 }
521
522 IPTR Title__MUIM_HandleEvent(struct IClass *cl, Object *obj,
523 struct MUIP_HandleEvent *msg)
524 {
525 if (!msg->imsg)
526 return 0;
527
528 switch (msg->imsg->Class)
529 {
530 case IDCMP_MOUSEBUTTONS:
531 if (msg->imsg->Code == SELECTDOWN
532 && _isinobj(msg->imsg->MouseX, msg->imsg->MouseY, obj))
533 {
534 struct List *children =
535 (struct List *)XGET(obj, MUIA_Group_ChildList);
536 APTR cstate = children->lh_Head;
537 Object *child;
538 int i;
539
540 /* Find previous and next tab */
541 for (i = 0; (child = NextObject(&cstate)); i++)
542 {
543 if (_isinobj(msg->imsg->MouseX, msg->imsg->MouseY, child))
544 {
545 /* Activate this tab */
546 set(obj, MUIA_Group_ActivePage, i);
547 break;
548 }
549 }
550 }
551 break;
552 }
553 return 0;
554 }
555
556 #if ZUNE_BUILTIN_TITLE
557 BOOPSI_DISPATCHER(IPTR, Title_Dispatcher, cl, obj, msg)
558 {
559 switch (msg->MethodID)
560 {
561 case OM_NEW:
562 return Title__OM_NEW(cl, obj, (struct opSet *)msg);
563 case OM_SET:
564 return Title__OM_SET(cl, obj, (struct opSet *)msg);
565 case OM_DISPOSE:
566 return Title_OM_DISPOSE(cl, obj, msg);
567 case MUIM_Draw:
568 return Title__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
569 case MUIM_Setup:
570 return Title__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
571 case MUIM_Cleanup:
572 return Title__MUIM_Cleanup(cl, obj, (struct MUIP_Cleanup *)msg);
573 case MUIM_HandleEvent:
574 return Title__MUIM_HandleEvent(cl, obj,
575 (struct MUIP_HandleEvent *)msg);
576 default:
577 return DoSuperMethodA(cl, obj, msg);
578 }
579 }
580 BOOPSI_DISPATCHER_END
581
582 const struct __MUIBuiltinClass _MUI_Title_desc =
583 {
584 MUIC_Title,
585 MUIC_Group,
586 sizeof(struct Title_DATA),
587 (void *) Title_Dispatcher
588 };
589 #endif /* ZUNE_BUILTIN_TITLE */
Mirror of AROS' svn.