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