?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add casts to zune macros to silence some warnings
[tangerine.git] / workbench / libs / asl / listviewclass.c
bloba2db6c6c7fddc335d15223c744ece7d4f50c80ce
1 /*
2 Copyright © 1995-2005, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #include <proto/exec.h>
7 #include <proto/dos.h>
8 #include <proto/utility.h>
9 #include <proto/intuition.h>
10 #include <proto/graphics.h>
11 #include <proto/cybergraphics.h>
12 #include <proto/layers.h>
13 #include <exec/memory.h>
14 #include <intuition/screens.h>
15 #include <intuition/icclass.h>
16 #include <intuition/cghooks.h>
17 #include <intuition/imageclass.h>
18 #include <intuition/gadgetclass.h>
19 #include <graphics/gfx.h>
20 #include <cybergraphx/cybergraphics.h>
21
22 #include <string.h>
23
24 #include "asl_intern.h"
25 #include "layout.h"
26
27 #define SDEBUG 0
28 #define DEBUG 0
29
30 #include <aros/debug.h>
31
32 #define CLASS_ASLBASE ((struct AslBase_intern *)cl->cl_UserData)
33 #define HOOK_ASLBASE ((struct AslBase_intern *)hook->h_Data)
34
35 #define AslBase CLASS_ASLBASE
36
37 /***********************************************************************************/
38
39 #undef AslBase
40 #define AslBase HOOK_ASLBASE
41
42 /************************
43 ** ASLLVRenderHook() **
44 ************************/
45 AROS_UFH3(IPTR, ASLLVRenderHook,
46 AROS_UFHA(struct Hook *, hook, A0),
47 AROS_UFHA(struct Node *, node, A2),
48 AROS_UFHA(struct ASLLVDrawMsg *, msg, A1)
49 )
50 {
51 AROS_USERFUNC_INIT
52
53 IPTR retval;
54
55 if (msg->lvdm_MethodID == LV_DRAW)
56 {
57 struct DrawInfo *dri = msg->lvdm_DrawInfo;
58 struct RastPort *rp = msg->lvdm_RastPort;
59
60 WORD min_x = msg->lvdm_Bounds.MinX;
61 WORD min_y = msg->lvdm_Bounds.MinY;
62 WORD max_x = msg->lvdm_Bounds.MaxX;
63 WORD max_y = msg->lvdm_Bounds.MaxY;
64
65 UWORD erasepen = BACKGROUNDPEN;
66 UWORD textpen = TEXTPEN;
67
68 SetDrMd(rp, JAM1);
69
70
71 switch (msg->lvdm_State)
72 {
73 case ASLLVR_SELECTED:
74 erasepen = FILLPEN;
75 textpen = FILLTEXTPEN;
76
77 /* Fall through */
78
79 case ASLLVR_NORMAL:
80 {
81 WORD numfit;
82 struct TextExtent te;
83
84 SetAPen(rp, dri->dri_Pens[erasepen]);
85 RectFill(rp, min_x, min_y, max_x, max_y);
86
87 if (node) if (node->ln_Name)
88 {
89 UWORD len = strlen(node->ln_Name);
90
91 numfit = TextFit(rp,
92 node->ln_Name,
93 len,
94 &te,
95 NULL,
96 1,
97 max_x - min_x + 1 - BORDERLVITEMSPACINGX * 2,
98 max_y - min_y + 1);
99
100 if (numfit < len) numfit++;
101
102 SetAPen(rp, dri->dri_Pens[textpen]);
103
104 /* Render text */
105 Move(rp, min_x + BORDERLVITEMSPACINGX,
106 min_y + BORDERLVITEMSPACINGY + rp->Font->tf_Baseline);
107 Text(rp, node->ln_Name, numfit);
108 }
109
110 } break;
111 }
112
113 retval = ASLLVCB_OK;
114 }
115 else
116 {
117 retval = ASLLVCB_UNKNOWN;
118 }
119
120 return retval;
121
122 AROS_USERFUNC_EXIT
123 }
124
125 /***********************************************************************************/
126
127 #undef AslBase
128 #define AslBase CLASS_ASLBASE
129
130 static struct Node *findnode(Class *cl, Object *o, WORD which)
131 {
132 struct AslListViewData *data;
133 struct Node *node = NULL;
134
135 data = INST_DATA(cl, o);
136
137 if (data->nodetable)
138 {
139 if ((which < data->total) && (which >= 0)) node = data->nodetable[which];
140 } else {
141 node = FindListNode(data->labels, which);
142 }
143
144 return node;
145 }
146
147 /***********************************************************************************/
148
149 static void makenodetable(Class *cl, Object *o)
150 {
151 struct AslListViewData *data;
152
153 data = INST_DATA(cl, o);
154
155 if (data->nodetable)
156 {
157 FreeVec(data->nodetable);
158 data->nodetable = NULL;
159 }
160
161 /* data->total must be correct here */
162
163 if (data->total > 0)
164 {
165 if ((data->nodetable = AllocVec(sizeof(struct Node *) * data->total, MEMF_PUBLIC)))
166 {
167 struct Node *node, **nodeptr = data->nodetable;
168 ForeachNode(data->labels, node)
169 {
170 *nodeptr++ = node;
171 }
172 }
173 }
174 }
175
176 /***********************************************************************************/
177
178 static void renderitem(Class *cl, Object *o, struct Node *node, WORD liney, struct RastPort *rp)
179 {
180 struct AslListViewData *data;
181 struct ASLLVDrawMsg msg;
182
183 data = INST_DATA(cl, o);
184
185 if (data->font) SetFont(rp, data->font);
186
187 msg.lvdm_MethodID = ASLLV_DRAW;
188 msg.lvdm_RastPort = rp;
189 msg.lvdm_DrawInfo = data->ld->ld_Dri;
190 msg.lvdm_Bounds.MinX = data->minx + BORDERLVSPACINGX;
191 msg.lvdm_Bounds.MaxX = data->maxx - BORDERLVSPACINGX;
192 msg.lvdm_Bounds.MinY = data->miny + BORDERLVSPACINGY + liney * data->lineheight -
193 (data->toppixel % data->lineheight);
194 msg.lvdm_Bounds.MaxY = msg.lvdm_Bounds.MinY + data->lineheight - 1;
195 msg.lvdm_State = node ? (IS_SELECTED(node) ? ASLLVR_SELECTED : ASLLVR_NORMAL) : ASLLVR_NORMAL;
196
197 if (data->renderrect)
198 {
199 if (!AndRectRect(data->renderrect, &msg.lvdm_Bounds, NULL)) return;
200 }
201
202 CallHookPkt(data->renderhook, node, &msg);
203 }
204
205 /***********************************************************************************/
206
207 static void renderallitems(Class *cl, Object *o, struct RastPort *rp)
208 {
209 struct AslListViewData *data;
210 struct Node *node;
211 LONG i, visible;
212
213 data = INST_DATA(cl, o);
214
215 node = findnode(cl, o, data->top);
216
217 visible = data->visiblepixels + data->lineheight - 1 + (data->toppixel % data->lineheight);
218 visible /= data->lineheight;
219
220 //kprintf("renderallitem: lineheight %d visible %d visiblepixels %d toppixel %d\n",
221 // data->lineheight, visible, data->visiblepixels, data->toppixel);
222
223 for(i = 0; i < visible; i++)
224 {
225 if (node) if (!node->ln_Succ) node = NULL;
226
227 renderitem(cl, o, node , i, rp);
228
229 if (node) node = node->ln_Succ;
230 }
231 }
232
233 /***********************************************************************************/
234
235 static void rendersingleitem(Class *cl, Object *o, struct GadgetInfo *gi, WORD which)
236 {
237 struct AslListViewData *data;
238
239 data = INST_DATA(cl, o);
240
241 if (!gi) return;
242 if (which < data->top) return;
243 if (which >= data->total) return;
244
245 if ((which - data->top) <
246 (data->visiblepixels + data->lineheight - 1 + (data->toppixel % data->lineheight)) / data->lineheight)
247 {
248 struct RastPort *rp;
249 struct Node *node;
250
251 node = findnode(cl, o, which);
252
253 if ((rp = ObtainGIRPort(gi)))
254 {
255 struct gpRender gpr;
256
257 data->rendersingleitem = which;
258
259 gpr.MethodID = GM_RENDER;
260 gpr.gpr_GInfo = gi;
261 gpr.gpr_RPort = rp;
262 gpr.gpr_Redraw = GREDRAW_UPDATE;
263
264 DoMethodA(o, (Msg)&gpr);
265
266 ReleaseGIRPort(rp);
267
268 } /* if ((rp = ObtainGIRPort(msg->gpi_GInfo))) */
269
270 } /* if ((which >= data->top) && ... */
271
272 }
273
274 /***********************************************************************************/
275
276 static WORD mouseitem(Class *cl, Object *o, WORD mousex, WORD mousey)
277 {
278 struct AslListViewData *data;
279 WORD result = -5;
280
281 data = INST_DATA(cl, o);
282
283 if (mousey < BORDERLVSPACINGY)
284 {
285 result = -1;
286 }
287 else if (mousey > data->maxy - data->miny - BORDERLVSPACINGY)
288 {
289 result = -2;
290 }
291 else if (mousex < BORDERLVSPACINGX)
292 {
293 result = -3;
294 }
295 else if (mousex > data->maxx - data->minx - BORDERLVSPACINGX)
296 {
297 result = -4;
298 }
299 else
300 {
301 LONG i = (mousey - BORDERLVSPACINGY + (data->toppixel % data->lineheight)) / data->lineheight;
302 LONG visible;
303
304 visible = data->visiblepixels + data->lineheight - 1 + (data->toppixel % data->lineheight);
305 visible /= data->lineheight;
306
307 if (i < visible)
308 {
309 struct Node *node;
310
311 i += data->top;
312
313 if ((node = findnode(cl, o, i)))
314 {
315 result = i;
316 }
317 }
318 }
319
320 //kprintf("mouseitem : %d\n", result);
321
322 return result;
323 }
324
325 /***********************************************************************************/
326
327 static void notifyall(Class *cl, Object *o, struct GadgetInfo *gi, STACKULONG flags)
328 {
329 struct AslListViewData *data = INST_DATA(cl, o);
330 struct TagItem tags[] =
331 {
332 {ASLLV_Top , data->top },
333 {ASLLV_TopPixel , data->toppixel },
334 {ASLLV_Total , data->total },
335 {ASLLV_TotalPixels , data->totalpixels },
336 {ASLLV_Visible , data->visible },
337 {ASLLV_VisiblePixels, data->visiblepixels },
338 {ASLLV_DeltaFactor , data->lineheight },
339 {TAG_DONE }
340 };
341 struct opUpdate opu;
342
343 opu.MethodID = OM_NOTIFY;
344 opu.opu_AttrList = tags;
345 opu.opu_GInfo = gi;
346 opu.opu_Flags = flags;
347
348 D(bug("asl listview notify all: top = %d (%d) total = %d (%d) visible = %d (%d)\n",
349 data->top, data->toppixel,
350 data->total, data->totalpixels,
351 data->visible, data->visiblepixels));
352
353 DoSuperMethodA(cl, o, (Msg)&opu);
354
355 };
356
357 /***********************************************************************************/
358
359 static void notifytop(Class *cl, Object *o, struct GadgetInfo *gi, STACKULONG flags)
360 {
361 struct AslListViewData *data = INST_DATA(cl, o);
362 struct TagItem tags[] =
363 {
364 {ASLLV_Top , data->top },
365 {ASLLV_TopPixel , data->toppixel},
366 {TAG_DONE }
367 };
368 struct opUpdate opu;
369
370 opu.MethodID = OM_NOTIFY;
371 opu.opu_AttrList = tags;
372 opu.opu_GInfo = gi;
373 opu.opu_Flags = flags;
374
375 D(bug("asl listview notify top: top = %d\n", data->top));
376
377 DoSuperMethodA(cl, o, (Msg)&opu);
378
379 };
380
381 /***********************************************************************************/
382
383 IPTR AslListView__OM_SET(Class * cl, Object * o, struct opSet * msg)
384 {
385 struct AslListViewData *data = INST_DATA(cl, o);
386 struct TagItem *tag;
387 const struct TagItem *tstate = msg->ops_AttrList;
388 IPTR retval, tidata;
389 BOOL redraw = FALSE, notify_all = FALSE, notify_top = FALSE;
390 LONG newtop;
391
392 retval = DoSuperMethod(cl, o, OM_SET, (IPTR) msg->ops_AttrList, (IPTR) msg->ops_GInfo);
393
394 while((tag = NextTagItem(&tstate)))
395 {
396 tidata = tag->ti_Data;
397
398 switch(tag->ti_Tag)
399 {
400 case ASLLV_Top:
401 tidata *= data->lineheight;
402 /* fall through */
403
404 case ASLLV_TopPixel:
405 newtop = tidata;
406 if (newtop + data->visiblepixels > data->totalpixels)
407 {
408 newtop = data->totalpixels - data->visiblepixels;
409 }
410 if (newtop < 0) newtop = 0;
411
412 if (newtop != data->toppixel)
413 {
414 data->scroll = redraw ? 0 : newtop - data->toppixel;
415 data->top = newtop / data->lineheight;
416 data->toppixel = newtop;
417 notify_top = TRUE;
418 redraw = TRUE;
419 }
420 break;
421
422 case ASLLV_MakeVisible:
423 newtop = (LONG)tidata * data->lineheight;
424
425 if (newtop < 0)
426 {
427 newtop = 0;
428 }
429 else if (newtop >= data->totalpixels)
430 {
431 newtop = data->totalpixels - 1;
432 if (newtop < 0) newtop = 0;
433 }
434
435 /* No need to do anything if it is already visible */
436
437 if (newtop < data->toppixel)
438 {
439 /* new_top already okay */
440
441 data->scroll = redraw ? 0 : newtop - data->toppixel;
442 data->top = newtop / data->lineheight;
443 data->toppixel = newtop;
444 notify_top = TRUE;
445 redraw = TRUE;
446 }
447 else if (newtop > data->toppixel + data->visiblepixels - data->lineheight)
448 {
449 newtop -= (data->visiblepixels - data->lineheight);
450 data->scroll = redraw ? 0 : newtop - data->toppixel;
451 data->top = newtop / data->lineheight;
452 data->toppixel = newtop;
453 notify_top = TRUE;
454 redraw = TRUE;
455 }
456 break;
457
458 case ASLLV_Active:
459 {
460 struct Node *node;
461 WORD n = 0;
462 WORD old_active = data->active;
463
464 data->active = (WORD)tidata;
465
466 if (data->domultiselect)
467 {
468 ForeachNode(data->labels, node)
469 {
470 if (IS_MULTISEL(node) && IS_SELECTED(node) && (n != data->active))
471 {
472 MARK_UNSELECTED(node);
473 rendersingleitem(cl, o, msg->ops_GInfo, n);
474 }
475 n++;
476 }
477 } else {
478 if ((node = findnode(cl, o, old_active)))
479 {
480 MARK_UNSELECTED(node);
481 rendersingleitem(cl, o, msg->ops_GInfo, old_active);
482 }
483 }
484
485 if ((node = findnode(cl, o, data->active)))
486 {
487 if (!data->domultiselect || IS_MULTISEL(node))
488 {
489 MARK_SELECTED(node);
490 rendersingleitem(cl, o, msg->ops_GInfo, data->active);
491 }
492 }
493
494 }
495 break;
496
497 case ASLLV_Labels:
498 data->labels = tidata ? (struct List *)tidata : &data->emptylist;
499 data->total = CountNodes(data->labels, 0);
500 data->totalpixels = data->total * data->lineheight;
501 data->active = -1;
502
503 if (!data->layouted)
504 {
505 data->visible = data->total;
506 data->visiblepixels = data->visible * data->lineheight;
507 }
508
509 if (data->toppixel + data->visiblepixels > data->totalpixels)
510 {
511 data->toppixel = data->totalpixels - data->visiblepixels;
512 }
513 if (data->toppixel < 0) data->toppixel = 0;
514 data->top = data->toppixel / data->lineheight;
515
516 if (!data->layouted)
517 {
518 data->visiblepixels = data->totalpixels;
519 data->visible = data->total;
520 }
521
522 makenodetable(cl, o);
523
524 notify_all = TRUE;
525 redraw = TRUE;
526 break;
527
528 case ASLLV_DoMultiSelect:
529 data->domultiselect = tidata ? TRUE : FALSE;
530 break;
531
532 case ASLLV_ReadOnly:
533 data->readonly = tidata ? TRUE : FALSE;
534 break;
535
536 case ASLLV_Font:
537 data->font = (struct TextFont *)tidata;
538 break;
539
540 } /* switch(tag->ti_Tag) */
541
542 } /* while((tag = NextTagItem(&tsate))) */
543
544 if (redraw)
545 {
546 struct RastPort *rp;
547 struct gpRender gpr;
548
549 if ((rp = ObtainGIRPort(msg->ops_GInfo)))
550 {
551 gpr.MethodID = GM_RENDER;
552 gpr.gpr_GInfo = msg->ops_GInfo;
553 gpr.gpr_RPort = rp;
554 gpr.gpr_Redraw = GREDRAW_UPDATE;
555
556 DoMethodA(o, (Msg)&gpr);
557
558 ReleaseGIRPort(rp);
559 }
560 }
561
562 if (notify_all)
563 {
564 notifyall(cl, o, msg->ops_GInfo, 0);
565 }
566 else if (notify_top)
567 {
568 notifytop(cl, o, msg->ops_GInfo, 0);
569 }
570
571 return retval;
572 }
573
574 /***********************************************************************************/
575
576 IPTR AslListView__OM_NEW(Class * cl, Object * o, struct opSet * msg)
577 {
578 struct AslListViewData *data;
579 struct TagItem fitags[] =
580 {
581 {IA_FrameType, FRAME_BUTTON},
582 {IA_EdgesOnly, TRUE },
583 {TAG_DONE, 0UL}
584 };
585
586 struct Gadget *g = (struct Gadget *)DoSuperMethodA(cl, o, (Msg)msg);
587 if (g)
588 {
589 data = INST_DATA(cl, g);
590
591 /* We want to get a GM_LAYOUT message, no matter if gadget is GFLG_RELRIGHT/RELBOTTOM/
592 RELWIDTH/RELHEIGHT or not */
593 g->Flags |= GFLG_RELSPECIAL;
594
595 data->frame = NewObjectA(NULL, FRAMEICLASS, fitags);
596 data->ld = (struct LayoutData *)GetTagData(GA_UserData, 0, msg->ops_AttrList);
597
598 if (!data->ld || !data->frame)
599 {
600 CoerceMethod(cl, (Object *)g, OM_DISPOSE);
601 g = NULL;
602 }
603 else
604 {
605 data->itemheight = GetTagData(ASLLV_ItemHeight, data->ld->ld_Font->tf_YSize, msg->ops_AttrList);
606 data->spacing = GetTagData(ASLLV_Spacing, BORDERLVITEMSPACINGY * 2, msg->ops_AttrList);
607
608 data->lineheight = data->itemheight + data->spacing;
609
610 NEWLIST(&data->emptylist);
611 data->labels = &data->emptylist;
612 data->active = -1;
613 data->rendersingleitem = -1;
614
615 data->renderhook = (struct Hook *)GetTagData(ASLLV_CallBack, 0, msg->ops_AttrList);
616 data->default_renderhook.h_Entry = (APTR) AROS_ASMSYMNAME(ASLLVRenderHook);
617 data->default_renderhook.h_SubEntry = NULL;
618 data->default_renderhook.h_Data = (APTR)AslBase;
619 if (!data->renderhook) data->renderhook = &data->default_renderhook;
620
621 AslListView__OM_SET(cl, (Object *)g, msg);
622 }
623 }
624
625 return (IPTR)g;
626 }
627
628 /***********************************************************************************/
629
630 IPTR AslListView__OM_GET(Class * cl, Object * o, struct opGet *msg)
631 {
632 struct AslListViewData *data;
633 IPTR retval = 1;
634
635 data = INST_DATA(cl, o);
636
637 switch(msg->opg_AttrID)
638 {
639 case ASLLV_Active:
640 *msg->opg_Storage = data->active;
641 break;
642
643 case ASLLV_Top:
644 *msg->opg_Storage = data->top;
645 break;
646
647 case ASLLV_TopPixel:
648 *msg->opg_Storage = data->toppixel;
649 break;
650
651 case ASLLV_Total:
652 *msg->opg_Storage = data->total;
653 break;
654
655 case ASLLV_TotalPixels:
656 *msg->opg_Storage = data->totalpixels;
657 break;
658
659 case ASLLV_Visible:
660 *msg->opg_Storage = data->visible;
661 break;
662
663 case ASLLV_VisiblePixels:
664 *msg->opg_Storage = data->visiblepixels;
665 break;
666
667 default:
668 retval = DoSuperMethodA(cl, o, (Msg)msg);
669 break;
670
671 } /* switch(msg->opg_AttrID) */
672
673 return retval;
674 }
675
676 /***********************************************************************************/
677
678 IPTR AslListView__OM_DISPOSE(Class * cl, Object * o, Msg msg)
679 {
680 struct AslListViewData *data;
681 IPTR retval;
682
683 data = INST_DATA(cl, o);
684 if (data->frame) DisposeObject(data->frame);
685 if (data->nodetable) FreeVec(data->nodetable);
686 retval = DoSuperMethodA(cl, o, msg);
687
688 return retval;
689 }
690
691 /***********************************************************************************/
692
693 IPTR AslListView__GM_GOACTIVE(Class *cl, Object *o, struct gpInput *msg)
694 {
695 struct AslListViewData *data;
696 WORD i;
697 IPTR retval = GMR_NOREUSE;
698
699 data = INST_DATA(cl, o);
700 if ((data->total < 1) || (data->readonly)) return retval;
701
702 i = mouseitem(cl, o, msg->gpi_Mouse.X, msg->gpi_Mouse.Y);
703
704 if (i >= 0)
705 {
706 struct Node *node;
707
708 if ((node = findnode(cl, o, i)))
709 {
710 ULONG sec, micro;
711
712 CurrentTime(&sec, &micro);
713
714 if (data->domultiselect && IS_MULTISEL(node) &&
715 (msg->gpi_IEvent->ie_Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)))
716 {
717 data->multiselecting = TRUE;
718 }
719 else
720 {
721 data->multiselecting = FALSE;
722
723 if (data->domultiselect)
724 {
725 struct Node *node;
726 WORD n = 0;
727
728 ForeachNode(data->labels, node)
729 {
730 if (IS_MULTISEL(node) && IS_SELECTED(node) && (n != data->active))
731 {
732 MARK_UNSELECTED(node);
733 rendersingleitem(cl, o, msg->gpi_GInfo, n);
734 }
735 n++;
736 }
737 }
738 }
739
740 data->doubleclicked = FALSE;
741 if (data->active == i)
742 {
743 if (DoubleClick(data->clicksec, data->clickmicro, sec, micro))
744 {
745 data->doubleclicked = TRUE;
746 }
747 }
748 else
749 {
750 if (!data->multiselecting && (data->active >= 0))
751 {
752 struct Node *oldnode = findnode(cl, o, data->active);
753
754 MARK_UNSELECTED(oldnode);
755 rendersingleitem(cl, o, msg->gpi_GInfo, data->active);
756 }
757
758 MARK_SELECTED(node);
759 rendersingleitem(cl, o, msg->gpi_GInfo, i);
760
761 data->active = i;
762
763 } /* if (data->active != i) */
764
765 data->clicksec = sec;
766 data->clickmicro = micro;
767
768 retval = GMR_MEACTIVE;
769
770 } /* if ((node = findnode(cl, o, i))) */
771
772 } /* if (i >= 0) */
773
774 return retval;
775 }
776
777 /***********************************************************************************/
778
779 IPTR AslListView__GM_HANDLEINPUT(Class *cl, Object *o, struct gpInput *msg)
780 {
781 struct AslListViewData *data;
782 UWORD code;
783 IPTR retval = GMR_MEACTIVE;
784
785 data = INST_DATA(cl, o);
786
787 switch(msg->gpi_IEvent->ie_Class)
788 {
789 case IECLASS_TIMER:
790 code = IECODE_NOBUTTON;
791 /* fall through */
792
793 case IECLASS_RAWMOUSE:
794 code = msg->gpi_IEvent->ie_Code;
795
796 switch(code)
797 {
798 case SELECTUP:
799 *msg->gpi_Termination = data->doubleclicked;
800 retval = GMR_VERIFY | GMR_NOREUSE;
801 break;
802
803 case IECODE_NOBUTTON:
804 {
805 WORD n = mouseitem(cl, o, msg->gpi_Mouse.X, msg->gpi_Mouse.Y);
806
807 if ((n == -1) && (data->active > 0)) n = data->active - 1;
808 if ((n == -2) && (data->active < data->total - 1)) n = data->active + 1;
809
810 if ((n >= 0) && (n != data->active))
811 {
812 struct Node *old = findnode(cl, o, data->active);
813 struct Node *new = findnode(cl, o, n);
814
815 if (data->multiselecting && new)
816 {
817 if (!IS_MULTISEL(new)) new = NULL;
818 }
819
820 if (new && old)
821 {
822 if (!data->multiselecting)
823 {
824 MARK_UNSELECTED(old);
825 rendersingleitem(cl, o, msg->gpi_GInfo, data->active);
826 }
827
828 MARK_SELECTED(new);
829 rendersingleitem(cl, o, msg->gpi_GInfo, n);
830
831 data->active = n;
832 }
833
834 if ((n * data->lineheight < data->toppixel) ||
835 (n * data->lineheight > data->toppixel + data->visiblepixels - data->lineheight))
836 {
837 struct RastPort *rp;
838
839 if (n * data->lineheight < data->toppixel)
840 {
841 LONG newtop = n * data->lineheight;
842 data->scroll = newtop - data->toppixel;
843 data->toppixel = newtop;
844 data->top = newtop / data->lineheight;
845 }
846 else
847 {
848 LONG newtop = n * data->lineheight - (data->visiblepixels - data->lineheight);
849
850 data->scroll = newtop - data->toppixel;
851 data->toppixel = newtop;
852 data->top = newtop / data->lineheight;
853 }
854
855 if ((rp = ObtainGIRPort(msg->gpi_GInfo)))
856 {
857 struct gpRender gpr;
858
859 gpr.MethodID = GM_RENDER;
860 gpr.gpr_GInfo = msg->gpi_GInfo;
861 gpr.gpr_RPort = rp;
862 gpr.gpr_Redraw = GREDRAW_UPDATE;
863
864 DoMethodA(o, (Msg)&gpr);
865
866 ReleaseGIRPort(rp);
867 }
868
869 notifytop(cl, o, msg->gpi_GInfo, OPUF_INTERIM);
870
871 } /* if ((n < data->top) || (n >= data->top + data->visible)) */
872
873 } /* if ((n >= 0) && (n != data->active)) */
874 break;
875 }
876
877 } /* switch(msg->gpi_IEvent->ie_Code) */
878 break;
879
880 } /* switch(msg->gpi_IEvent->ie_Class) */
881
882 return retval;
883 }
884
885 /***********************************************************************************/
886
887 IPTR AslListView__GM_LAYOUT(Class *cl, struct Gadget *g, struct gpLayout *msg)
888 {
889 struct AslListViewData *data;
890 IPTR retval = 0;
891
892 data = INST_DATA(cl, g);
893
894 if (msg->gpl_GInfo)
895 {
896 LONG newtop = data->toppixel;
897 LONG newvisible = data->visiblepixels;
898
899 getgadgetcoords(g, msg->gpl_GInfo, &data->minx, &data->miny, &data->width, &data->height);
900
901 data->maxx = data->minx + data->width - 1;
902 data->maxy = data->miny + data->height - 1;
903
904 newvisible = (data->height - BORDERLVSPACINGY * 2);
905 if (newtop + newvisible > data->totalpixels)
906 {
907 newtop = data->totalpixels - newvisible;
908 }
909 if (newtop < 0) newtop = 0;
910
911 if ((newtop != data->toppixel) || (newvisible != data->visiblepixels) || (!data->layouted))
912 {
913 data->toppixel = newtop;
914 data->top = newtop / data->lineheight;
915 data->visiblepixels = newvisible;
916 data->visible = newvisible / data->lineheight;
917
918 notifyall(cl, (Object *)g, msg->gpl_GInfo, 0);
919 }
920
921 data->layouted = TRUE;
922
923 retval = 1;
924 }
925
926 return retval;
927 }
928
929 /***********************************************************************************/
930
931 IPTR AslListView__GM_RENDER(Class *cl, Object *o, struct gpRender *msg)
932 {
933 struct AslListViewData *data;
934 struct Region *clip, *oldclip;
935 BOOL updating;
936 IPTR retval = 0;
937
938 data = INST_DATA(cl, o);
939
940 if (msg->gpr_Redraw == GREDRAW_REDRAW)
941 {
942 struct TagItem im_tags[] =
943 {
944 {IA_Width , data->width },
945 {IA_Height , data->height },
946 {IA_Recessed , data->readonly },
947 {TAG_DONE }
948 };
949
950 SetAttrsA(data->frame, im_tags);
951
952 DrawImageState(msg->gpr_RPort,
953 (struct Image *)data->frame,
954 data->minx,
955 data->miny,
956 IDS_NORMAL,
957 msg->gpr_GInfo->gi_DrInfo);
958 #if AVOID_FLICKER
959 {
960 struct IBox ibox, fbox;
961
962 fbox.Left = data->minx;
963 fbox.Top = data->miny;
964 fbox.Width = data->maxx - data->minx + 1;
965 fbox.Height = data->maxy - data->miny + 1;
966
967 ibox.Left = data->minx + BORDERLVSPACINGX;
968 ibox.Top = data->miny + BORDERLVSPACINGY;
969 ibox.Width = (data->maxx - data->minx + 1) - BORDERLVSPACINGX * 2;
970 ibox.Height = (data->maxy - data->miny + 1) - BORDERLVSPACINGY * 2;
971
972 PaintInnerFrame(msg->gpr_RPort,
973 msg->gpr_GInfo->gi_DrInfo,
974 data->frame,
975 &fbox,
976 &ibox,
977 msg->gpr_GInfo->gi_DrInfo->dri_Pens[BACKGROUNDPEN],
978 AslBase);
979
980 }
981
982 #endif
983
984 }
985
986 if ((clip = NewRectRegion(data->minx + BORDERLVSPACINGX,
987 data->miny + BORDERLVSPACINGY,
988 data->maxx - BORDERLVSPACINGX,
989 data->maxy - BORDERLVSPACINGY)))
990 {
991 struct Layer *lay = msg->gpr_GInfo->gi_Layer;
992
993 updating = (lay->Flags & LAYERUPDATING) != 0;
994
995 if (updating) EndUpdate(lay, FALSE);
996 oldclip = InstallClipRegion(lay, clip);
997 if (updating) BeginUpdate(lay);
998 }
999
1000 if (msg->gpr_Redraw == GREDRAW_REDRAW)
1001 {
1002 renderallitems(cl, o, msg->gpr_RPort);
1003
1004 } /* if (msg->gpr_Redraw == GREDRAW_REDRAW) */
1005 else if (msg->gpr_Redraw == GREDRAW_UPDATE)
1006 {
1007 if (data->rendersingleitem == -1)
1008 {
1009 WORD abs_scroll = (data->scroll >= 0) ? data->scroll : -data->scroll;
1010
1011 if ((abs_scroll == 0) || (abs_scroll > data->visiblepixels / 2))
1012 {
1013 renderallitems(cl, o, msg->gpr_RPort);
1014 }
1015 else
1016 {
1017 struct Rectangle rect;
1018 WORD scrollx1 = data->minx + BORDERLVSPACINGX;
1019 WORD scrolly1 = data->miny + BORDERLVSPACINGY;
1020 WORD scrollx2 = data->maxx - BORDERLVSPACINGX;
1021 WORD scrolly2 = data->maxy - BORDERLVSPACINGY;
1022 BOOL mustrefresh, update;
1023
1024 ScrollRaster(msg->gpr_RPort, 0, data->scroll,
1025 scrollx1, scrolly1, scrollx2, scrolly2);
1026
1027 mustrefresh = (msg->gpr_GInfo->gi_Layer->Flags & LAYERREFRESH) != 0;
1028
1029 rect.MinX = scrollx1;
1030 rect.MaxX = scrollx2;
1031
1032 if (data->scroll >= 0)
1033 {
1034 rect.MinY = scrolly2 - abs_scroll;
1035 rect.MaxY = scrolly2;
1036 }
1037 else
1038 {
1039 rect.MinY = scrolly1;
1040 rect.MaxY = scrolly1 + abs_scroll;
1041 }
1042
1043 data->renderrect = &rect;
1044 renderallitems(cl, o, msg->gpr_RPort);
1045 data->renderrect = NULL;
1046
1047 /* the LAYERUPDATING check should not be necessary,
1048 as then we should always have a GREDRAW_REDRAW,
1049 while here we are in GREDRAW_UPDATE. But just
1050 to be sure ... */
1051
1052 if (mustrefresh && !(msg->gpr_GInfo->gi_Layer->Flags & LAYERUPDATING))
1053 {
1054 if(!(update = BeginUpdate(msg->gpr_GInfo->gi_Layer)))
1055 {
1056 EndUpdate(msg->gpr_GInfo->gi_Layer, FALSE);
1057 }
1058
1059 renderallitems(cl, o, msg->gpr_RPort);
1060
1061 if(update) EndUpdate(msg->gpr_GInfo->gi_Layer, TRUE);
1062 }
1063
1064 }
1065 }
1066 else
1067 {
1068 if (data->rendersingleitem >= data->top)
1069 {
1070 struct Node *node = findnode(cl, o, data->rendersingleitem);
1071
1072 renderitem(cl, o, node, data->rendersingleitem - data->top, msg->gpr_RPort);
1073 }
1074 }
1075
1076 data->scroll = 0;
1077 data->rendersingleitem = -1;
1078
1079 } /* if (msg->gpr_Redraw == GREDRAW_UPDATE) */
1080
1081 if (clip)
1082 {
1083 struct Layer *lay = msg->gpr_GInfo->gi_Layer;
1084
1085 if (updating) EndUpdate(lay, FALSE);
1086 InstallClipRegion(lay, oldclip);
1087 if (updating) BeginUpdate(lay);
1088
1089 DisposeRegion(clip);
1090 }
1091
1092 return retval;
1093 }
1094
1095 /***********************************************************************************/
A totally sweet operating system