?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Experiment:
[AROS-Contrib.git] / bgui / listclass.c
blob704ef3fe063ff31acdb8ab59251e058516c4b141
1 /*
2 * @(#) $Header$
3 *
4 * BGUI library
5 * listclass.c
6 *
7 * (C) Copyright 1998 Manuel Lemos.
8 * (C) Copyright 1996-1997 Ian J. Einman.
9 * (C) Copyright 1993-1996 Jaba Development.
10 * (C) Copyright 1993-1996 Jan van den Baard.
11 * All Rights Reserved.
12 *
13 * $Log$
14 * Revision 42.4 2004/06/16 20:16:48 verhaegs
15 * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
16 *
17 * Revision 42.3 2000/08/17 15:09:18 chodorowski
18 * Fixed compiler warnings.
19 *
20 * Revision 42.2 2000/05/15 19:27:01 stegerg
21 * another hundreds of REG() macro replacements in func headers/protos.
22 *
23 * Revision 42.1 2000/05/14 23:32:47 stegerg
24 * changed over 200 function headers which all use register
25 * parameters (oh boy ...), because the simple REG() macro
26 * doesn't work with AROS. And there are still hundreds
27 * of headers left to be fixed :(
28 *
29 * Many of these functions would also work with stack
30 * params, but since i have fixed every single one
31 * I encountered up to now, I guess will have to do
32 * the same for the rest.
33 *
34 * Revision 42.0 2000/05/09 22:09:28 mlemos
35 * Bumped to revision 42.0 before handing BGUI to AROS team
36 *
37 * Revision 41.11 2000/05/09 19:54:37 mlemos
38 * Merged with the branch Manuel_Lemos_fixes.
39 *
40 * Revision 41.10.2.17 1999/08/08 23:05:11 mlemos
41 * Assured that the list is redrawn when the list font or the default font
42 * changes.
43 * Made the entry height be always recomputed every time the list is rendered.
44 *
45 * Revision 41.10.2.16 1999/07/28 06:34:32 mlemos
46 * Added rendering damage list after the ScrollRaster() call.
47 *
48 * Revision 41.10.2.15 1999/07/18 06:15:42 mlemos
49 * Fixed the problem of very quick drop without dragging.
50 *
51 * Revision 41.10.2.14 1999/07/03 15:17:40 mlemos
52 * Replaced the calls to CallHookPkt to BGUI_CallHookPkt.
53 *
54 * Revision 41.10.2.13 1999/05/24 20:20:43 mlemos
55 * Added fix for attempt to free BaseInfo handle twice when dragging 10 or
56 * more entries.
57 *
58 * Revision 41.10.2.12 1998/12/20 01:37:42 mlemos
59 * Ensured that the list is fully redrawn when a change like adding a new
60 * entry that makes the list partially invisible, makes the list overhead
61 * increase.
62 * Fixed computation of the top overhead area of a list view with title to
63 * include the height of the separator line (2 pixels).
64 *
65 * Revision 41.10.2.11 1998/12/07 03:07:03 mlemos
66 * Replaced OpenFont and CloseFont calls by the respective BGUI debug macros.
67 *
68 * Revision 41.10.2.10 1998/12/07 00:49:52 mlemos
69 * Fixed range checking bug of new list top entry when the number of visible
70 * entries is larger than the total entries.
71 *
72 * Revision 41.10.2.9 1998/12/06 21:38:21 mlemos
73 * Ensured that when the parent view and window are passed to the listview
74 * scroller gadget on its creation or when are set by OM_SET OM_UPDATE.
75 *
76 * Revision 41.10.2.8 1998/12/06 21:20:41 mlemos
77 * Ensured that the key activation selects the previous or the next selected
78 * entries in Multi Selection lists.
79 * Ensured that selecting the previous or the next selected entries in Multi
80 * Selection lists always deselects any previously selected entries.
81 *
82 * Revision 41.10.2.7 1998/11/28 13:45:17 mlemos
83 * Made the default flag of the list to pre clear the entries.
84 *
85 * Revision 41.10.2.6 1998/11/12 16:23:33 mlemos
86 * Passed NULL rastport pointer to AllocBaseInfo in the methods
87 * BASE_DRAGACTIVE, BASE_DRAGINACTIVE and BASE_DRAGUPDATE to ensure that it
88 * legally obtains the Rastport.
89 *
90 * Revision 41.10.2.5 1998/10/11 15:28:58 mlemos
91 * Enforced the columns minimum width value.
92 *
93 * Revision 41.10.2.4 1998/10/11 14:50:21 mlemos
94 * Fixed the computation of the initial offset of the column bars when the
95 * user starts to drag them.
96 *
97 * Revision 41.10.2.3 1998/06/16 01:22:10 mlemos
98 * Passed NULL rastport pointer to AllocBaseInfo in DrawDragLine to ensure
99 * that it legally obtains the Rastport.
100 *
101 * Revision 41.10.2.2 1998/06/15 21:48:43 mlemos
102 * Passed NULL rastport pointer to AllocBaseInfo in NewTop to ensure that it
103 * legally obtains the Rastport.
104 *
105 * Revision 41.10.2.1 1998/03/01 15:38:05 mlemos
106 * Added support to track BaseInfo memory leaks.
107 *
108 * Revision 41.10 1998/02/25 21:12:31 mlemos
109 * Bumping to 41.10
110 *
111 * Revision 1.1 1998/02/25 17:09:00 mlemos
112 * Ian sources
113 *
114 *
115 */
116
117 /*
118 * Incorporates MultiColumnListview by Nick Christie.
119 * New code, but the interface is the same.
120 */
121
122 #include "include/classdefs.h"
123
124 /*
125 * Internal entry storage.
126 */
127 typedef struct lvEntry {
128 struct lvEntry *lve_Next; /* Next entry. */
129 struct lvEntry *lve_Prev; /* Previous entry. */
130 ULONG lve_Flags; /* See below. */
131 APTR lve_Entry; /* Entry data. */
132 } LVE;
133
134 #define LVEF_SELECTED (1<<0) /* Entry is selected. */
135 #define LVEF_DISABLED (1<<1) /* Entry is disabled. */
136 #define LVEF_HIDDEN (1<<2) /* Entry is hidden. */
137 #define LVEF_REFRESH (1<<31) /* Entry must be redrawn. */
138
139 typedef struct {
140 LVE *lvl_First; /* First entry. */
141 LVE *lvl_EndMarker; /* End marker. */
142 LVE *lvl_Last; /* Last entry. */
143 } LVL;
144
145 typedef struct cd_ {
146 UWORD cd_Offset; /* Left offset of column. */
147 UWORD cd_Width; /* Width of column. */
148 UWORD cd_MinWidth; /* Minimum column width. */
149 UWORD cd_MaxWidth; /* Maximum column width. */
150 UWORD cd_Weight; /* Relative Weight of column. */
151 ULONG cd_Flags; /* Column Flags. */
152 } CD;
153
154 #define LVCF_NOSEPARATOR (1<<0) /* No column separator. */
155 #define LVCF_HIDDEN (1<<1) /* Column is not visible. */
156 #define LVCF_DRAGGABLE (1<<2) /* Column is draggable. */
157 #define LVCF_PRECLEAR (1<<3) /* Column is pre-cleared. */
158
159 /*
160 * Object instance data.
161 */
162 typedef struct ld_ {
163 ULONG ld_Flags; /* See below. */
164 Object *ld_Prop; /* Scroller. */
165 BC *ld_BC; /* Bounding boxes. */
166 struct IBox ld_ListArea; /* Area bounds. */
167 LVL ld_Entries; /* List of entries. */
168 // LVL ld_Hidden; /* Entries filtered out. */
169 LVE *ld_TopEntry; /* Top entry. */
170 ULONG ld_ActiveEntry; /* Active entry number. */
171 LVE *ld_LastActive; /* Last active entry. */
172 ULONG ld_LastNum; /* Last active entry number. */
173 UWORD ld_LastCol; /* Last active column. */
174 LVE *ld_LastAdded; /* Last added entry. */
175
176 UWORD ld_EntryHeight; /* Height of a single entry. */
177 UWORD ld_Overhead; /* View area overhead. */
178 ULONG ld_Top; /* Top entry visible. */
179 ULONG ld_Total; /* Number of entries. */
180 LONG ld_Visible; /* Number of visible entries. */
181 struct Hook *ld_Resource; /* Resource hook. */
182 struct Hook *ld_Display; /* Display hook. */
183 struct Hook *ld_Compare; /* Comparisson hook. */
184 struct Hook *ld_TitleHook; /* Title hook. */
185 UBYTE *ld_Title; /* Title. */
186 // struct Hook *ld_Filter; /* Filter hook. */
187 struct TextAttr *ld_ListFont; /* List font. */
188 struct TextFont *ld_Font; /* List font. */
189 APTR ld_MemoryPool; /* OS 3.0 memory pool. */
190 ULONG ld_MultiStart; /* Start of multi-(de)select. */
191 UWORD ld_MultiMode; /* Mode of multi-(de)select. */
192 UWORD ld_MinShown; /* Min # lines shown. */
193 ULONG ld_Secs[2]; /* Double-clicks. */
194 ULONG ld_Mics[2];
195 ULONG ld_NewPos; /* New entry position. */
196 APTR ld_ScanEntry; /* Last scanned entry. */
197 LVE *ld_ScanNode; /* And it's node. */
198 ULONG ld_DropSpot; /* Place where dropped. */
199 ULONG ld_DrawSpot; /* Place where line drawn. */
200 struct RastPort *ld_DragRP; /* Draggable bitmap+rport. */
201 struct RastPort *ld_LineBuffer; /* Place for drop line. */
202
203 UWORD ld_Columns; /* number of columns, > 0 */
204 UWORD ld_OneColumn; /* Render only one column. */
205 UWORD ld_DragColumn; /* column # being dragged, 0...n */
206 WORD ld_DragXLine; /* current x position of drag line */
207 CD *ld_CD; /* Column Descriptors. */
208
209 } LD;
210
211 #define ld_InnerBox ld_BC->bc_InnerBox
212 #define ld_OuterBox ld_BC->bc_OuterBox
213 #define ld_HitBox ld_BC->bc_HitBox
214 #define ld_Frame ld_BC->bc_Frame
215
216 #define LDF_READ_ONLY (1 << 0 ) /* Read-only list. */
217 #define LDF_MULTI_SELECT (1 << 1 ) /* Multi-select list. */
218 #define LDF_REFRESH_ALL (1 << 2 ) /* Refresh whole list. */
219 #define LDF_PROPACTIVE (1 << 4 ) /* Prop gadget is active. */
220 #define LDF_LIST_BUSY (1 << 5 ) /* We are busy with the list. */
221 #define LDF_NOSHIFT (1 << 6 ) /* Multi-select without shift */
222 #define LDF_CUSTOMDISABLE (1 << 7 ) /* Display hook renders disabled state. */
223 #define LDF_SHOWDROPSPOT (1 << 8 ) /* Show where we they drop. */
224 #define LDF_DRAGGABLE (1 << 9 ) /* We are in draggable mode. */
225 #define LDF_ALLOW_DRAG (1 << 10) /* Allow column dragging by user */
226 #define LDF_OFFSETS_VALID (1 << 11) /* Column offsets are valid */
227 #define LDF_DRAGGING_COLUMN (1 << 12) /* Currently dragging a column */
228 #define LDF_NEW_COLUMN_POS (1 << 13) /* Set when user releases column */
229 #define LDF_PRE_CLEAR (1 << 14) /* Pre-clear entry rectangle. */
230 #define LDF_THIN_FRAMES (1 << 15) /* 1:1 Aspect ratio frames. */
231 #define LDF_MOVE_DROPBOX (1 << 16) /* Move the dragbox around? */
232 #define LDF_ONE_COLUMN (1 << 17) /* Redraw only one column. */
233
234 #define LD_ENTRY(tag, offset, flags) PACK_ENTRY(LISTV_TAGSTART, tag, ld_, offset, flags)
235 #define LD_FLAG(tag, flag) PACK_LONGBIT(LISTV_TAGSTART, tag, ld_, ld_Flags, PKCTRL_BIT, flag)
236
237 static ULONG ListPackTable[] =
238 {
239 PACK_STARTTABLE(LISTV_TAGSTART),
240
241 LD_ENTRY(LISTV_ResourceHook, ld_Resource, PKCTRL_ULONG),
242 LD_ENTRY(LISTV_DisplayHook, ld_Display, PKCTRL_ULONG),
243 LD_ENTRY(LISTV_CompareHook, ld_Compare, PKCTRL_ULONG),
244 LD_ENTRY(LISTV_TitleHook, ld_TitleHook, PKCTRL_ULONG),
245 LD_ENTRY(LISTV_MinEntriesShown, ld_MinShown, PKCTRL_UWORD),
246 LD_ENTRY(LISTV_Top, ld_Top, PKCTRL_ULONG),
247 LD_ENTRY(LISTV_Columns, ld_Columns, PKCTRL_UWORD),
248 LD_ENTRY(LISTV_Title, ld_Title, PKCTRL_ULONG),
249 LD_ENTRY(LISTV_PropObject, ld_Prop, PKCTRL_ULONG),
250 LD_ENTRY(LISTV_ListFont, ld_ListFont, PKCTRL_ULONG),
251
252 LD_FLAG(LISTV_ReadOnly, LDF_READ_ONLY),
253 LD_FLAG(LISTV_MultiSelect, LDF_MULTI_SELECT),
254 LD_FLAG(LISTV_ThinFrames, LDF_THIN_FRAMES),
255 LD_FLAG(LISTV_MultiSelectNoShift, LDF_NOSHIFT),
256 LD_FLAG(LISTV_ShowDropSpot, LDF_SHOWDROPSPOT),
257 LD_FLAG(LISTV_CustomDisable, LDF_CUSTOMDISABLE),
258 LD_FLAG(LISTV_DragColumns, LDF_ALLOW_DRAG),
259 LD_FLAG(LISTV_PreClear, LDF_PRE_CLEAR),
260
261 PACK_ENDTABLE
262 };
263
264 #define LC_ENTRY(tag, offset, flags) PACK_ENTRY(LISTC_TAGSTART, tag, cd_, offset, flags)
265 #define LC_FLAG(tag, flag) PACK_LONGBIT(LISTC_TAGSTART, tag, cd_, cd_Flags, PKCTRL_BIT, flag)
266
267 static ULONG ColumnPackTable[] =
268 {
269 PACK_STARTTABLE(LISTV_TAGSTART),
270
271 LC_ENTRY(LISTC_MinWidth, cd_MinWidth, PKCTRL_UWORD),
272 LC_ENTRY(LISTC_MaxWidth, cd_MaxWidth, PKCTRL_UWORD),
273 LC_ENTRY(LISTC_Weight, cd_Weight, PKCTRL_UWORD),
274
275 LC_FLAG(LISTC_Draggable, LVCF_DRAGGABLE),
276 LC_FLAG(LISTC_Hidden, LVCF_HIDDEN),
277 LC_FLAG(LISTC_NoSeparator, LVCF_NOSEPARATOR),
278 LC_FLAG(LISTC_PreClear, LVCF_PRECLEAR),
279
280 PACK_ENDTABLE
281 };
282
283 /*
284 * Prop map-list.
285 */
286 STATIC struct TagItem PGA2LISTV[] = {
287 PGA_Top, LISTV_Top,
288 TAG_END
289 };
290
291 STATIC VOID RenderEntry(Object *obj, LD *ld, struct BaseInfo *bi, LVE *lve, ULONG top);
292 #define REL_ZERO (0x80000000)
293
294
295 //VOID ASM ColumnSeparators(REG(a0) LD *ld, REG(a1) struct BaseInfo *bi, REG(d0) ULONG x, REG(d1) ULONG y, REG(d2) ULONG h)
296 ASM REGFUNC5(VOID, ColumnSeparators,
297 REGPARAM(A0, LD *, ld),
298 REGPARAM(A1, struct BaseInfo *, bi),
299 REGPARAM(D0, ULONG, x),
300 REGPARAM(D1, ULONG, y),
301 REGPARAM(D2, ULONG, h))
302 {
303 int col, pena, penb, x2, y2;
304
305 struct RastPort *rp = bi->bi_RPort;
306
307 x2 = x + ld->ld_InnerBox.Width - 4;
308 y2 = y + h - 1;
309
310 if (ld->ld_Flags & LDF_READ_ONLY)
311 {
312 pena = SHINEPEN;
313 penb = SHADOWPEN;
314 }
315 else
316 {
317 pena = SHADOWPEN;
318 penb = SHINEPEN;
319 };
320
321 for (col = 0; col < ld->ld_Columns; col++)
322 {
323 if (!(ld->ld_CD[col].cd_Flags & LVCF_HIDDEN))
324 {
325 x += ld->ld_CD[col].cd_Width - 2;
326
327 if (!(ld->ld_CD[col].cd_Flags & LVCF_NOSEPARATOR) && (x < x2))
328 {
329 BSetDPenA(bi, pena);
330 Move(rp, x, y);
331 Draw(rp, x++, y2);
332
333 BSetDPenA(bi, penb);
334 Move(rp, x, y);
335 Draw(rp, x++, y2);
336 };
337 };
338 };
339 }
340 REGFUNC_END
341 /*
342 * Find a node by it's number (slow!).
343 */
344 //STATIC ASM LVE *FindNode( REG(a0) LD *ld, REG(d0) ULONG num )
345 STATIC ASM REGFUNC2(LVE *, FindNode,
346 REGPARAM(A0, LD *, ld),
347 REGPARAM(D0, ULONG, num))
348 {
349 LVE *lve;
350 ULONG lnum = 0L;
351
352 /*
353 * List empty?
354 */
355 if ( ! ld->ld_Entries.lvl_First->lve_Next )
356 return( NULL );
357
358 /*
359 * Scan the list top-down to find
360 * the correct entry.
361 */
362 for ( lve = ld->ld_Entries.lvl_First; lve->lve_Next; lve = lve->lve_Next, lnum++ ) {
363 if ( lnum == num )
364 break;
365 }
366
367 return( lve );
368 }
369 REGFUNC_END
370
371 /*
372 * Find a node by it's number (quickly).
373 */
374 //STATIC ASM LVE *FindNodeQuick( REG(a0) LD *ld, REG(d0) ULONG num )
375 STATIC ASM REGFUNC2(LVE *, FindNodeQuick,
376 REGPARAM(A0, LD *, ld),
377 REGPARAM(D0, ULONG, num))
378 {
379 LVE *lve = ld->ld_TopEntry;
380 ULONG top = ld->ld_Top;
381
382 /*
383 * List empty?
384 */
385 if ( ! ld->ld_Entries.lvl_First->lve_Next )
386 return( NULL );
387
388 /*
389 * Scan the list from the current node
390 * to find the correct entry.
391 */
392 if ( num > top ) {
393 for ( ; lve->lve_Next; lve = lve->lve_Next, top++ ) {
394 if ( top == num )
395 break;
396 }
397 } else if ( num < top ) {
398 for ( ; lve->lve_Prev != ( LVE * )&ld->ld_Entries; lve = lve->lve_Prev, top-- ) {
399 if ( top == num )
400 break;
401 }
402 }
403
404 return( lve );
405 }
406 REGFUNC_END
407
408 /*
409 * Add an entry in the list. Ugly code with
410 * lotsa goto's :)
411 */
412 //STATIC ASM VOID AddEntryInList( REG(a0) LD *ld, REG(a1) Object *obj, REG(a2) LVE *lve, REG(d0) ULONG how )
413 STATIC ASM REGFUNC4(VOID, AddEntryInList,
414 REGPARAM(A0, LD *, ld),
415 REGPARAM(A1, Object *, obj),
416 REGPARAM(A2, LVE *, lve),
417 REGPARAM(D0, ULONG, how))
418 {
419 LVE *tmp;
420 struct lvCompare lvc;
421
422 /*
423 * Save it.
424 */
425 ld->ld_LastAdded = lve;
426
427 /*
428 * Set top entry if not
429 * defined yet.
430 */
431 if (!ld->ld_TopEntry)
432 ld->ld_TopEntry = lve;
433
434 switch (how)
435 {
436 case LVAP_SORTED:
437 /*
438 * Entries available?
439 */
440 if (!ld->ld_Entries.lvl_First->lve_Next)
441 /*
442 * No. Simply AddTail the entry.
443 */
444 goto tailIt;
445
446 /*
447 * Scan through the entries.
448 */
449 for (tmp = ld->ld_Entries.lvl_Last; ; tmp = tmp->lve_Prev)
450 {
451 /*
452 * Comparrison hook?
453 */
454 if (!ld->ld_Compare)
455 {
456 /*
457 * No. Simple string comparrison.
458 */
459 if (Stricmp((STRPTR)lve->lve_Entry, (STRPTR)tmp->lve_Entry) >= 0)
460 break;
461 }
462 else
463 {
464 lvc.lvc_EntryA = lve->lve_Entry;
465 lvc.lvc_EntryB = tmp->lve_Entry;
466 if ((LONG)BGUI_CallHookPkt(ld->ld_Compare, (VOID *)obj, (VOID *)&lvc) >= 0)
467 break;
468 };
469 /*
470 * Done?
471 */
472 if (tmp == ld->ld_Entries.lvl_First)
473 {
474 ld->ld_TopEntry = lve;
475 /*
476 * First entry is AddHead'ed.
477 */
478 goto headIt;
479 };
480 };
481
482 insertIt:
483 ld->ld_Flags |= LDF_REFRESH_ALL;
484 Insert((struct List *)&ld->ld_Entries, (struct Node *)lve, (struct Node *)tmp);
485 break;
486
487 case LVAP_HEAD:
488 headIt:
489 ld->ld_Flags |= LDF_REFRESH_ALL;
490 AddHead((struct List *)&ld->ld_Entries, (struct Node *)lve);
491 ld->ld_TopEntry = lve;
492 break;
493
494 case LVAP_TAIL:
495 default:
496 tailIt:
497 AddTail((struct List *)&ld->ld_Entries, (struct Node *)lve);
498 break;
499 }
500 }
501 REGFUNC_END
502
503 /*
504 * Add entries to the list.
505 */
506 //STATIC ASM BOOL AddEntries(REG(a0) LD *ld, REG(a1) APTR *entries, REG(a2) Object *obj, REG(d0) ULONG how, REG(a3) LVE *pred)
507 STATIC ASM REGFUNC5(BOOL, AddEntries,
508 REGPARAM(A0, LD *, ld),
509 REGPARAM(A1, APTR *, entries),
510 REGPARAM(A2, Object *, obj),
511 REGPARAM(D0, ULONG, how),
512 REGPARAM(A3, LVE *, pred))
513 {
514 LVE *lve;
515 struct lvResource lvr;
516 BOOL success = TRUE;
517
518 /*
519 * Entries valid?
520 */
521 if (!entries) return FALSE;
522
523 /*
524 * Initialize lvResource structure to make entries.
525 */
526 lvr.lvr_Command = LVRC_MAKE;
527
528 ld->ld_Flags |= LDF_LIST_BUSY;
529
530 /*
531 * Loop through the entries.
532 */
533 while (lvr.lvr_Entry = *entries++)
534 {
535 /*
536 * Create a node.
537 */
538 if (lve = (LVE *)BGUI_AllocPoolMem(sizeof(LVE)))
539 {
540 /*
541 * Do we have a resource hook?
542 */
543 if (ld->ld_Resource)
544 {
545 /*
546 * Let the hook make the entry.
547 */
548 lve->lve_Entry = (APTR)BGUI_CallHookPkt(ld->ld_Resource, (void *)obj, (void *)&lvr);
549 }
550 else
551 {
552 /*
553 * Simple string copy.
554 */
555 if (lve->lve_Entry = (APTR)BGUI_AllocPoolMem(strlen((STRPTR)lvr.lvr_Entry) + 1))
556 strcpy((STRPTR)lve->lve_Entry, (STRPTR)lvr.lvr_Entry);
557 }
558 /*
559 * All ok?
560 */
561 if (lve->lve_Entry)
562 {
563 if (!pred)
564 {
565 AddEntryInList(ld, obj, lve, how);
566 if (how == LVAP_HEAD)
567 pred = lve;
568 }
569 else
570 {
571 Insert((struct List *)&ld->ld_Entries, (struct Node *)lve, (struct Node *)pred);
572 pred = lve;
573 };
574 ld->ld_LastAdded = lve;
575 ld->ld_Total++;
576 }
577 else
578 {
579 success = FALSE;
580 BGUI_FreePoolMem(lve);
581 }
582 }
583 }
584 ld->ld_Flags &= ~LDF_LIST_BUSY;
585
586 return success;
587 }
588 REGFUNC_END
589
590 /*
591 * Make an entry visible.
592 */
593 //STATIC ASM ULONG MakeVisible(REG(a0) LD *ld, REG(d0) ULONG entry)
594 STATIC ASM REGFUNC2(ULONG, MakeVisible,
595 REGPARAM(A0, LD *, ld),
596 REGPARAM(D0, ULONG, entry))
597 {
598 ULONG new_top;
599
600 /*
601 * # of visible items known?
602 */
603 if (!ld->ld_Visible)
604 ld->ld_Visible = 1;
605
606 /*
607 * Otherwise adjust the top to
608 * make it visible.
609 */
610 if (entry < ld->ld_Top) new_top = entry;
611 else if (entry >= (ld->ld_Top + ld->ld_Visible)) new_top = max((LONG)(entry - (ld->ld_Visible - 1)), 0);
612 else if (entry >= ld->ld_Total) new_top = max((LONG)ld->ld_Total - (LONG)(ld->ld_Visible - 1), 0);
613 else new_top = ld->ld_Top;
614
615 return new_top;
616 }
617 REGFUNC_END
618
619 /*
620 * De-select node list (slow!).
621 */
622 //STATIC ASM VOID DeSelect(REG(a0) LD *ld)
623 STATIC ASM REGFUNC1(VOID, DeSelect,
624 REGPARAM(A0, LD *, ld))
625 {
626 LVE *lve;
627
628 for (lve = ld->ld_Entries.lvl_First; lve->lve_Next; lve = lve->lve_Next)
629 {
630 if (lve->lve_Flags & LVEF_SELECTED)
631 {
632 lve->lve_Flags &= ~LVEF_SELECTED;
633 lve->lve_Flags |= LVEF_REFRESH;
634 };
635 };
636 }
637 REGFUNC_END
638
639 /*
640 * Select node list (slow!).
641 */
642 //STATIC ASM VOID Select(REG(a0) LD *ld)
643 STATIC ASM REGFUNC1(VOID, Select,
644 REGPARAM(A0, LD *, ld))
645 {
646 LVE *lve;
647
648 for ( lve = ld->ld_Entries.lvl_First; lve->lve_Next; lve = lve->lve_Next ) {
649 if ( ! ( lve->lve_Flags & LVEF_SELECTED ))
650 lve->lve_Flags |= LVEF_SELECTED | LVEF_REFRESH;
651 }
652 }
653 REGFUNC_END
654
655 /*
656 * Setup a new top-value.
657 */
658 //STATIC ASM VOID NewTop(REG(a0) LD *ld, REG(a1) struct GadgetInfo *gi, REG(a2) Object *obj, REG(d0) ULONG new_top)
659 STATIC ASM REGFUNC4(VOID, NewTop,
660 REGPARAM(A0, LD *, ld),
661 REGPARAM(A1, struct GadgetInfo *, gi),
662 REGPARAM(A2, Object *, obj),
663 REGPARAM(D0, ULONG, new_top))
664 {
665 struct BaseInfo *bi;
666 int i;
667 BC *bc = BASE_DATA(obj);
668
669 /*
670 * How much do we need to go up?
671 */
672 int diff = new_top - ld->ld_Top;
673
674 /*
675 * Gadget info present?
676 * New position different than old one?
677 */
678 if (gi && diff)
679 {
680 /*
681 * Create rastport.
682 */
683 #ifdef DEBUG_BGUI
684 if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
685 #else
686 if (bi = AllocBaseInfo(BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
687 #endif
688 {
689 BOOL needs_refresh=FALSE;
690
691 /*
692 * Setup font.
693 */
694 BSetFont(bi, ld->ld_Font);
695
696 /*
697 * Set top position.
698 */
699 ld->ld_TopEntry = FindNodeQuick(ld, new_top);
700 ld->ld_Top = new_top;
701
702 if (diff <= -ld->ld_Visible)
703 {
704 /*
705 * More than a single view?
706 */
707 diff = -ld->ld_Visible;
708 }
709 else if (diff >= +ld->ld_Visible)
710 {
711 /*
712 * More than a single view?
713 */
714 diff = +ld->ld_Visible;
715 }
716 else
717 {
718 /*
719 * Scroll view 'diff' lines.
720 */
721 ScrollRaster(bi->bi_RPort, 0, diff * ld->ld_EntryHeight,
722 ld->ld_ListArea.Left, ld->ld_ListArea.Top,
723 ld->ld_ListArea.Left + ld->ld_ListArea.Width - 1,
724 ld->ld_ListArea.Top + ld->ld_ListArea.Height - 1);
725 needs_refresh=(bi->bi_RPort->Layer->Flags & LAYERREFRESH);
726 };
727
728 ColumnSeparators(ld, bi, bc->bc_InnerBox.Left, bc->bc_InnerBox.Top, bc->bc_InnerBox.Height);
729
730 /*
731 * Re-render first 'diff' lines.
732 */
733 if (diff < 0)
734 {
735 i = -diff;
736 }
737 else
738 {
739 i = diff;
740 new_top += ld->ld_Visible - diff;
741 };
742
743 while (i--)
744 {
745 RenderEntry(obj, ld, bi, FindNodeQuick(ld, new_top), new_top - ld->ld_Top);
746 new_top++;
747 };
748
749 /*
750 * Dump BaseInfo.
751 */
752 FreeBaseInfo(bi);
753
754 if(needs_refresh)
755 {
756 BOOL update;
757
758 if(!(update=BeginUpdate(gi->gi_Layer)))
759 EndUpdate(gi->gi_Layer,FALSE);
760 DoRenderMethod( obj, gi, GREDRAW_REDRAW );
761 if(update)
762 EndUpdate(gi->gi_Layer,TRUE);
763 }
764
765 /*
766 * Needed by RenderEntry().
767 */
768 ld->ld_Flags &= ~LDF_REFRESH_ALL;
769 }
770 }
771 else
772 {
773 ld->ld_TopEntry = FindNodeQuick(ld, new_top);
774 ld->ld_Top = new_top;
775 }
776 }
777 REGFUNC_END
778
779
780
781 /************************************************************************
782 ********************** MCLV_GETCOLUMNPOSITIONS() **********************
783 *************************************************************************
784 * Work out the left offset (relative to listview view area) of each
785 * column separator. Put the results in ld_Offsets array, starting
786 * with the first separator (ie. the left offset of the *second* column
787 * from the left). Returns TRUE or FALSE to indicate success. Currently
788 * this can only fail if the object is not displayed when this function
789 * is called. If all goes well, LDF_OFFSETS_VALID is set to TRUE.
790 *
791 *************************************************************************/
792
793 STATIC BOOL GetColumnPositions(Object *obj, LD *ld)
794 {
795 int w, dw, x;
796 int totalwidth, columnwidth, totalweight, lastwidth;
797 int listwidth = ld->ld_ListArea.Width;
798 CD *cd, *fcd = ld->ld_CD, *lcd = fcd + ld->ld_Columns - 1;
799
800 /*
801 * Start widths at minimum and compute width of all columns.
802 */
803 columnwidth = 0;
804 for (cd = fcd; cd <= lcd; ++cd)
805 {
806 cd->cd_Width = cd->cd_MinWidth;
807 columnwidth += cd->cd_Width;
808 };
809
810 /*
811 * Cycle through until all extra space is used.
812 */
813 while (columnwidth < listwidth)
814 {
815 lastwidth = columnwidth;
816 totalwidth = listwidth;
817 totalweight = 0;
818 for (cd = fcd; cd <= lcd; ++cd)
819 {
820 if (!(cd->cd_Flags & LVCF_HIDDEN))
821 {
822 if (cd->cd_Width < cd->cd_MaxWidth)
823 {
824 totalweight += cd->cd_Weight;
825 }
826 else
827 {
828 cd->cd_Width = cd->cd_MaxWidth;
829 totalwidth -= cd->cd_Width;
830 };
831 };
832 };
833
834 if (totalweight == 0) break;
835
836 for (cd = fcd; cd <= lcd; ++cd)
837 {
838 if (!(cd->cd_Flags & LVCF_HIDDEN))
839 {
840 if (cd->cd_Width < cd->cd_MaxWidth)
841 {
842 w = (cd->cd_Weight * totalwidth) / totalweight;
843 if (w > cd->cd_MaxWidth) w = cd->cd_MaxWidth;
844 if (w < cd->cd_MinWidth) w = cd->cd_MinWidth;
845
846 dw = w - cd->cd_Width;
847 if (dw > listwidth - columnwidth)
848 {
849 dw = listwidth - columnwidth;
850 cd->cd_Width += dw;
851 columnwidth += dw;
852 break;
853 };
854 cd->cd_Width += dw;
855 columnwidth += dw;
856 };
857 };
858 };
859 if (columnwidth == lastwidth) break;
860 };
861
862 x = 0;
863 for (cd = fcd; cd <= lcd; ++cd)
864 {
865 if (!(cd->cd_Flags & LVCF_HIDDEN))
866 {
867 cd->cd_Offset = x;
868 x += cd->cd_Width;
869 };
870 };
871 cd->cd_Offset = x; // Last "dummy" column needs right offset of list.
872
873 ld->ld_Flags |= LDF_OFFSETS_VALID|LDF_REFRESH_ALL;
874
875 return TRUE;
876 }
877
878 /************************************************************************
879 ************************* MCLV_DRAWDRAGLINE() *************************
880 *************************************************************************
881 * Draw, using complement mode, the line that shows the user the position
882 * s/he has dragged the column separator to within the mclv.
883 *
884 *************************************************************************/
885
886 //STATIC ASM VOID DrawDragLine(REG(a0) LD *ld, REG(a1) struct GadgetInfo *gi)
887 STATIC ASM REGFUNC2(VOID, DrawDragLine,
888 REGPARAM(A0, LD *, ld),
889 REGPARAM(A1, struct GadgetInfo *, gi))
890 {
891 WORD x1 = ld->ld_InnerBox.Left + ld->ld_DragXLine - 2;
892 WORD x2 = x1 + 1;
893 WORD y1 = ld->ld_InnerBox.Top;
894 WORD y2 = ld->ld_InnerBox.Top + ld->ld_InnerBox.Height - 1;
895
896 struct BaseInfo *bi;
897
898 #ifdef DEBUG_BGUI
899 if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
900 #else
901 if (bi = AllocBaseInfo(BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
902 #endif
903 {
904 BSetDrMd(bi, COMPLEMENT);
905 BRectFill(bi, x1, y1, x2, y2);
906 FreeBaseInfo(bi);
907 };
908 }
909 REGFUNC_END
910
911 /// OM_NEW
912 /*
913 * Create a new object.
914 */
915 METHOD(ListClassNew, struct opSet *, ops)
916 {
917 LD *ld;
918 struct TagItem *tags, *tstate, *tag;
919 ULONG rc, sort = LVAP_TAIL, data;
920 ULONG *new_weights = NULL;
921 APTR *new_entries = NULL;
922 int i;
923
924 tags = DefTagList(BGUI_LISTVIEW_GADGET, ops->ops_AttrList);
925
926 /*
927 * Let the superclass make the object.
928 */
929 if (rc = NewSuperObject(cl, obj, tags))
930 {
931 /*
932 * Get the instance data.
933 */
934 ld = INST_DATA(cl, rc);
935 ld->ld_BC = BASE_DATA(rc);
936
937 ld->ld_Flags = LDF_REFRESH_ALL|LDF_PRE_CLEAR;
938 ld->ld_MinShown = 3;
939 ld->ld_Columns = 1;
940 ld->ld_Prop = (Object *)~0;
941
942 /*
943 * Initialize the list of entries.
944 */
945 NewList((struct List *)&ld->ld_Entries);
946 // NewList((struct List *)&ld->ld_Hidden);
947
948 BGUI_PackStructureTags((APTR)ld, ListPackTable, tags);
949
950 tstate = tags;
951
952 while (tag = NextTagItem(&tstate))
953 {
954 data = tag->ti_Data;
955 switch (tag->ti_Tag)
956 {
957 case LISTV_EntryArray:
958 new_entries = (APTR *)data;
959 break;
960
961 case LISTV_SortEntryArray:
962 sort = LVAP_SORTED;
963 break;
964
965 case LISTV_ColumnWeights:
966 new_weights = (ULONG *)data;
967 break;
968 };
969 };
970
971 if (ld->ld_Columns < 1) ld->ld_Columns = 1;
972
973 ld->ld_CD = BGUI_AllocPoolMem((ld->ld_Columns + 1) * sizeof(CD));
974
975 /*
976 * Verify array allocated.
977 */
978 if (ld->ld_CD)
979 {
980 for (i = 0; i <= ld->ld_Columns; i++)
981 {
982 ld->ld_CD[i].cd_MinWidth = 24;
983 ld->ld_CD[i].cd_MaxWidth = 0xFFFF;
984 ld->ld_CD[i].cd_Weight = new_weights ? (new_weights[i] ? new_weights[i] : 1) : DEFAULT_WEIGHT;
985 };
986
987 if (ld->ld_Prop == (Object *)~0)
988 {
989 /*
990 * Filter out frame and label attributes.
991 */
992 tstate = tags;
993
994 while (tag = NextTagItem(&tstate))
995 {
996 switch (tag->ti_Tag)
997 {
998 /*
999 * Don't disable prop!
1000 */
1001 case GA_Disabled:
1002 /*
1003 * No drag'n'drop on the prop.
1004 */
1005 case BT_DragObject:
1006 case BT_DropObject:
1007 tag->ti_Tag = TAG_IGNORE;
1008 break;
1009
1010 default:
1011 if (FRM_TAG(tag->ti_Tag) || LAB_TAG(tag->ti_Tag))
1012 tag->ti_Tag = TAG_IGNORE;
1013 break;
1014 };
1015 };
1016
1017 /*
1018 * Create a scroller.
1019 */
1020 ld->ld_Prop = BGUI_NewObject(BGUI_PROP_GADGET, GA_ID, GADGET(rc)->GadgetID,
1021 PGA_DontTarget, TRUE, BT_ParentView, ld->ld_BC->bc_View, BT_ParentWindow, ld->ld_BC->bc_Window,TAG_MORE, tags);
1022 };
1023
1024 if (ld->ld_Prop)
1025 {
1026 /*
1027 * Setup scroller notification.
1028 */
1029 AsmDoMethod(ld->ld_Prop, BASE_ADDMAP, rc, PGA2LISTV);
1030 };
1031
1032 if (ld->ld_Frame)
1033 {
1034 /*
1035 * Set frame attributes to match list attributes.
1036 */
1037 DoSetMethodNG(ld->ld_Frame, FRM_Recessed, ld->ld_Flags & LDF_READ_ONLY,
1038 FRM_ThinFrame, ld->ld_Flags & LDF_THIN_FRAMES,
1039 TAG_DONE);
1040 };
1041
1042 /*
1043 * Add entries.
1044 */
1045 AddEntries(ld, new_entries, (Object *)rc, sort, NULL);
1046 }
1047 else
1048 {
1049 AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
1050 rc = 0;
1051 };
1052 };
1053 FreeTagItems(tags);
1054
1055 return rc;
1056 }
1057 METHOD_END
1058 ///
1059 /// OM_SET, OM_UPDATE
1060 /*
1061 * Set or update some attributes.
1062 */
1063 METHOD(ListClassSetUpdate, struct opUpdate *, opu)
1064 {
1065 LD *ld = INST_DATA( cl, obj );
1066 struct TagItem *tstate = opu->opu_AttrList, *tag;
1067 LVE *lve;
1068 ULONG data, otop = ld->ld_Top, ntop = otop, num, oldcol = ld->ld_Columns;
1069 WORD dis = GADGET(obj)->Flags & GFLG_DISABLED;
1070 BOOL vc = FALSE;
1071 ULONG *new_weights;
1072
1073 int i;
1074
1075 /*
1076 * First the superclass...
1077 */
1078 AsmDoSuperMethodA(cl, obj, (Msg)opu);
1079
1080 BGUI_PackStructureTags((APTR)ld, ListPackTable, tstate);
1081
1082 /*
1083 * Scan for known attributes.
1084 */
1085 while (tag = NextTagItem(&tstate))
1086 {
1087 data = tag->ti_Data;
1088 switch (tag->ti_Tag)
1089 {
1090 case LISTV_PropObject:
1091 if (ld->ld_Prop) DisposeObject(ld->ld_Prop);
1092 ld->ld_Flags &= ~LDF_PROPACTIVE;
1093
1094 if (ld->ld_Prop = (Object *)data)
1095 {
1096 /*
1097 * Setup scroller notification.
1098 */
1099 AsmDoMethod(ld->ld_Prop, BASE_ADDMAP, obj, PGA2LISTV);
1100 };
1101 vc = TRUE;
1102 break;
1103
1104 case FRM_ThinFrame:
1105 /*
1106 * Set frame thickness.
1107 */
1108 if (ld->ld_Frame) DoSetMethodNG(ld->ld_Frame, FRM_ThinFrame, data, TAG_END);
1109 if (ld->ld_Prop) DoSetMethodNG(ld->ld_Prop, FRM_ThinFrame, data, TAG_END);
1110 break;
1111
1112 case BT_TextAttr:
1113 /*
1114 * Pickup superclass font.
1115 */
1116 if (ld->ld_Font)
1117 {
1118 BGUI_CloseFont(ld->ld_Font);
1119 ld->ld_Font = NULL;
1120 };
1121 vc=TRUE;
1122 break;
1123
1124 case LISTV_ListFont:
1125 ld->ld_ListFont = (struct TextAttr *)data;
1126 if (ld->ld_Font)
1127 {
1128 BGUI_CloseFont(ld->ld_Font);
1129 ld->ld_Font = NULL;
1130 };
1131 vc=TRUE;
1132 break;
1133
1134 case LISTV_Top:
1135 ld->ld_Top = otop; // Needed to circumvent PackStructureTags.
1136 /*
1137 * Make sure we stay in range.
1138 */
1139 ntop = range(data, 0, (ld->ld_Total > ld->ld_Visible) ? ld->ld_Total - ld->ld_Visible : 0);
1140 break;
1141
1142 case LISTV_MakeVisible:
1143 /*
1144 * Stay in range.
1145 */
1146 if ((num = data) >= ld->ld_Total)
1147 num = ld->ld_Total - 1;
1148
1149 /*
1150 * Make it visible.
1151 */
1152 ntop = MakeVisible( ld, num );
1153 vc = TRUE;
1154 break;
1155
1156 case LISTV_DeSelect:
1157 /*
1158 * Get the node number.
1159 */
1160 if (( num = data ) == ~0 ) {
1161 /*
1162 * A value of -1 means deselect
1163 * all entries.
1164 */
1165 DeSelect( ld );
1166 vc = TRUE;
1167 } else {
1168 /*
1169 * Stay in range.
1170 */
1171 num = num >= ld->ld_Total ? ld->ld_Total - 1 : num;
1172
1173 /*
1174 * Find the node to deselect.
1175 */
1176 if ( lve = FindNodeQuick( ld, num )) {
1177 /*
1178 * Set it up.
1179 */
1180 ld->ld_LastActive = lve;
1181 ld->ld_LastNum = num;
1182
1183 /*
1184 * Already unselected?
1185 */
1186 if (( lve->lve_Flags & LVEF_SELECTED ) && ( ! ( ld->ld_Flags & LDF_READ_ONLY ))) {
1187 /*
1188 * Mark it for a refresh.
1189 */
1190 lve->lve_Flags &= ~LVEF_SELECTED;
1191 lve->lve_Flags |= LVEF_REFRESH;
1192
1193 /*
1194 * Notify change.
1195 */
1196 DoNotifyMethod( obj, opu->opu_GInfo, opu->MethodID == OM_UPDATE ? opu->opu_Flags : 0L, GA_ID, GADGET( obj )->GadgetID, LISTV_Entry, lve->lve_Entry, LISTV_EntryNumber, ld->ld_LastNum, TAG_END );
1197 vc = TRUE;
1198 }
1199 }
1200 }
1201 break;
1202
1203 case LISTV_SelectMulti:
1204 case LISTV_SelectMultiNotVisible:
1205 /*
1206 * Must be a multi-select object.
1207 */
1208 if ( ! ( ld->ld_Flags & LDF_MULTI_SELECT ))
1209 break;
1210
1211 /*
1212 * LISTV_Select_All?
1213 */
1214 if (data == LISTV_Select_All)
1215 {
1216 Select(ld);
1217 vc = TRUE;
1218 break;
1219 }
1220
1221 /* Fall through. */
1222
1223 case LISTV_Select:
1224 case LISTV_SelectNotVisible:
1225 /*
1226 * Do some Magic?
1227 */
1228 switch (data)
1229 {
1230 case LISTV_Select_First:
1231 num = 0;
1232 goto doIt;
1233
1234 case LISTV_Select_Last:
1235 num = ld->ld_Total - 1;
1236 goto doIt;
1237
1238 case LISTV_Select_Next:
1239 if (!ld->ld_LastActive) num = ld->ld_Top;
1240 else num = ld->ld_LastNum + 1;
1241 goto doIt;
1242
1243 case LISTV_Select_Previous:
1244 if (!ld->ld_LastActive) num = ld->ld_Top;
1245 else num = max((LONG)ld->ld_LastNum - 1, 0);
1246 goto doIt;
1247
1248 case LISTV_Select_Top:
1249 num = ld->ld_Top;
1250 goto doIt;
1251
1252 case LISTV_Select_Page_Up:
1253 if (!ld->ld_LastActive) num = ld->ld_Top;
1254 else
1255 {
1256 num = ld->ld_LastNum;
1257 if (num > ld->ld_Top) num = ld->ld_Top;
1258 else num = max((LONG)(num - ld->ld_Visible + 1), 0);
1259 }
1260 goto doIt;
1261
1262 case LISTV_Select_Page_Down:
1263 if (!ld->ld_LastActive ) num = ld->ld_Top;
1264 else
1265 {
1266 num = ld->ld_LastNum;
1267 if (num < (ld->ld_Top + ld->ld_Visible - 1)) num = ld->ld_Top + ld->ld_Visible - 1;
1268 else num = min((LONG)(num + (ld->ld_Visible - 1)), ld->ld_Total - 1);
1269 }
1270 goto doIt;
1271
1272 default:
1273 num = data;
1274
1275 doIt:
1276
1277 /*
1278 * Make sure we stay in range.
1279 */
1280 num = (num >= ld->ld_Total) ? ld->ld_Total - 1 : num;
1281
1282 /*
1283 * Find the node to select.
1284 */
1285 if (lve = ld->ld_LastActive = FindNodeQuick(ld, num))
1286 {
1287 /*
1288 * Setup the number as the last
1289 * selected one.
1290 */
1291 ld->ld_LastNum = num;
1292
1293 /*
1294 * Already selected?
1295 */
1296 if (((( tag->ti_Tag != LISTV_SelectMulti ) && ( tag->ti_Tag != LISTV_SelectMultiNotVisible )) || ! ( lve->lve_Flags & LVEF_SELECTED )) && ( ! ( ld->ld_Flags & LDF_READ_ONLY ))) {
1297 /*
1298 * No? DeSelect all other labels if we are not
1299 * multi-selecting.
1300 */
1301 if (( tag->ti_Tag != LISTV_SelectMulti ) && ( tag->ti_Tag != LISTV_SelectMultiNotVisible ))
1302 DeSelect( ld );
1303
1304 /*
1305 * Mark this entry as selected.
1306 */
1307 lve->lve_Flags |= LVEF_SELECTED | LVEF_REFRESH;
1308
1309 /*
1310 * Notify change.
1311 */
1312 DoNotifyMethod( obj, opu->opu_GInfo, opu->MethodID == OM_UPDATE ? opu->opu_Flags : 0L, GA_ID, GADGET( obj )->GadgetID, LISTV_Entry, lve->lve_Entry, LISTV_EntryNumber, ld->ld_LastNum, TAG_END );
1313 vc = TRUE;
1314 }
1315 /*
1316 * Make the entry visible if requested.
1317 */
1318 if (( tag->ti_Tag != LISTV_SelectNotVisible ) && ( tag->ti_Tag != LISTV_SelectMultiNotVisible ))
1319 ntop = MakeVisible( ld, num );
1320 }
1321 break;
1322 }
1323 break;
1324
1325 case LISTV_ColumnWeights:
1326 if (!(ld->ld_Flags & LDF_DRAGGING_COLUMN))
1327 {
1328 new_weights = (ULONG *)data;
1329 for (i = 0; i < ld->ld_Columns; i++)
1330 {
1331 ld->ld_CD[i].cd_Weight = new_weights ? (new_weights[i] ? new_weights[i] : 1) : DEFAULT_WEIGHT;
1332 };
1333 ld->ld_Flags &= ~LDF_OFFSETS_VALID;
1334 vc = TRUE;
1335 };
1336 break;
1337
1338 case LISTV_Columns:
1339 ld->ld_Columns = oldcol; // can't change yet
1340 break;
1341
1342 case BT_ParentWindow:
1343 case BT_ParentView:
1344 DoSetMethodNG(ld->ld_Prop, tag->ti_Tag, data, TAG_DONE);
1345 break;
1346 };
1347 };
1348
1349 /*
1350 * Disabled state changed?
1351 */
1352 if ((GADGET(obj)->Flags & GFLG_DISABLED) != dis)
1353 {
1354 if ( opu->opu_GInfo ) {
1355 ld->ld_Flags |= LDF_REFRESH_ALL;
1356 DoRenderMethod( obj, opu->opu_GInfo, GREDRAW_REDRAW );
1357 vc = FALSE;
1358 }
1359 }
1360
1361 /*
1362 * Top value changed?
1363 */
1364 if (vc)
1365 {
1366 DoRenderMethod(obj, opu->opu_GInfo, GREDRAW_UPDATE);
1367 if (ntop != otop)
1368 {
1369 NewTop(ld, opu->opu_GInfo, obj, ntop);
1370 if (ld->ld_Prop) DoSetMethod(ld->ld_Prop, opu->opu_GInfo, PGA_Top, ntop, TAG_DONE);
1371 }
1372 }
1373 else if (ntop != otop)
1374 {
1375 if (!FindTagItem(GA_ID, opu->opu_AttrList))
1376 if (ld->ld_Prop) DoSetMethod(ld->ld_Prop, opu->opu_GInfo, PGA_Top, ntop, TAG_END);
1377 NewTop(ld, opu->opu_GInfo, obj, ntop);
1378 };
1379
1380 return 1;
1381 }
1382 METHOD_END
1383 ///
1384 /// OM_GET
1385 /*
1386 * They want to know something.
1387 */
1388 METHOD(ListClassGet, struct opGet *, opg)
1389 {
1390 LD *ld = INST_DATA( cl, obj );
1391 ULONG rc = TRUE, num = ~0;
1392 ULONG tag = opg->opg_AttrID, *store = opg->opg_Storage;
1393
1394 switch (tag)
1395 {
1396 case LISTV_LastClicked:
1397 if (ld->ld_LastActive) STORE ld->ld_LastActive->lve_Entry;
1398 else STORE 0;
1399 break;
1400
1401 case LISTV_LastClickedNum:
1402 if (ld->ld_LastActive)
1403 num = ld->ld_LastNum;
1404 STORE num;
1405 break;
1406
1407 case LISTV_NumEntries:
1408 STORE ld->ld_Total;
1409 break;
1410
1411 case LISTV_DropSpot:
1412 STORE ld->ld_DropSpot;
1413 break;
1414
1415 case LISTV_NewPosition:
1416 STORE ld->ld_NewPos;
1417 break;
1418
1419 case LISTV_ViewBounds:
1420 STORE &ld->ld_InnerBox;
1421 break;
1422
1423 case LISTV_LastColumn:
1424 STORE ld->ld_LastCol;
1425 break;
1426
1427 default:
1428 rc = BGUI_UnpackStructureTag((UBYTE *)ld, ListPackTable, tag, store);
1429 if (!rc) rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
1430 break;
1431 }
1432 return rc;
1433 }
1434 METHOD_END
1435 ///
1436 /// OM_DISPOSE
1437 /*
1438 * Dispose of the object.
1439 */
1440 METHOD(ListClassDispose, Msg, msg)
1441 {
1442 LD *ld = INST_DATA(cl, obj);
1443 LVE *lve;
1444 struct lvResource lvr;
1445
1446 /*
1447 * Free all entries.
1448 */
1449 while (lve = (LVE *)RemHead((struct List *)&ld->ld_Entries))
1450 {
1451 /*
1452 * Do we have a resource hook?
1453 */
1454 if (ld->ld_Resource)
1455 {
1456 /*
1457 * Initialize lvResource structure to kill the entry.
1458 */
1459 lvr.lvr_Command = LVRC_KILL;
1460 lvr.lvr_Entry = lve->lve_Entry;
1461
1462 /*
1463 * Call the hook.
1464 */
1465 BGUI_CallHookPkt(ld->ld_Resource, (VOID *)obj, (VOID *)&lvr);
1466 }
1467 else
1468 {
1469 /*
1470 * Simple deallocation.
1471 */
1472 BGUI_FreePoolMem(lve->lve_Entry);
1473 };
1474
1475 /*
1476 * Free the entry node.
1477 */
1478 BGUI_FreePoolMem(lve);
1479 }
1480
1481 /*
1482 * Kill the scroller.
1483 */
1484 if (ld->ld_Prop) AsmDoMethod(ld->ld_Prop, OM_DISPOSE);
1485
1486 if (ld->ld_CD) BGUI_FreePoolMem(ld->ld_CD);
1487
1488 if (ld->ld_Font) BGUI_CloseFont(ld->ld_Font);
1489
1490 /*
1491 * The superclass takes care of the rest.
1492 */
1493 return AsmDoSuperMethodA(cl, obj, msg);
1494 }
1495 METHOD_END
1496 ///
1497
1498 /// ListAreaBounds
1499 /*
1500 * Setup the list area bounds.
1501 */
1502 //STATIC ASM VOID ListAreaBounds(REG(a0) Object *obj, REG(a1) LD *ld)
1503 STATIC ASM REGFUNC2(VOID, ListAreaBounds,
1504 REGPARAM(A0, Object *, obj),
1505 REGPARAM(A1, LD *, ld))
1506 {
1507 int fh = ld->ld_EntryHeight;
1508 int overhead;
1509
1510 if (ld->ld_ListArea.Width != ld->ld_InnerBox.Width)
1511 ld->ld_Flags &= ~LDF_OFFSETS_VALID;
1512
1513 /*
1514 * Setup list display area and view bounds.
1515 */
1516 ld->ld_ListArea = ld->ld_InnerBox;
1517
1518 /*
1519 * Title?
1520 */
1521 if (ld->ld_Title || ld->ld_TitleHook)
1522 {
1523 ld->ld_ListArea.Top += (fh + 2);
1524 ld->ld_ListArea.Height -= (fh + 2);
1525 };
1526
1527 /*
1528 * Setup the amount of visible entries
1529 * and the amount of pixels to adjust.
1530 */
1531 ld->ld_Visible = ld->ld_ListArea.Height / fh;
1532 overhead = ld->ld_ListArea.Height % fh;
1533
1534 /*
1535 * If the list area is larger than the
1536 * total amount of entries we set overhead
1537 * to 0.
1538 */
1539 if (ld->ld_Total <= ld->ld_Visible)
1540 {
1541 overhead = 0;
1542 }
1543 else
1544 {
1545 ld->ld_ListArea.Top += overhead / 2;
1546 ld->ld_ListArea.Height -= overhead;
1547 };
1548
1549 /*
1550 * Any change in the overhead?
1551 */
1552 if (overhead != ld->ld_Overhead)
1553 {
1554 ld->ld_Overhead = overhead;
1555 ld->ld_Flags |= LDF_REFRESH_ALL;
1556 };
1557
1558 /*
1559 * Recompute the columns.
1560 */
1561 if (!(ld->ld_Flags & LDF_OFFSETS_VALID))
1562 GetColumnPositions(obj, ld);
1563
1564 /*
1565 * Check top setting.
1566 */
1567 ld->ld_Top = max(0, min(ld->ld_Top, ld->ld_Total - ld->ld_Visible));
1568
1569 /*
1570 * Get top entry.
1571 */
1572 ld->ld_TopEntry = FindNode(ld, ld->ld_Top);
1573
1574 }
1575 REGFUNC_END
1576 ///
1577 /// RenderColumn
1578
1579 //STATIC ASM SAVEDS VOID RenderColumn(REG(a0) char *text, REG(a2) Object *obj, REG(a1) struct lvRender *lvr)
1580 STATIC ASM SAVEDS REGFUNC3(VOID, RenderColumn,
1581 REGPARAM(A0, char *, text),
1582 REGPARAM(A2, Object *, obj),
1583 REGPARAM(A1, struct lvRender *, lvr))
1584 {
1585 int col = lvr->lvr_Column;
1586 struct BaseInfo *bi;
1587 struct IBox area;
1588 char *term = NULL;
1589
1590 /*
1591 * Setup rendering area.
1592 */
1593 area.Left = lvr->lvr_Bounds.MinX + 2;
1594 area.Width = lvr->lvr_Bounds.MaxX - lvr->lvr_Bounds.MinX - 3;
1595 area.Top = lvr->lvr_Bounds.MinY;
1596 area.Height = lvr->lvr_Bounds.MaxY - lvr->lvr_Bounds.MinY + 1;
1597
1598 if (strchr(text, '\t'))
1599 {
1600 while (col--)
1601 {
1602 text = strchr(text, '\t');
1603 if (text) text++;
1604 else break;
1605 };
1606 if (text)
1607 {
1608 term = strchr(text, '\t');
1609 if (term) *term = 0;
1610 };
1611 }
1612
1613 #ifdef DEBUG_BGUI
1614 if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_DrawInfo, lvr->lvr_DrawInfo, BI_RastPort, lvr->lvr_RPort, TAG_DONE))
1615 #else
1616 if (bi = AllocBaseInfo(BI_DrawInfo, lvr->lvr_DrawInfo, BI_RastPort, lvr->lvr_RPort, TAG_DONE))
1617 #endif
1618 {
1619 /*
1620 * Render entry.
1621 */
1622 if (text)
1623 {
1624 RenderText(bi, text, &area);
1625 if (term) *term = '\t';
1626 };
1627
1628 if (GADGET(obj)->Flags & GFLG_DISABLED)
1629 {
1630 area.Left -= 2;
1631 area.Width += 4;
1632 /*
1633 * Disable it.
1634 */
1635 BDisableBox(bi, &area);
1636 };
1637 FreeBaseInfo(bi);
1638 };
1639 }
1640 REGFUNC_END
1641 ///
1642 /// RenderEntry
1643 /*
1644 * Render a single entry.
1645 */
1646 STATIC VOID RenderEntry(Object *obj, LD *ld, struct BaseInfo *bi, LVE *lve, ULONG top)
1647 {
1648 BC *bc = BASE_DATA(obj);
1649 struct lvRender lvr;
1650 UBYTE *txt;
1651 UWORD col;
1652 int cx, cw, xoff, yoff;
1653 BOOL sel, clear;
1654 struct Hook *hook;
1655 struct RastPort *rp = bi->bi_RPort;
1656
1657 if (top & REL_ZERO)
1658 {
1659 top &= ~REL_ZERO;
1660 xoff = yoff = 0;
1661 }
1662 else
1663 {
1664 xoff = ld->ld_ListArea.Left;
1665 yoff = ld->ld_ListArea.Top;
1666 };
1667
1668 /*
1669 * Initialize the lvRender structure.
1670 */
1671 lvr.lvr_RPort = rp;
1672 lvr.lvr_DrawInfo = bi->bi_DrInfo;
1673
1674 if (lve)
1675 {
1676 sel = lve->lve_Flags & LVEF_SELECTED;
1677 hook = ld->ld_Display;
1678
1679 lvr.lvr_Entry = lve->lve_Entry;
1680 lvr.lvr_Bounds.MinY = yoff + ld->ld_EntryHeight * top;
1681 lvr.lvr_Bounds.MaxY = lvr.lvr_Bounds.MinY + ld->ld_EntryHeight - 1;
1682 }
1683 else
1684 {
1685 /*
1686 * A NULL entry means render the title.
1687 */
1688 sel = FALSE;
1689 hook = ld->ld_TitleHook;
1690
1691 lvr.lvr_Entry = ld->ld_Title;
1692 lvr.lvr_Bounds.MinY = bc->bc_InnerBox.Top;
1693 lvr.lvr_Bounds.MaxY = bc->bc_InnerBox.Top + ld->ld_EntryHeight - 1;
1694 };
1695
1696 /*
1697 * Setup state information.
1698 */
1699 if (GADGET(obj)->Flags & GFLG_DISABLED)
1700 lvr.lvr_State = sel ? LVRS_SELECTED_DISABLED : LVRS_NORMAL_DISABLED;
1701 else
1702 lvr.lvr_State = sel ? LVRS_SELECTED : LVRS_NORMAL;
1703
1704 for (col = 0, cx = xoff; col < ld->ld_Columns; col++)
1705 {
1706 if (!(ld->ld_CD[col].cd_Flags & LVCF_HIDDEN))
1707 {
1708 cw = ld->ld_CD[col].cd_Width;
1709
1710 lvr.lvr_Bounds.MinX = cx;
1711 lvr.lvr_Bounds.MaxX = cx + cw - ((col < (ld->ld_Columns - 1)) ? 3 : 1);
1712 lvr.lvr_Column = col;
1713
1714 cx += cw;
1715
1716 if (!(ld->ld_Flags & LDF_ONE_COLUMN) || (col == ld->ld_OneColumn))
1717 {
1718 /*
1719 * Do we have a display hook?
1720 */
1721 if (hook)
1722 {
1723 clear = (ld->ld_Flags & LDF_PRE_CLEAR) || (ld->ld_CD[col].cd_Flags & LVCF_PRECLEAR);
1724
1725 if (clear)
1726 {
1727 AsmDoMethod(ld->ld_Frame, FRAMEM_BACKFILL, bi, &lvr.lvr_Bounds, sel ? IDS_SELECTED : IDS_NORMAL);
1728 clear = FALSE;
1729 };
1730 /*
1731 * Call the hook.
1732 */
1733 txt = (UBYTE *)BGUI_CallHookPkt(hook, (void *)obj, (void *)&lvr);
1734 }
1735 else
1736 {
1737 /*
1738 * Pick up the entry text.
1739 */
1740 clear = TRUE;
1741 txt = lvr.lvr_Entry;
1742 };
1743 if (txt)
1744 {
1745 if (clear)
1746 {
1747 AsmDoMethod(ld->ld_Frame, FRAMEM_BACKFILL, bi, &lvr.lvr_Bounds, sel ? IDS_SELECTED : IDS_NORMAL);
1748 };
1749 BSetDPenA(bi, sel ? FILLTEXTPEN : TEXTPEN);
1750 RenderColumn(txt, obj, &lvr);
1751 };
1752 };
1753 };
1754 };
1755 /*
1756 * Done this one.
1757 */
1758 if (lve) lve->lve_Flags &= ~LVEF_REFRESH;
1759 }
1760 ///
1761 /// BASE_LAYOUT
1762 /*
1763 * Render the list.
1764 */
1765 METHOD(ListClassLayout, struct bmLayout *, bml)
1766 {
1767 LD *ld = INST_DATA(cl, obj);
1768 BC *bc = BASE_DATA(obj);
1769 struct TextAttr *lf;
1770 int sw = 0;
1771 ULONG rc;
1772
1773 if (ld->ld_Prop)
1774 {
1775 lf = ld->ld_ListFont ? ld->ld_ListFont : bc->bc_TextAttr;
1776 if (lf)
1777 {
1778 sw = max((lf->ta_YSize * 2) / 3, 16);
1779 }
1780 else
1781 {
1782 sw = 16;
1783 };
1784 /*
1785 * Setup offset.
1786 */
1787 bml->bml_Bounds->Width -= sw;
1788 };
1789
1790 /*
1791 * First the superclass.
1792 */
1793 rc = AsmDoSuperMethodA(cl, obj, (Msg)bml);
1794
1795 if (sw) bml->bml_Bounds->Width += sw;
1796
1797 return rc;
1798 }
1799 METHOD_END
1800 ///
1801 /// BASE_RENDER
1802 /*
1803 * Render the list.
1804 */
1805 METHOD(ListClassRender, struct bmRender *, bmr)
1806 {
1807 LD *ld = INST_DATA(cl, obj);
1808 BC *bc = BASE_DATA(obj);
1809 struct BaseInfo *bi = bmr->bmr_BInfo;
1810 struct RastPort *rp = bi->bi_RPort;
1811 struct TextFont *tf = ld->ld_Font, *of;
1812 struct TextAttr *lf = ld->ld_ListFont;
1813 struct Rectangle rect;
1814 ULONG num, a;
1815 LVE *lve;
1816 int x, y, w, h, sw;
1817 UWORD overhead;
1818
1819 /*
1820 * Render the baseclass.
1821 */
1822 AsmDoSuperMethodA(cl, obj, (Msg)bmr);
1823
1824 if (!lf) lf = bc->bc_TextAttr;
1825
1826 sw = lf ? ((lf->ta_YSize * 2) / 3) : 0;
1827 if (sw < 16) sw = 16;
1828
1829 /*
1830 * Setup the font.
1831 */
1832 of = rp->Font;
1833 if (!tf)
1834 {
1835 if (lf)
1836 {
1837 if (tf = BGUI_OpenFont(lf))
1838 {
1839 ld->ld_Font = tf;
1840 BSetFont(bi, tf);
1841 }
1842 else
1843 {
1844 tf = of;
1845 };
1846 }
1847 else
1848 {
1849 tf = of;
1850 };
1851 };
1852
1853 /*
1854 * Setup entry height always even.
1855 */
1856 ld->ld_EntryHeight = (tf->tf_YSize + 1) & (ULONG)~1;
1857
1858 overhead=ld->ld_Overhead;
1859
1860 /*
1861 * Setup the list area bounds.
1862 */
1863 ListAreaBounds(obj, ld);
1864
1865 x = bc->bc_InnerBox.Left;
1866 w = bc->bc_InnerBox.Width;
1867
1868 /*
1869 * Complete redraw?
1870 */
1871 if (overhead<ld->ld_Overhead
1872 || bmr->bmr_Flags == GREDRAW_REDRAW)
1873 {
1874 if(overhead<ld->ld_Overhead)
1875 overhead=ld->ld_Overhead;
1876
1877 /*
1878 * Clear the overhead.
1879 */
1880 if (h = overhead >> 1)
1881 {
1882 y = bc->bc_InnerBox.Top;
1883 if (ld->ld_Title || ld->ld_TitleHook) y += ld->ld_EntryHeight+2;
1884
1885 rect.MinX = x; rect.MaxX = x + w - 1;
1886 rect.MinY = y; rect.MaxY = y + h - 1;
1887
1888 AsmDoMethod(bc->bc_Frame, FRAMEM_BACKFILL, bi, &rect, IDS_NORMAL);
1889 };
1890
1891 if (h = overhead - h)
1892 {
1893 y = bc->bc_InnerBox.Top + bc->bc_InnerBox.Height - h;
1894
1895 rect.MinX = x; rect.MaxX = x + w - 1;
1896 rect.MinY = y; rect.MaxY = y + h - 1;
1897
1898 AsmDoMethod(bc->bc_Frame, FRAMEM_BACKFILL, bi, &rect, IDS_NORMAL);
1899 };
1900
1901 /*
1902 * Draw the separators.
1903 */
1904 ColumnSeparators(ld, bi, bc->bc_InnerBox.Left, bc->bc_InnerBox.Top, bc->bc_InnerBox.Height);
1905
1906 /*
1907 * If we have a title render it.
1908 */
1909 if (ld->ld_Title || ld->ld_TitleHook)
1910 {
1911 /*
1912 * Just in case the font changed.
1913 */
1914 if (tf) BSetFont(bi, tf);
1915
1916 RenderEntry(obj, ld, bi, NULL, 0);
1917
1918 if (ld->ld_Columns > 1)
1919 {
1920 y = bc->bc_InnerBox.Top + ld->ld_EntryHeight;
1921 BSetDPenA(bi, ld->ld_Flags & LDF_READ_ONLY ? SHINEPEN : SHADOWPEN);
1922 HLine(rp, x, y++, x + w - 1);
1923 BSetDPenA(bi, ld->ld_Flags & LDF_READ_ONLY ? SHADOWPEN : SHINEPEN);
1924 HLine(rp, x, y, x + w - 1);
1925 };
1926 };
1927
1928 /*
1929 * Just do it.
1930 */
1931 ld->ld_Flags |= LDF_REFRESH_ALL;
1932 };
1933
1934 /*
1935 * Just in case the font changed.
1936 */
1937 if (tf) BSetFont(bi, tf);
1938
1939 /*
1940 * Loop through the entries.
1941 */
1942 for (num = ld->ld_Top, a = 0; (a < ld->ld_Visible) && (num < ld->ld_Total); num++, a++)
1943 {
1944 /*
1945 * Render the entry.
1946 */
1947 if (lve = FindNodeQuick(ld, num))
1948 {
1949 /*
1950 * Only render when necessary.
1951 */
1952 if ((ld->ld_Flags & LDF_REFRESH_ALL) || (lve->lve_Flags & LVEF_REFRESH))
1953 {
1954 RenderEntry(obj, ld, bi, lve, a);
1955 };
1956 };
1957 };
1958
1959 /*
1960 * Disabled?
1961 */
1962 if ((!(ld->ld_Flags & LDF_CUSTOMDISABLE)) && ld->ld_Display)
1963 {
1964 if (GADGET(obj)->Flags & GFLG_DISABLED)
1965 {
1966 BDisableBox(bi, &bc->bc_HitBox);
1967 };
1968 };
1969
1970 /*
1971 * Done.
1972 */
1973 ld->ld_Flags &= ~LDF_REFRESH_ALL;
1974
1975 /*
1976 * Replace the font.
1977 */
1978 BSetFont(bi, of);
1979
1980 if (ld->ld_Prop)
1981 {
1982 /*
1983 * Setup scroller bounds.
1984 */
1985 GADGETBOX(ld->ld_Prop)->Left = ld->ld_HitBox.Left + ld->ld_HitBox.Width;
1986 GADGETBOX(ld->ld_Prop)->Top = ld->ld_HitBox.Top;
1987 GADGETBOX(ld->ld_Prop)->Width = sw;
1988 GADGETBOX(ld->ld_Prop)->Height = ld->ld_HitBox.Height;
1989
1990 /*
1991 * Set top, total etc.
1992 */
1993 DoSetMethodNG(ld->ld_Prop, PGA_Top, ld->ld_Top, PGA_Total, ld->ld_Total,
1994 PGA_Visible, ld->ld_Visible, TAG_DONE);
1995
1996 /*
1997 * Re-render the scroller.
1998 */
1999 AsmDoMethod(ld->ld_Prop, GM_RENDER, bi, rp, bmr->bmr_Flags);
2000 };
2001 return 1;
2002 }
2003 METHOD_END
2004 ///
2005
2006 /*
2007 * Find out over which entry the mouse is located.
2008 */
2009 //STATIC ASM LONG MouseOverEntry(REG(a0) LD *ld, REG(d0) LONG t)
2010 STATIC ASM REGFUNC2(LONG, MouseOverEntry,
2011 REGPARAM(A0, LD *, ld),
2012 REGPARAM(D0, LONG, t))
2013 {
2014 t -= ld->ld_ListArea.Top;
2015 if (t < 0) return -1;
2016
2017 t = (t / ld->ld_EntryHeight) + ld->ld_Top;
2018
2019 if (t > ld->ld_Total) t = ld->ld_Total;
2020
2021 return t;
2022 }
2023 REGFUNC_END
2024
2025 /*
2026 * Perform multi-(de)selection.
2027 */
2028 //STATIC ASM BOOL MultiSelect( REG(a0) LD *ld, REG(d0) ULONG active )
2029 STATIC ASM REGFUNC2(BOOL, MultiSelect,
2030 REGPARAM(A0, LD *, ld),
2031 REGPARAM(D0, ULONG, active))
2032 {
2033 LVE *node = FindNodeQuick( ld, ld->ld_MultiStart ), *anode = FindNodeQuick( ld, active );
2034 BOOL rc = FALSE;
2035
2036 /*
2037 * Backward?
2038 */
2039 if ( ld->ld_MultiStart > active ) {
2040 /*
2041 * Loop through the entries.
2042 */
2043 for ( ; ; node = node->lve_Prev ) {
2044 /*
2045 * Select entries?
2046 */
2047 if ( ! ld->ld_MultiMode ) {
2048 /*
2049 * Yes.
2050 */
2051 if ( ! ( node->lve_Flags & LVEF_SELECTED )) {
2052 node->lve_Flags |= LVEF_SELECTED | LVEF_REFRESH;
2053 rc = TRUE;
2054 }
2055 }
2056 else
2057 {
2058 if (node->lve_Flags & LVEF_SELECTED)
2059 {
2060 node->lve_Flags &= ~LVEF_SELECTED;
2061 node->lve_Flags |= LVEF_REFRESH;
2062 rc = TRUE;
2063 }
2064 }
2065 /*
2066 * Done?
2067 */
2068 if ( node == anode )
2069 return( rc );
2070 }
2071 } else {
2072 /*
2073 * Loop through the entries.
2074 */
2075 for ( ; ; node = node->lve_Next ) {
2076 /*
2077 * Select entries?
2078 */
2079 if ( ! ld->ld_MultiMode ) {
2080 /*
2081 * Yes.
2082 */
2083 if ( ! ( node->lve_Flags & LVEF_SELECTED )) {
2084 node->lve_Flags |= LVEF_SELECTED | LVEF_REFRESH;
2085 rc = TRUE;
2086 }
2087 } else {
2088 if ( node->lve_Flags & LVEF_SELECTED ) {
2089 node->lve_Flags &= ~LVEF_SELECTED;
2090 node->lve_Flags |= LVEF_REFRESH;
2091 rc = TRUE;
2092 }
2093 }
2094 /*
2095 * Done?
2096 */
2097 if ( node == anode )
2098 return( rc );
2099 }
2100 }
2101 return rc;
2102 }
2103 REGFUNC_END
2104 /// GM_HITTEST
2105 /*
2106 * Test if the gadget was hit.
2107 */
2108 METHOD(ListClassHitTest, struct gpHitTest *, gph)
2109 {
2110 LD *ld = INST_DATA(cl, obj);
2111 BC *bc = BASE_DATA(obj);
2112 ULONG rc = 0;
2113
2114 /*
2115 * Get absolute click position.
2116 */
2117 WORD l = GADGET(obj)->LeftEdge + gph->gpht_Mouse.X;
2118 WORD t = GADGET(obj)->TopEdge + gph->gpht_Mouse.Y;
2119
2120 if (PointInBox(&bc->bc_InnerBox, l, t))
2121 /*
2122 * Hit inside the list area?
2123 */
2124 return GMR_GADGETHIT;
2125
2126 if (ld->ld_Prop)
2127 {
2128 /*
2129 * Route the message.
2130 */
2131 rc = ForwardMsg(obj, ld->ld_Prop, (Msg)gph);
2132
2133 if (rc == GMR_GADGETHIT)
2134 /*
2135 * Mark the scroller active.
2136 */
2137 ld->ld_Flags |= LDF_PROPACTIVE;
2138 };
2139 return rc;
2140 }
2141 METHOD_END
2142 ///
2143 /// GM_GOACTIVE
2144 /*
2145 * They want us to go active.
2146 */
2147 METHOD(ListClassGoActive, struct gpInput *, gpi)
2148 {
2149 LD *ld = INST_DATA(cl, obj);
2150 LVE *lve;
2151 ULONG rc = GMR_NOREUSE, last = ld->ld_LastNum;
2152 int col, dx;
2153 struct GadgetInfo *gi = gpi->gpi_GInfo;
2154
2155 /*
2156 * Get hit position.
2157 */
2158 int x = gpi->gpi_Mouse.X;
2159 int y = gpi->gpi_Mouse.Y;
2160 int l = x + GADGET(obj)->LeftEdge;
2161 int t = y + GADGET(obj)->TopEdge;
2162
2163 /*
2164 * We do not go active if we were activated by ActivateGadget().
2165 */
2166 if (!gpi->gpi_IEvent)
2167 return GMR_NOREUSE;
2168
2169 /*
2170 * Check for left mouse button down event
2171 */
2172 if ((gpi->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE) && (gpi->gpi_IEvent->ie_Code == SELECTDOWN))
2173 {
2174 /*
2175 * Update column positions if required
2176 */
2177 if (!(ld->ld_Flags & LDF_OFFSETS_VALID))
2178 GetColumnPositions(obj, ld);
2179
2180 /*
2181 * Step through column positions array, marking a hit if
2182 * mouse is within 4 pixels either side of column separator.
2183 */
2184 col = ld->ld_Columns - 1;
2185 while (col--)
2186 {
2187 if (!(ld->ld_CD[col].cd_Flags & LVCF_HIDDEN))
2188 {
2189 dx = x - ld->ld_CD[col + 1].cd_Offset;
2190 /*
2191 * If hit column separator, set Dragging to TRUE, record
2192 * drag column and initial drag position, draw first
2193 * drag line and return GMR_MEACTIVE.
2194 */
2195 if ((dx >= -4) && (dx <= 4))
2196 {
2197 /*
2198 * Check for column dragging enabled.
2199 */
2200 if ((ld->ld_Flags & LDF_ALLOW_DRAG) || (ld->ld_CD[col].cd_Flags & LVCF_DRAGGABLE))
2201 {
2202 ld->ld_Flags |= LDF_DRAGGING_COLUMN;
2203 ld->ld_DragColumn = col;
2204 ld->ld_DragXLine = ld->ld_CD[col+1].cd_Offset;
2205 DrawDragLine(ld, gi);
2206
2207 return GMR_MEACTIVE;
2208 };
2209 };
2210 };
2211 };
2212 };
2213
2214 if (ld->ld_Prop)
2215 {
2216 /*
2217 * Prop hit?
2218 */
2219 if (ld->ld_Flags & LDF_PROPACTIVE)
2220 {
2221 /*
2222 * Adjust coordinates and re-direct message.
2223 */
2224 return ForwardMsg(obj, ld->ld_Prop, (Msg)gpi) & ~GMR_VERIFY;
2225 };
2226 }
2227
2228 /*
2229 * Can we go active?
2230 */
2231 if (( GADGET( obj )->Flags & GFLG_DISABLED ) || ( ld->ld_Flags & LDF_READ_ONLY ) || ( ld->ld_Flags & LDF_LIST_BUSY ))
2232 return( GMR_NOREUSE );
2233
2234 /*
2235 * Get the entry which lays under the mouse.
2236 */
2237 ld->ld_ActiveEntry = (ULONG)MouseOverEntry(ld, t);
2238
2239 col = ld->ld_Columns;
2240 while (--col)
2241 {
2242 if (x >= ld->ld_CD[col].cd_Offset)
2243 break;
2244 };
2245 ld->ld_LastCol = col;
2246
2247 /*
2248 * Is it in range?
2249 */
2250 if (ld->ld_ActiveEntry < ld->ld_Total)
2251 {
2252 if (lve = ld->ld_LastActive = FindNodeQuick(ld, ld->ld_ActiveEntry))
2253 {
2254 ld->ld_LastNum = ld->ld_ActiveEntry;
2255 /*
2256 * If we are not a multi-select object we
2257 * de-select all entries. Otherwise we mark the
2258 * entry which initiated the multi-(de)select.
2259 */
2260 if (!(ld->ld_Flags & LDF_MULTI_SELECT)) DeSelect(ld);
2261 else {
2262 /*
2263 * De-select entries if shift isn't down.
2264 */
2265 if (!(ld->ld_Flags & LDF_NOSHIFT))
2266 {
2267 if (!(gpi->gpi_IEvent->ie_Qualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)))
2268 DeSelect(ld);
2269 }
2270
2271 /*
2272 * Multi-selection. When MultiMode is 1 we need
2273 * to multi-deselect. Otherwise we multi-select.
2274 */
2275 if (lve->lve_Flags & LVEF_SELECTED) ld->ld_MultiMode = 1;
2276 else ld->ld_MultiMode = 0;
2277
2278 /*
2279 * Setup starting position.
2280 */
2281 ld->ld_MultiStart = ld->ld_ActiveEntry;
2282 }
2283 /*
2284 * Select entry if necessary.
2285 */
2286 if ( ! ld->ld_MultiMode ) {
2287 /*
2288 * Note the time we got clicked.
2289 */
2290 CurrentTime( &ld->ld_Secs[ 0 ], &ld->ld_Mics[ 0 ] );
2291 lve->lve_Flags |= LVEF_SELECTED | LVEF_REFRESH;
2292 } else {
2293 /*
2294 * De-selection only in multi-mode.
2295 */
2296 if ( ld->ld_Flags & LDF_MULTI_SELECT ) {
2297 /*
2298 * The same selection as the previous?
2299 */
2300 if ( ld->ld_ActiveEntry == last ) {
2301 /*
2302 * Yes, time it.
2303 */
2304 CurrentTime( &ld->ld_Secs[ 1 ], &ld->ld_Mics[ 1 ] );
2305
2306 /*
2307 * Double clicked the selection?
2308 */
2309 if ( ! DoubleClick( ld->ld_Secs[ 0 ], ld->ld_Mics[ 0 ], ld->ld_Secs[ 1 ], ld->ld_Mics[ 1 ] )) {
2310 /*
2311 * No, deselect it.
2312 */
2313 lve->lve_Flags &= ~LVEF_SELECTED;
2314 lve->lve_Flags |= LVEF_REFRESH;
2315 }
2316 } else {
2317 /*
2318 * Deselect the entry.
2319 */
2320 lve->lve_Flags &= ~LVEF_SELECTED;
2321 lve->lve_Flags |= LVEF_REFRESH;
2322 }
2323 } else
2324 lve->lve_Flags |= LVEF_SELECTED | LVEF_REFRESH;
2325 }
2326 /*
2327 * Notify & Re-render.
2328 */
2329 DoNotifyMethod(obj, gi, OPUF_INTERIM, GA_ID, GADGET(obj)->GadgetID, LISTV_Entry, lve->lve_Entry,
2330 LISTV_EntryNumber, ld->ld_LastNum, LISTV_LastColumn, ld->ld_LastCol, TAG_DONE);
2331 DoRenderMethod(obj, gi, GREDRAW_UPDATE );
2332 }
2333 /*
2334 * Setup any drag and drop buffers we may need.
2335 */
2336 if ( AsmDoSuperMethodA( cl, obj, ( Msg )gpi ) == GMR_MEACTIVE )
2337 ld->ld_Flags |= LDF_DRAGGABLE;
2338
2339 rc = GMR_MEACTIVE;
2340 }
2341 else if (ld->ld_ActiveEntry == (ULONG)-1)
2342 {
2343 /*
2344 * Notify.
2345 */
2346 DoNotifyMethod(obj, gi, OPUF_INTERIM, GA_ID, GADGET(obj)->GadgetID, LISTV_Entry, -1,
2347 LISTV_EntryNumber, -1, LISTV_LastColumn, ld->ld_LastCol, TAG_DONE);
2348 };
2349 return rc;
2350 }
2351 METHOD_END
2352 ///
2353 /// GM_HANDLEINPUT
2354 /*
2355 * Handle user input.
2356 */
2357 METHOD(ListClassHandleInput, struct gpInput *, gpi)
2358 {
2359 LD *ld = INST_DATA(cl, obj);
2360 LVE *lve;
2361 struct gpInput hit;
2362 int vc, xmin, xmax, dx;
2363 ULONG rc = GMR_MEACTIVE, otop = ld->ld_Top, ntop = ld->ld_Top;
2364 LONG nc;
2365 int dcol = ld->ld_DragColumn;
2366 int totalwidth, totalweight;
2367 struct GadgetInfo *gi = gpi->gpi_GInfo;
2368 CD *cd, *cd2, *cd3;
2369
2370
2371 /*
2372 * Get mouse position.
2373 */
2374 int x = gpi->gpi_Mouse.X;
2375 int y = gpi->gpi_Mouse.Y;
2376 int l = x + GADGET(obj)->LeftEdge;
2377 int t = y + GADGET(obj)->TopEdge;
2378
2379 /*
2380 * List in use?
2381 */
2382 if (ld->ld_Flags & LDF_LIST_BUSY)
2383 return rc;
2384
2385 /*
2386 * Dragging column?
2387 */
2388 if (ld->ld_Flags & LDF_DRAGGING_COLUMN)
2389 {
2390 cd = ld->ld_CD + dcol;
2391 cd2 = cd + 1;
2392 cd3 = cd + 2;
2393
2394 /*
2395 * Return this by default, implying we want to
2396 * remain the active gadget.
2397 */
2398 rc = GMR_MEACTIVE;
2399
2400 /*
2401 * If this is a mouse event (movement or button)
2402 */
2403
2404 if (gpi->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE)
2405 {
2406 /*
2407 * Update column offsets if required
2408 */
2409 if (!(ld->ld_Flags & LDF_OFFSETS_VALID))
2410 GetColumnPositions(obj, ld);
2411
2412 /*
2413 * gpi_Mouse.X has mouse-x relative to left side of gadget
2414 * hitbox. Set minimum and maximum values for x at positions
2415 * of columns either side of the one being dragged. Add a
2416 * minimum column width to those limits as well.
2417 */
2418 xmin = cd->cd_Offset + cd->cd_MinWidth;
2419 xmax = min(cd->cd_Offset + cd->cd_MaxWidth, cd3->cd_Offset - cd2->cd_MinWidth);
2420
2421 if (xmax < xmin) /* just in case column is */
2422 { /* already very narrow, */
2423 xmin = xmax = cd2->cd_Offset; /* stop user from adjusting it */
2424 };
2425
2426 /*
2427 * Prevent dragline from wandering outside of limits.
2428 */
2429 if (x < xmin) x = xmin;
2430 if (x > xmax) x = xmax;
2431
2432 /*
2433 * Don't update if dragline position hasn't changed.
2434 */
2435
2436 if (x != ld->ld_DragXLine)
2437 {
2438 /*
2439 * Reposition dragline by drawing again at old position
2440 * using complement mode, then drawing at new position.
2441 */
2442
2443 DrawDragLine(ld, gi);
2444 ld->ld_DragXLine = x;
2445 DrawDragLine(ld, gi);
2446 }
2447
2448 /*
2449 * Check for left mouse button release: implies user
2450 * has stopped dragging column and it's time to recalculate
2451 * the column weights.
2452 */
2453 if (gpi->gpi_IEvent->ie_Code == SELECTUP)
2454 {
2455 rc = GMR_NOREUSE; /* we will use LMB-up event */
2456
2457 /*
2458 * No need to do anything if column position not changed.
2459 */
2460 if (dx = x - cd2->cd_Offset)
2461 {
2462 /*
2463 * Set new column position at x.
2464 */
2465 cd2->cd_Offset = x;
2466 cd2->cd_Width -= dx;
2467 cd->cd_Width += dx;
2468
2469 /*
2470 * Set new weights for dragged column and the one to the
2471 * right of it, by redistributing the total of their
2472 * original weights in the ratio of their new positions
2473 * over the original total distance between them. Both
2474 * total weight and total distance remain unchanged.
2475 */
2476 totalweight = cd->cd_Weight + cd2->cd_Weight;
2477 totalwidth = cd3->cd_Offset - cd->cd_Offset;
2478
2479 cd2->cd_Weight = ((cd3->cd_Offset - x) * totalweight) / totalwidth;
2480 cd->cd_Weight = totalweight - cd2->cd_Weight;
2481
2482 /*
2483 * If we have a GadgetInfo, invoke GM_RENDER
2484 * to update gadget visuals.
2485 */
2486
2487 if (gi)
2488 {
2489 DoRenderMethod(obj, gi, GREDRAW_REDRAW);
2490
2491 /*
2492 * No need for GoInactive() to erase dragline:
2493 */
2494 ld->ld_Flags |= LDF_NEW_COLUMN_POS;
2495 };
2496
2497 } /* endif posn changed */
2498
2499 } /* endif LMB down */
2500 /*
2501 * If event was menu button down, abandon dragging
2502 * and let Intuition activate menus.
2503 */
2504
2505 if (gpi->gpi_IEvent->ie_Code == MENUDOWN)
2506 rc = GMR_REUSE;
2507
2508 } /* endif mouse event */
2509
2510 /*
2511 * If event was either shift key going down, abandon
2512 * dragging as per BGUI standard.
2513 */
2514
2515 if (gpi->gpi_IEvent->ie_Class == IECLASS_RAWKEY)
2516 {
2517 if ((gpi->gpi_IEvent->ie_Code == 0x60) || (gpi->gpi_IEvent->ie_Code == 0x61))
2518 rc = GMR_REUSE;
2519 };
2520 return rc;
2521 };
2522
2523 /*
2524 * Prop gadget active?
2525 */
2526 if (ld->ld_Prop && (ld->ld_Flags & LDF_PROPACTIVE))
2527 {
2528 /*
2529 * Adjust coordinates and route message.
2530 */
2531 return ForwardMsg(obj, ld->ld_Prop, (Msg)gpi) & ~GMR_VERIFY;
2532 };
2533
2534 hit = *gpi;
2535 hit.MethodID = BASE_DRAGGING;
2536
2537 nc = AsmDoMethodA(obj, (Msg)&hit);
2538
2539 switch (nc)
2540 {
2541 case BDR_DROP:
2542 DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, LISTV_Entry, ld->ld_LastActive ? ld->ld_LastActive->lve_Entry : NULL, LISTV_EntryNumber, ld->ld_LastNum, TAG_END);
2543 rc = GMR_VERIFY;
2544 break;
2545
2546 case BDR_CANCEL:
2547 rc = GMR_NOREUSE;
2548 break;
2549
2550 case BDR_NONE:
2551 /*
2552 * Get the entry which lies under the mouse.
2553 */
2554 nc = MouseOverEntry(ld, t);
2555
2556 /*
2557 * There are only so much entries...
2558 */
2559 if (nc < 0) nc = ld->ld_Top - 1;
2560 if (nc < 0) nc = 0;
2561 if (nc >= ld->ld_Total) nc = ld->ld_Total - 1;
2562
2563 /*
2564 * Let's see what we got...
2565 */
2566 if (gpi->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE)
2567 {
2568 /*
2569 * We do not support drag-selection when we
2570 * are in drag and drop mode.
2571 */
2572 if (!(ld->ld_Flags & LDF_DRAGGABLE))
2573 {
2574 /*
2575 * We only respond when:
2576 * A) The entry under the mouse changed.
2577 * B) The entry under the mouse is in the visible area.
2578 */
2579 if ((nc != ld->ld_ActiveEntry) && (nc >= ld->ld_Top) && (nc < (ld->ld_Top + ld->ld_Visible)))
2580 {
2581 /*
2582 * Mark the new entry.
2583 */
2584 ld->ld_ActiveEntry = nc;
2585
2586 /*
2587 * Get the node.
2588 */
2589 if (lve = ld->ld_LastActive = FindNodeQuick(ld, nc))
2590 {
2591 ld->ld_LastNum = nc;
2592 /*
2593 * Are we a multi-select object?
2594 */
2595 if (!(ld->ld_Flags & LDF_MULTI_SELECT))
2596 {
2597 /*
2598 * No. Deselect other entries.
2599 */
2600 DeSelect(ld);
2601
2602 /*
2603 * We need a visual change.
2604 */
2605 vc = TRUE;
2606
2607 /*
2608 * Select entry.
2609 */
2610 lve->lve_Flags |= LVEF_SELECTED | LVEF_REFRESH;
2611 } else
2612 /*
2613 * Do a multi-(de)select.
2614 */
2615 vc = MultiSelect( ld, nc );
2616
2617 /*
2618 * Update visuals if necessary.
2619 */
2620 if (vc) DoRenderMethod(obj, gi, GREDRAW_UPDATE);
2621 DoNotifyMethod(obj, gi, OPUF_INTERIM, GA_ID, GADGET(obj)->GadgetID, LISTV_Entry, lve->lve_Entry, LISTV_EntryNumber, ld->ld_LastNum, TAG_END );
2622 }
2623 }
2624 }
2625
2626 /*
2627 * What code do we have...
2628 */
2629 switch (gpi->gpi_IEvent->ie_Code)
2630 {
2631 case SELECTUP:
2632 /*
2633 * Releasing the left button
2634 * de-activates the object.
2635 */
2636 rc = GMR_NOREUSE | GMR_VERIFY;
2637 CurrentTime(&ld->ld_Secs[0], &ld->ld_Mics[0]);
2638 DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, LISTV_Entry, ld->ld_LastActive->lve_Entry, LISTV_EntryNumber, ld->ld_LastNum, TAG_END );
2639 break;
2640
2641 case MENUDOWN:
2642 /*
2643 * Reuse menu events.
2644 */
2645 rc = GMR_REUSE | GMR_VERIFY;
2646 DoNotifyMethod(obj, gi, 0, GA_ID, GADGET(obj)->GadgetID, LISTV_Entry, ld->ld_LastActive->lve_Entry, LISTV_EntryNumber, ld->ld_LastNum, TAG_END );
2647 break;
2648 }
2649 }
2650 else if (gpi->gpi_IEvent->ie_Class == IECLASS_TIMER)
2651 {
2652 /*
2653 * When the mouse is moved above or below
2654 * the visible area the entries scroll up
2655 * or down using timer events for a delay.
2656 */
2657 if ((nc != ld->ld_ActiveEntry) && (!(ld->ld_Flags & LDF_DRAGGABLE)))
2658 {
2659 /*
2660 * When the active entry is located before
2661 * the top entry we scroll up one entry. When the
2662 * entry is located after the last visible entry
2663 * we scroll down one entry.
2664 */
2665 vc = FALSE;
2666 if (nc >= ntop + ld->ld_Visible)
2667 {
2668 nc = ntop++ + ld->ld_Visible;
2669 vc = TRUE;
2670 }
2671 else if (nc < ntop)
2672 {
2673 nc = --ntop;
2674 vc = TRUE;
2675 };
2676
2677 if (vc)
2678 {
2679 /*
2680 * Set the new entry.
2681 */
2682 ld->ld_LastNum = ld->ld_ActiveEntry = nc;
2683
2684 /*
2685 * Find the entry.
2686 */
2687 if (lve = ld->ld_LastActive = FindNodeQuick(ld, nc))
2688 {
2689 /*
2690 * Are we a multi-select object?
2691 */
2692 if (ld->ld_Flags & LDF_MULTI_SELECT)
2693 {
2694 /*
2695 * Do a multi-(de)select.
2696 */
2697 vc = MultiSelect(ld, nc);
2698 }
2699 else
2700 {
2701 /*
2702 * No. Deselect all entries.
2703 */
2704 DeSelect(ld);
2705 /*
2706 * Select the entry.
2707 */
2708 lve->lve_Flags |= LVEF_SELECTED | LVEF_REFRESH;
2709 /*
2710 * We need a visual change.
2711 */
2712 vc = TRUE;
2713 };
2714
2715 /*
2716 * Update visuals when necessary.
2717 */
2718 if (vc || (otop != ntop))
2719 {
2720 /*
2721 * Top changed?
2722 */
2723 DoRenderMethod(obj, gi, GREDRAW_UPDATE);
2724 if (otop != ntop)
2725 {
2726 NewTop(ld, gi, obj, ntop);
2727 if (ld->ld_Prop)
2728 DoSetMethod(ld->ld_Prop, gi, PGA_Top, ntop, TAG_END);
2729 };
2730 DoNotifyMethod(obj, gi, OPUF_INTERIM, GA_ID, GADGET(obj)->GadgetID, LISTV_Entry, lve->lve_Entry, LISTV_EntryNumber, ld->ld_LastNum, TAG_END);
2731 };
2732 };
2733 };
2734 };
2735 };
2736 break;
2737 }
2738 return rc;
2739 }
2740 METHOD_END
2741 ///
2742 /// GM_GOINACTIVE
2743 /*
2744 * Go inactive.
2745 */
2746 METHOD(ListClassGoInActive, struct gpGoInactive *, ggi)
2747 {
2748 LD *ld = INST_DATA(cl, obj);
2749
2750 if (ld->ld_Flags & LDF_DRAGGING_COLUMN)
2751 {
2752 if (!(ld->ld_Flags & LDF_NEW_COLUMN_POS))
2753 DrawDragLine(ld, ggi->gpgi_GInfo);
2754
2755 ld->ld_Flags &= ~(LDF_DRAGGING_COLUMN|LDF_NEW_COLUMN_POS);
2756 return 0;
2757 }
2758 else
2759 {
2760 /*
2761 * Clear draggable bit.
2762 */
2763 ld->ld_Flags &= ~LDF_DRAGGABLE;
2764
2765 if (ld->ld_Prop)
2766 {
2767 /*
2768 * If the scroller was active pass this message on for compatibility reasons.
2769 */
2770 if (ld->ld_Flags & LDF_PROPACTIVE)
2771 {
2772 /*
2773 * Mark the scroller as not active.
2774 */
2775 ld->ld_Flags &= ~LDF_PROPACTIVE;
2776
2777 return AsmDoMethodA(ld->ld_Prop, (Msg)ggi);
2778 };
2779 };
2780 return AsmDoSuperMethodA(cl, obj, (Msg)ggi);
2781 };
2782 }
2783 METHOD_END
2784 ///
2785 /// BASE_DIMENSIONS
2786 /*
2787 * They want our minimum dimensions.
2788 */
2789 METHOD(ListClassDimensions, struct bmDimensions *, bmd)
2790 {
2791 LD *ld = INST_DATA(cl, obj);
2792 struct BaseInfo *bi = bmd->bmd_BInfo;
2793 UWORD my, mx = 0, mpx = 0, mpy = 0;
2794 int th = ld->ld_EntryHeight, col;
2795 struct TextAttr *lf = ld->ld_ListFont;
2796
2797 /*
2798 * First the prop...
2799 */
2800 if (ld->ld_Prop) AsmDoMethod(ld->ld_Prop, GRM_DIMENSIONS, bi, bi->bi_RPort, &mpx, &mpy, 0);
2801
2802 if (!lf)
2803 {
2804 /*
2805 * Pickup superclass font.
2806 */
2807 Get_SuperAttr(cl, obj, BT_TextAttr, &lf);
2808 };
2809 /*
2810 * Setup entry height always even.
2811 */
2812 ld->ld_EntryHeight = (lf->ta_YSize + 1) & (ULONG)~1;
2813
2814 /*
2815 * Calculate minimum x&y size.
2816 */
2817 my = ld->ld_EntryHeight * ld->ld_MinShown;
2818
2819 for (col = 0; col < ld->ld_Columns; col++)
2820 {
2821 mx += ld->ld_CD[col].cd_MinWidth;
2822 };
2823
2824 /*
2825 * The listview grows when a title
2826 * hook is specified.
2827 */
2828 if (ld->ld_Title)
2829 my += th + 4;
2830
2831 mpx += mx;
2832 if (my > mpy) mpy = my;
2833
2834 /*
2835 * Set it.
2836 */
2837 return CalcDimensions(cl, obj, bmd, mpx, mpy);
2838 }
2839 METHOD_END
2840 ///
2841 /// WM_KEYACTIVE
2842 /*
2843 * Key activation.
2844 */
2845 //STATIC ASM ULONG ListClassKeyActive( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct wmKeyInput *wmki )
2846 STATIC ASM REGFUNC3(ULONG, ListClassKeyActive,
2847 REGPARAM(A0, Class *, cl),
2848 REGPARAM(A2, Object *, obj),
2849 REGPARAM(A1, struct wmKeyInput *, wmki))
2850 {
2851 LD *ld = ( LD * )INST_DATA( cl, obj );
2852 UWORD qual = wmki->wmki_IEvent->ie_Qualifier;
2853 LONG nnum = 0, otop = ld->ld_Top, newtop = otop;
2854 LVE *node;
2855 BOOL sel = FALSE;
2856
2857 /*
2858 * Read-only?
2859 */
2860 if ( ld->ld_Flags & LDF_READ_ONLY ) {
2861 /*
2862 * Shifted scrolls up.
2863 */
2864 if ( qual & ( IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT )) {
2865 if ( newtop ) newtop--;
2866 } else {
2867 if ( newtop < ( ld->ld_Total - ld->ld_Visible )) newtop++;
2868 }
2869
2870 /*
2871 * Top changed?
2872 */
2873 if ( newtop != otop )
2874 DoSetMethod( obj, wmki->wmki_GInfo, LISTV_Top, newtop, TAG_END );
2875
2876 /*
2877 * Ignore this.
2878 */
2879 *( wmki->wmki_ID ) = WMHI_IGNORE;
2880 } else {
2881 /*
2882 * Find the selected node.
2883 */
2884 for ( node = ld->ld_Entries.lvl_First; node->lve_Next; node = node->lve_Next, nnum++ ) {
2885 if ( node->lve_Flags & LVEF_SELECTED ) {
2886 sel = TRUE;
2887 break;
2888 }
2889 }
2890
2891 /*
2892 * Found?
2893 */
2894 if ( ! sel )
2895 /*
2896 * Select first entry.
2897 */
2898 DoSetMethod( obj, wmki->wmki_GInfo, LISTV_Select, 0L, TAG_END );
2899 else {
2900 if ( qual & ( IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT )) {
2901 /*
2902 * Shifted selectes the previous entry.
2903 */
2904 nnum=LISTV_Select_Previous;
2905 } else {
2906 /*
2907 * Normal the next entry.
2908 */
2909 nnum=LISTV_Select_Next;
2910 }
2911
2912 /*
2913 * Select the new entry.
2914 */
2915 DoSetMethod( obj, wmki->wmki_GInfo, LISTV_Select, nnum, TAG_END );
2916 }
2917 /*
2918 * Ignore this..
2919 */
2920 *( wmki->wmki_ID ) = WMHI_IGNORE;
2921 }
2922
2923 return( WMKF_VERIFY );
2924 }
2925 REGFUNC_END
2926
2927 /*
2928 * Get entry predecessor, position and add method.
2929 */
2930 //STATIC ASM VOID EntryPosHow( REG(a0) LD *ld, REG(a1) LVE **lve, REG(d0) ULONG pos, REG(a2) ULONG *how )
2931 STATIC ASM REGFUNC4(VOID, EntryPosHow,
2932 REGPARAM(A0, LD *, ld),
2933 REGPARAM(A1, LVE **, lve),
2934 REGPARAM(D0, ULONG, pos),
2935 REGPARAM(A2, ULONG, *how))
2936 {
2937 if ( ! pos ) {
2938 /*
2939 * Position of 0 means add to the head.
2940 */
2941 *how = LVAP_HEAD;
2942 *lve = NULL;
2943 } else if ( pos >= ld->ld_Total ) {
2944 /*
2945 * A position larger or equal to the
2946 * number of available entries means
2947 * add to the tail.
2948 */
2949 *how = LVAP_TAIL;
2950 *lve = NULL;
2951 } else {
2952 /*
2953 * Look up the entry to insert after.
2954 */
2955 *how = 0L;
2956 *lve = FindNodeQuick( ld, pos - 1 );
2957 }
2958 }
2959 REGFUNC_END
2960 ///
2961
2962 /*
2963 * (Multi)Select entry and/or make it visible.
2964 */
2965 //SAVEDS ASM VOID DoEntry(REG(a0) struct GadgetInfo *gi, REG(a1) Object *obj, REG(a2) LD *ld, REG(d0) ULONG flags, REG(d1) ULONG number)
2966 SAVEDS ASM REGFUNC5(VOID, DoEntry,
2967 REGPARAM(A0, struct GadgetInfo *, gi),
2968 REGPARAM(A1, Object *, obj),
2969 REGPARAM(A2, LD *, ld),
2970 REGPARAM(D0, ULONG, flags),
2971 REGPARAM(D1, ULONG, number))
2972 {
2973 ULONG tag;
2974
2975 /*
2976 * Make visible? Select?
2977 */
2978 if (flags & LVASF_SELECT)
2979 {
2980 /*
2981 * Visible or not?
2982 */
2983 tag = (flags & LVASF_NOT_VISIBLE) ? LISTV_SelectNotVisible : LISTV_Select;
2984
2985 DoSetMethod(obj, gi, tag, number, TAG_DONE);
2986 }
2987 else if (flags & LVASF_MULTISELECT)
2988 {
2989 /*
2990 * Visible or not?
2991 */
2992 tag = (flags & LVASF_NOT_VISIBLE) ? LISTV_SelectMultiNotVisible : LISTV_SelectMulti;
2993
2994 DoSetMethod(obj, gi, tag, number, TAG_DONE);
2995 }
2996 else if (flags & LVASF_MAKEVISIBLE)
2997 {
2998 /*
2999 * Just make it visible.
3000 */
3001 DoSetMethod(obj, gi, LISTV_MakeVisible, number, TAG_DONE);
3002 }
3003 else
3004 {
3005 /*
3006 * Re-render list.
3007 */
3008 ld->ld_Flags |= LDF_REFRESH_ALL;
3009 DoRenderMethod(obj, gi, GREDRAW_UPDATE);
3010 }
3011 }
3012 REGFUNC_END
3013 /// LVM_INSERTENTRIES
3014 /*
3015 * Insert entries.
3016 */
3017 METHOD(ListClassInsertEntries, struct lvmInsertEntries *, lvmi)
3018 {
3019 LD *ld = INST_DATA( cl, obj );
3020 LVE *lve;
3021 ULONG rc, pos = lvmi->lvmi_Pos, how;
3022
3023 /*
3024 * Where do we insert them.
3025 */
3026 EntryPosHow(ld, &lve, pos, &how);
3027
3028 /*
3029 * Insert the entries.
3030 */
3031 rc = AddEntries(ld, lvmi->lvmi_Entries, obj, how, lve);
3032
3033 /*
3034 * We want the list completely refreshed.
3035 */
3036 ld->ld_Flags |= LDF_REFRESH_ALL;
3037
3038 /*
3039 * Render the object.
3040 */
3041 DoRenderMethod(obj, lvmi->lvmi_GInfo, GREDRAW_UPDATE);
3042
3043 return rc;
3044 }
3045 METHOD_END
3046 ///
3047 /// LVM_INSERTSINGLE
3048 /*
3049 * Insert a single entry.
3050 */
3051 METHOD(ListClassInsertSingle, struct lvmInsertSingle *, lvis)
3052 {
3053 LD *ld = INST_DATA(cl, obj);
3054 struct lvmInsertEntries lvmi;
3055 APTR entries[2];
3056 ULONG rc;
3057
3058 /*
3059 * Set it up.
3060 */
3061 entries[0] = lvis->lvis_Entry;
3062 entries[1] = NULL;
3063
3064 lvmi.MethodID = LVM_INSERTENTRIES;
3065 lvmi.lvmi_GInfo = lvis->lvis_GInfo;
3066 lvmi.lvmi_Entries = entries;
3067 lvmi.lvmi_Pos = lvis->lvis_Pos;
3068
3069 /*
3070 * Insert them.
3071 */
3072 rc = ListClassInsertEntries( cl, obj, &lvmi );
3073
3074 /*
3075 * Select the entry or make it visible
3076 * or just redraw the list.
3077 */
3078 ld->ld_LastAdded->lve_Flags |= LVEF_REFRESH;
3079
3080 /*
3081 * Make visible? Select?
3082 */
3083 DoEntry(lvis->lvis_GInfo, obj, ld, lvis->lvis_Flags, lvis->lvis_Pos >= ld->ld_Total ? ld->ld_Total - 1 : lvis->lvis_Pos );
3084
3085 return rc;
3086 }
3087 METHOD_END
3088 ///
3089 /// LVM_ADDENTRIES
3090 /*
3091 * Add entries.
3092 */
3093 METHOD(ListClassAddEntries, struct lvmAddEntries *, lva)
3094 {
3095 LD *ld = INST_DATA( cl, obj );
3096 ULONG rc;
3097
3098 /*
3099 * Add the entries.
3100 */
3101 rc = AddEntries(ld, lva->lvma_Entries, obj, lva->lvma_How, NULL);
3102
3103 /*
3104 * We want the list completely refreshed.
3105 */
3106 ld->ld_Flags |= LDF_REFRESH_ALL;
3107
3108 /*
3109 * Render the object.
3110 */
3111 DoRenderMethod(obj, lva->lvma_GInfo, GREDRAW_UPDATE);
3112
3113 return rc;
3114 }
3115 METHOD_END
3116 ///
3117 /// LVM_ADDSINGLE
3118 /*
3119 * Add a single entry.
3120 */
3121 METHOD(ListClassAddSingle, struct lvmAddSingle *, lva)
3122 {
3123 LD *ld = INST_DATA(cl, obj);
3124 APTR entries[2];
3125 ULONG number, rc;
3126 LVE *tmp;
3127
3128 /*
3129 * Set it up.
3130 */
3131 entries[0] = lva->lvma_Entry;
3132 entries[1] = NULL;
3133
3134 /*
3135 * Add it.
3136 */
3137 ld->ld_LastAdded = NULL;
3138 rc = AddEntries(ld, entries, obj, lva->lvma_How, NULL);
3139
3140 /*
3141 * No need to compute the number of the
3142 * entry when it is added to the start or
3143 * the end of the list.
3144 */
3145 if (lva->lvma_How == LVAP_HEAD) number = 0;
3146 else if (lva->lvma_How == LVAP_TAIL) number = ld->ld_Total - 1;
3147 else
3148 {
3149 /*
3150 * Get it's number.
3151 */
3152 for (tmp = ld->ld_Entries.lvl_First, number = 0; tmp->lve_Next; tmp = tmp->lve_Next, number++)
3153 {
3154 if (tmp == ld->ld_LastAdded)
3155 break;
3156 }
3157 /*
3158 * Select the entry or make it visible
3159 * or just redraw the list.
3160 */
3161 tmp->lve_Flags |= LVEF_REFRESH;
3162 }
3163
3164 /*
3165 * New top visible entry?
3166 */
3167 if (number == ld->ld_Top)
3168 ld->ld_TopEntry = ld->ld_LastAdded;
3169
3170 /*
3171 * Make visible? Select?
3172 */
3173 DoEntry(lva->lvma_GInfo, obj, ld, lva->lvma_Flags, number);
3174
3175 return rc;
3176 }
3177 METHOD_END
3178 ///
3179 /// LVM_CLEAR
3180 /*
3181 * Clear the entire list.
3182 */
3183 METHOD(ListClassClear, struct lvmCommand *, lvc)
3184 {
3185 LD *ld = INST_DATA(cl, obj);
3186 LVE *lve;
3187 struct lvResource lvr;
3188
3189 /*
3190 * Initialize lvResource structure to kill the entry.
3191 */
3192 lvr.lvr_Command = LVRC_KILL;
3193
3194 /*
3195 * Say were busy.
3196 */
3197 ld->ld_Flags |= LDF_LIST_BUSY;
3198
3199 /*
3200 * Free all entries.
3201 */
3202 while (lve = (LVE *)RemHead((struct List *)&ld->ld_Entries))
3203 {
3204 /*
3205 * Do we have a resource hook?
3206 */
3207 if (ld->ld_Resource)
3208 {
3209 /*
3210 * Setup the entry.
3211 */
3212 lvr.lvr_Entry = lve->lve_Entry;
3213
3214 /*
3215 * Call the hook.
3216 */
3217 BGUI_CallHookPkt(ld->ld_Resource, (VOID *)obj, (VOID *)&lvr);
3218 }
3219 else
3220 {
3221 /*
3222 * Simple deallocation.
3223 */
3224 BGUI_FreePoolMem(lve->lve_Entry);
3225 };
3226 /*
3227 * Free the entry node.
3228 */
3229 BGUI_FreePoolMem(lve);
3230 }
3231
3232 /*
3233 * Zero entries.
3234 */
3235 ld->ld_Total = ld->ld_Top = 0;
3236 ld->ld_TopEntry = NULL;
3237 ld->ld_LastActive = NULL;
3238 ld->ld_LastNum = 0;
3239 ld->ld_LastAdded = NULL;
3240
3241 /*
3242 * We ain't busy no more.
3243 */
3244 ld->ld_Flags &= ~LDF_LIST_BUSY;
3245
3246 /*
3247 * Notify a NULL entry.
3248 */
3249 DoNotifyMethod(obj, lvc->lvmc_GInfo, 0, GA_ID, GADGET(obj)->GadgetID, LISTV_Entry, NULL, TAG_END);
3250
3251 /*
3252 * We need a complete refresh.
3253 */
3254 DoRenderMethod(obj, lvc->lvmc_GInfo, GREDRAW_REDRAW);
3255
3256 return 1;
3257 }
3258 METHOD_END
3259 ///
3260 /*
3261 * Find a node by it's entry data (slow!).
3262 */
3263 //STATIC ASM LVE *FindEntryData(REG(a0) LD *ld, REG(a1) APTR data, REG(a2) ULONG *number)
3264 STATIC ASM REGFUNC3(LVE *, FindEntryData,
3265 REGPARAM(A0, LD *, ld),
3266 REGPARAM(A1, APTR, data),
3267 REGPARAM(A2, ULONG *, number))
3268 {
3269 LVE *lve;
3270 ULONG num = 0;
3271
3272 for (lve = ld->ld_Entries.lvl_First; lve->lve_Next; lve = lve->lve_Next, num++)
3273 {
3274 if (lve->lve_Entry == data)
3275 {
3276 if (number) *number = num;
3277 return lve;
3278 }
3279 }
3280 return NULL;
3281 }
3282 REGFUNC_END
3283
3284 /*
3285 * Find a node by it's entry data (can be fast!).
3286 */
3287 //STATIC ASM LVE *FindEntryDataF(REG(a0) LD *ld, REG(a1) APTR data)
3288 STATIC ASM REGFUNC2(LVE *, FindEntryDataF,
3289 REGPARAM(A0, LD *, ld),
3290 REGPARAM(A1, APTR, data))
3291 {
3292 LVE *lve;
3293
3294 if (data == ld->ld_ScanEntry)
3295 return ld->ld_ScanNode;
3296
3297 for (lve = ld->ld_Entries.lvl_First; lve->lve_Next; lve = lve->lve_Next)
3298 {
3299 if (lve->lve_Entry == data)
3300 return lve;
3301 }
3302 return NULL;
3303 }
3304 REGFUNC_END
3305
3306 /// LVM_GETENTRY
3307 /*
3308 * Get an entry.
3309 */
3310 //STATIC ASM ULONG ListClassGetEntry( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct lvmGetEntry *lvg )
3311 STATIC ASM REGFUNC3(ULONG, ListClassGetEntry,
3312 REGPARAM(A0, Class *, cl),
3313 REGPARAM(A2, Object *, obj),
3314 REGPARAM(A1, struct lvmGetEntry *, lvg))
3315 {
3316 LD *ld = ( LD * )INST_DATA( cl, obj );
3317 LVE *lve;
3318 ULONG rc = 0L;
3319
3320 /*
3321 * Were busy.
3322 */
3323 ld->ld_Flags |= LDF_LIST_BUSY;
3324
3325 /*
3326 * What do they want?
3327 */
3328 switch ( lvg->MethodID ) {
3329
3330 case LVM_FIRSTENTRY:
3331 /*
3332 * The first entry.
3333 */
3334 if ( ld->ld_Total ) {
3335 /*
3336 * Selected entry?
3337 */
3338 if ( lvg->lvmg_Flags & LVGEF_SELECTED ) {
3339 /*
3340 * Scan the list.
3341 */
3342 for ( lve = ld->ld_Entries.lvl_First; lve->lve_Next; lve = lve->lve_Next ) {
3343 /*
3344 * Found?
3345 */
3346 if ( lve->lve_Flags & LVEF_SELECTED ) {
3347 ld->ld_ScanNode = lve;
3348 ld->ld_ScanEntry = lve->lve_Entry;
3349 rc = ( ULONG )lve->lve_Entry;
3350 break;
3351 }
3352 }
3353 } else {
3354 /*
3355 * Normal first entry.
3356 */
3357 if ( ld->ld_Entries.lvl_First->lve_Next ) {
3358 ld->ld_ScanNode = ld->ld_Entries.lvl_First;
3359 ld->ld_ScanEntry = ld->ld_ScanNode->lve_Entry;
3360 rc = ( ULONG )ld->ld_ScanEntry;
3361 }
3362 }
3363 }
3364 break;
3365
3366 case LVM_LASTENTRY:
3367 /*
3368 * The last entry.
3369 */
3370 if ( ld->ld_Total ) {
3371 /*
3372 * Selected entry?
3373 */
3374 if ( lvg->lvmg_Flags & LVGEF_SELECTED ) {
3375 /*
3376 * Scan the list.
3377 */
3378 for ( lve = ld->ld_Entries.lvl_Last; ; lve = lve->lve_Prev ) {
3379 /*
3380 * Found?
3381 */
3382 if ( lve->lve_Flags & LVEF_SELECTED ) {
3383 ld->ld_ScanNode = lve;
3384 ld->ld_ScanEntry = lve->lve_Entry;
3385 rc = ( ULONG )lve->lve_Entry;
3386 break;
3387 }
3388 /*
3389 * Done?
3390 */
3391 if ( lve == ld->ld_Entries.lvl_First )
3392 break;
3393 }
3394 } else {
3395 /*
3396 * Normal last entry.
3397 */
3398 if ( ld->ld_Entries.lvl_First->lve_Next ) {
3399 ld->ld_ScanNode = ld->ld_Entries.lvl_Last;
3400 ld->ld_ScanEntry = ld->ld_ScanNode->lve_Entry;
3401 rc = ( ULONG )ld->ld_ScanEntry;
3402 }
3403 }
3404 }
3405 break;
3406
3407 case LVM_NEXTENTRY:
3408 /*
3409 * Valid entry?
3410 */
3411 if ( lve = FindEntryDataF( ld, lvg->lvmg_Previous )) {
3412 /*
3413 * Is there a next one?
3414 */
3415 if ( lve != ld->ld_Entries.lvl_Last ) {
3416 /*
3417 * Selected entry?
3418 */
3419 if ( lvg->lvmg_Flags & LVGEF_SELECTED ) {
3420 /*
3421 * Scan the list.
3422 */
3423 for ( lve = lve->lve_Next; lve->lve_Next; lve = lve->lve_Next ) {
3424 /*
3425 * Found?
3426 */
3427 if ( lve->lve_Flags & LVEF_SELECTED ) {
3428 ld->ld_ScanNode = lve;
3429 ld->ld_ScanEntry = lve->lve_Entry;
3430 rc = ( ULONG )lve->lve_Entry;
3431 break;
3432 }
3433 }
3434 } else {
3435 /*
3436 * Normal next entry.
3437 */
3438 ld->ld_ScanNode = lve->lve_Next;
3439 ld->ld_ScanEntry = lve->lve_Next->lve_Entry;
3440 rc = ( ULONG )ld->ld_ScanEntry;
3441 }
3442 }
3443 }
3444 break;
3445
3446 case LVM_PREVENTRY:
3447 /*
3448 * Valid entry?
3449 */
3450 if ( lve = FindEntryDataF( ld, lvg->lvmg_Previous )) {
3451 /*
3452 * Is there a previous one?
3453 */
3454 if ( lve != ld->ld_Entries.lvl_First ) {
3455 /*
3456 * Selected entry?
3457 */
3458 if ( lvg->lvmg_Flags & LVGEF_SELECTED ) {
3459 /*
3460 * Scan the list.
3461 */
3462 for ( lve = lve->lve_Prev; ; lve = lve->lve_Prev ) {
3463 /*
3464 * Found?
3465 */
3466 if ( lve->lve_Flags & LVEF_SELECTED ) {
3467 ld->ld_ScanNode = lve;
3468 ld->ld_ScanEntry = lve->lve_Entry;
3469 rc = ( ULONG )lve->lve_Entry;
3470 break;
3471 }
3472 /*
3473 * Done?
3474 */
3475 if ( lve == ld->ld_Entries.lvl_First )
3476 break;
3477 }
3478 } else {
3479 /*
3480 * Normal previous entry.
3481 */
3482 ld->ld_ScanNode = lve->lve_Prev;
3483 ld->ld_ScanEntry = lve->lve_Prev->lve_Entry;
3484 rc = ( ULONG )ld->ld_ScanEntry;
3485 }
3486 }
3487 }
3488 break;
3489 }
3490
3491 /*
3492 * Were not busy anymore.
3493 */
3494 ld->ld_Flags &= ~LDF_LIST_BUSY;
3495 return rc;
3496 }
3497 REGFUNC_END
3498 ///
3499 /// LVM_REMENTRY
3500 /*
3501 * Remove an entry from the list.
3502 */
3503 //STATIC ASM ULONG ListClassRemEntry( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct lvmRemEntry *lvmr )
3504 STATIC ASM REGFUNC3(ULONG, ListClassRemEntry,
3505 REGPARAM(A0, Class *, cl),
3506 REGPARAM(A2, Object *, obj),
3507 REGPARAM(A1, struct lvmRemEntry *, lvmr))
3508 {
3509 LD *ld = INST_DATA(cl, obj);
3510 LVE *lve;
3511 struct lvResource lvr;
3512 ULONG rc = 0L;
3513
3514 /*
3515 * Mark us as busy.
3516 */
3517 ld->ld_Flags |= LDF_LIST_BUSY;
3518
3519 /*
3520 * Find the entry node.
3521 */
3522 if (lve = FindEntryData(ld, lvmr->lvmr_Entry, NULL))
3523 {
3524 /*
3525 * Remove the node.
3526 */
3527 Remove(( struct Node * )lve );
3528
3529 /*
3530 * The last clicked one?
3531 */
3532 if ( lve == ld->ld_LastActive ) {
3533 ld->ld_LastActive = NULL;
3534 ld->ld_LastNum = 0L;
3535 }
3536
3537 /*
3538 * Send NULL notification when this is
3539 * a single-select listview and the entry
3540 * is selected.
3541 */
3542 if (( ! ( ld->ld_Flags & LDF_MULTI_SELECT )) && ( lve->lve_Flags & LVEF_SELECTED ))
3543 DoNotifyMethod( obj, lvmr->lvmr_GInfo, 0L, GA_ID, GADGET( obj )->GadgetID, LISTV_Entry, NULL, TAG_END );
3544
3545 /*
3546 * Resource hook?
3547 */
3548 if ( ld->ld_Resource ) {
3549 /*
3550 * Init structure.
3551 */
3552 lvr.lvr_Command = LVRC_KILL;
3553 lvr.lvr_Entry = lve->lve_Entry;
3554
3555 /*
3556 * Call the hook.
3557 */
3558 rc = ( ULONG )BGUI_CallHookPkt(( void * )ld->ld_Resource, ( void * )obj, ( void * )&lvr );
3559 } else {
3560 /*
3561 * Simple de-allocation
3562 */
3563 BGUI_FreePoolMem( lve->lve_Entry );
3564 rc = 1L;
3565 }
3566 /*
3567 * Free node.
3568 */
3569 BGUI_FreePoolMem( lve );
3570
3571 /*
3572 * One less entry.
3573 */
3574 ld->ld_Total--;
3575
3576 /*
3577 * Not busy anymore.
3578 */
3579 ld->ld_Flags &= ~LDF_LIST_BUSY;
3580
3581 /*
3582 * Refresh list.
3583 */
3584 DoRenderMethod( obj, lvmr->lvmr_GInfo, GREDRAW_REDRAW );
3585 }
3586 ld->ld_Flags &= ~LDF_LIST_BUSY;
3587 return rc;
3588 }
3589 REGFUNC_END
3590 ///
3591 /// LVM_REMSELECTED
3592 /*
3593 * Remove the selected entry from the list and
3594 * select the next/previous one.
3595 */
3596 METHOD(ListClassRemSelected, struct lvmCommand *, lvmc)
3597 {
3598 LD *ld = INST_DATA(cl, obj);
3599 LVE *lve, *sel = NULL;
3600 ULONG rc = 0;
3601
3602 /*
3603 * Scan the selected entry.
3604 */
3605 while (FirstSelected(obj))
3606 {
3607 /*
3608 * Pick up it's node.
3609 */
3610 lve = ld->ld_ScanNode;
3611
3612 /*
3613 * Was it the last one?
3614 */
3615 if (lve == ld->ld_Entries.lvl_Last)
3616 {
3617 /*
3618 * Also the first one?
3619 */
3620 if (lve != ld->ld_Entries.lvl_First)
3621 {
3622 /*
3623 * No. Deselect entry and select
3624 * it's predecessor.
3625 */
3626 lve->lve_Flags &= ~LVEF_SELECTED;
3627 sel = lve->lve_Prev;
3628
3629 /*
3630 * Setup selection data.
3631 */
3632 if (lve == ld->ld_LastActive)
3633 {
3634 ld->ld_LastActive = sel;
3635 ld->ld_LastNum--;
3636 };
3637 }
3638 else
3639 {
3640 sel = NULL;
3641 };
3642 }
3643 else
3644 {
3645 /*
3646 * Deselect entry and select it's successor.
3647 */
3648 lve->lve_Flags &= ~LVEF_SELECTED;
3649 sel = lve->lve_Next;
3650
3651 /*
3652 * Setup selection data.
3653 */
3654 if (lve == ld->ld_LastActive)
3655 ld->ld_LastActive = sel;
3656 }
3657
3658 /*
3659 * Remove entry.
3660 */
3661 AsmDoMethod(obj, LVM_REMENTRY, NULL, lve->lve_Entry);
3662
3663 rc++;
3664 }
3665 if (sel)
3666 {
3667 /*
3668 * Notify new entry.
3669 */
3670 sel->lve_Flags |= (LVEF_SELECTED | LVEF_REFRESH);
3671 DoNotifyMethod(obj, lvmc->lvmc_GInfo, 0L, GA_ID, GADGET(obj)->GadgetID, LISTV_Entry, sel->lve_Entry, TAG_END);
3672 };
3673 if (rc)
3674 {
3675 AsmDoMethod(obj, LVM_REFRESH, lvmc->lvmc_GInfo);
3676 };
3677 return rc;
3678 }
3679 METHOD_END
3680 ///
3681 /// LVM_REFRESH
3682 /*
3683 * Refresh the listview.
3684 */
3685 METHOD(ListClassRefresh, struct lvmCommand *, lvmc)
3686 {
3687 return DoRenderMethod(obj, lvmc->lvmc_GInfo, GREDRAW_REDRAW);
3688 }
3689 METHOD_END
3690 ///
3691 /// LVM_REDRAW
3692 /*
3693 * Redraw the listview entries.
3694 */
3695 METHOD(ListClassRedraw, struct lvmCommand *, lvmc)
3696 {
3697 LD *ld = INST_DATA(cl, obj);
3698
3699 ld->ld_Flags |= LDF_REFRESH_ALL;
3700 return DoRenderMethod(obj, lvmc->lvmc_GInfo, GREDRAW_UPDATE);
3701 }
3702 METHOD_END
3703 ///
3704 /// LVM_REDRAWSINGLE
3705 METHOD(ListClassRedrawSingle, struct lvmRedrawSingle *, lvrs)
3706 {
3707 LD *ld = INST_DATA(cl, obj);
3708 LVE *lve;
3709 ULONG rc;
3710
3711 if (!(lvrs->lvrs_Flags & LVRF_ALL_COLUMNS))
3712 {
3713 ld->ld_OneColumn = lvrs->lvrs_Column;
3714 ld->ld_Flags |= LDF_ONE_COLUMN;
3715 };
3716
3717 if (!(lvrs->lvrs_Flags & LVRF_ALL_ENTRIES))
3718 {
3719 if (lve = FindEntryDataF(ld, lvrs->lvrs_Entry))
3720 lve->lve_Flags |= LVEF_REFRESH;
3721 }
3722 else
3723 {
3724 ld->ld_Flags |= LDF_REFRESH_ALL;
3725 };
3726 rc = DoRenderMethod(obj, lvrs->lvrs_GInfo, GREDRAW_UPDATE);
3727
3728 ld->ld_Flags &= ~LDF_ONE_COLUMN;
3729
3730 return rc;
3731 }
3732 METHOD_END
3733 ///
3734 /// LVM_SORT
3735 /*
3736 * Sort the list.
3737 */
3738 //STATIC ASM ULONG ListClassSort( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct lvmCommand *lvmc )
3739 STATIC ASM REGFUNC3(ULONG, ListClassSort,
3740 REGPARAM(A0, Class *, cl),
3741 REGPARAM(A2, Object *, obj),
3742 REGPARAM(A1, struct lvmCommand *, lvmc))
3743 {
3744 LD *ld = ( LD * )INST_DATA( cl, obj );
3745 LVE *lve;
3746 LVL buffer;
3747
3748 /*
3749 * Do we have entries?
3750 */
3751 if ( ld->ld_Total ) {
3752 /*
3753 * Were busy.
3754 */
3755 ld->ld_Flags |= LDF_LIST_BUSY;
3756
3757 /*
3758 * Initialize buffer.
3759 */
3760 NewList(( struct List * )&buffer );
3761
3762 /*
3763 * Attach all entries to the buffer.
3764 */
3765 while ( lve = ( LVE * )RemHead(( struct List * )&ld->ld_Entries ))
3766 AddTail(( struct List * )&buffer, ( struct Node * )lve );
3767
3768 /*
3769 * And put them back again sorted.
3770 */
3771 while ( lve = ( LVE * )RemHead(( struct List * )&buffer ))
3772 AddEntryInList( ld, obj, lve, LVAP_SORTED );
3773
3774 /*
3775 * Were not busy anymore.
3776 */
3777 ld->ld_Flags &= ~LDF_LIST_BUSY;
3778
3779 /*
3780 * Refresh the list.
3781 */
3782 ld->ld_Flags |= LDF_REFRESH_ALL;
3783 DoRenderMethod( obj, lvmc->lvmc_GInfo, GREDRAW_UPDATE );
3784 }
3785 return 1;
3786 }
3787 REGFUNC_END
3788 ///
3789 /// LVM_LOCK, LVM_UNLOCK
3790 /*
3791 * (Un)lock the list.
3792 */
3793 //STATIC ASM ULONG ListClassLock( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct lvmCommand *lvmc )
3794 STATIC ASM REGFUNC3(ULONG, ListClassLock,
3795 REGPARAM(A0, Class *, cl),
3796 REGPARAM(A2, Object *, obj),
3797 REGPARAM(A1, struct lvmCommand *, lvmc))
3798 {
3799 LD *ld = INST_DATA(cl, obj);
3800
3801 switch (lvmc->MethodID)
3802 {
3803 case LVM_LOCKLIST:
3804 ld->ld_Flags |= LDF_LIST_BUSY;
3805 break;
3806
3807 case LVM_UNLOCKLIST:
3808 ld->ld_Flags &= ~LDF_LIST_BUSY;
3809 DoRenderMethod(obj, lvmc->lvmc_GInfo, GREDRAW_REDRAW);
3810 break;
3811 }
3812 return 1;
3813 }
3814 REGFUNC_END
3815 ///
3816 /// LVM_MOVE
3817 /*
3818 * Move an entry.
3819 */
3820 //STATIC ASM ULONG ListClassMove( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct lvmMove *lvm )
3821 STATIC ASM REGFUNC3(ULONG, ListClassMove,
3822 REGPARAM(A0, Class *, cl),
3823 REGPARAM(A2, Object *, obj),
3824 REGPARAM(A1, struct lvmMove *, lvm))
3825 {
3826 LD *ld = ( LD * )INST_DATA( cl, obj );
3827 LVE *lve, *tmp;
3828 ULONG rc = 0L, num = 0L, cpos;
3829
3830 /*
3831 * Look up the entry.
3832 */
3833 if ( ! lvm->lvmm_Entry ) lve = ld->ld_LastActive;
3834 else lve = FindEntryData( ld, lvm->lvmm_Entry, &cpos );
3835
3836 if ( lve ) {
3837 /*
3838 * Lock the list.
3839 */
3840 ld->ld_Flags |= LDF_LIST_BUSY;
3841
3842 /*
3843 * Move to?
3844 */
3845 switch ( lvm->lvmm_Direction ) {
3846
3847 case LVMOVE_UP:
3848 /*
3849 * Already at the top?
3850 */
3851 if ( lve != ld->ld_Entries.lvl_First ) {
3852 /*
3853 * Pick up new predeccessor.
3854 */
3855 tmp = lve->lve_Prev->lve_Prev;
3856
3857 /*
3858 * Do it.
3859 */
3860 goto insertIt;
3861 }
3862 break;
3863
3864 case LVMOVE_DOWN:
3865 /*
3866 * Already at the bottom?
3867 */
3868 if ( lve != ld->ld_Entries.lvl_Last ) {
3869 /*
3870 * Pick up new predeccessor.
3871 */
3872 tmp = lve->lve_Next;
3873
3874 insertIt:
3875
3876 /*
3877 * Remove the node.
3878 */
3879 Remove(( struct Node * )lve );
3880
3881 /*
3882 * Insert it into it's new spot.
3883 */
3884 Insert(( struct List * )&ld->ld_Entries, ( struct Node * )lve, ( struct Node * )tmp );
3885 rc = 1L;
3886 }
3887 break;
3888
3889 case LVMOVE_TOP:
3890 /*
3891 * Already at the top?
3892 */
3893 if ( lve != ld->ld_Entries.lvl_First ) {
3894 /*
3895 * Remove the node.
3896 */
3897 Remove(( struct Node * )lve );
3898
3899 /*
3900 * Insert it into it's new spot.
3901 */
3902 AddHead(( struct List * )&ld->ld_Entries, ( struct Node * )lve );
3903
3904 /*
3905 * The number is known.
3906 */
3907 num = 0;
3908 rc = 1L;
3909 ld->ld_Flags &= ~LDF_LIST_BUSY;
3910 goto gotNum;
3911 }
3912 break;
3913
3914 case LVMOVE_BOTTOM:
3915 /*
3916 * Already at the bottom?
3917 */
3918 if ( lve != ld->ld_Entries.lvl_Last ) {
3919 /*
3920 * Remove the node.
3921 */
3922 Remove(( struct Node * )lve );
3923
3924 /*
3925 * Insert it into it's new spot.
3926 */
3927 AddTail(( struct List * )&ld->ld_Entries, ( struct Node * )lve );
3928
3929 /*
3930 * The number is known.
3931 */
3932 num = ld->ld_Total - 1;
3933 rc = 1L;
3934 ld->ld_Flags &= ~LDF_LIST_BUSY;
3935 goto gotNum;
3936 }
3937 break;
3938
3939 case LVMOVE_NEWPOS:
3940 /*
3941 * Current position changed?
3942 */
3943 if ( cpos != lvm->lvmm_NewPos ) {
3944 /*
3945 * New position 0?
3946 */
3947 if ( lvm->lvmm_NewPos == 0 ) {
3948 Remove(( struct Node * )lve );
3949 AddHead(( struct List * )&ld->ld_Entries, ( struct Node * )lve );
3950 num = 0;
3951 } else if ( lvm->lvmm_NewPos >= ld->ld_Total ) {
3952 Remove(( struct Node * )lve );
3953 AddTail(( struct List * )&ld->ld_Entries, ( struct Node * )lve );
3954 num = ld->ld_Total - 1;
3955 } else {
3956 /*
3957 * Not at the start and not at the end. Find the predecessor
3958 * of the place we drop the this node.
3959 */
3960 tmp = FindNodeQuick( ld, lvm->lvmm_NewPos - 1 );
3961
3962 /*
3963 * If we are our precedecessor ourselves
3964 * we take the one before us.
3965 */
3966 if ( tmp == lve ) tmp = tmp->lve_Prev;
3967
3968 /*
3969 * Remove the node from it's current location
3970 * and insert back in it's new place.
3971 */
3972 Remove(( struct Node * )lve );
3973 Insert(( struct List * )&ld->ld_Entries, ( struct Node * )lve, ( struct Node * )tmp );
3974
3975 /*
3976 * The number is known.
3977 */
3978 num = lvm->lvmm_NewPos;
3979 }
3980 rc = 1L;
3981 ld->ld_Flags &= ~LDF_LIST_BUSY;
3982 goto gotNum;
3983 }
3984 break;
3985 }
3986 /*
3987 * List changed?
3988 */
3989 if ( rc ) {
3990 /*
3991 * Not busy anymore.
3992 */
3993 ld->ld_Flags &= ~LDF_LIST_BUSY;
3994
3995 /*
3996 * Find out it's number.
3997 */
3998 for ( tmp = ld->ld_Entries.lvl_First; tmp->lve_Next; tmp = tmp->lve_Next, num++ ) {
3999 /*
4000 * Is this the one?
4001 */
4002 if ( tmp == lve ) {
4003 gotNum:
4004 /*
4005 * Was it selected?
4006 */
4007 if (lve->lve_Flags & LVEF_SELECTED)
4008 /*
4009 * Setup it's number.
4010 */
4011 ld->ld_LastNum = num;
4012
4013 /*
4014 * Make the moved entry visible.
4015 */
4016 ld->ld_Flags |= LDF_REFRESH_ALL;
4017 DoSetMethod( obj, lvm->lvmm_GInfo, LISTV_MakeVisible, num, TAG_END );
4018
4019 /*
4020 * Notify and setup the new position.
4021 */
4022 DoNotifyMethod( obj, lvm->lvmm_GInfo, 0L, GA_ID, GADGET( obj )->GadgetID, LISTV_NewPosition, num, TAG_END );
4023 ld->ld_NewPos = num;
4024 return rc;
4025 }
4026 }
4027 }
4028 }
4029 /*
4030 * Not busy anymore.
4031 */
4032 ld->ld_Flags &= ~LDF_LIST_BUSY;
4033 return rc;
4034 }
4035 REGFUNC_END
4036 ///
4037 /// LVM_REPLACE
4038 /*
4039 * Replace an entry.
4040 */
4041 //STATIC ASM ULONG ListClassReplace( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct lvmReplace *lvmr )
4042 STATIC ASM REGFUNC3(ULONG, ListClassReplace,
4043 REGPARAM(A0, Class *, cl),
4044 REGPARAM(A2, Object *, obj),
4045 REGPARAM(A1, struct lvmReplace *, lvmr))
4046 {
4047 LD *ld = ( LD * )INST_DATA( cl, obj );
4048 LVE *lvo;
4049 struct lvResource lvr;
4050 APTR newdata;
4051 ULONG rc = 0L;
4052
4053 /*
4054 * Data OK?
4055 */
4056 if (( ! lvmr->lvmr_OldEntry ) || ( ! lvmr->lvmr_NewEntry ))
4057 return( 0L );
4058
4059 /*
4060 * Were busy.
4061 */
4062 ld->ld_Flags |= LDF_LIST_BUSY;
4063
4064 /*
4065 * Find the old entry.
4066 */
4067 if (lvo = FindEntryData(ld, lvmr->lvmr_OldEntry, NULL))
4068 {
4069 /*
4070 * Create the new entry.
4071 */
4072 if ( ld->ld_Resource ) {
4073 /*
4074 * Init structure.
4075 */
4076 lvr.lvr_Command = LVRC_MAKE;
4077 lvr.lvr_Entry = lvmr->lvmr_NewEntry;
4078
4079 /*
4080 * Call the hook.
4081 */
4082 if ( newdata = ( APTR )BGUI_CallHookPkt(( void * )ld->ld_Resource, ( void * )obj, ( void * )&lvr )) {
4083 /*
4084 * Free the old entry and setup the new one.
4085 */
4086 lvr.lvr_Command = LVRC_KILL;
4087 lvr.lvr_Entry = lvmr->lvmr_OldEntry;
4088 BGUI_CallHookPkt(( void * )ld->ld_Resource, ( void * )obj, ( void * )&lvr );
4089 lvo->lve_Entry = newdata;
4090 lvo->lve_Flags |= LVEF_REFRESH;
4091 rc = ( ULONG )newdata;
4092 }
4093 } else {
4094 /*
4095 * Allocate a string copy of the new data.
4096 */
4097 if ( newdata = ( APTR )BGUI_AllocPoolMem( strlen(( UBYTE * )lvmr->lvmr_NewEntry ) + 1 )) {
4098 /*
4099 * Copy it.
4100 */
4101 strcpy(( UBYTE * )newdata, ( UBYTE * )lvmr->lvmr_NewEntry );
4102
4103 /*
4104 * Free the old entry, and setup the new one.
4105 */
4106 BGUI_FreePoolMem( lvmr->lvmr_OldEntry );
4107 lvo->lve_Entry = newdata;
4108 lvo->lve_Flags |= LVEF_REFRESH;
4109 rc = ( ULONG )newdata;
4110 }
4111 }
4112 }
4113
4114 /*
4115 * Were not busy anymore.
4116 */
4117 ld->ld_Flags &= ~LDF_LIST_BUSY;
4118
4119 if ( rc ) DoRenderMethod( obj, lvmr->lvmr_GInfo, GREDRAW_UPDATE );
4120 return( rc );
4121 }
4122 REGFUNC_END
4123 ///
4124 /// LVM_SETCOLUMNATTRS
4125
4126 METHOD(ListClassSetColumnAttrs, struct lvmColumnAttrs *, lvca)
4127 {
4128 LD *ld = INST_DATA(cl, obj);
4129 ULONG rc;
4130
4131 rc = BGUI_PackStructureTags(&ld->ld_CD[lvca->lvca_Column], ColumnPackTable, (struct TagItem *)&lvca->lvca_AttrList);
4132
4133 if (rc) AsmDoMethod(obj, LVM_REDRAW, lvca->lvca_GInfo);
4134
4135 return rc;
4136 }
4137 METHOD_END
4138 ///
4139 /// LVM_GETCOLUMNATTRS
4140
4141 METHOD(ListClassGetColumnAttrs, struct lvmColumnAttrs *, lvca)
4142 {
4143 LD *ld = INST_DATA(cl, obj);
4144
4145 return BGUI_UnpackStructureTags(&ld->ld_CD[lvca->lvca_Column], ColumnPackTable, (struct TagItem *)&lvca->lvca_AttrList);
4146 }
4147 METHOD_END
4148 ///
4149 /// BASE_DRAGQUERY
4150 /*
4151 * Query if we accept data from the dragged object. We only accept when:
4152 *
4153 * A) The querying object is us.
4154 * B) We are in LISTV_ShowDropSpot mode.
4155 * C) The mouse is located inside the list view area.
4156 *
4157 * All other instances are refused.
4158 */
4159 METHOD(ListClassDragQuery, struct bmDragPoint *, bmdp)
4160 {
4161 LD *ld = INST_DATA( cl, obj );
4162
4163 if (bmdp->bmdp_Source == obj && ld->ld_Flags & LDF_SHOWDROPSPOT)
4164 {
4165 if (bmdp->bmdp_Mouse.X >= 0 &&
4166 bmdp->bmdp_Mouse.Y >= 0 &&
4167 bmdp->bmdp_Mouse.X < ld->ld_InnerBox.Width &&
4168 bmdp->bmdp_Mouse.Y < ld->ld_InnerBox.Height)
4169 return BQR_ACCEPT;
4170 }
4171 return BQR_REJECT;
4172 }
4173 METHOD_END
4174 ///
4175 /// BASE_DRAGACTIVE
4176 /*
4177 * Show us being the active drop object.
4178 */
4179 METHOD(ListClassDragActive, struct bmDragMsg *, bmdm)
4180 {
4181 LD *ld = INST_DATA(cl, obj);
4182 struct BaseInfo *bi;
4183
4184 ld->ld_DropSpot=ld->ld_DrawSpot = ~0;
4185
4186 /*
4187 * Drop anywhere or do we have to mark the spot?
4188 */
4189 if ((!(ld->ld_Flags & LDF_SHOWDROPSPOT)) || (!ld->ld_Entries.lvl_First->lve_Next))
4190 {
4191 /*
4192 * Anywhere or the list is empty. Simply place a dotted line around the view area.
4193 */
4194 #ifdef DEBUG_BGUI
4195 if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, bmdm->bmdm_GInfo, BI_RastPort, NULL, TAG_DONE))
4196 #else
4197 if (bi = AllocBaseInfo(BI_GadgetInfo, bmdm->bmdm_GInfo, BI_RastPort, NULL, TAG_DONE))
4198 #endif
4199 {
4200 ld->ld_Flags |= LDF_MOVE_DROPBOX;
4201 /*
4202 * Draw the box.
4203 */
4204 DottedBox(bi, &ld->ld_InnerBox);
4205 FreeBaseInfo(bi);
4206 };
4207 };
4208 return 1;
4209 }
4210 METHOD_END
4211 ///
4212 /// BASE_DRAGINACTIVE
4213 /*
4214 * Deactivate.
4215 */
4216 //STATIC ASM ULONG ListClassDragInactive( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct bmDragMsg *bmdm )
4217 STATIC ASM REGFUNC3(ULONG, ListClassDragInactive,
4218 REGPARAM(A0, Class *, cl),
4219 REGPARAM(A2, Object *, obj),
4220 REGPARAM(A1, struct bmDragMsg *, bmdm))
4221 {
4222 LD *ld = INST_DATA(cl, obj);
4223
4224 /*
4225 * Clear drop spot.
4226 */
4227 if (ld->ld_LineBuffer)
4228 {
4229 BGUI_FreeRPortBitMap(ld->ld_LineBuffer);
4230 ld->ld_LineBuffer = NULL;
4231 };
4232 ld->ld_DropSpot = ~0;
4233 ld->ld_Flags &= ~LDF_MOVE_DROPBOX;
4234
4235 return AsmDoSuperMethodA(cl, obj, (Msg)bmdm);
4236 }
4237 REGFUNC_END
4238 ///
4239 /// BASE_DRAGUPDATE
4240 /*
4241 * Update drop position.
4242 */
4243 METHOD(ListClassDragUpdate, struct bmDragPoint *, bmdp)
4244 {
4245 LD *ld = INST_DATA(cl, obj);
4246 struct IBox *ib;
4247 struct GadgetInfo *gi = bmdp->bmdp_GInfo;
4248 struct BaseInfo *bi;
4249
4250 int dpos, otop = ld->ld_Top, ntop = otop;
4251
4252 int x = bmdp->bmdp_Mouse.X;
4253 int y = bmdp->bmdp_Mouse.Y;
4254 int x1, y1, w, h;
4255
4256 if (ld->ld_Flags & LDF_MOVE_DROPBOX)
4257 {
4258 #ifdef DEBUG_BGUI
4259 if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
4260 #else
4261 if (bi = AllocBaseInfo(BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
4262 #endif
4263 {
4264 DottedBox(bi, &ld->ld_InnerBox);
4265 FreeBaseInfo(bi);
4266 };
4267 };
4268
4269 /*
4270 * Keep track of the drop position?
4271 */
4272 if (ld->ld_Flags & LDF_SHOWDROPSPOT && ld->ld_Entries.lvl_First->lve_Next)
4273 {
4274 /*
4275 * Reject when we are out of the list bounds.
4276 */
4277 if ((x < 0) || (x >= ld->ld_InnerBox.Width))
4278 {
4279 /*
4280 * We deactivate when the mouse has left us out of the hitbox.
4281 */
4282 ld->ld_DropSpot = ld->ld_DrawSpot = ~0;
4283 return BUR_ABORT;
4284 };
4285
4286 /*
4287 * Make the y position relative to the window.
4288 */
4289 Get_SuperAttr(cl, obj, BT_HitBox, &ib);
4290 y += ib->Top + (ld->ld_EntryHeight >> 1);
4291
4292 /*
4293 * Get the entry under the mouse.
4294 */
4295 dpos = MouseOverEntry(ld, y);
4296
4297 /*
4298 * New position above or below the
4299 * visible entries?
4300 */
4301 if (dpos < ntop)
4302 {
4303 dpos = --ntop;
4304 }
4305 else if (dpos > (ntop + ld->ld_Visible))
4306 {
4307 dpos = ++ntop + ld->ld_Visible;
4308 }
4309
4310 if (ntop > ld->ld_Total - ld->ld_Visible)
4311 ntop = ld->ld_Total - ld->ld_Visible;
4312 if (ntop < 0) ntop = 0;
4313
4314 if (dpos < 0) dpos = 0;
4315 if (dpos > ld->ld_Total) dpos = ld->ld_Total;
4316
4317 /*
4318 * Position changed?
4319 */
4320 if (dpos != ld->ld_DropSpot)
4321 {
4322 /*
4323 * Yes. Get RastPort.
4324 */
4325 if (gi)
4326 {
4327 x1 = ld->ld_ListArea.Left;
4328 y1 = ld->ld_ListArea.Top;
4329 w = ld->ld_ListArea.Width;
4330 h = ld->ld_ListArea.Height;
4331
4332 /*
4333 * Re-render the current entry.
4334 */
4335 if ((ld->ld_DrawSpot != (UWORD)~0) && ld->ld_LineBuffer)
4336 {
4337 #ifdef DEBUG_BGUI
4338 if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
4339 #else
4340 if (bi = AllocBaseInfo(BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
4341 #endif
4342 {
4343 /*
4344 * Fix line at the old position.
4345 */
4346 ClipBlit(ld->ld_LineBuffer, 0, 0, bi->bi_RPort, x1, ld->ld_DrawSpot, w, 1, 0xC0);
4347 FreeBaseInfo(bi);
4348 };
4349 };
4350
4351 /*
4352 * Scroll if necessary.
4353 */
4354 if (ntop != otop)
4355 {
4356 DoSetMethod(obj, gi, LISTV_Top, ntop, TAG_DONE);
4357 };
4358
4359 /*
4360 * Mark new position.
4361 */
4362 ld->ld_DropSpot = dpos;
4363
4364 /*
4365 * Setup y position.
4366 */
4367 y = range((dpos - ld->ld_Top) * ld->ld_EntryHeight, 0, h - 1) + y1;
4368
4369 ld->ld_DrawSpot = y;
4370
4371 #ifdef DEBUG_BGUI
4372 if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
4373 #else
4374 if (bi = AllocBaseInfo(BI_GadgetInfo, gi, BI_RastPort, NULL, TAG_DONE))
4375 #endif
4376 {
4377 if (!ld->ld_LineBuffer) ld->ld_LineBuffer = BGUI_CreateRPortBitMap(bi->bi_RPort, w, 1, 0);
4378
4379 if (ld->ld_LineBuffer)
4380 {
4381 /*
4382 * Copy the old line to a buffer.
4383 */
4384 ClipBlit(bi->bi_RPort, x1, y, ld->ld_LineBuffer, 0, 0, w, 1, 0xC0);
4385
4386 /*
4387 * Render line at the new position.
4388 */
4389 SetDashedLine(bi, 0);
4390 HLine(bi->bi_RPort, x1, y, x1 + w - 1);
4391 };
4392 FreeBaseInfo(bi);
4393 };
4394 };
4395 };
4396 }
4397 else
4398 {
4399 /*
4400 * Reject when we are out of the list bounds.
4401 */
4402 if ((x < 0) || (x >= ld->ld_InnerBox.Width) ||
4403 (y < 0) || (y >= ld->ld_InnerBox.Height))
4404 {
4405 /*
4406 * We deactivate when the mouse has left us out of the hitbox.
4407 */
4408 return BUR_ABORT;
4409 };
4410 };
4411 return BUR_CONTINUE;
4412 }
4413 METHOD_END
4414 ///
4415 /// BASE_DROPPED
4416 /*
4417 * We have been dropped upon.
4418 */
4419 //STATIC ASM ULONG ListClassDropped( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct bmDropped *bmd )
4420 STATIC ASM REGFUNC3(ULONG, ListClassDropped,
4421 REGPARAM(A0, Class *, cl),
4422 REGPARAM(A2, Object *, obj),
4423 REGPARAM(A1, struct bmDropped *, bmd))
4424 {
4425 LD *ld = ( LD * )INST_DATA( cl, obj );
4426 struct MinList buffer;
4427 LVE *lve, *tmp, *pred = NULL;
4428 ULONG spot = ld->ld_DropSpot, pos = 0;
4429
4430 if(spot==~0)
4431 return(1);
4432 /*
4433 * Initialize buffer list.
4434 */
4435 NewList(( struct List * )&buffer );
4436
4437 /*
4438 * Were busy buddy.
4439 */
4440 ld->ld_Flags |= LDF_LIST_BUSY;
4441
4442 /*
4443 * Were we dropped in the list?
4444 */
4445 if ( spot ) {
4446 /*
4447 * Find the drop-position node.
4448 */
4449 if ( spot == 1 ) {
4450 pos = 0;
4451 pred = ld->ld_Entries.lvl_First;
4452 /*
4453 * We do make this the predecessor
4454 * if it's selected.
4455 */
4456 if ( pred->lve_Flags & LVEF_SELECTED )
4457 pred = NULL;
4458 } else if ( spot >= ld->ld_Total ) {
4459 pos = ld->ld_Total - 1;
4460 pred = ld->ld_Entries.lvl_Last;
4461 } else {
4462 pred = FindNodeQuick( ld, spot - 1 );
4463 if ( spot > ld->ld_LastNum ) pos = spot - 1;
4464 else pos = spot;
4465 }
4466
4467 /*
4468 * Now we have to scan back from the drop
4469 * position to find the first not selected
4470 * entry node.
4471 */
4472 if ( pred ) {
4473 while ( pred->lve_Flags & LVEF_SELECTED ) {
4474 /*
4475 * Get previous entry.
4476 */
4477 pred = pred->lve_Prev;
4478
4479 /*
4480 * Is it the first one and still selected?
4481 */
4482 if ( pred == ld->ld_Entries.lvl_First && pred->lve_Flags & LVEF_SELECTED ) {
4483 pred = NULL;
4484 break;
4485 }
4486 }
4487 }
4488 }
4489
4490 /*
4491 * Remove all selected entries and append them to the buffer.
4492 */
4493 lve = ld->ld_Entries.lvl_First;
4494
4495 /*
4496 * Clear the last-active data.
4497 */
4498 ld->ld_LastActive = NULL;
4499 ld->ld_LastNum = 0;
4500
4501 while ( lve->lve_Next ) {
4502 /*
4503 * Is this a selected entry?
4504 */
4505 if ( lve->lve_Flags & LVEF_SELECTED ) {
4506 /*
4507 * Mark successor.
4508 */
4509 tmp = lve->lve_Next;
4510
4511 /*
4512 * Remove from the list and
4513 * append it to the buffer.
4514 */
4515 Remove(( struct Node * )lve );
4516 AddTail(( struct List * )&buffer, ( struct Node * )lve );
4517
4518 /*
4519 * Make the successor current.
4520 */
4521 lve = tmp;
4522 } else
4523 /*
4524 * Next please.
4525 */
4526 lve = lve->lve_Next;
4527 }
4528
4529 /*
4530 * Move 'm back into their new position.
4531 */
4532 while ( lve = ( LVE * )RemHead(( struct List * )&buffer )) {
4533 if ( ! ld->ld_LastActive ) {
4534 ld->ld_LastActive = lve;
4535 ld->ld_LastNum = pos;
4536 }
4537 if ( ! pred ) AddHead(( struct List * )&ld->ld_Entries, ( struct Node * )lve );
4538 else Insert(( struct List * )&ld->ld_Entries, ( struct Node * )lve, ( struct Node * )pred );
4539 pred = lve;
4540 }
4541
4542 /*
4543 * We are not busy anymore.
4544 */
4545 ld->ld_Flags &= ~LDF_LIST_BUSY;
4546 ld->ld_DropSpot = ~0;
4547
4548 return 1;
4549 }
4550 REGFUNC_END
4551 ///
4552 /// BASE_GETOBJECT
4553 /*
4554 * Create a rastport in which the selected entries(s) are rendered.
4555 */
4556 METHOD(ListClassGetObject, struct bmGetDragObject *, bmgo)
4557 {
4558 LD *ld = INST_DATA(cl, obj);
4559 struct GadgetInfo *gi = bmgo->bmgo_GInfo;
4560 struct RastPort *drag_rp, *rp = &gi->gi_Screen->RastPort;
4561 APTR entry;
4562 struct IBox box;
4563 ULONG rc = 0, num, i = 0;
4564 int depth = gi->gi_DrInfo->dri_Depth;
4565 struct BaseInfo *bi;
4566
4567 int lx = ld->ld_ListArea.Left;
4568 int ly = ld->ld_ListArea.Top;
4569 int lw = ld->ld_ListArea.Width;
4570 int lh = ld->ld_ListArea.Height;
4571 int eh = ld->ld_EntryHeight;
4572 int mx = gi->gi_Window->MouseX;
4573 int my = gi->gi_Window->MouseY;
4574
4575 /*
4576 * Do we have any selected entries?
4577 */
4578 if (entry = (APTR)FirstSelected(obj))
4579 {
4580 /*
4581 * Count the number of selected entries.
4582 */
4583 for (num = 0; entry && (num <= 10); num++)
4584 {
4585 entry = (APTR)NextSelected(obj, entry);
4586 };
4587
4588 /*
4589 * Less than the maximum?
4590 */
4591 if (num <= 10)
4592 {
4593 /*
4594 * Allocate the rastport.
4595 */
4596 if (drag_rp = BGUI_CreateRPortBitMap(rp, lw, num * lh, depth))
4597 {
4598 #ifdef DEBUG_BGUI
4599 if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, gi, BI_RastPort, drag_rp, TAG_DONE))
4600 #else
4601 if (bi = AllocBaseInfo(BI_GadgetInfo, gi, BI_RastPort, drag_rp, TAG_DONE))
4602 #endif
4603 {
4604 BSetFont(bi, ld->ld_Font);
4605 ColumnSeparators(ld, bi, 0, 0, num * ld->ld_EntryHeight);
4606
4607 /*
4608 * Render them...
4609 */
4610 entry = (APTR)FirstSelected(obj);
4611 do
4612 {
4613 RenderEntry(obj, ld, bi, ld->ld_ScanNode, REL_ZERO | i++);
4614 } while (entry = (APTR)NextSelected(obj, entry));
4615 setIt:
4616
4617 /*
4618 * Setup the rastport so we can
4619 * deallocate it later.
4620 */
4621 ld->ld_DragRP = drag_rp;
4622
4623 /*
4624 * Setup bounds.
4625 */
4626 bmgo->bmgo_Bounds->Left = lx;
4627 bmgo->bmgo_Bounds->Top = my - ((num * eh) >> 1);
4628 bmgo->bmgo_Bounds->Width = lw;
4629 bmgo->bmgo_Bounds->Height = num * eh;
4630
4631 /*
4632 * Return a pointer to the bitmap.
4633 */
4634 rc = (ULONG)drag_rp->BitMap;
4635
4636 if(bi) FreeBaseInfo(bi);
4637 };
4638 }
4639 }
4640 else
4641 {
4642 /*
4643 * More than 10 entries is a special case.
4644 */
4645 if (drag_rp = BGUI_CreateRPortBitMap(rp, lw, 3 * eh, depth))
4646 {
4647 #ifdef DEBUG_BGUI
4648 if (bi = AllocBaseInfoDebug(__FILE__,__LINE__,BI_GadgetInfo, gi, BI_RastPort, drag_rp, TAG_DONE))
4649 #else
4650 if (bi = AllocBaseInfo(BI_GadgetInfo, gi, BI_RastPort, drag_rp, TAG_DONE))
4651 #endif
4652 {
4653 BSetFont(bi, ld->ld_Font);
4654 ColumnSeparators(ld, bi, 0, 0, 3 * ld->ld_EntryHeight);
4655
4656 /*
4657 * Render the first entry...
4658 */
4659 FirstSelected(obj);
4660 RenderEntry(obj, ld, bi, ld->ld_ScanNode, REL_ZERO | 0);
4661
4662 /*
4663 * Setup rendering bounds.
4664 */
4665 box.Left = 0;
4666 box.Top = eh;
4667 box.Width = lw;
4668 box.Height = eh;
4669
4670 /*
4671 * Jam special text...
4672 */
4673 RenderText(bi, "\33d3\33D5--->", &box);
4674
4675 /*
4676 * Render the last entry...
4677 */
4678 LastSelected(obj);
4679 RenderEntry(obj, ld, bi, ld->ld_ScanNode, REL_ZERO | 2);
4680
4681 FreeBaseInfo(bi); bi=NULL;
4682 };
4683
4684 num = 3;
4685 goto setIt;
4686 }
4687 }
4688 }
4689 return rc;
4690 }
4691 METHOD_END
4692 ///
4693 /// BASE_FREEOBJECT
4694 /*
4695 * Free the dragged object.
4696 */
4697 //STATIC ASM ULONG ListClassFreeObject( REG(a0) Class *cl, REG(a2) Object *obj, REG(a1) struct bmFreeDragObject *bmfo )
4698 STATIC ASM REGFUNC3(ULONG, ListClassFreeObject,
4699 REGPARAM(A0, Class *, cl),
4700 REGPARAM(A2, Object *, obj),
4701 REGPARAM(A1, struct bmFreeDragObject *, bmfo))
4702 {
4703 LD *ld = INST_DATA( cl, obj );
4704
4705 /*
4706 * Simply deallocate the bitmap and rastport.
4707 */
4708 BGUI_FreeRPortBitMap( ld->ld_DragRP );
4709 ld->ld_DragRP = NULL;
4710
4711 return 1;
4712 }
4713 REGFUNC_END
4714 ///
4715
4716 /// Class initialization.
4717 /*
4718 * Function table.
4719 */
4720 STATIC DPFUNC ClassFunc[] = {
4721 BASE_RENDER, (FUNCPTR)ListClassRender,
4722 BASE_LAYOUT, (FUNCPTR)ListClassLayout,
4723 BASE_DIMENSIONS, (FUNCPTR)ListClassDimensions,
4724
4725 OM_NEW, (FUNCPTR)ListClassNew,
4726 OM_SET, (FUNCPTR)ListClassSetUpdate,
4727 OM_UPDATE, (FUNCPTR)ListClassSetUpdate,
4728 OM_GET, (FUNCPTR)ListClassGet,
4729 OM_DISPOSE, (FUNCPTR)ListClassDispose,
4730 GM_HITTEST, (FUNCPTR)ListClassHitTest,
4731 GM_GOACTIVE, (FUNCPTR)ListClassGoActive,
4732 GM_HANDLEINPUT, (FUNCPTR)ListClassHandleInput,
4733 GM_GOINACTIVE, (FUNCPTR)ListClassGoInActive,
4734 WM_KEYACTIVE, (FUNCPTR)ListClassKeyActive,
4735 LVM_ADDENTRIES, (FUNCPTR)ListClassAddEntries,
4736 LVM_INSERTENTRIES, (FUNCPTR)ListClassInsertEntries,
4737 LVM_ADDSINGLE, (FUNCPTR)ListClassAddSingle,
4738 LVM_INSERTSINGLE, (FUNCPTR)ListClassInsertSingle,
4739 LVM_CLEAR, (FUNCPTR)ListClassClear,
4740 LVM_FIRSTENTRY, (FUNCPTR)ListClassGetEntry,
4741 LVM_LASTENTRY, (FUNCPTR)ListClassGetEntry,
4742 LVM_NEXTENTRY, (FUNCPTR)ListClassGetEntry,
4743 LVM_PREVENTRY, (FUNCPTR)ListClassGetEntry,
4744 LVM_REMENTRY, (FUNCPTR)ListClassRemEntry,
4745 LVM_REFRESH, (FUNCPTR)ListClassRefresh,
4746 LVM_REDRAW, (FUNCPTR)ListClassRedraw,
4747 LVM_REDRAWSINGLE, (FUNCPTR)ListClassRedrawSingle,
4748 LVM_SORT, (FUNCPTR)ListClassSort,
4749 LVM_LOCKLIST, (FUNCPTR)ListClassLock,
4750 LVM_UNLOCKLIST, (FUNCPTR)ListClassLock,
4751 LVM_REMSELECTED, (FUNCPTR)ListClassRemSelected,
4752 LVM_MOVE, (FUNCPTR)ListClassMove,
4753 LVM_REPLACE, (FUNCPTR)ListClassReplace,
4754 LVM_SETCOLUMNATTRS, (FUNCPTR)ListClassSetColumnAttrs,
4755 LVM_GETCOLUMNATTRS, (FUNCPTR)ListClassGetColumnAttrs,
4756 BASE_DRAGQUERY, (FUNCPTR)ListClassDragQuery,
4757 BASE_DRAGACTIVE, (FUNCPTR)ListClassDragActive,
4758 BASE_DRAGINACTIVE, (FUNCPTR)ListClassDragInactive,
4759 BASE_DRAGUPDATE, (FUNCPTR)ListClassDragUpdate,
4760 BASE_DROPPED, (FUNCPTR)ListClassDropped,
4761 BASE_GETDRAGOBJECT, (FUNCPTR)ListClassGetObject,
4762 BASE_FREEDRAGOBJECT, (FUNCPTR)ListClassFreeObject,
4763 DF_END, NULL
4764 };
4765
4766 /*
4767 * Simple class initialization.
4768 */
4769 makeproto Class *InitListClass(void)
4770 {
4771 return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_BASE_GADGET,
4772 CLASS_ObjectSize, sizeof(LD),
4773 CLASS_DFTable, ClassFunc,
4774 TAG_DONE);
4775 }
4776 ///
Mirror of AROS' Contrib svn.