?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixes to comments.
[AROS.git] / workbench / system / Wanderer / Classes / iconlist.c
blob5d080c9e8933b1bb081c3011159e74249e497856
1 /*
2 Copyright © 2001-2012, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #include "../portable_macros.h"
7 #if !defined(__AROS__)
8 #define WANDERER_BUILTIN_ICONLIST 1
9 #else
10 #define DEBUG 0
11 #include <aros/debug.h>
12 #endif
13
14 //#define DEBUG_ILC_FUNCS
15 //#define DEBUG_ILC_ATTRIBS
16 //#define DEBUG_ILC_EVENTS
17 //#define DEBUG_ILC_KEYEVENTS
18 //#define DEBUG_ILC_ICONDRAGDROP
19 //#define DEBUG_ILC_ICONRENDERING
20 //#define DEBUG_ILC_ICONSORTING
21 //#define DEBUG_ILC_ICONSORTING_DUMP
22 //#define DEBUG_ILC_ICONPOSITIONING
23 //#define DEBUG_ILC_LASSO
24 //#define DEBUG_ILC_MEMALLOC
25
26 #define CREATE_FULL_DRAGIMAGE
27
28 #include <string.h>
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <math.h>
33
34 #include <dos/dos.h>
35 #include <dos/datetime.h>
36 #include <dos/filehandler.h>
37
38 #include <exec/memory.h>
39 #include <graphics/gfx.h>
40 #include <graphics/view.h>
41 #include <graphics/rpattr.h>
42 #include <workbench/icon.h>
43 #include <workbench/workbench.h>
44
45 #if defined(__AROS__)
46 #include <devices/rawkeycodes.h>
47 #include <clib/alib_protos.h>
48 #else
49 #include <devices_AROS/rawkeycodes.h>
50 #endif
51
52
53 #include <proto/exec.h>
54 #include <proto/graphics.h>
55 #include <proto/utility.h>
56 #include <proto/dos.h>
57 #include <proto/icon.h>
58 #include <proto/layers.h>
59 #include <proto/dos.h>
60 #include <proto/iffparse.h>
61
62 #if defined(__AROS__)
63 #include <prefs/prefhdr.h>
64 #include <prefs/wanderer.h>
65 #else
66 #include <prefs_AROS/prefhdr.h>
67 #include <prefs_AROS/wanderer.h>
68 #endif
69
70 #include <proto/cybergraphics.h>
71
72 #if defined(__AROS__)
73 #include <cybergraphx/cybergraphics.h>
74 #else
75 #include <cybergraphx_AROS/cybergraphics.h>
76 #endif
77
78
79 #if defined(__AMIGA__) && !defined(__PPC__)
80 #define NO_INLINE_STDARG
81 #endif
82 #include <proto/intuition.h>
83 #include <proto/muimaster.h>
84 #include <libraries/mui.h>
85 #include "iconlist_attributes.h"
86 #include "icon_attributes.h"
87 #include "iconlist.h"
88 #include "iconlist_private.h"
89 #include "iconlistview.h"
90
91 #if !defined(__AROS__)
92 #define DEBUG 1
93
94 #ifdef DEBUG
95 #define D(x) if (DEBUG) x
96 #ifdef __amigaos4__
97 #define bug DebugPrintF
98 #else
99 #define bug kprintf
100 #endif
101 #else
102 #define D(...)
103 #endif
104 #endif
105
106 #define _between(a,x,b) ((x)>=(a) && (x)<=(b))
107 #define _isinobject(x,y) (_between(_mleft(obj),(x),_mright (obj)) \
108 && _between(_mtop(obj) ,(y),_mbottom(obj)))
109
110 extern struct Library *MUIMasterBase;
111
112 static struct Hook __iconlist_UpdateLabels_hook;
113
114 // N.B: We Handle frame/background rendering so make sure icon.library doesnt do it ..
115 static struct TagItem __iconList_DrawIconStateTags[] = {
116 { ICONDRAWA_Frameless, TRUE },
117 { ICONDRAWA_Borderless, TRUE },
118 { ICONDRAWA_EraseBackground, FALSE },
119 { TAG_DONE, }
120 };
121
122 #if 0
123 static struct TagItem __iconList_BackBuffLayerTags[] =
124 {
125 { LA_Visible, FALSE },
126 { TAG_DONE, }
127 };
128 #endif
129
130 #ifndef NO_ICON_POSITION
131 #define NO_ICON_POSITION (0x8000000) /* belongs to workbench/workbench.h */
132 #endif
133
134 #define UPDATE_HEADERENTRY 1
135 #define UPDATE_SINGLEENTRY 2
136 #define UPDATE_SCROLL 3
137 #define UPDATE_RESIZE 4
138
139 #define LEFT_BUTTON 1
140 #define RIGHT_BUTTON 2
141 #define MIDDLE_BUTTON 4
142
143 #define ICONLIST_DRAWMODE_NORMAL 1
144 #define ICONLIST_DRAWMODE_FAST 2
145
146 /* Values used for List View-Mode */
147 #define COLOR_COLUMN_BACKGROUND 0
148 #define COLOR_COLUMN_BACKGROUND_SORTED 1
149 #define COLOR_COLUMN_BACKGROUND_LASSO 2
150 #define COLOR_COLUMN_BACKGROUND_LASSO_SORTED 3
151
152 #define COLOR_SELECTED_BACKGROUND 4
153 #define COLOR_SELECTED_BACKGROUND_SORTED 5
154
155 #define MIN_COLUMN_WIDTH 10
156
157 #define COLUMN_ALIGN_LEFT 0
158 #define COLUMN_ALIGN_CENTER 1
159 #define COLUMN_ALIGN_RIGHT 2
160
161 #define LINE_SPACING_TOP 2
162 #define LINE_SPACING_BOTTOM 2
163 #define LINE_EXTRAHEIGHT (LINE_SPACING_TOP + LINE_SPACING_BOTTOM)
164
165 #define LINE_SPACING_LEFT 1
166 #define LINE_SPACING_RIGHT 1
167 #define LINE_EXTRAWIDTH (LINE_SPACING_LEFT + LINE_SPACING_RIGHT)
168
169 #define ENTRY_SPACING_LEFT 1
170 #define ENTRY_SPACING_RIGHT 1
171 #define ENTRY_EXTRAWIDTH (ENTRY_SPACING_LEFT + ENTRY_SPACING_RIGHT)
172
173 #define HEADERLINE_SPACING_TOP 3
174 #define HEADERLINE_SPACING_BOTTOM 3
175 #define HEADERLINE_EXTRAHEIGHT (HEADERLINE_SPACING_TOP + HEADERLINE_SPACING_BOTTOM)
176
177 #define HEADERLINE_SPACING_LEFT 1
178 #define HEADERLINE_SPACING_RIGHT 1
179 #define HEADERLINE_EXTRAWIDTH (HEADERLINE_SPACING_LEFT + HEADERLINE_SPACING_RIGHT)
180
181 #define HEADERENTRY_SPACING_LEFT 4
182 #define HEADERENTRY_SPACING_RIGHT 4
183 #define HEADERENTRY_EXTRAWIDTH (HEADERENTRY_SPACING_LEFT + HEADERENTRY_SPACING_RIGHT)
184
185 enum
186 {
187 INDEX_TYPE,
188 INDEX_NAME,
189 INDEX_SIZE,
190 INDEX_PROTECTION,
191 INDEX_LASTACCESS,
192 INDEX_COMMENT
193 };
194
195 /**************************************************************************
196 Support Functions
197 **************************************************************************/
198
199 #define ForeachPrevNode(list, node) \
200 for \
201 ( \
202 node = (void *)(((struct List *)(list))->lh_TailPred); \
203 ((struct Node *)(node))->ln_Pred; \
204 node = (void *)(((struct Node *)(node))->ln_Pred) \
205 )
206
207 #define RPALPHAFLAT (1 << 0)
208 #define RPALPHARADIAL (1 << 1)
209
210 static void RastPortSetAlpha(struct RastPort *arport, ULONG ax, ULONG ay, ULONG width, ULONG height, UBYTE val, UBYTE alphamode)
211 {
212 ULONG x, y;
213 ULONG alphaval, pixelval;
214 APTR buffer, pixelptr;
215
216 if ((buffer = AllocVec(width * height * sizeof(ULONG), MEMF_ANY)) == NULL)
217 return;
218
219 ReadPixelArray(buffer, 0, 0, width * sizeof(ULONG), arport, 0, 0, width, height, RECTFMT_ARGB);
220
221 pixelptr = buffer;
222
223 for (y = 0; y < height; y++)
224 {
225 for (x = 0; x < width; x++)
226 {
227 if((pixelval = *((ULONG *)pixelptr)))
228 {
229 if (alphamode == RPALPHARADIAL){
230 //Set the alpha value based on distance from ax,ay
231 } else {
232 alphaval = val;
233 }
234 pixelval = (pixelval & 0xffffff00) | alphaval;
235 *((ULONG *)pixelptr) = pixelval;
236 }
237 pixelptr += sizeof(ULONG);
238 }
239 }
240
241 WritePixelArray(buffer, 0, 0, width * sizeof(ULONG), arport, 0, 0, width, height, RECTFMT_ARGB);
242 FreeVec(buffer);
243 }
244
245 ///RectAndRect()
246 // Entry/Label Area support functions
247 static int RectAndRect(struct Rectangle *a, struct Rectangle *b)
248 {
249 if ((a->MinX > b->MaxX) || (a->MinY > b->MaxY) || (a->MaxX < b->MinX) || (a->MaxY < b->MinY))
250 return 0;
251 return 1;
252 }
253 ///
254
255 ///RegionAndRect()
256 static int RegionAndRect(struct Region * a, struct Rectangle *b)
257 {
258 D(bug("Region (%d, %d)(%d, %d), Rect (%d, %d)(%d, %d)\n",
259 (LONG)a->bounds.MinX, (LONG)a->bounds.MinY, (LONG)a->bounds.MaxX, (LONG)a->bounds.MaxY,
260 (LONG)b->MinX, (LONG)b->MinY, (LONG)b->MaxX, (LONG)b->MaxY));
261
262 /* First check with region bounds */
263 if (RectAndRect(&a->bounds, b) == 0)
264 return 0;
265
266 if (a->RegionRectangle)
267 {
268 struct RegionRectangle * c = a->RegionRectangle;
269 while(c)
270 {
271 struct Rectangle d = {
272 a->bounds.MinX + c->bounds.MinX,
273 a->bounds.MinY + c->bounds.MinY,
274 a->bounds.MinX + c->bounds.MaxX,
275 a->bounds.MinY + c->bounds.MaxY
276 }; /* We need absolute coordinates */
277
278 if (RectAndRect(&d, b))
279 return 1;
280 c = c->Next;
281 }
282 }
283
284 return 0;
285 }
286
287 ///Node_NextVisible()
288 // IconEntry List navigation functions ..
289 static struct IconEntry *Node_NextVisible(struct IconEntry *current_Node)
290 {
291 current_Node = (struct IconEntry *)GetSucc(&current_Node->ie_IconNode);
292 while ((current_Node != NULL) && (!(current_Node->ie_Flags & ICONENTRY_FLAG_VISIBLE)))
293 {
294 current_Node = (struct IconEntry *)GetSucc(&current_Node->ie_IconNode);
295 }
296 return current_Node;
297 }
298 ///
299
300 ///Node_FirstVisible()
301 static struct IconEntry *Node_FirstVisible(struct List *icon_list)
302 {
303 struct IconEntry *current_Node = (struct IconEntry *)GetHead(icon_list);
304
305 if ((current_Node != NULL) && !(current_Node->ie_Flags & ICONENTRY_FLAG_VISIBLE))
306 current_Node = Node_NextVisible(current_Node);
307
308 return current_Node;
309 }
310 ///
311
312 ///Node_PreviousVisible()
313 static struct IconEntry *Node_PreviousVisible(struct IconEntry *current_Node)
314 {
315 current_Node = (struct IconEntry *)GetPred(&current_Node->ie_IconNode);
316 while ((current_Node != NULL) && (!(current_Node->ie_Flags & ICONENTRY_FLAG_VISIBLE)))
317 {
318 current_Node = (struct IconEntry *)GetPred(&current_Node->ie_IconNode);
319 }
320 return current_Node;
321 }
322 ///
323
324 ///Node_LastVisible()
325 static struct IconEntry *Node_LastVisible(struct List *icon_list)
326 {
327 struct IconEntry *current_Node = (struct IconEntry *)GetTail(icon_list);
328
329 if ((current_Node != NULL) && !(current_Node->ie_Flags & ICONENTRY_FLAG_VISIBLE))
330 current_Node = Node_PreviousVisible(current_Node);
331
332 return current_Node;
333 }
334 ///
335
336 const UBYTE MSG_MEM_G[] = "GB";
337 const UBYTE MSG_MEM_M[] = "MB";
338 const UBYTE MSG_MEM_K[] = "KB";
339 const UBYTE MSG_MEM_B[] = "Bytes";
340
341 ///FmtSizeToString()
342 static void FmtSizeToString(UBYTE *buf, ULONG num)
343 {
344 UQUAD d;
345 const UBYTE *ch;
346 struct
347 {
348 IPTR val;
349 IPTR dec;
350 } array =
351 {
352 num,
353 0
354 };
355
356 if (num >= 1073741824)
357 {
358 //Gigabytes
359 array.val = num >> 30;
360 d = ((UQUAD)num * 10 + 536870912) / 1073741824;
361 array.dec = d % 10;
362 ch = MSG_MEM_G;
363 }
364 else if (num >= 1048576)
365 {
366 //Megabytes
367 array.val = num >> 20;
368 d = ((UQUAD)num * 10 + 524288) / 1048576;
369 array.dec = d % 10;
370 ch = MSG_MEM_M;
371 }
372 else if (num >= 1024)
373 {
374 //Kilobytes
375 array.val = num >> 10;
376 d = (num * 10 + 512) / 1024;
377 array.dec = d % 10;
378 ch = MSG_MEM_K;
379 }
380 else
381 {
382 //Bytes
383 array.val = num;
384 array.dec = 0;
385 d = 0;
386 ch = MSG_MEM_B;
387 }
388
389 if (!array.dec && (d > array.val * 10))
390 {
391 array.val++;
392 }
393
394 RawDoFmt(array.dec ? "%lu.%lu" : "%lu", &array, NULL, buf);
395
396 while (*buf)
397 {
398 buf++;
399 }
400
401 sprintf(buf, " %s", ch);
402 }
403 ///
404
405 ///GetAbsoluteLassoRect()
406 // get positive lasso coords
407 static void GetAbsoluteLassoRect(struct IconList_DATA *data, struct Rectangle *LassoRectangle)
408 {
409 WORD minx = data->icld_LassoRectangle.MinX;
410 WORD miny = data->icld_LassoRectangle.MinY;
411 WORD maxx = data->icld_LassoRectangle.MaxX;
412 WORD maxy = data->icld_LassoRectangle.MaxY;
413
414 #if defined(DEBUG_ILC_LASSO) || defined(DEBUG_ILC_FUNCS)
415 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
416 #endif
417
418 if (minx > maxx)
419 {
420 /* Swap minx, maxx */
421 minx ^= maxx;
422 maxx ^= minx;
423 minx ^= maxx;
424 }
425
426 if (miny > maxy)
427 {
428 /* Swap miny, maxy */
429 miny ^= maxy;
430 maxy ^= miny;
431 miny ^= maxy;
432 }
433
434 LassoRectangle->MinX = data->view_rect.MinX - data->icld_ViewX + minx;
435 LassoRectangle->MinY = data->view_rect.MinY - data->icld_ViewY + miny;
436 LassoRectangle->MaxX = data->view_rect.MinX - data->icld_ViewX + maxx;
437 LassoRectangle->MaxY = data->view_rect.MinY - data->icld_ViewY + maxy;
438 }
439 ///
440
441 ///IconList_InvertPixelRect()
442 static void IconList_InvertPixelRect(struct RastPort *rp, WORD minx, WORD miny, WORD maxx, WORD maxy, struct Rectangle *clip)
443 {
444 struct Rectangle r, clipped_r;
445
446 #if defined(DEBUG_ILC_RENDERING) || defined(DEBUG_ILC_FUNCS)
447 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
448 #endif
449
450 if (maxx < minx)
451 {
452 /* Swap minx, maxx */
453 minx ^= maxx;
454 maxx ^= minx;
455 minx ^= maxx;
456 }
457
458 if (maxy < miny)
459 {
460 /* Swap miny, maxy */
461 miny ^= maxy;
462 maxy ^= miny;
463 miny ^= maxy;
464 }
465
466 r.MinX = minx;
467 r.MinY = miny;
468 r.MaxX = maxx;
469 r.MaxY = maxy;
470
471 if (AndRectRect(&r, clip, &clipped_r))
472 {
473 InvertPixelArray(rp, clipped_r.MinX, clipped_r.MinY,
474 clipped_r.MaxX - clipped_r.MinX + 1, clipped_r.MaxY - clipped_r.MinY + 1);
475 }
476 }
477 ///
478
479 ///IconList_InvertLassoOutlines()
480 // Simple lasso drawing by inverting area outlines
481 static void IconList_InvertLassoOutlines(Object *obj, struct IconList_DATA *data, struct Rectangle *rect)
482 {
483 struct Rectangle lasso;
484 struct Rectangle clip;
485
486 #if defined(DEBUG_ILC_LASSO) || defined(DEBUG_ILC_FUNCS)
487 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
488 #endif
489
490 /* get abolute iconlist coords */
491 lasso.MinX = rect->MinX + _mleft(obj);
492 lasso.MaxX = rect->MaxX + _mleft(obj);
493 lasso.MinY = rect->MinY + _mtop(obj);
494 lasso.MaxY = rect->MaxY + _mtop(obj);
495
496 clip.MinX = _mleft(obj);
497 clip.MinY = _mtop(obj);
498 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
499 {
500 clip.MinY += data->icld_LVMAttribs->lmva_HeaderHeight;
501 }
502 clip.MaxX = _mright(obj);
503 clip.MaxY = _mbottom(obj);
504
505 /* horizontal lasso lines */
506 IconList_InvertPixelRect(_rp(obj), lasso.MinX, lasso.MinY, lasso.MaxX-1, lasso.MinY + 1, &clip);
507 IconList_InvertPixelRect(_rp(obj), lasso.MinX, lasso.MaxY, lasso.MaxX-1, lasso.MaxY + 1, &clip);
508
509 /* vertical lasso lines */
510 IconList_InvertPixelRect(_rp(obj), lasso.MinX, lasso.MinY, lasso.MinX + 1, lasso.MaxY - 1, &clip);
511 IconList_InvertPixelRect(_rp(obj), lasso.MaxX, lasso.MinY, lasso.MaxX + 1, lasso.MaxY - 1, &clip);
512 }
513 ///
514
515 ///IconList_GetIconImageRectangle()
516 //We don't use icon.library's label drawing so we do this by hand
517 static void IconList_GetIconImageRectangle(Object *obj, struct IconList_DATA *data, struct IconEntry *entry, struct Rectangle *rect)
518 {
519 #if defined(DEBUG_ILC_ICONPOSITIONING) || defined(DEBUG_ILC_FUNCS)
520 D(bug("[IconList]: %s(entry @ %p)\n", __PRETTY_FUNCTION__, entry));
521 #endif
522
523 /* Get basic width/height */
524 GetIconRectangleA(NULL, entry->ie_DiskObj, NULL, rect, __iconList_DrawIconStateTags);
525 #if defined(DEBUG_ILC_ICONPOSITIONING)
526 D(bug("[IconList] %s: MinX %d, MinY %d MaxX %d, MaxY %d\n", __PRETTY_FUNCTION__, rect->MinX, rect->MinY, rect->MaxX, rect->MaxY));
527 #endif
528 entry->ie_IconWidth = (rect->MaxX - rect->MinX) + 1;
529 entry->ie_IconHeight = (rect->MaxY - rect->MinY) + 1;
530
531 if (entry->ie_IconHeight > data->icld_IconLargestHeight)
532 data->icld_IconLargestHeight = entry->ie_IconHeight;
533 }
534 ///
535
536 ///IconList_GetIconImageOffsets()
537 static void IconList_GetIconImageOffsets(struct IconList_DATA *data, struct IconEntry *entry, LONG *offsetx, LONG *offsety)
538 {
539 *offsetx = *offsety = 0;
540 if (entry->ie_IconWidth < entry->ie_AreaWidth)
541 *offsetx += (entry->ie_AreaWidth - entry->ie_IconWidth)/2;
542
543 if ((data->icld__Option_IconListMode == ICON_LISTMODE_GRID) &&
544 (entry->ie_AreaWidth < data->icld_IconAreaLargestWidth))
545 *offsetx += ((data->icld_IconAreaLargestWidth - entry->ie_AreaWidth)/2);
546
547 if ((data->icld__Option_IconListMode == ICON_LISTMODE_GRID) &&
548 (entry->ie_AreaHeight < data->icld_IconAreaLargestHeight))
549 *offsety += ((data->icld_IconAreaLargestHeight - entry->ie_AreaHeight)/2);
550 }
551
552 ///IconList_GetIconLabelRectangle()
553 static void IconList_GetIconLabelRectangle(Object *obj, struct IconList_DATA *data, struct IconEntry *entry, struct Rectangle *rect)
554 {
555 ULONG outline_offset = 0;
556 ULONG textwidth = 0;
557
558 #if defined(DEBUG_ILC_ICONPOSITIONING) || defined(DEBUG_ILC_FUNCS)
559 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
560 #endif
561
562 switch ( data->icld__Option_LabelTextMode )
563 {
564 case ICON_TEXTMODE_DROPSHADOW:
565 outline_offset = 1;
566 break;
567
568 case ICON_TEXTMODE_PLAIN:
569 break;
570
571 default:
572 outline_offset = 2;
573 break;
574 }
575
576 /* Get entry box width including text width */
577 if ((entry->ie_IconListEntry.label != NULL) && (entry->ie_TxtBuf_DisplayedLabel != NULL))
578 {
579 ULONG curlabel_TotalLines;
580 SetFont(data->icld_BufferRastPort, data->icld_IconLabelFont);
581
582 rect->MinX = 0;
583 rect->MaxX = (((data->icld__Option_LabelTextHorizontalPadding + data->icld__Option_LabelTextBorderWidth) * 2) + entry->ie_TxtBuf_DisplayedLabelWidth + outline_offset) - 1;
584
585 rect->MinY = 0;
586
587 curlabel_TotalLines = entry->ie_SplitParts;
588 if (curlabel_TotalLines == 0)
589 curlabel_TotalLines = 1;
590 if (curlabel_TotalLines > data->icld__Option_LabelTextMultiLine)
591 curlabel_TotalLines = data->icld__Option_LabelTextMultiLine;
592
593 rect->MaxY = (((data->icld__Option_LabelTextBorderHeight + data->icld__Option_LabelTextVerticalPadding) * 2) +
594 ((data->icld_IconLabelFont->tf_YSize + outline_offset) * curlabel_TotalLines)) - 1;
595
596 /* Date/size sorting has the date/size appended under the entry label
597 only list regular files like this (drawers have no size/date output) */
598 if(
599 entry->ie_IconListEntry.type != ST_USERDIR &&
600 ((data->icld_SortFlags & MUIV_IconList_Sort_BySize) || (data->icld_SortFlags & MUIV_IconList_Sort_ByDate))
601 )
602 {
603 SetFont(data->icld_BufferRastPort, data->icld_IconInfoFont);
604
605 if( (data->icld_SortFlags & MUIV_IconList_Sort_BySize) && !(data->icld_SortFlags & MUIV_IconList_Sort_ByDate) )
606 {
607 entry->ie_TxtBuf_SIZEWidth = TextLength(data->icld_BufferRastPort, entry->ie_TxtBuf_SIZE, strlen(entry->ie_TxtBuf_SIZE));
608 textwidth = entry->ie_TxtBuf_SIZEWidth;
609 }
610 else
611 {
612 if( !(data->icld_SortFlags & MUIV_IconList_Sort_BySize) && (data->icld_SortFlags & MUIV_IconList_Sort_ByDate) )
613 {
614 if( entry->ie_Flags & ICONENTRY_FLAG_TODAY )
615 {
616 entry->ie_TxtBuf_TIMEWidth = TextLength(data->icld_BufferRastPort, entry->ie_TxtBuf_TIME, strlen(entry->ie_TxtBuf_TIME));
617 textwidth = entry->ie_TxtBuf_TIMEWidth;
618 }
619 else
620 {
621 entry->ie_TxtBuf_DATEWidth = TextLength(data->icld_BufferRastPort, entry->ie_TxtBuf_DATE, strlen(entry->ie_TxtBuf_DATE));
622 textwidth = entry->ie_TxtBuf_DATEWidth;
623 }
624 }
625 }
626
627 if (textwidth > 0)
628 {
629 rect->MaxY = rect->MaxY + data->icld_IconInfoFont->tf_YSize + outline_offset;
630 if ((textwidth + outline_offset + ((data->icld__Option_LabelTextHorizontalPadding + data->icld__Option_LabelTextBorderWidth) * 2)) > ((rect->MaxX - rect->MinX) + 1))
631 rect->MaxX = (textwidth + outline_offset + ((data->icld__Option_LabelTextVerticalPadding + data->icld__Option_LabelTextBorderWidth) * 2)) - 1;
632 }
633 }
634 }
635 if (((rect->MaxY - rect->MinY) + 1) > data->icld_LabelLargestHeight) data->icld_LabelLargestHeight = ((rect->MaxY - rect->MinY) + 1);
636 }
637 ///
638
639 ///IconList_GetIconAreaRectangle()
640 static void IconList_GetIconAreaRectangle(Object *obj, struct IconList_DATA *data, struct IconEntry *entry, struct Rectangle *rect)
641 {
642 struct Rectangle labelrect;
643 ULONG iconlabel_Width;
644 ULONG iconlabel_Height;
645
646 #if defined(DEBUG_ILC_ICONPOSITIONING) || defined(DEBUG_ILC_FUNCS)
647 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
648 #endif
649
650 /* Get entry box width including text width */
651 memset(rect, 0, sizeof(struct Rectangle));
652
653 IconList_GetIconImageRectangle(obj, data, entry, rect);
654
655 entry->ie_AreaWidth = entry->ie_IconWidth;
656 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
657 {
658 entry->ie_AreaHeight = data->icld_IconLargestHeight;
659 }
660 else
661 {
662 entry->ie_AreaHeight = entry->ie_IconHeight;
663 }
664
665 IconList_GetIconLabelRectangle(obj, data, entry, &labelrect);
666
667 iconlabel_Width = ((labelrect.MaxX - labelrect.MinX) + 1);
668 iconlabel_Height = ((labelrect.MaxY - labelrect.MinY) + 1);
669
670 if (iconlabel_Width > entry->ie_AreaWidth)
671 entry->ie_AreaWidth = iconlabel_Width;
672
673 entry->ie_AreaHeight = entry->ie_AreaHeight + data->icld__Option_IconImageSpacing + iconlabel_Height;
674
675 /* Store */
676 rect->MaxX = (rect->MinX + entry->ie_AreaWidth) - 1;
677 rect->MaxY = (rect->MinY + entry->ie_AreaHeight) - 1;
678
679 if (entry->ie_AreaWidth > data->icld_IconAreaLargestWidth) data->icld_IconAreaLargestWidth = entry->ie_AreaWidth;
680 if (entry->ie_AreaHeight > data->icld_IconAreaLargestHeight) data->icld_IconAreaLargestHeight = entry->ie_AreaHeight;
681 }
682 ///
683
684 static LONG FirstVisibleColumnNumber(struct IconList_DATA *data)
685 {
686 LONG i;
687 LONG retval = -1;
688
689 if (data->icld_LVMAttribs != NULL)
690 {
691 for(i = 0; i < NUM_COLUMNS; i++)
692 {
693 LONG index = data->icld_LVMAttribs->lmva_ColumnPos[i];
694
695 if (data->icld_LVMAttribs->lmva_ColumnFlags[index] & LVMCF_COLVISIBLE)
696 {
697 retval = i;
698 break;
699 }
700 }
701 }
702
703 return retval;
704 }
705
706 static LONG LastVisibleColumnNumber(struct IconList_DATA *data)
707 {
708 LONG i;
709 LONG retval = -1;
710
711 if (data->icld_LVMAttribs != NULL)
712 {
713 for(i = 0; i < NUM_COLUMNS; i++)
714 {
715 LONG index = data->icld_LVMAttribs->lmva_ColumnPos[i];
716
717 if (data->icld_LVMAttribs->lmva_ColumnFlags[index] & LVMCF_COLVISIBLE)
718 {
719 retval = i;
720 }
721 }
722 }
723
724 return retval;
725
726 }
727
728 static void RenderEntryField(Object *obj, struct IconList_DATA *data,
729 struct IconEntry *entry, struct Rectangle *rect, LONG index, BOOL firstvis,
730 BOOL lastvis, struct RastPort * rp)
731 {
732 STRPTR text = NULL, renderflag = "<UHOH>";
733 struct TextExtent te;
734 ULONG fit;
735
736 if (entry->ie_Flags & ICONENTRY_FLAG_SELECTED)
737 {
738 FillPixelArray(rp,
739 rect->MinX, rect->MinY,
740 rect->MaxX - rect->MinX + 1, rect->MaxY - rect->MinY,
741 0x0A246A);
742 }
743
744 rect->MinX += ENTRY_SPACING_LEFT;
745 rect->MaxX -= ENTRY_SPACING_RIGHT;
746 rect->MinY += LINE_SPACING_TOP;
747 rect->MaxY -= LINE_SPACING_BOTTOM;
748
749 if (firstvis) rect->MinX += LINE_SPACING_LEFT;
750 if (lastvis) rect->MaxX -= LINE_SPACING_RIGHT;
751
752 if (!entry) return;
753
754 switch(index)
755 {
756 case INDEX_TYPE:
757 /* Special case !! we draw an image instead .. */
758 text = renderflag;
759 break;
760
761 case INDEX_NAME:
762 text = entry->ie_IconListEntry.label;
763 break;
764
765 case INDEX_SIZE:
766 text = entry->ie_TxtBuf_SIZE;
767 break;
768
769 case INDEX_LASTACCESS:
770 text = AllocVec(strlen(entry->ie_TxtBuf_DATE) + strlen(entry->ie_TxtBuf_TIME) + 5, MEMF_CLEAR);
771 sprintf(text, "%s at %s", entry->ie_TxtBuf_DATE, entry->ie_TxtBuf_TIME);
772 break;
773
774 case INDEX_COMMENT:
775 text = entry->ie_FileInfoBlock->fib_Comment;
776 break;
777
778 case INDEX_PROTECTION:
779 text = entry->ie_TxtBuf_PROT;
780 break;
781 }
782
783 if (!text) return;
784 if (!text[0]) return;
785
786 if (text == renderflag)
787 {
788 if (entry->ie_IconListEntry.type == ST_USERDIR)
789 {
790 if (data->icld_LVMAttribs->lvma_IconDrawer)
791 {
792 DrawIconStateA
793 (
794 rp, data->icld_LVMAttribs->lvma_IconDrawer, NULL,
795 rect->MinX + 1, rect->MinY + 1,
796 (entry->ie_Flags & ICONENTRY_FLAG_SELECTED) ? IDS_SELECTED : IDS_NORMAL,
797 __iconList_DrawIconStateTags
798 );
799 }
800 else
801 {
802 FillPixelArray(rp,
803 rect->MinX + 1, rect->MinY + 1,
804 rect->MaxX - rect->MinX - 1, rect->MaxY - rect->MinY - 1,
805 0xc0f0f0);
806 }
807 }
808 else
809 {
810 if (data->icld_LVMAttribs->lvma_IconFile)
811 {
812 DrawIconStateA
813 (
814 rp, data->icld_LVMAttribs->lvma_IconFile, NULL,
815 rect->MinX + 1, rect->MinY + 1,
816 (entry->ie_Flags & ICONENTRY_FLAG_SELECTED) ? IDS_SELECTED : IDS_NORMAL,
817 __iconList_DrawIconStateTags
818 );
819 }
820 else
821 {
822 FillPixelArray(rp,
823 rect->MinX + 1, rect->MinY + 1,
824 rect->MaxX - rect->MinX - 1, rect->MaxY - rect->MinY - 1,
825 0xe0e0e0);
826 }
827 }
828 }
829 else
830 {
831 fit = TextFit(rp, text, strlen(text), &te, NULL, 1,
832 rect->MaxX - rect->MinX + 1,
833 rect->MaxY - rect->MinY + 1);
834
835 if (!fit) return;
836
837 SetABPenDrMd(rp, _pens(obj)[(entry->ie_Flags & ICONENTRY_FLAG_SELECTED) ? MPEN_SHINE : MPEN_TEXT], 0, JAM1);
838
839 if (((rect->MaxY - rect->MinY + 1) - data->icld_IconLabelFont->tf_YSize) > 0)
840 {
841 rect->MinY += ((rect->MaxY - rect->MinY + 1) - data->icld_IconLabelFont->tf_YSize)/2;
842 }
843
844 switch(data->icld_LVMAttribs->lmva_ColumnHAlign[index])
845 {
846 case COLUMN_ALIGN_LEFT:
847 Move(rp, rect->MinX, rect->MinY + rp->TxBaseline);
848 break;
849
850 case COLUMN_ALIGN_RIGHT:
851 Move(rp, rect->MaxX - te.te_Width, rect->MinY + rp->TxBaseline);
852 break;
853
854 case COLUMN_ALIGN_CENTER:
855 Move(rp, rect->MinX + (rect->MaxX - rect->MinX + 1 + 1 - te.te_Width) / 2,
856 rect->MinY + rp->TxBaseline);
857 break;
858
859 }
860 Text(rp, text, fit);
861 }
862 if ((index == INDEX_LASTACCESS) && text)
863 FreeVec(text);
864
865 }
866
867 /**************************************************************************
868 Draw the entry at its position
869 **************************************************************************/
870 ///IconList__MUIM_IconList_DrawEntry()
871 IPTR IconList__MUIM_IconList_DrawEntry(struct IClass *CLASS, Object *obj, struct MUIP_IconList_DrawEntry *message)
872 {
873 struct IconList_DATA *data = INST_DATA(CLASS, obj);
874
875 BOOL outside = FALSE;
876
877 struct Rectangle iconrect;
878 struct Rectangle objrect;
879
880 ULONG objX, objY, objW, objH;
881 LONG iconX, iconY;
882
883 if (data->icld_BufferRastPort == data->icld_DisplayRastPort)
884 {
885 objX = _mleft(obj);
886 objY = _mtop(obj);
887 }
888 else
889 {
890 objX = objY = 0;
891 }
892 objW = _mright(obj) - _mleft(obj) + 1;
893 objH = _mbottom(obj) - _mtop(obj) + 1;
894
895 #if defined(DEBUG_ILC_ICONRENDERING)
896 D(bug("[IconList]: %s(message->entry = 0x%p)\n", __PRETTY_FUNCTION__, message->entry));
897 #endif
898
899 if ((!(message->entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)) ||
900 (data->icld_BufferRastPort == NULL) ||
901 (!(message->entry->ie_DiskObj)))
902 {
903 #if defined(DEBUG_ILC_ICONRENDERING)
904 D(bug("[IconList] %s: Not visible or missing DOB\n", __PRETTY_FUNCTION__));
905 #endif
906 return FALSE;
907 }
908
909 /* Set the dimensions of our "view" */
910 objrect.MinX = objX;
911 objrect.MinY = objY;
912 objrect.MaxX = objX + objW - 1;
913 objrect.MaxY = objY + objH - 1;
914
915 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
916 {
917 struct Rectangle linerect;
918 LONG x, i;
919 LONG firstvis, lastvis;
920
921 linerect.MinX = objX - data->icld_ViewX;
922 linerect.MaxX = objX + objW - 1; //linerect.MinX + data->width - 1;
923 linerect.MinY = (objY - data->icld_ViewY) + data->icld_LVMAttribs->lmva_HeaderHeight + (message->drawmode * data->icld_LVMAttribs->lmva_RowHeight);
924 linerect.MaxY = linerect.MinY + data->icld_LVMAttribs->lmva_RowHeight - 1;
925
926 if (!AndRectRect(&linerect, &objrect, NULL)) return FALSE;
927 // if (!MustRenderRect(data, &linerect)) return;
928
929 SetFont(data->icld_BufferRastPort, data->icld_IconLabelFont);
930
931 x = linerect.MinX + LINE_SPACING_LEFT;
932
933 firstvis = FirstVisibleColumnNumber(data);
934 lastvis = LastVisibleColumnNumber(data);
935
936 for(i = 0; i < NUM_COLUMNS; i++)
937 {
938 struct Rectangle field_rect;
939 LONG index = data->icld_LVMAttribs->lmva_ColumnPos[i];
940
941 if (!(data->icld_LVMAttribs->lmva_ColumnFlags[i] & LVMCF_COLVISIBLE)) continue;
942
943 field_rect.MinX = (i == firstvis) ? linerect.MinX : x;
944 field_rect.MinY = linerect.MinY;
945 field_rect.MaxX = x + data->icld_LVMAttribs->lmva_ColumnWidth[index] - 1 + ((i == lastvis) ? LINE_SPACING_RIGHT : 0);
946 field_rect.MaxY = linerect.MaxY;
947
948 /* if (MustRenderRect(data, &field_rect))
949 {*/
950 if (AndRectRect(&field_rect, &objrect, NULL))
951 {
952 RenderEntryField(obj, data, message->entry, &field_rect, index,
953 (i == firstvis), (i == lastvis), data->icld_BufferRastPort);
954 }
955 /* }*/
956 x += data->icld_LVMAttribs->lmva_ColumnWidth[index];
957 }
958
959 if ((data->icld_LVMAttribs->lvma_Flags & LVMAF_ROWDRAWTOEND) == LVMAF_ROWDRAWTOEND)
960 {
961 x += LINE_SPACING_RIGHT;
962
963 if (x < linerect.MaxX)
964 {
965 linerect.MinX = x;
966
967 SetABPenDrMd(data->icld_BufferRastPort, _pens(obj)[MPEN_SHINE], 0, JAM1);
968 RectFill(data->icld_BufferRastPort, linerect.MinX, linerect.MinY, linerect.MaxX, linerect.MaxY);
969 }
970 }
971 }
972 else
973 {
974 LONG offsetx,offsety;
975
976 /* Get the dimensions and affected area of message->entry */
977 IconList_GetIconImageRectangle(obj, data, message->entry, &iconrect);
978
979 /* Get offset corrections */
980 IconList_GetIconImageOffsets(data, message->entry, &offsetx, &offsety);
981
982 /* Add the relative position offset of the message->entry */
983 iconrect.MinX += objX - data->icld_ViewX + message->entry->ie_IconX + offsetx;
984 iconrect.MaxX += objX - data->icld_ViewX + message->entry->ie_IconX + offsetx;
985 iconrect.MinY += objY - data->icld_ViewY + message->entry->ie_IconY + offsety;
986 iconrect.MaxY += objY - data->icld_ViewY + message->entry->ie_IconY + offsety;
987
988 if (!RectAndRect(&iconrect, &objrect))
989 {
990 #if defined(DEBUG_ILC_ICONRENDERING)
991 D(bug("[IconList] %s: Entry '%s' image outside of visible area .. skipping\n", __PRETTY_FUNCTION__, message->entry->ie_IconListEntry.label));
992 #endif
993 return FALSE;
994 }
995
996 /* data->update_rect1 and data->update_rect2 may
997 point to rectangles to indicate that only icons
998 in any of this rectangles need to be drawn */
999 if (data->update_rect1)
1000 {
1001 if (!RectAndRect(&iconrect, data->update_rect1)) outside = TRUE;
1002 }
1003
1004 if (data->update_rect2)
1005 {
1006 if (data->update_rect1)
1007 {
1008 if ((outside == TRUE) && RectAndRect(&iconrect, data->update_rect2))
1009 outside = FALSE;
1010 }
1011 else
1012 {
1013 if (!RectAndRect(&iconrect, data->update_rect2))
1014 outside = TRUE;
1015 }
1016 }
1017
1018 if (outside == TRUE)
1019 {
1020 #if defined(DEBUG_ILC_ICONRENDERING)
1021 D(bug("[IconList] %s: Entry '%s' image outside of update area .. skipping\n", __PRETTY_FUNCTION__, message->entry->ie_IconListEntry.label));
1022 #endif
1023 return FALSE;
1024 }
1025
1026 if (message->drawmode == ICONENTRY_DRAWMODE_NONE) return TRUE;
1027
1028 // Center entry image
1029 iconX = iconrect.MinX - objX + data->icld_DrawOffsetX;
1030 iconY = iconrect.MinY - objY + data->icld_DrawOffsetY;
1031
1032 #if defined(DEBUG_ILC_ICONRENDERING)
1033 D(bug("[IconList] %s: DrawIconState('%s') .. %d, %d\n", __PRETTY_FUNCTION__, message->entry->ie_IconListEntry.label, iconX, iconY));
1034 #endif
1035 DrawIconStateA
1036 (
1037 data->icld_BufferRastPort, message->entry->ie_DiskObj, NULL,
1038 iconX,
1039 iconY,
1040 (message->entry->ie_Flags & ICONENTRY_FLAG_SELECTED) ? IDS_SELECTED : IDS_NORMAL,
1041 __iconList_DrawIconStateTags
1042 );
1043 #if defined(DEBUG_ILC_ICONRENDERING)
1044 D(bug("[IconList] %s: DrawIconState Done\n", __PRETTY_FUNCTION__));
1045 #endif
1046 }
1047
1048 return TRUE;
1049 }
1050 ///
1051
1052 ///IconList__LabelFunc_SplitLabel()
1053 static void IconList__LabelFunc_SplitLabel(Object *obj, struct IconList_DATA *data, struct IconEntry *entry)
1054 {
1055 ULONG labelSplit_MaxLabelLineLength = data->icld__Option_LabelTextMaxLen;
1056 ULONG labelSplit_LabelLength = strlen(entry->ie_IconListEntry.label);
1057 ULONG txwidth;
1058 // ULONG labelSplit_FontY = data->icld_IconLabelFont->tf_YSize;
1059 int labelSplit_CharsDone, labelSplit_CharsSplit;
1060 ULONG labelSplit_CurSplitWidth;
1061
1062 if ((data->icld__Option_TrimVolumeNames) &&
1063 ((entry->ie_IconListEntry.type == ST_ROOT) && (entry->ie_IconListEntry.label[labelSplit_LabelLength - 1] == ':')))
1064 labelSplit_LabelLength--;
1065
1066 if (labelSplit_MaxLabelLineLength >= labelSplit_LabelLength)
1067 {
1068 #if defined(DEBUG_ILC_ICONRENDERING)
1069 D(bug("[IconList]: %s: Label'%s' doesnt need split (onyl %d chars)\n", __PRETTY_FUNCTION__, entry->ie_IconListEntry.label, labelSplit_LabelLength));
1070 #endif
1071 return;
1072 }
1073
1074 SetFont(data->icld_BufferRastPort, data->icld_IconLabelFont);
1075 txwidth = TextLength(data->icld_BufferRastPort, entry->ie_IconListEntry.label, labelSplit_MaxLabelLineLength);
1076 #if defined(DEBUG_ILC_ICONRENDERING)
1077 D(bug("[IconList]: %s: txwidth = %d\n", __PRETTY_FUNCTION__, txwidth));
1078 #endif
1079 entry->ie_TxtBuf_DisplayedLabel = AllocVecPooled(data->icld_Pool, 256);
1080 memset(entry->ie_TxtBuf_DisplayedLabel, 0, 256);
1081 entry->ie_SplitParts = 0;
1082
1083 labelSplit_CharsDone = 0;
1084 labelSplit_CharsSplit = 0;
1085
1086 while (labelSplit_CharsDone < labelSplit_LabelLength)
1087 {
1088 ULONG labelSplit_CurSplitLength = labelSplit_LabelLength - labelSplit_CharsDone;
1089 IPTR labelSplit_SplitStart = (IPTR)(entry->ie_IconListEntry.label + labelSplit_CharsDone);
1090 int tmp_checkoffs = 0;
1091 IPTR labelSplit_RemainingCharsAfterSplit;
1092 IPTR labelSplit_CurSplitDest;
1093
1094 while (*(char *)(labelSplit_SplitStart) == ' ')
1095 {
1096 //Skip preceding spaces..
1097 labelSplit_SplitStart = labelSplit_SplitStart + 1;
1098 labelSplit_CurSplitLength = labelSplit_CurSplitLength - 1;
1099 labelSplit_CharsDone = labelSplit_CharsDone + 1;
1100 }
1101
1102 while(TextLength(data->icld_BufferRastPort, (char *)labelSplit_SplitStart, labelSplit_CurSplitLength) < txwidth) labelSplit_CurSplitLength++;
1103 while(TextLength(data->icld_BufferRastPort, (char *)labelSplit_SplitStart, labelSplit_CurSplitLength) > txwidth) labelSplit_CurSplitLength--;
1104 #if defined(DEBUG_ILC_ICONRENDERING)
1105 D(bug("[IconList]: %s: labelSplit_CurSplitLength = %d\n", __PRETTY_FUNCTION__, labelSplit_CurSplitLength));
1106 #endif
1107
1108 #if defined(DEBUG_ILC_ICONRENDERING)
1109 D(bug("[IconList]: %s: Attempting to find neat split ", __PRETTY_FUNCTION__));
1110 #endif
1111 while(tmp_checkoffs < (labelSplit_CurSplitLength - ILC_ICONLABEL_SHORTEST))
1112 {
1113 #if defined(DEBUG_ILC_ICONRENDERING)
1114 D(bug("%d", tmp_checkoffs));
1115 #endif
1116 labelSplit_RemainingCharsAfterSplit = labelSplit_LabelLength - (labelSplit_CharsDone + labelSplit_CurSplitLength);
1117
1118 if ((labelSplit_CurSplitLength - tmp_checkoffs) > ILC_ICONLABEL_SHORTEST)
1119 {
1120 #if defined(DEBUG_ILC_ICONRENDERING)
1121 D(bug("<"));
1122 #endif
1123 if ((*(char *)(labelSplit_SplitStart + labelSplit_CurSplitLength - tmp_checkoffs) == ' ') ||
1124 (*(char *)(labelSplit_SplitStart + labelSplit_CurSplitLength - tmp_checkoffs) == '.') ||
1125 (*(char *)(labelSplit_SplitStart + labelSplit_CurSplitLength - tmp_checkoffs) == '-'))
1126 {
1127 #if defined(DEBUG_ILC_ICONRENDERING)
1128 D(bug("!"));
1129 #endif
1130 labelSplit_CurSplitLength = labelSplit_CurSplitLength - tmp_checkoffs;
1131 labelSplit_RemainingCharsAfterSplit = labelSplit_RemainingCharsAfterSplit - tmp_checkoffs;
1132 tmp_checkoffs = 0;
1133 break;
1134 }
1135 }
1136
1137 if ((labelSplit_RemainingCharsAfterSplit - tmp_checkoffs) < 0)
1138 {
1139 #if defined(DEBUG_ILC_ICONRENDERING)
1140 D(bug("="));
1141 #endif
1142 labelSplit_CurSplitLength = labelSplit_CurSplitLength + tmp_checkoffs;
1143 labelSplit_RemainingCharsAfterSplit = labelSplit_RemainingCharsAfterSplit + tmp_checkoffs;
1144 tmp_checkoffs = 0;
1145 break;
1146 }
1147
1148 if ((labelSplit_RemainingCharsAfterSplit - tmp_checkoffs) >= ILC_ICONLABEL_SHORTEST)
1149 {
1150 #if defined(DEBUG_ILC_ICONRENDERING)
1151 D(bug(">"));
1152 #endif
1153 if ((*(char *)(labelSplit_SplitStart + labelSplit_CurSplitLength + tmp_checkoffs) == ' ') ||
1154 (*(char *)(labelSplit_SplitStart + labelSplit_CurSplitLength + tmp_checkoffs) == '.') ||
1155 (*(char *)(labelSplit_SplitStart + labelSplit_CurSplitLength + tmp_checkoffs) == '-'))
1156 {
1157 #if defined(DEBUG_ILC_ICONRENDERING)
1158 D(bug("!"));
1159 #endif
1160 labelSplit_CurSplitLength = labelSplit_CurSplitLength + tmp_checkoffs;
1161 labelSplit_RemainingCharsAfterSplit = labelSplit_RemainingCharsAfterSplit + tmp_checkoffs;
1162 tmp_checkoffs = 0;
1163 break;
1164 }
1165 }
1166
1167 tmp_checkoffs = tmp_checkoffs + 1;
1168 }
1169 #if defined(DEBUG_ILC_ICONRENDERING)
1170 D(bug("\n"));
1171 #endif
1172 if (tmp_checkoffs != 0)
1173 {
1174 #if defined(DEBUG_ILC_ICONRENDERING)
1175 D(bug("[IconList]: %s: Couldnt find neat split : Still %d chars\n", __PRETTY_FUNCTION__, labelSplit_RemainingCharsAfterSplit));
1176 #endif
1177 if (labelSplit_RemainingCharsAfterSplit <= ILC_ICONLABEL_SHORTEST)
1178 {
1179 labelSplit_CurSplitLength = labelSplit_CurSplitLength + (labelSplit_RemainingCharsAfterSplit - ILC_ICONLABEL_SHORTEST);
1180 }
1181 }
1182 if ((labelSplit_CharsDone + labelSplit_CurSplitLength) > labelSplit_LabelLength) labelSplit_CurSplitLength = labelSplit_LabelLength - labelSplit_CharsDone;
1183
1184 labelSplit_CurSplitDest = (IPTR)(entry->ie_TxtBuf_DisplayedLabel + labelSplit_CharsSplit + entry->ie_SplitParts);
1185
1186 strncpy((char *)labelSplit_CurSplitDest, (char *)labelSplit_SplitStart, labelSplit_CurSplitLength);
1187
1188 labelSplit_CurSplitWidth = TextLength(data->icld_BufferRastPort, (char *)labelSplit_CurSplitDest, labelSplit_CurSplitLength);
1189
1190 entry->ie_SplitParts = entry->ie_SplitParts + 1;
1191
1192 labelSplit_CharsDone = labelSplit_CharsDone + labelSplit_CurSplitLength;
1193 labelSplit_CharsSplit = labelSplit_CharsSplit + labelSplit_CurSplitLength;
1194
1195 if (labelSplit_CurSplitWidth > entry->ie_TxtBuf_DisplayedLabelWidth) entry->ie_TxtBuf_DisplayedLabelWidth = labelSplit_CurSplitWidth;
1196 }
1197 if ((entry->ie_SplitParts <= 1) && entry->ie_TxtBuf_DisplayedLabel)
1198 {
1199 FreeVecPooled(data->icld_Pool, entry->ie_TxtBuf_DisplayedLabel);
1200 entry->ie_TxtBuf_DisplayedLabel = NULL;
1201 entry->ie_SplitParts = 0;
1202 }
1203 // if ((labelSplit_FontY * entry->ie_SplitParts) > data->icld_LabelLargestHeight) data->icld_LabelLargestHeight = (labelSplit_FontY * entry->ie_SplitParts);
1204 }
1205 ///
1206
1207 ///IconList__LabelFunc_CreateLabel()
1208 static IPTR IconList__LabelFunc_CreateLabel(Object *obj, struct IconList_DATA *data, struct IconEntry *entry)
1209 {
1210 #if defined(DEBUG_ILC_ICONRENDERING) || defined(DEBUG_ILC_FUNCS)
1211 D(bug("[IconList]: %s('%s')\n", __PRETTY_FUNCTION__, entry->ie_IconListEntry.label));
1212 #endif
1213 if (entry->ie_TxtBuf_DisplayedLabel)
1214 {
1215 FreeVecPooled(data->icld_Pool, entry->ie_TxtBuf_DisplayedLabel);
1216 entry->ie_TxtBuf_DisplayedLabel = NULL;
1217 entry->ie_SplitParts = 0;
1218 }
1219
1220 if (data->icld__Option_LabelTextMultiLine > 1)
1221 {
1222 #if defined(DEBUG_ILC_ICONRENDERING)
1223 D(bug("[IconList]: %s: Attempting to split label ..\n", __PRETTY_FUNCTION__));
1224 #endif
1225 IconList__LabelFunc_SplitLabel(obj, data, entry);
1226 }
1227
1228 if (entry->ie_TxtBuf_DisplayedLabel == NULL)
1229 {
1230 ULONG ie_LabelLength = strlen(entry->ie_IconListEntry.label);
1231 entry->ie_SplitParts = 1;
1232
1233 #if defined(DEBUG_ILC_ICONRENDERING)
1234 D(bug("[IconList]: %s: Building unsplit label (len = %d) ..\n", __PRETTY_FUNCTION__, ie_LabelLength));
1235 #endif
1236
1237 if ((data->icld__Option_TrimVolumeNames) &&
1238 ((entry->ie_IconListEntry.type == ST_ROOT) && (entry->ie_IconListEntry.label[ie_LabelLength - 1] == ':')))
1239 ie_LabelLength--;
1240
1241 if(ie_LabelLength > data->icld__Option_LabelTextMaxLen)
1242 {
1243 if (!(entry->ie_TxtBuf_DisplayedLabel = AllocVecPooled(data->icld_Pool, data->icld__Option_LabelTextMaxLen + 1)))
1244 {
1245 return (IPTR)NULL;
1246 }
1247 memset(entry->ie_TxtBuf_DisplayedLabel, 0, data->icld__Option_LabelTextMaxLen + 1);
1248 strncpy(entry->ie_TxtBuf_DisplayedLabel, entry->ie_IconListEntry.label, data->icld__Option_LabelTextMaxLen - 3);
1249 strcat(entry->ie_TxtBuf_DisplayedLabel , " ..");
1250 }
1251 else
1252 {
1253 if (!(entry->ie_TxtBuf_DisplayedLabel = AllocVecPooled(data->icld_Pool, ie_LabelLength + 1)))
1254 {
1255 return (IPTR)NULL;
1256 }
1257 memset(entry->ie_TxtBuf_DisplayedLabel, 0, ie_LabelLength + 1);
1258 strncpy(entry->ie_TxtBuf_DisplayedLabel, entry->ie_IconListEntry.label, ie_LabelLength );
1259 }
1260 entry->ie_TxtBuf_DisplayedLabelWidth = TextLength(data->icld_BufferRastPort, entry->ie_TxtBuf_DisplayedLabel, strlen(entry->ie_TxtBuf_DisplayedLabel));
1261 // if ((data->icld_IconLabelFont->tf_YSize) > data->icld_LabelLargestHeight) data->icld_LabelLargestHeight = data->icld_IconLabelFont->tf_YSize;
1262 }
1263
1264 // if (entry->ie_TxtBuf_DisplayedLabelWidth > data->icld_LabelLargestWidth) data->icld_LabelLargestWidth = entry->ie_TxtBuf_DisplayedLabelWidth;
1265
1266 return (IPTR)entry->ie_TxtBuf_DisplayedLabel;
1267 }
1268 ///
1269
1270 ///IconList__HookFunc_UpdateLabelsFunc()
1271 AROS_UFH3(
1272 void, IconList__HookFunc_UpdateLabelsFunc,
1273 AROS_UFHA(struct Hook *, hook, A0),
1274 AROS_UFHA(APTR *, obj, A2),
1275 AROS_UFHA(APTR, param, A1)
1276 )
1277 {
1278 AROS_USERFUNC_INIT
1279
1280 /* Get our private data */
1281 Class *CLASS = *( Class **)param;
1282 struct IconList_DATA *data = INST_DATA(CLASS, obj);
1283
1284 #if defined(DEBUG_ILC_LASSO) || defined(DEBUG_ILC_FUNCS)
1285 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
1286 #endif
1287
1288 if (((data->icld__Option_LabelTextMaxLen != data->icld__Option_LastLabelTextMaxLen) &&
1289 (data->icld__Option_LabelTextMultiLine > 1)) ||
1290 (data->icld__Option_LabelTextMultiLine != data->icld__Option_LastLabelTextMultiLine));
1291 {
1292 struct IconEntry *iconentry_Current = NULL;
1293 #if defined(__AROS__)
1294 ForeachNode(&data->icld_IconList, iconentry_Current)
1295 #else
1296 Foreach_Node(&data->icld_IconList, iconentry_Current);
1297 #endif
1298 {
1299 IconList__LabelFunc_CreateLabel((Object *)obj, data, iconentry_Current);
1300 }
1301 }
1302
1303 data->icld__Option_LastLabelTextMaxLen = data->icld__Option_LabelTextMaxLen;
1304 data->icld__Option_LastLabelTextMultiLine = data->icld__Option_LabelTextMultiLine;
1305
1306 AROS_USERFUNC_EXIT
1307 }
1308 ///
1309
1310 ///IconList__MUIM_IconList_DrawEntryLabel()
1311 IPTR IconList__MUIM_IconList_DrawEntryLabel(struct IClass *CLASS, Object *obj, struct MUIP_IconList_DrawEntry *message)
1312 {
1313 struct IconList_DATA *data = INST_DATA(CLASS, obj);
1314
1315 STRPTR buf = NULL;
1316 BOOL outside = FALSE;
1317
1318 struct Rectangle iconlabelrect;
1319 struct Rectangle objrect;
1320
1321 ULONG txtbox_width = 0;
1322 LONG tx,ty,offsetx,offsety;
1323 LONG txwidth; // txheight;
1324
1325 ULONG objX, objY, objW, objH;
1326 LONG labelX, labelY;
1327
1328 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
1329 return FALSE;
1330
1331 if (data->icld_BufferRastPort == data->icld_DisplayRastPort)
1332 {
1333 objX = _mleft(obj);
1334 objY = _mtop(obj);
1335 }
1336 else
1337 {
1338 objX = objY = 0;
1339 }
1340 objW = _mright(obj) - _mleft(obj) + 1;
1341 objH = _mbottom(obj) - _mtop(obj) + 1;
1342
1343 ULONG txtarea_width;
1344 ULONG curlabel_TotalLines, curlabel_CurrentLine, offset_y;
1345
1346 #if defined(DEBUG_ILC_ICONRENDERING) || defined(DEBUG_ILC_FUNCS)
1347 D(bug("[IconList]: %s(message->entry = 0x%p), '%s'\n", __PRETTY_FUNCTION__, message->entry, message->entry->ie_IconListEntry.label));
1348 #endif
1349
1350 if ((!(message->entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)) ||
1351 (data->icld_BufferRastPort == NULL) ||
1352 (!(message->entry->ie_DiskObj)))
1353 {
1354 #if defined(DEBUG_ILC_ICONRENDERING)
1355 D(bug("[IconList] %s: Not visible or missing DOB\n", __PRETTY_FUNCTION__));
1356 #endif
1357 return FALSE;
1358 }
1359
1360 /* Get the dimensions and affected area of message->entry's label */
1361 IconList_GetIconLabelRectangle(obj, data, message->entry, &iconlabelrect);
1362
1363 /* Add the relative position offset of the message->entry's label */
1364 offsetx = (objX - data->icld_ViewX) + message->entry->ie_IconX;
1365 txtbox_width = (iconlabelrect.MaxX - iconlabelrect.MinX) + 1;
1366
1367 if (txtbox_width < message->entry->ie_AreaWidth)
1368 offsetx += ((message->entry->ie_AreaWidth - txtbox_width)/2);
1369
1370 if ((data->icld__Option_IconListMode == ICON_LISTMODE_GRID) &&
1371 (message->entry->ie_AreaWidth < data->icld_IconAreaLargestWidth))
1372 offsetx += ((data->icld_IconAreaLargestWidth - message->entry->ie_AreaWidth)/2);
1373
1374 iconlabelrect.MinX += offsetx;
1375 iconlabelrect.MaxX += offsetx;
1376
1377 offsety = (objY - data->icld_ViewY) + message->entry->ie_IconY + data->icld__Option_IconImageSpacing;
1378 if ((data->icld__Option_IconListMode == ICON_LISTMODE_GRID) &&
1379 (message->entry->ie_AreaHeight < data->icld_IconAreaLargestHeight))
1380 offsety += ((data->icld_IconAreaLargestHeight - message->entry->ie_AreaHeight)/2);
1381
1382 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
1383 {
1384 offsety = offsety + data->icld_IconLargestHeight;
1385 }
1386 else
1387 {
1388 offsety = offsety + message->entry->ie_IconHeight;
1389 }
1390 iconlabelrect.MinY += offsety;
1391 iconlabelrect.MaxY += offsety;
1392
1393 /* Add the relative position of the window */
1394 objrect.MinX = objX;
1395 objrect.MinY = objX;
1396 objrect.MaxX = objX + objW;
1397 objrect.MaxY = objY + objH;
1398
1399 if (!RectAndRect(&iconlabelrect, &objrect))
1400 {
1401 #if defined(DEBUG_ILC_ICONRENDERING)
1402 (bug("[IconList] %s: Entry '%s' label outside of visible area .. skipping\n", __PRETTY_FUNCTION__, message->entry->ie_IconListEntry.label));
1403 #endif
1404 return FALSE;
1405 }
1406
1407 /* data->update_rect1 and data->update_rect2 may
1408 point to rectangles to indicate that only icons
1409 in any of this rectangles need to be drawn */
1410 if (data->update_rect1)
1411 {
1412 if (!RectAndRect(&iconlabelrect, data->update_rect1))
1413 outside = TRUE;
1414 }
1415
1416 if (data->update_rect2)
1417 {
1418 if (data->update_rect1)
1419 {
1420 if ((outside == TRUE) && RectAndRect(&iconlabelrect, data->update_rect2))
1421 outside = FALSE;
1422 }
1423 else
1424 {
1425 if (!RectAndRect(&iconlabelrect, data->update_rect2))
1426 outside = TRUE;
1427 }
1428 }
1429
1430 if (outside == TRUE)
1431 {
1432 #if defined(DEBUG_ILC_ICONRENDERING)
1433 D(bug("[IconList] %s: Entry '%s' label outside of update area .. skipping\n", __PRETTY_FUNCTION__, message->entry->ie_IconListEntry.label));
1434 #endif
1435 return FALSE;
1436 }
1437
1438 if (message->drawmode == ICONENTRY_DRAWMODE_NONE)
1439 return TRUE;
1440
1441 SetABPenDrMd(data->icld_BufferRastPort, _pens(obj)[MPEN_TEXT], 0, JAM1);
1442
1443 iconlabelrect.MinX = (iconlabelrect.MinX - objX) + data->icld_DrawOffsetX;
1444 iconlabelrect.MinY = (iconlabelrect.MinY - objY) + data->icld_DrawOffsetY;
1445 iconlabelrect.MaxX = (iconlabelrect.MaxX - objX) + data->icld_DrawOffsetX;
1446 iconlabelrect.MaxY = (iconlabelrect.MaxY - objY) + data->icld_DrawOffsetY;
1447
1448 labelX = iconlabelrect.MinX + data->icld__Option_LabelTextBorderWidth + data->icld__Option_LabelTextHorizontalPadding;
1449 labelY = iconlabelrect.MinY + data->icld__Option_LabelTextBorderHeight + data->icld__Option_LabelTextVerticalPadding;
1450
1451 txtarea_width = txtbox_width - ((data->icld__Option_LabelTextBorderWidth + data->icld__Option_LabelTextHorizontalPadding) * 2);
1452
1453 #if defined(DEBUG_ILC_ICONRENDERING)
1454 D(bug("[IconList] %s: Drawing Label '%s' .. %d, %d\n", __PRETTY_FUNCTION__, message->entry->ie_IconListEntry.label, labelX, labelY));
1455 #endif
1456 if (message->entry->ie_IconListEntry.label && message->entry->ie_TxtBuf_DisplayedLabel)
1457 {
1458 char *curlabel_StrPtr;
1459
1460 if ((message->entry->ie_Flags & ICONENTRY_FLAG_FOCUS))
1461 {
1462 //Draw the focus box around the selected label ..
1463 if (data->icld__Option_LabelTextBorderHeight > 0)
1464 {
1465 InvertPixelArray(data->icld_BufferRastPort,
1466 iconlabelrect.MinX, iconlabelrect.MinY,
1467 (iconlabelrect.MaxX - iconlabelrect.MinX) + 1, data->icld__Option_LabelTextBorderHeight);
1468
1469 InvertPixelArray(data->icld_BufferRastPort,
1470 iconlabelrect.MinX, iconlabelrect.MaxY - (data->icld__Option_LabelTextBorderHeight - 1),
1471 (iconlabelrect.MaxX - iconlabelrect.MinX) + 1, data->icld__Option_LabelTextBorderHeight);
1472 }
1473 if (data->icld__Option_LabelTextBorderWidth > 0)
1474 {
1475 InvertPixelArray(data->icld_BufferRastPort,
1476 iconlabelrect.MinX, iconlabelrect.MinY + data->icld__Option_LabelTextBorderHeight,
1477 data->icld__Option_LabelTextBorderWidth, (((iconlabelrect.MaxY - iconlabelrect.MinY) + 1) - (data->icld__Option_LabelTextBorderHeight * 2)));
1478
1479 InvertPixelArray(data->icld_BufferRastPort,
1480 iconlabelrect.MaxX - (data->icld__Option_LabelTextBorderWidth - 1), iconlabelrect.MinY + data->icld__Option_LabelTextBorderHeight,
1481 data->icld__Option_LabelTextBorderWidth, (((iconlabelrect.MaxY - iconlabelrect.MinY) + 1) - (data->icld__Option_LabelTextBorderHeight * 2)));
1482 }
1483 }
1484
1485 SetFont(data->icld_BufferRastPort, data->icld_IconLabelFont);
1486
1487 curlabel_TotalLines = message->entry->ie_SplitParts;
1488 curlabel_CurrentLine = 0;
1489
1490 if (curlabel_TotalLines == 0)
1491 curlabel_TotalLines = 1;
1492
1493 if (!(data->icld__Option_LabelTextMultiLineOnFocus) || (data->icld__Option_LabelTextMultiLineOnFocus && (message->entry->ie_Flags & ICONENTRY_FLAG_FOCUS)))
1494 {
1495 if (curlabel_TotalLines > data->icld__Option_LabelTextMultiLine)
1496 curlabel_TotalLines = data->icld__Option_LabelTextMultiLine;
1497 }
1498 else
1499 curlabel_TotalLines = 1;
1500
1501 curlabel_StrPtr = message->entry->ie_TxtBuf_DisplayedLabel;
1502
1503 ty = labelY - 1;
1504
1505 #if defined(DEBUG_ILC_ICONRENDERING)
1506 D(bug("[IconList] %s: Font YSize %d Baseline %d\n", __PRETTY_FUNCTION__,data->icld_IconLabelFont->tf_YSize, data->icld_IconLabelFont->tf_Baseline));
1507 #endif
1508 for (curlabel_CurrentLine = 0; curlabel_CurrentLine < curlabel_TotalLines; curlabel_CurrentLine++)
1509 {
1510 ULONG ie_LabelLength;
1511
1512 if (curlabel_CurrentLine > 0) curlabel_StrPtr = curlabel_StrPtr + strlen(curlabel_StrPtr) + 1;
1513 if ((curlabel_CurrentLine >= (curlabel_TotalLines -1)) && (curlabel_TotalLines < message->entry->ie_SplitParts))
1514 {
1515 char *tmpLine = curlabel_StrPtr;
1516 ULONG tmpLen = strlen(tmpLine);
1517
1518 if ((curlabel_StrPtr = AllocVecPooled(data->icld_Pool, tmpLen + 1)) != NULL)
1519 {
1520 memset(curlabel_StrPtr, 0, tmpLen + 1);
1521 strncpy(curlabel_StrPtr, tmpLine, tmpLen - 3);
1522 strcat(curlabel_StrPtr , " ..");
1523 }
1524 else
1525 return FALSE;
1526
1527 }
1528
1529 ie_LabelLength = strlen(curlabel_StrPtr);
1530 offset_y = 0;
1531
1532 // Center message->entry's label
1533 tx = (labelX + (message->entry->ie_TxtBuf_DisplayedLabelWidth / 2) - (TextLength(data->icld_BufferRastPort, curlabel_StrPtr, strlen(curlabel_StrPtr)) / 2));
1534
1535 if (message->entry->ie_TxtBuf_DisplayedLabelWidth < txtarea_width)
1536 tx += ((txtarea_width - message->entry->ie_TxtBuf_DisplayedLabelWidth)/2);
1537
1538 ty = ty + data->icld_IconLabelFont->tf_YSize;
1539
1540 switch ( data->icld__Option_LabelTextMode )
1541 {
1542 case ICON_TEXTMODE_DROPSHADOW:
1543 SetAPen(data->icld_BufferRastPort, data->icld_LabelShadowPen);
1544 Move(data->icld_BufferRastPort, tx + 1, ty + 1);
1545 Text(data->icld_BufferRastPort, curlabel_StrPtr, ie_LabelLength);
1546 offset_y = 1;
1547 case ICON_TEXTMODE_PLAIN:
1548 SetAPen(data->icld_BufferRastPort, data->icld_LabelPen);
1549 Move(data->icld_BufferRastPort, tx, ty);
1550 Text(data->icld_BufferRastPort, curlabel_StrPtr, ie_LabelLength);
1551 break;
1552
1553 default:
1554 // Outline mode:
1555 SetSoftStyle(data->icld_BufferRastPort, FSF_BOLD, AskSoftStyle(data->icld_BufferRastPort));
1556
1557 SetAPen(data->icld_BufferRastPort, data->icld_LabelShadowPen);
1558 Move(data->icld_BufferRastPort, tx + 1, ty );
1559 Text(data->icld_BufferRastPort, curlabel_StrPtr, ie_LabelLength);
1560 Move(data->icld_BufferRastPort, tx - 1, ty );
1561 Text(data->icld_BufferRastPort, curlabel_StrPtr, ie_LabelLength);
1562 Move(data->icld_BufferRastPort, tx, ty + 1);
1563 Text(data->icld_BufferRastPort, curlabel_StrPtr, ie_LabelLength);
1564 Move(data->icld_BufferRastPort, tx, ty - 1);
1565 Text(data->icld_BufferRastPort, curlabel_StrPtr, ie_LabelLength);
1566
1567 SetAPen(data->icld_BufferRastPort, data->icld_LabelPen);
1568 Move(data->icld_BufferRastPort, tx , ty );
1569 Text(data->icld_BufferRastPort, curlabel_StrPtr, ie_LabelLength);
1570
1571 SetSoftStyle(data->icld_BufferRastPort, FS_NORMAL, AskSoftStyle(data->icld_BufferRastPort));
1572 offset_y = 2;
1573 break;
1574 }
1575 if ((curlabel_CurrentLine >= (curlabel_TotalLines -1)) && (curlabel_TotalLines < message->entry->ie_SplitParts))
1576 {
1577 FreeVecPooled(data->icld_Pool, curlabel_StrPtr);
1578 }
1579 ty = ty + offset_y;
1580 }
1581
1582 /*date/size sorting has the date/size appended under the message->entry label*/
1583
1584 if ((message->entry->ie_IconListEntry.type != ST_USERDIR) && ((data->icld_SortFlags & (MUIV_IconList_Sort_BySize|MUIV_IconList_Sort_ByDate)) != 0))
1585 {
1586 buf = NULL;
1587 SetFont(data->icld_BufferRastPort, data->icld_IconInfoFont);
1588
1589 if (data->icld_SortFlags & MUIV_IconList_Sort_BySize)
1590 {
1591 buf = message->entry->ie_TxtBuf_SIZE;
1592 txwidth = message->entry->ie_TxtBuf_SIZEWidth;
1593 }
1594 else if (data->icld_SortFlags & MUIV_IconList_Sort_ByDate)
1595 {
1596 if (message->entry->ie_Flags & ICONENTRY_FLAG_TODAY)
1597 {
1598 buf = message->entry->ie_TxtBuf_TIME;
1599 txwidth = message->entry->ie_TxtBuf_TIMEWidth;
1600 }
1601 else
1602 {
1603 buf = message->entry->ie_TxtBuf_DATE;
1604 txwidth = message->entry->ie_TxtBuf_DATEWidth;
1605 }
1606 }
1607
1608 if (buf)
1609 {
1610 ULONG ie_LabelLength = strlen(buf);
1611 tx = labelX;
1612
1613 if (txwidth < txtarea_width)
1614 tx += ((txtarea_width - txwidth)/2);
1615
1616 ty = labelY + ((data->icld__Option_LabelTextVerticalPadding + data->icld_IconLabelFont->tf_YSize ) * curlabel_TotalLines) + data->icld_IconInfoFont->tf_YSize;
1617
1618 switch ( data->icld__Option_LabelTextMode )
1619 {
1620 case ICON_TEXTMODE_DROPSHADOW:
1621 SetAPen(data->icld_BufferRastPort, data->icld_InfoShadowPen);
1622 Move(data->icld_BufferRastPort, tx + 1, ty + 1); Text(data->icld_BufferRastPort, buf, ie_LabelLength);
1623 case ICON_TEXTMODE_PLAIN:
1624 SetAPen(data->icld_BufferRastPort, data->icld_InfoPen);
1625 Move(data->icld_BufferRastPort, tx, ty); Text(data->icld_BufferRastPort, buf, ie_LabelLength);
1626 break;
1627
1628 default:
1629 // Outline mode..
1630 SetSoftStyle(data->icld_BufferRastPort, FSF_BOLD, AskSoftStyle(data->icld_BufferRastPort));
1631 SetAPen(data->icld_BufferRastPort, data->icld_InfoShadowPen);
1632
1633 Move(data->icld_BufferRastPort, tx + 1, ty );
1634 Text(data->icld_BufferRastPort, buf, ie_LabelLength);
1635 Move(data->icld_BufferRastPort, tx - 1, ty );
1636 Text(data->icld_BufferRastPort, buf, ie_LabelLength);
1637 Move(data->icld_BufferRastPort, tx, ty - 1 );
1638 Text(data->icld_BufferRastPort, buf, ie_LabelLength);
1639 Move(data->icld_BufferRastPort, tx, ty + 1 );
1640 Text(data->icld_BufferRastPort, buf, ie_LabelLength);
1641
1642 SetAPen(data->icld_BufferRastPort, data->icld_InfoPen);
1643
1644 Move(data->icld_BufferRastPort, tx, ty );
1645 Text(data->icld_BufferRastPort, buf, ie_LabelLength);
1646
1647 SetSoftStyle(data->icld_BufferRastPort, FS_NORMAL, AskSoftStyle(data->icld_BufferRastPort));
1648 break;
1649 }
1650 }
1651 }
1652 }
1653
1654 return TRUE;
1655 }
1656 ///
1657 /**************************************************************************
1658
1659 **************************************************************************/
1660 ///IconList__MUIM_IconList_RethinkDimensions()
1661 IPTR IconList__MUIM_IconList_RethinkDimensions(struct IClass *CLASS, Object *obj, struct MUIP_IconList_RethinkDimensions *message)
1662 {
1663 struct IconList_DATA *data = INST_DATA(CLASS, obj);
1664
1665 struct IconEntry *entry = NULL;
1666 LONG maxx = 0,
1667 maxy = 0;
1668 struct Rectangle icon_rect;
1669
1670 #if defined(DEBUG_ILC_ICONPOSITIONING) || defined(DEBUG_ILC_FUNCS)
1671 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
1672 #endif
1673
1674 if (message->singleicon != NULL)
1675 {
1676 entry = message->singleicon;
1677 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
1678 {
1679 maxy = data->icld_LVMAttribs->lmva_RowHeight;
1680 if ((data->icld_LVMAttribs->lvma_Flags & LVMAF_NOHEADER) == 0)
1681 {
1682 maxy += data->icld_LVMAttribs->lmva_HeaderHeight;
1683 }
1684 }
1685 else
1686 {
1687 maxx = data->icld_AreaWidth - 1,
1688 maxy = data->icld_AreaHeight - 1;
1689 }
1690
1691 #if defined(DEBUG_ILC_ICONPOSITIONING)
1692 D(bug("[IconList] %s: SingleIcon - maxx = %d, maxy = %d\n", __PRETTY_FUNCTION__, maxx, maxy));
1693 #endif
1694 }
1695 else
1696 {
1697 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
1698 {
1699 maxy = data->icld_LVMAttribs->lmva_RowHeight;
1700 if ((data->icld_LVMAttribs->lvma_Flags & LVMAF_NOHEADER) == 0)
1701 {
1702 maxy += data->icld_LVMAttribs->lmva_HeaderHeight;
1703 }
1704 }
1705 entry = (struct IconEntry *)GetHead(&data->icld_IconList);
1706 }
1707
1708 while (entry != NULL)
1709 {
1710 if (entry->ie_DiskObj &&
1711 (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE))
1712 {
1713 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
1714 {
1715 maxy += data->icld_LVMAttribs->lmva_RowHeight;
1716 }
1717 else
1718 {
1719 IconList_GetIconAreaRectangle(obj, data, entry, &icon_rect);
1720
1721 icon_rect.MaxX += entry->ie_IconX + data->icld__Option_IconHorizontalSpacing;
1722 if ((data->icld__Option_IconListMode == ICON_LISTMODE_GRID) &&
1723 (entry->ie_AreaWidth < data->icld_IconAreaLargestWidth))
1724 icon_rect.MaxX += (data->icld_IconAreaLargestWidth - entry->ie_AreaWidth);
1725
1726 icon_rect.MaxY += entry->ie_IconY + data->icld__Option_IconVerticalSpacing;
1727
1728 if (icon_rect.MaxX > maxx) maxx = icon_rect.MaxX;
1729 if (icon_rect.MaxY > maxy) maxy = icon_rect.MaxY;
1730 }
1731 }
1732
1733 if (message->singleicon)
1734 break;
1735
1736 entry = (struct IconEntry *)GetSucc(&entry->ie_IconNode);
1737 }
1738
1739 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
1740 {
1741 int col;
1742
1743 for(col = 0; col < NUM_COLUMNS; col++)
1744 {
1745 LONG index = data->icld_LVMAttribs->lmva_ColumnPos[col];
1746
1747 if (!(data->icld_LVMAttribs->lmva_ColumnFlags[index] & LVMCF_COLVISIBLE)) continue;
1748
1749 maxx += data->icld_LVMAttribs->lmva_ColumnWidth[index];
1750 }
1751 }
1752
1753 /* update our view when max x/y have changed */
1754 if (maxx + 1 != data->icld_AreaWidth)
1755 {
1756 data->icld_AreaWidth = maxx + 1;
1757 SET(obj, MUIA_IconList_Width, data->icld_AreaWidth);
1758 }
1759 if (maxy + 1 != data->icld_AreaHeight)
1760 {
1761 data->icld_AreaHeight = maxy + 1;
1762 SET(obj, MUIA_IconList_Height, data->icld_AreaHeight);
1763 }
1764
1765 return TRUE;
1766 }
1767
1768 /*
1769 * This function executes the layouting when AutoSort is enabled. This means all icons are layouted regardless if
1770 * they have Provided position or not.
1771 */
1772
1773 static VOID IconList_Layout_FullAutoLayout(struct IClass *CLASS, Object *obj)
1774 {
1775 struct IconList_DATA *data = INST_DATA(CLASS, obj);
1776 struct IconEntry *entry = NULL;
1777 struct IconEntry *pass_first = NULL; /* First entry of current column or row */
1778
1779 LONG left = data->icld__Option_IconHorizontalSpacing;
1780 LONG top = data->icld__Option_IconVerticalSpacing;
1781 LONG cur_x = left;
1782 LONG cur_y = top;
1783 LONG gridx = 0;
1784 LONG gridy = 0;
1785 LONG maxw = 0; /* Widest & talest entry in a column or row */
1786 LONG maxh = 0;
1787
1788 BOOL calcnextpos;
1789 struct Rectangle iconrect;
1790
1791 /* Now go to the actual positioning */
1792 entry = (struct IconEntry *)GetHead(&data->icld_IconList);
1793 while (entry != NULL)
1794 {
1795 calcnextpos = FALSE;
1796 if ((entry->ie_DiskObj != NULL) && (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE))
1797 {
1798 calcnextpos = TRUE;
1799
1800 /* Set previously calculated position to this icon */
1801 entry->ie_IconX = cur_x;
1802 entry->ie_IconY = cur_y;
1803
1804 if (entry->ie_Flags & ICONENTRY_FLAG_SELECTED)
1805 {
1806 if (data->icld_SelectionLastClicked == NULL) data->icld_SelectionLastClicked = entry;
1807 if (data->icld_FocusIcon == NULL) data->icld_FocusIcon = entry;
1808 }
1809
1810 /* Calculate grid size to advanced the coordinate in next step */
1811 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
1812 {
1813 maxw = data->icld_IconAreaLargestWidth + data->icld__Option_IconHorizontalSpacing;
1814 maxh = data->icld_IconLargestHeight + data->icld__Option_IconImageSpacing + data->icld_LabelLargestHeight + data->icld__Option_IconVerticalSpacing;
1815 gridx = maxw;
1816 gridy = maxh;
1817 }
1818 else
1819 {
1820 if (!(pass_first)) pass_first = entry;
1821
1822 IconList_GetIconAreaRectangle(obj, data, entry, &iconrect);
1823
1824 if ((maxw < entry->ie_AreaWidth) || (maxh < entry->ie_AreaHeight))
1825 {
1826 if (maxw < entry->ie_AreaWidth) maxw = entry->ie_AreaWidth;
1827 if (maxh < entry->ie_AreaHeight) maxh = entry->ie_AreaHeight;
1828 if (pass_first != entry)
1829 {
1830 entry = pass_first;
1831 cur_x = entry->ie_IconX;
1832 cur_y = entry->ie_IconY;
1833 /* We detected that the new icon it taller/wider than icons so far in this row/column.
1834 * We need to re-layout this row/column. */
1835 continue;
1836 }
1837 }
1838
1839 if (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)
1840 {
1841 /* Centering */
1842 if (entry->ie_AreaWidth < maxw)
1843 entry->ie_IconX += ( maxw - entry->ie_AreaWidth ) / 2;
1844
1845 gridx = maxw;
1846 gridy = entry->ie_AreaHeight + data->icld__Option_IconVerticalSpacing;
1847 }
1848 else
1849 {
1850 /* Centering */ /* Icons look better not centered in this case - disabled */
1851 /* if (entry->ie_AreaHeight < maxh)
1852 entry->ie_IconY += ( maxh - entry->ie_AreaHeight ) / 2; */
1853
1854 gridx = entry->ie_AreaWidth + data->icld__Option_IconHorizontalSpacing;
1855 gridy = maxh;
1856 }
1857 }
1858 }
1859
1860 /*
1861 * Advance to next icon and calculate its position based on grid sizes from previous step.
1862 * Don't set position - it is done at beginning of the loop.
1863 */
1864 if ((entry = (struct IconEntry *)GetSucc(&entry->ie_IconNode)) != NULL)
1865 {
1866 if (calcnextpos)
1867 {
1868 if (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)
1869 {
1870 cur_y += gridy;
1871
1872 if ((cur_y >= data->icld_ViewHeight) ||
1873 ((data->icld__Option_IconListMode == ICON_LISTMODE_ROUGH) && ((cur_y + entry->ie_AreaHeight - data->icld__Option_IconBorderOverlap) >= data->icld_ViewHeight)) ||
1874 ((data->icld__Option_IconListMode == ICON_LISTMODE_GRID) && ((cur_y + data->icld_IconAreaLargestHeight - data->icld__Option_IconBorderOverlap) >= data->icld_ViewHeight)))
1875 {
1876 /* Wrap "around" if the icon would be below bottom border */
1877 cur_x += maxw;
1878 cur_y = top;
1879 pass_first = NULL;
1880 maxw = 0;
1881 }
1882 }
1883 else
1884 {
1885 cur_x += gridx;
1886
1887 if ((cur_x >= data->icld_ViewWidth) ||
1888 ((data->icld__Option_IconListMode == ICON_LISTMODE_ROUGH) && ((cur_x + entry->ie_AreaWidth - data->icld__Option_IconBorderOverlap) >= data->icld_ViewWidth)) ||
1889 ((data->icld__Option_IconListMode == ICON_LISTMODE_GRID) && ((cur_x + data->icld_IconAreaLargestWidth - data->icld__Option_IconBorderOverlap) >= data->icld_ViewWidth)))
1890 {
1891 /* Wrap "around" if the icon would be right of right border */
1892 cur_x = left;
1893 cur_y += maxh;
1894 pass_first = NULL;
1895 maxh = 0;
1896 }
1897 }
1898 }
1899 }
1900 }
1901 }
1902
1903 static VOID IconList_Layout_PartialAutoLayout(struct IClass *CLASS, Object *obj)
1904 {
1905 struct IconList_DATA *data = INST_DATA(CLASS, obj);
1906 struct Region *occupied = NewRegion();
1907 struct IconEntry *entry = NULL;
1908 LONG left = data->icld__Option_IconHorizontalSpacing;
1909 LONG top = data->icld__Option_IconVerticalSpacing;
1910 LONG cur_x = left, cur_y = top;
1911
1912 entry = (struct IconEntry *)GetHead(&data->icld_IconList);
1913 while (entry != NULL)
1914 {
1915 if ((entry->ie_ProvidedIconX != NO_ICON_POSITION) && (entry->ie_ProvidedIconY != NO_ICON_POSITION)
1916 && (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE))
1917 {
1918 struct Rectangle iconrect = {
1919 entry->ie_ProvidedIconX,
1920 entry->ie_ProvidedIconY,
1921 entry->ie_ProvidedIconX + entry->ie_AreaWidth - 1,
1922 entry->ie_ProvidedIconY + entry->ie_AreaHeight - 1
1923 };
1924
1925 if (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)
1926 iconrect.MaxY += data->icld__Option_IconVerticalSpacing;
1927 else
1928 iconrect.MaxX += data->icld__Option_IconHorizontalSpacing;
1929
1930 D(bug("Adding %s (%d %d)(%d %d)\n", entry->ie_TxtBuf_DisplayedLabel,
1931 (LONG)iconrect.MinX, (LONG)iconrect.MinY, (LONG)iconrect.MaxX, (LONG)iconrect.MaxY));
1932
1933 OrRectRegion(occupied, &iconrect);
1934 }
1935 entry = (struct IconEntry *)GetSucc(&entry->ie_IconNode);
1936 }
1937
1938 /* Now go to the actual positioning */
1939 entry = (struct IconEntry *)GetHead(&data->icld_IconList);
1940 while (entry != NULL)
1941 {
1942 if ((entry->ie_DiskObj != NULL) && (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE))
1943 {
1944 if ((entry->ie_ProvidedIconX != NO_ICON_POSITION) && (entry->ie_ProvidedIconY != NO_ICON_POSITION))
1945 {
1946 entry->ie_IconX = entry->ie_ProvidedIconX;
1947 entry->ie_IconY = entry->ie_ProvidedIconY;
1948 }
1949 else
1950 {
1951 LONG gridx, gridy, stepx, stepy, addx = 0;
1952 struct Rectangle iconarea;
1953 BOOL first = TRUE;
1954
1955 /* Calculate grid size and step */
1956 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
1957 {
1958 gridx = data->icld_IconAreaLargestWidth + data->icld__Option_IconHorizontalSpacing;
1959 gridy = data->icld_IconLargestHeight + data->icld__Option_IconImageSpacing + data->icld_LabelLargestHeight + data->icld__Option_IconVerticalSpacing;
1960 stepx = gridx;
1961 stepy = gridy;
1962 }
1963 else
1964 {
1965 if (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)
1966 {
1967 gridx = data->icld_IconAreaLargestWidth; /* This gives better centering effect */
1968 gridy = entry->ie_AreaHeight + data->icld__Option_IconVerticalSpacing;
1969 stepx = gridx;
1970 stepy = 2;
1971 addx = (gridx - entry->ie_AreaWidth) / 2;
1972 }
1973 else
1974 {
1975 gridx = entry->ie_AreaWidth + data->icld__Option_IconHorizontalSpacing;
1976 gridy = entry->ie_AreaHeight + data->icld__Option_IconVerticalSpacing;
1977 stepx = 2;
1978 stepy = gridy;
1979 }
1980 }
1981
1982 /* Find first not occupied spot matching the calculate rectangle */
1983 do
1984 {
1985 if (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)
1986 {
1987 /* Advance to next position */
1988 if (!first) cur_y += stepy;
1989
1990 if ((cur_y >= data->icld_ViewHeight) ||
1991 ((cur_y + gridy - data->icld__Option_IconBorderOverlap) >= data->icld_ViewHeight))
1992 {
1993 /* Wrap "around" if the icon would be below bottom border */
1994 cur_x += stepx;
1995 cur_y = top;
1996 }
1997 }
1998 else
1999 {
2000 /* Advance to next position */
2001 if (!first) cur_x += stepx;
2002
2003 if ((cur_x >= data->icld_ViewWidth) ||
2004 ((cur_x + gridx - data->icld__Option_IconBorderOverlap) >= data->icld_ViewWidth))
2005 {
2006 /* Wrap "around" if the icon would be right of right border */
2007 cur_x = left;
2008 cur_y += stepy;
2009 }
2010 }
2011
2012 iconarea.MinX = cur_x;
2013 iconarea.MinY = cur_y;
2014 iconarea.MaxX = cur_x + gridx - 1;
2015 iconarea.MaxY = cur_y + gridy - 1;
2016
2017 first = FALSE;
2018
2019 } while(RegionAndRect(occupied, &iconarea));
2020
2021 entry->ie_IconX = iconarea.MinX + addx;
2022 entry->ie_IconY = iconarea.MinY;
2023
2024 /* Add this area to occupied list */
2025 OrRectRegion(occupied, &iconarea);
2026
2027 /* Add spacing to next icon */
2028 if (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)
2029 cur_y += gridy;
2030 else
2031 cur_x += gridx;
2032 }
2033 }
2034
2035 entry = (struct IconEntry *)GetSucc(&entry->ie_IconNode);
2036 }
2037
2038 DisposeRegion(occupied);
2039 }
2040
2041
2042 ///IconList__MUIM_IconList_PositionIcons()
2043 /**************************************************************************
2044 MUIM_PositionIcons - Place icons with NO_ICON_POSITION coords somewhere
2045 **************************************************************************/
2046 IPTR IconList__MUIM_IconList_PositionIcons(struct IClass *CLASS, Object *obj, struct MUIP_IconList_PositionIcons *message)
2047 {
2048 struct IconList_DATA *data = INST_DATA(CLASS, obj);
2049 struct IconEntry *entry = NULL;
2050
2051
2052 #if defined(DEBUG_ILC_ICONPOSITIONING) || defined(DEBUG_ILC_FUNCS)
2053 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2054 #endif
2055 if ((data->icld_SortFlags & MUIV_IconList_Sort_AutoSort) == 0)
2056 {
2057 IconList_Layout_PartialAutoLayout(CLASS, obj);
2058 }
2059 else
2060 {
2061 IconList_Layout_FullAutoLayout(CLASS, obj);
2062 }
2063
2064 /*
2065 * Set Provided icon position on all icons (this can't be done as part of previous loop!)
2066 * The icons will not no longer be autolayouted unless MUIV_IconList_Sort_AutoSort is set.
2067 * This give the stability that new icons appearing won't make existing icons jump from their places
2068 */
2069 entry = (struct IconEntry *)GetHead(&data->icld_IconList);
2070 while (entry != NULL)
2071 {
2072 if (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
2073 DoMethod(obj, MUIM_IconList_PropagateEntryPos, entry);
2074
2075 entry = (struct IconEntry *)GetSucc(&entry->ie_IconNode);
2076 }
2077
2078
2079 DoMethod(obj, MUIM_IconList_RethinkDimensions, NULL);
2080 return (IPTR)NULL;
2081 }
2082 ///
2083
2084 ///OM_NEW()
2085
2086 #define ICONENTRY_SIZE 16
2087
2088 static inline void CalcHeight(struct ListViewModeAttribs *LVMAttribs, struct TextFont *LabelFont)
2089 {
2090 ULONG YSize = LabelFont ? LabelFont->tf_YSize : 0;
2091
2092 LVMAttribs->lmva_HeaderHeight = HEADERLINE_EXTRAHEIGHT + YSize;
2093 LVMAttribs->lmva_RowHeight = LINE_EXTRAHEIGHT + ((ICONENTRY_SIZE > YSize) ? ICONENTRY_SIZE : YSize);
2094 }
2095
2096 /**************************************************************************
2097 OM_NEW
2098 **************************************************************************/
2099 IPTR IconList__OM_NEW(struct IClass *CLASS, Object *obj, struct opSet *message)
2100 {
2101 struct IconList_DATA *data = NULL;
2102 struct TextFont *icl_WindowFont = NULL;
2103 // struct RastPort *icl_RastPort = NULL;
2104 int i;
2105
2106 #if defined(DEBUG_ILC_FUNCS)
2107 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2108 #endif
2109
2110 icl_WindowFont = (struct TextFont *) GetTagData(MUIA_Font, (IPTR) NULL, message->ops_AttrList);
2111
2112 obj = (Object *)DoSuperNewTags(CLASS, obj, NULL,
2113 MUIA_FillArea, FALSE,
2114 MUIA_Dropable, TRUE,
2115 MUIA_Font, MUIV_Font_Tiny,
2116 TAG_MORE, (IPTR) message->ops_AttrList);
2117
2118 if (!obj) return FALSE;
2119
2120 data = INST_DATA(CLASS, obj);
2121
2122 data->icld_Pool = CreatePool(0,4096,4096);
2123 if (!data->icld_Pool)
2124 {
2125 CoerceMethod(CLASS,obj,OM_DISPOSE);
2126 return (IPTR)NULL;
2127 }
2128
2129 #if defined(DEBUG_ILC_FUNCS)
2130 D(bug("[IconList] %s: SELF = 0x%p, muiRenderInfo = 0x%p\n", __PRETTY_FUNCTION__, obj, muiRenderInfo(obj)));
2131 #endif
2132 NewList((struct List*)&data->icld_IconList);
2133 NewList((struct List*)&data->icld_SelectionList);
2134
2135 data->icld_IconLabelFont = icl_WindowFont;
2136
2137 /* Setup Icon View-Mode options */
2138 data->icld_IVMAttribs = AllocMem(sizeof(struct IconViewModeAttribs), MEMF_CLEAR);
2139 /* Setup List View-Mode options */
2140 if ((data->icld_LVMAttribs = AllocMem(sizeof(struct ListViewModeAttribs), MEMF_CLEAR)) != NULL)
2141 {
2142 for(i = 0; i < NUM_COLUMNS; i++)
2143 {
2144 data->icld_LVMAttribs->lmva_ColumnPos[i] = i;
2145 data->icld_LVMAttribs->lmva_ColumnFlags[i] = LVMCF_COLVISIBLE;
2146 data->icld_LVMAttribs->lmva_ColumnWidth[i] = 100;
2147 data->icld_LVMAttribs->lmva_ColumnHAlign[i] = COLUMN_ALIGN_LEFT;
2148 switch (i)
2149 {
2150 case INDEX_TYPE:
2151 data->icld_LVMAttribs->lmva_ColumnHAlign[i] = COLUMN_ALIGN_RIGHT;
2152 data->icld_LVMAttribs->lmva_ColumnFlags[i] |= (LVMCF_COLCLICKABLE|LVMCF_COLSORTABLE);
2153 data->icld_LVMAttribs->lmva_ColumnTitle[i] = "Type";
2154 data->icld_LVMAttribs->lmva_ColumnWidth[i] = ICONENTRY_SIZE + 2;
2155 break;
2156
2157 case INDEX_NAME:
2158 data->icld_LVMAttribs->lmva_ColumnFlags[i] |= (LVMCF_COLCLICKABLE|LVMCF_COLSORTABLE);
2159 data->icld_LVMAttribs->lmva_ColumnTitle[i] = "Name";
2160 break;
2161
2162 case INDEX_SIZE:
2163 data->icld_LVMAttribs->lmva_ColumnHAlign[i] = COLUMN_ALIGN_RIGHT;
2164 data->icld_LVMAttribs->lmva_ColumnFlags[i] |= LVMCF_COLSORTABLE;
2165 data->icld_LVMAttribs->lmva_ColumnTitle[i] = "Size";
2166 break;
2167
2168 case INDEX_LASTACCESS:
2169 data->icld_LVMAttribs->lmva_ColumnFlags[i] |= LVMCF_COLSORTABLE;
2170 data->icld_LVMAttribs->lmva_ColumnTitle[i] = "Last Accessed";
2171 break;
2172
2173 case INDEX_COMMENT:
2174 data->icld_LVMAttribs->lmva_ColumnTitle[i] = "Comment";
2175 break;
2176
2177 case INDEX_PROTECTION:
2178 data->icld_LVMAttribs->lmva_ColumnTitle[i] = "Protection";
2179 break;
2180
2181 default:
2182 data->icld_LVMAttribs->lmva_ColumnTitle[i] = "<Unknown>";
2183 break;
2184 }
2185 }
2186 data->icld_LVMAttribs->lmva_LastSelectedColumn = -1;
2187 data->icld_LVMAttribs->lmva_SortColumn = INDEX_NAME;
2188 data->icld_LVMAttribs->lvma_Flags = LVMAF_HEADERDRAWTOEND;
2189 /*
2190 * Seems to be not needed because it's done in MUIM_Setup. No rendering happens before it.
2191 * Height calculation moved to MUIM_Setup because font pointer can be NULL here (if user-specified
2192 * font failed to open). In this case we fail back to the font specified in MUI's AreaData, but
2193 * it becomes known only in MUIM_Setup
2194 *
2195 CalcHeight(data->icld_LVMAttribs, data->icld_IconLabelFont); */
2196 }
2197
2198 /* Get/Set initial values */
2199 /* TODO: TrimVolumeNames should be prefs settable */
2200 data->icld__Option_TrimVolumeNames = TRUE;
2201 /* TODO: Adjust overlap by window border width */
2202 data->icld__Option_IconBorderOverlap = 10;
2203
2204 data->icld__Option_IconListMode = (UBYTE)GetTagData(MUIA_IconList_IconListMode, 0, message->ops_AttrList);
2205 data->icld__Option_LabelTextMode = (UBYTE)GetTagData(MUIA_IconList_LabelText_Mode, 0, message->ops_AttrList);
2206 data->icld__Option_LabelTextMaxLen = (ULONG)GetTagData(MUIA_IconList_LabelText_MaxLineLen, ILC_ICONLABEL_MAXLINELEN_DEFAULT, message->ops_AttrList);
2207 data->icld__Option_DragImageTransparent = (BOOL)GetTagData(MUIA_IconList_DragImageTransparent, FALSE, message->ops_AttrList);
2208
2209 if ( data->icld__Option_LabelTextMaxLen < ILC_ICONLABEL_SHORTEST )
2210 data->icld__Option_LabelTextMaxLen = ILC_ICONLABEL_MAXLINELEN_DEFAULT;
2211
2212 data->icld__Option_LastLabelTextMaxLen = data->icld__Option_LabelTextMaxLen;
2213
2214 #if defined(DEBUG_ILC_FUNCS)
2215 D(bug("[IconList] %s: MaxLineLen : %ld\n", __PRETTY_FUNCTION__, data->icld__Option_LabelTextMaxLen));
2216 #endif
2217 data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY | IDCMP_NEWSIZE;
2218 data->ehn.ehn_Priority = 0;
2219 data->ehn.ehn_Flags = 0;
2220 data->ehn.ehn_Object = obj;
2221 data->ehn.ehn_Class = CLASS;
2222
2223 data->icld_SortFlags = MUIV_IconList_Sort_ByName;
2224 data->icld_DisplayFlags = ICONLIST_DISP_SHOWINFO;
2225
2226 __iconlist_UpdateLabels_hook.h_Entry = (HOOKFUNC)IconList__HookFunc_UpdateLabelsFunc;
2227
2228 DoMethod
2229 (
2230 obj, MUIM_Notify, MUIA_IconList_LabelText_MaxLineLen, MUIV_EveryTime,
2231 (IPTR)obj, 3,
2232 MUIM_CallHook, &__iconlist_UpdateLabels_hook, (IPTR)CLASS
2233 );
2234
2235 DoMethod
2236 (
2237 obj, MUIM_Notify, MUIA_IconList_LabelText_MultiLine, MUIV_EveryTime,
2238 (IPTR)obj, 3,
2239 MUIM_CallHook, &__iconlist_UpdateLabels_hook, (IPTR)CLASS
2240 );
2241
2242 #if defined(DEBUG_ILC_FUNCS)
2243 D(bug("[IconList] obj = %ld\n", obj));
2244 #endif
2245 return (IPTR)obj;
2246 }
2247 ///
2248
2249 ///OM_DISPOSE()
2250 /**************************************************************************
2251 OM_DISPOSE
2252 **************************************************************************/
2253 IPTR IconList__OM_DISPOSE(struct IClass *CLASS, Object *obj, Msg message)
2254 {
2255 struct IconList_DATA *data = INST_DATA(CLASS, obj);
2256 struct IconEntry *node = NULL;
2257
2258 #if defined(DEBUG_ILC_FUNCS)
2259 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2260 #endif
2261
2262 #if defined(__AROS__)
2263 ForeachNode(&data->icld_IconList, node)
2264 #else
2265 Foreach_Node(&data->icld_IconList, node);
2266 #endif
2267 {
2268 if (node->ie_DiskObj)
2269 FreeDiskObject(node->ie_DiskObj);
2270 }
2271
2272 if (data->icld_Pool) DeletePool(data->icld_Pool);
2273
2274 DoSuperMethodA(CLASS,obj,message);
2275 return (IPTR)NULL;
2276 }
2277 ///
2278
2279 ///OM_SET()
2280 /**************************************************************************
2281 OM_SET
2282 **************************************************************************/
2283 IPTR IconList__OM_SET(struct IClass *CLASS, Object *obj, struct opSet *message)
2284 {
2285 struct IconList_DATA *data = INST_DATA(CLASS, obj);
2286 struct TagItem *tag = NULL,
2287 *tags = NULL;
2288
2289 WORD oldleft = data->icld_ViewX,
2290 oldtop = data->icld_ViewY;
2291 //oldwidth = data->icld_ViewWidth,
2292 //oldheight = data->icld_ViewHeight;
2293
2294 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ATTRIBS)
2295 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2296 #endif
2297
2298 /* parse initial taglist */
2299 for (tags = message->ops_AttrList; (tag = NextTagItem((TAGITEM)&tags)); )
2300 {
2301 switch (tag->ti_Tag)
2302 {
2303 case MUIA_Virtgroup_Left:
2304 #if defined(DEBUG_ILC_ATTRIBS)
2305 D(bug("[IconList] %s: MUIA_Virtgroup_Left %ld\n", __PRETTY_FUNCTION__, tag->ti_Data));
2306 #endif
2307 if (data->icld_ViewX != tag->ti_Data)
2308 data->icld_ViewX = tag->ti_Data;
2309 break;
2310
2311 case MUIA_Virtgroup_Top:
2312 #if defined(DEBUG_ILC_ATTRIBS)
2313 D(bug("[IconList] %s: MUIA_Virtgroup_Top %ld\n", __PRETTY_FUNCTION__, tag->ti_Data));
2314 #endif
2315 if (data->icld_ViewY != tag->ti_Data)
2316 data->icld_ViewY = tag->ti_Data;
2317 break;
2318
2319 case MUIA_IconList_Rastport:
2320 #if defined(DEBUG_ILC_ATTRIBS)
2321 D(bug("[IconList] %s: MUIA_IconList_Rastport 0x%p\n", __PRETTY_FUNCTION__, tag->ti_Data));
2322 #endif
2323 data->icld_DisplayRastPort = (struct RastPort*)tag->ti_Data;
2324 data->icld_DrawOffsetX = _mleft(obj);
2325 data->icld_DrawOffsetY = _mtop(obj);
2326 if (data->icld_BufferRastPort != NULL)
2327 {
2328 //Buffer still set!?!?!
2329 }
2330 SET(obj, MUIA_IconList_BufferRastport, tag->ti_Data);
2331 break;
2332
2333 case MUIA_IconList_BufferRastport:
2334 #if defined(DEBUG_ILC_ATTRIBS)
2335 D(bug("[IconList] %s: MUIA_IconList_BufferRastport 0x%p\n", __PRETTY_FUNCTION__, tag->ti_Data));
2336 #endif
2337 data->icld_BufferRastPort = (struct RastPort*)tag->ti_Data;
2338 break;
2339
2340 case MUIA_Font:
2341 #if defined(DEBUG_ILC_ATTRIBS)
2342 D(bug("[IconList] %s: MUIA_Font 0x%p\n", __PRETTY_FUNCTION__, tag->ti_Data));
2343 #endif
2344 data->icld_IconLabelFont = (struct TextFont*)tag->ti_Data;
2345 /* FIXME: Should we call CalcHeight() here because our font changed? */
2346 break;
2347
2348 case MUIA_IconList_LabelInfoText_Font:
2349 #if defined(DEBUG_ILC_ATTRIBS)
2350 D(bug("[IconList] %s: MUIA_IconList_LabelInfoText_Font 0x%p\n", __PRETTY_FUNCTION__, tag->ti_Data));
2351 #endif
2352 data->icld_IconInfoFont = (struct TextFont*)tag->ti_Data;
2353 break;
2354
2355 case MUIA_IconList_DisplayFlags:
2356 {
2357 #if defined(DEBUG_ILC_ATTRIBS)
2358 D(bug("[IconList] %s: MUIA_IconList_DisplayFlags %08x\n", __PRETTY_FUNCTION__, tag->ti_Data));
2359 #endif
2360 // ULONG origModeFlags = data->icld_DisplayFlags & (ICONLIST_DISP_MODEDEFAULT|ICONLIST_DISP_MODELABELRIGHT|ICONLIST_DISP_MODELIST);
2361 data->icld_DisplayFlags = (ULONG)tag->ti_Data;
2362
2363 if (data->icld_DisplayFlags & ICONLIST_DISP_BUFFERED)
2364 {
2365 #if defined(DEBUG_ILC_ATTRIBS) || defined(DEBUG_ILC_ICONRENDERING)
2366 D(bug("[IconList] %s: MUIA_IconList_DisplayFlags & ICONLIST_DISP_BUFFERED\n", __PRETTY_FUNCTION__));
2367 #endif
2368 if ((data->icld_BufferRastPort != NULL)
2369 && (data->icld_BufferRastPort != data->icld_DisplayRastPort))
2370 {
2371 #if defined(DEBUG_ILC_ATTRIBS) || defined(DEBUG_ILC_ICONRENDERING)
2372 D(bug("[IconList] %s: BackLayer @ %p for BackRastport @ %p\n", __PRETTY_FUNCTION__, data->icld_BufferRastPort->Layer, data->icld_BufferRastPort));
2373 #endif
2374 if ((GetBitMapAttr(data->icld_BufferRastPort->BitMap, BMA_WIDTH) != data->icld_ViewWidth)
2375 || (GetBitMapAttr(data->icld_BufferRastPort->BitMap, BMA_HEIGHT) != data->icld_ViewHeight))
2376 {
2377 struct Layer *oldLayer = data->icld_BufferRastPort->Layer;
2378 #if defined(DEBUG_ILC_ATTRIBS) || defined(DEBUG_ILC_ICONRENDERING)
2379 D(bug("[IconList] %s: Destroying old BackLayer\n", __PRETTY_FUNCTION__));
2380 #endif
2381 data->icld_BufferRastPort = data->icld_DisplayRastPort;
2382 DeleteLayer(0, oldLayer);
2383 }
2384 }
2385
2386 if ((data->icld_BufferRastPort == NULL) || (data->icld_BufferRastPort == data->icld_DisplayRastPort))
2387 {
2388 struct BitMap *bitmap_New = NULL;
2389 ULONG tmp_RastDepth;
2390 struct Layer_Info *li = NULL;
2391
2392 tmp_RastDepth = GetCyberMapAttr(data->icld_DisplayRastPort->BitMap, CYBRMATTR_DEPTH);
2393 if ((bitmap_New = AllocBitMap(data->icld_ViewWidth,
2394 data->icld_ViewHeight,
2395 tmp_RastDepth,
2396 BMF_CLEAR,
2397 data->icld_DisplayRastPort->BitMap))!=NULL)
2398 {
2399 if ((data->icld_BufferRastPort = CreateRastPort())!=NULL)
2400 {
2401 data->icld_BufferRastPort->BitMap = bitmap_New;
2402 if ((li = NewLayerInfo()))
2403 {
2404 if ((data->icld_BufferRastPort->Layer = CreateUpfrontLayer(li, data->icld_BufferRastPort->BitMap, 0, 0, data->icld_ViewWidth - 1, data->icld_ViewHeight - 1, 0, NULL)))
2405 {
2406 /*
2407 * Mark it as a buffered rastport.
2408 */
2409
2410 #if defined(DEBUG_ILC_ATTRIBS) || defined(DEBUG_ILC_ICONRENDERING)
2411 D(bug("[IconList] %s: FrontRastPort @ %p, New BackLayer @ %p, BackRastport @ %p\n", __PRETTY_FUNCTION__, data->icld_DisplayRastPort, data->icld_BufferRastPort->Layer, data->icld_BufferRastPort));
2412 #endif
2413 SET(obj, MUIA_IconList_BufferRastport, data->icld_BufferRastPort);
2414 data->icld_DrawOffsetX = 0;
2415 data->icld_DrawOffsetY = 0;
2416 }
2417 else
2418 data->icld_BufferRastPort = data->icld_DisplayRastPort;
2419 }
2420 else
2421 data->icld_BufferRastPort = data->icld_DisplayRastPort;
2422 }
2423 else
2424 data->icld_BufferRastPort = data->icld_DisplayRastPort;
2425 }
2426 if (data->icld_BufferRastPort == data->icld_DisplayRastPort)
2427 {
2428 if (bitmap_New) FreeBitMap(bitmap_New);
2429 if (li) DisposeLayerInfo(li);
2430 data->icld_DrawOffsetX = _mleft(obj);
2431 data->icld_DrawOffsetY = _mtop(obj);
2432 }
2433 }
2434 }
2435 else
2436 {
2437 if ((data->icld_BufferRastPort) && (data->icld_BufferRastPort != data->icld_DisplayRastPort))
2438 {
2439 //Free up the buffers layer, rastport and bitmap since they are no longer needed ..
2440 struct Layer *oldLayer = data->icld_BufferRastPort->Layer;
2441 data->icld_BufferRastPort = data->icld_DisplayRastPort;
2442 InstallClipRegion(oldLayer, NULL);
2443 DeleteLayer(0, oldLayer);
2444 FreeBitMap(data->icld_BufferRastPort->BitMap);
2445 data->icld_DrawOffsetX = _mleft(obj);
2446 data->icld_DrawOffsetY = _mtop(obj);
2447 }
2448 }
2449 SET(obj, MUIA_IconList_Changed, TRUE);
2450 }
2451 break;
2452
2453 case MUIA_IconList_SortFlags:
2454 #if defined(DEBUG_ILC_ATTRIBS)
2455 D(bug("[IconList] %s: MUIA_IconList_SortFlags %08x\n", __PRETTY_FUNCTION__, tag->ti_Data));
2456 #endif
2457 data->icld_SortFlags = (ULONG)tag->ti_Data;
2458 break;
2459
2460 case MUIA_IconList_DragImageTransparent:
2461 data->icld__Option_DragImageTransparent = (BOOL)tag->ti_Data;
2462 break;
2463
2464 case MUIA_IconList_IconListMode:
2465 #if defined(DEBUG_ILC_ATTRIBS)
2466 D(bug("[IconList] %s: MUIA_IconList_IconListMode %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2467 #endif
2468 data->icld__Option_IconListMode = (UBYTE)tag->ti_Data;
2469 break;
2470
2471 case MUIA_IconList_LabelText_Mode:
2472 #if defined(DEBUG_ILC_ATTRIBS)
2473 D(bug("[IconList] %s: MUIA_IconList_LabelText_Mode %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2474 #endif
2475 data->icld__Option_LabelTextMode = (UBYTE)tag->ti_Data;
2476 break;
2477
2478 case MUIA_IconList_LabelText_MaxLineLen:
2479 #if defined(DEBUG_ILC_ATTRIBS)
2480 D(bug("[IconList] %s: MUIA_IconList_LabelText_MaxLineLen %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2481 #endif
2482 if (tag->ti_Data >= ILC_ICONLABEL_SHORTEST)
2483 {
2484 data->icld__Option_LabelTextMaxLen = (ULONG)tag->ti_Data;
2485 }
2486 else
2487 {
2488 data->icld__Option_LabelTextMaxLen = ILC_ICONLABEL_MAXLINELEN_DEFAULT;
2489 }
2490 break;
2491
2492 case MUIA_IconList_LabelText_MultiLine:
2493 #if defined(DEBUG_ILC_ATTRIBS)
2494 D(bug("[IconList] %s: MUIA_IconList_LabelText_MultiLine %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2495 #endif
2496 data->icld__Option_LabelTextMultiLine = (ULONG)tag->ti_Data;
2497 if (data->icld__Option_LabelTextMultiLine == 0)data->icld__Option_LabelTextMultiLine = 1;
2498 break;
2499
2500 case MUIA_IconList_LabelText_MultiLineOnFocus:
2501 #if defined(DEBUG_ILC_ATTRIBS)
2502 D(bug("[IconList] %s: MUIA_IconList_LabelText_MultiLineOnFocus %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2503 #endif
2504 data->icld__Option_LabelTextMultiLineOnFocus = (BOOL)tag->ti_Data;
2505 break;
2506
2507 case MUIA_IconList_Icon_HorizontalSpacing:
2508 #if defined(DEBUG_ILC_ATTRIBS)
2509 D(bug("[IconList] %s: MUIA_IconList_Icon_HorizontalSpacing %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2510 #endif
2511 data->icld__Option_IconHorizontalSpacing = (UBYTE)tag->ti_Data;
2512 break;
2513
2514 case MUIA_IconList_Icon_VerticalSpacing:
2515 #if defined(DEBUG_ILC_ATTRIBS)
2516 D(bug("[IconList] %s: MUIA_IconList_Icon_VerticalSpacing %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2517 #endif
2518 data->icld__Option_IconVerticalSpacing = (UBYTE)tag->ti_Data;
2519 break;
2520
2521 case MUIA_IconList_Icon_ImageSpacing:
2522 #if defined(DEBUG_ILC_ATTRIBS)
2523 D(bug("[IconList] %s: MUIA_IconList_Icon_ImageSpacing %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2524 #endif
2525 data->icld__Option_IconImageSpacing = (UBYTE)tag->ti_Data;
2526 break;
2527
2528 case MUIA_IconList_LabelText_HorizontalPadding:
2529 #if defined(DEBUG_ILC_ATTRIBS)
2530 D(bug("[IconList] %s: MUIA_IconList_LabelText_HorizontalPadding %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2531 #endif
2532 data->icld__Option_LabelTextHorizontalPadding = (UBYTE)tag->ti_Data;
2533 break;
2534
2535 case MUIA_IconList_LabelText_VerticalPadding:
2536 #if defined(DEBUG_ILC_ATTRIBS)
2537 D(bug("[IconList] %s: MUIA_IconList_LabelText_VerticalPadding %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2538 #endif
2539 data->icld__Option_LabelTextVerticalPadding = (UBYTE)tag->ti_Data;
2540 break;
2541
2542 case MUIA_IconList_LabelText_BorderWidth:
2543 #if defined(DEBUG_ILC_ATTRIBS)
2544 D(bug("[IconList] %s: MUIA_IconList_LabelText_BorderWidth %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2545 #endif
2546 data->icld__Option_LabelTextBorderWidth = (UBYTE)tag->ti_Data;
2547 break;
2548
2549 case MUIA_IconList_LabelText_BorderHeight:
2550 #if defined(DEBUG_ILC_ATTRIBS)
2551 D(bug("[IconList] %s: MUIA_IconList_LabelText_BorderHeight %d\n", __PRETTY_FUNCTION__, tag->ti_Data));
2552 #endif
2553 data->icld__Option_LabelTextBorderHeight = (UBYTE)tag->ti_Data;
2554 break;
2555
2556 case MUIA_IconList_LabelText_Pen:
2557 data->icld_LabelPen = (ULONG)tag->ti_Data;
2558 break;
2559
2560 case MUIA_IconList_LabelText_ShadowPen:
2561 data->icld_LabelShadowPen = (ULONG)tag->ti_Data;
2562 break;
2563
2564 case MUIA_IconList_LabelInfoText_Pen:
2565 data->icld_InfoPen = (ULONG)tag->ti_Data;
2566 break;
2567
2568 case MUIA_IconList_LabelInfoText_ShadowPen:
2569 data->icld_InfoShadowPen = (ULONG)tag->ti_Data;
2570 break;
2571
2572 /* Settings defined by the view class */
2573 case MUIA_IconListview_FixedBackground:
2574 #if defined(DEBUG_ILC_ATTRIBS)
2575 D(bug("[IconList] %s: MUIA_IconListview_FixedBackground\n", __PRETTY_FUNCTION__));
2576 #endif
2577 data->icld__Option_IconListFixedBackground = (BOOL)tag->ti_Data;
2578 break;
2579
2580 case MUIA_IconListview_ScaledBackground:
2581 #if defined(DEBUG_ILC_ATTRIBS)
2582 D(bug("[IconList] %s: MUIA_IconListview_ScaledBackground\n", __PRETTY_FUNCTION__));
2583 #endif
2584 data->icld__Option_IconListScaledBackground = (BOOL)tag->ti_Data;
2585 break;
2586
2587 /* We listen for MUIA_Background and set default values for known types */
2588 case MUIA_Background:
2589 #if defined(DEBUG_ILC_ATTRIBS) || defined(DEBUG_ILC_ICONRENDERING)
2590 D(bug("[IconList] %s: MUIA_Background\n", __PRETTY_FUNCTION__));
2591 #endif
2592 {
2593 char *bgmode_string = (char *)tag->ti_Data;
2594 BYTE this_mode = bgmode_string[0] - 48;
2595
2596 #if defined(DEBUG_ILC_ATTRIBS) || defined(DEBUG_ILC_ICONRENDERING)
2597 D(bug("[IconList] %s: MUIA_Background | MUI BG Mode = %d\n", __PRETTY_FUNCTION__, this_mode));
2598 #endif
2599 switch (this_mode)
2600 {
2601 case 0:
2602 //MUI Pattern
2603 NNSET(obj, MUIA_IconListview_FixedBackground, FALSE);
2604 NNSET(obj, MUIA_IconListview_ScaledBackground, FALSE);
2605 break;
2606 case 2:
2607 //MUI RGB color
2608 NNSET(obj, MUIA_IconListview_FixedBackground, FALSE);
2609 NNSET(obj, MUIA_IconListview_ScaledBackground, FALSE);
2610 break;
2611 case 7:
2612 //Zune Gradient
2613 NNSET(obj, MUIA_IconListview_FixedBackground, TRUE);
2614 NNSET(obj, MUIA_IconListview_ScaledBackground, TRUE);
2615 break;
2616 case 5:
2617 //Image
2618 NNSET(obj, MUIA_IconListview_FixedBackground, FALSE);
2619 NNSET(obj, MUIA_IconListview_ScaledBackground, FALSE);
2620 break;
2621 }
2622 }
2623 break;
2624 case MUIA_IconList_IconsDropped:
2625 data->icld_DragDropEvent = (struct IconList_Drop_Event *)tag->ti_Data;
2626 break;
2627 }
2628 }
2629
2630 #if defined(DEBUG_ILC_ATTRIBS)
2631 D(bug("[IconList] %s(), out of switch\n", __PRETTY_FUNCTION__));
2632 #endif
2633 if ((oldleft != data->icld_ViewX) || (oldtop != data->icld_ViewY))
2634 {
2635 data->icld_UpdateMode = UPDATE_SCROLL;
2636 data->update_scrolldx = data->icld_ViewX - oldleft;
2637 data->update_scrolldy = data->icld_ViewY - oldtop;
2638 #if defined(DEBUG_ILC_ATTRIBS)
2639 D(bug("[IconList] %s(), call MUI_Redraw()\n", __PRETTY_FUNCTION__));
2640 #endif
2641 MUI_Redraw(obj, MADF_DRAWUPDATE);
2642 }
2643
2644 #if defined(DEBUG_ILC_ATTRIBS)
2645 D(bug("[IconList] %s(), call DoSuperMethodA()\n", __PRETTY_FUNCTION__));
2646 #endif
2647 return DoSuperMethodA(CLASS, obj, (Msg)message);
2648 }
2649 ///
2650
2651 ///OM_GET()
2652 /**************************************************************************
2653 OM_GET
2654 **************************************************************************/
2655 IPTR IconList__OM_GET(struct IClass *CLASS, Object *obj, struct opGet *message)
2656 {
2657 /* small macro to simplify return value storage */
2658 #define STORE *(message->opg_Storage)
2659 struct IconList_DATA *data = INST_DATA(CLASS, obj);
2660
2661 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ATTRIBS)
2662 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2663 #endif
2664
2665 switch (message->opg_AttrID)
2666 {
2667 case MUIA_IconList_Rastport: STORE = (IPTR)data->icld_DisplayRastPort; return 1;
2668 case MUIA_IconList_BufferRastport: STORE = (IPTR)data->icld_BufferRastPort; return 1;
2669 case MUIA_IconList_BufferLeft: STORE = (IPTR)data->icld_DrawOffsetX; return 1;
2670 case MUIA_IconList_BufferTop: STORE = (IPTR)data->icld_DrawOffsetY; return 1;
2671 case MUIA_IconList_BufferWidth:
2672 case MUIA_IconList_Width: STORE = (IPTR)data->icld_AreaWidth; return 1;
2673 case MUIA_IconList_BufferHeight:
2674 case MUIA_IconList_Height: STORE = (IPTR)data->icld_AreaHeight; return 1;
2675 case MUIA_IconList_IconsDropped: STORE = (IPTR)data->icld_DragDropEvent; return 1;
2676 case MUIA_IconList_Clicked: STORE = (IPTR)&data->icld_ClickEvent; return 1;
2677 case MUIA_IconList_IconListMode: STORE = (IPTR)data->icld__Option_IconListMode; return 1;
2678 case MUIA_IconList_LabelText_Mode: STORE = (IPTR)data->icld__Option_LabelTextMode; return 1;
2679 case MUIA_IconList_LabelText_MaxLineLen: STORE = (IPTR)data->icld__Option_LabelTextMaxLen; return 1;
2680 case MUIA_IconList_LabelText_MultiLine: STORE = (IPTR)data->icld__Option_LabelTextMultiLine; return 1;
2681 case MUIA_IconList_LabelText_MultiLineOnFocus: STORE = (IPTR)data->icld__Option_LabelTextMultiLineOnFocus; return 1;
2682 case MUIA_IconList_DisplayFlags: STORE = (IPTR)data->icld_DisplayFlags; return 1;
2683 case MUIA_IconList_SortFlags: STORE = (IPTR)data->icld_SortFlags; return 1;
2684
2685 case MUIA_IconList_FocusIcon: STORE = (IPTR)data->icld_FocusIcon; return 1;
2686
2687 case MUIA_Font: STORE = (IPTR)data->icld_IconLabelFont; return 1;
2688 case MUIA_IconList_LabelText_Pen: STORE = (IPTR)data->icld_LabelPen; return 1;
2689 case MUIA_IconList_LabelText_ShadowPen: STORE = (IPTR)data->icld_LabelShadowPen; return 1;
2690 case MUIA_IconList_LabelInfoText_Font: STORE = (IPTR)data->icld_IconInfoFont; return 1;
2691 case MUIA_IconList_LabelInfoText_Pen: STORE = (IPTR)data->icld_InfoPen; return 1;
2692 case MUIA_IconList_LabelInfoText_ShadowPen: STORE = (IPTR)data->icld_InfoShadowPen; return 1;
2693 case MUIA_IconList_DragImageTransparent: STORE = (IPTR)data->icld__Option_DragImageTransparent; return 1;
2694
2695 case MUIA_IconList_Icon_HorizontalSpacing: STORE = (IPTR)data->icld__Option_IconHorizontalSpacing; return 1;
2696 case MUIA_IconList_Icon_VerticalSpacing: STORE = (IPTR)data->icld__Option_IconVerticalSpacing; return 1;
2697 case MUIA_IconList_Icon_ImageSpacing: STORE = (IPTR)data->icld__Option_IconImageSpacing; return 1;
2698 case MUIA_IconList_LabelText_HorizontalPadding: STORE = (IPTR)data->icld__Option_LabelTextHorizontalPadding; return 1;
2699 case MUIA_IconList_LabelText_VerticalPadding: STORE = (IPTR)data->icld__Option_LabelTextVerticalPadding; return 1;
2700 case MUIA_IconList_LabelText_BorderWidth: STORE = (IPTR)data->icld__Option_LabelTextBorderWidth; return 1;
2701 case MUIA_IconList_LabelText_BorderHeight: STORE = (IPTR)data->icld__Option_LabelTextBorderHeight; return 1;
2702
2703 /* Settings defined by the view class */
2704 case MUIA_IconListview_FixedBackground: STORE = (IPTR)data->icld__Option_IconListFixedBackground; return 1;
2705 case MUIA_IconListview_ScaledBackground: STORE = (IPTR)data->icld__Option_IconListScaledBackground; return 1;
2706
2707 /* ICON obj Changes */
2708 case MUIA_Virtgroup_Left: STORE = (IPTR)data->icld_ViewX; return 1;
2709 case MUIA_Virtgroup_Top: STORE = (IPTR)data->icld_ViewY; return 1;
2710 case MUIA_Family_List: STORE = (IPTR)&(data->icld_IconList); return 1; /* Get our list object */
2711
2712 /* TODO: Get the version/revision from our config.. */
2713 case MUIA_Version: STORE = (IPTR)1; return 1;
2714 case MUIA_Revision: STORE = (IPTR)7; return 1;
2715 }
2716
2717 return DoSuperMethodA(CLASS, obj, (Msg) message);
2718 #undef STORE
2719 }
2720 ///
2721
2722 IPTR IconList__MUIM_Family_AddHead(struct IClass *CLASS, Object *obj, struct MUIP_Family_AddHead *message)
2723 {
2724 struct IconList_DATA *data = INST_DATA(CLASS, obj);
2725 #if defined(DEBUG_ILC_FUNCS)
2726 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2727 #endif
2728
2729 if (message->obj)
2730 {
2731 /* TODO: Use the correct _OBJECT() code when we switch to icon.mui */
2732 // AddHead(&(data->icld_IconList), (struct Node *)_OBJECT(message->obj));
2733 AddHead(&(data->icld_IconList), (struct Node *)message->obj);
2734 return TRUE;
2735 }
2736 else
2737 return FALSE;
2738 }
2739
2740 IPTR IconList__MUIM_Family_AddTail(struct IClass *CLASS, Object *obj, struct MUIP_Family_AddTail *message)
2741 {
2742 struct IconList_DATA *data = INST_DATA(CLASS, obj);
2743 #if defined(DEBUG_ILC_FUNCS)
2744 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2745 #endif
2746
2747 D(bug("[IconList] %s: list @ 0x%p, entry @ 0x%p '%s'\n", __PRETTY_FUNCTION__, &(data->icld_IconList), message->obj, ((struct IconEntry *)message->obj)->ie_IconNode.ln_Name));
2748
2749 if (message->obj)
2750 {
2751 /* TODO: Use the correct _OBJECT() code when we switch to icon.mui */
2752 // AddTail(&(data->icld_IconList), (struct Node *)_OBJECT(message->obj));
2753 AddTail(&(data->icld_IconList), (struct Node *)message->obj);
2754 return TRUE;
2755 }
2756 else
2757 return FALSE;
2758
2759 return (IPTR)NULL;
2760 }
2761 #if !defined(WANDERER_BUILTIN_ICONLIST)
2762 IPTR IconList__OM_ADDMEMBER(struct IClass *CLASS, Object *obj, struct MUIP_Family_AddTail *message)
2763 {
2764 return IconList__MUIM_Family_AddTail(CLASS, obj, message);
2765 }
2766 #endif
2767
2768 IPTR IconList__MUIM_Family_Remove(struct IClass *CLASS, Object *obj, struct MUIP_Family_Remove *message)
2769 {
2770 // struct IconList_DATA *data = INST_DATA(CLASS, obj);
2771 #if defined(DEBUG_ILC_FUNCS)
2772 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2773 #endif
2774
2775 D(bug("[IconList] %s: entry @ 0x%p '%s'\n", __PRETTY_FUNCTION__, message->obj, ((struct IconEntry *)message->obj)->ie_IconNode.ln_Name));
2776
2777 if (message->obj)
2778 {
2779 /* TODO: Use the correct _OBJECT() code when we switch to icon.mui */
2780 // Remove((struct Node *)_OBJECT(message->obj));
2781 Remove((struct Node *)message->obj);
2782 return TRUE;
2783 }
2784 else
2785 return FALSE;
2786
2787 return (IPTR)NULL;
2788 }
2789 #if !defined(WANDERER_BUILTIN_ICONLIST)
2790 IPTR IconList__OM_REMMEMBER(struct IClass *CLASS, Object *obj, struct MUIP_Family_Remove *message)
2791 {
2792 return IconList__MUIM_Family_Remove(CLASS, obj, message);
2793 }
2794 #endif
2795
2796 ///MUIM_Setup()
2797 /**************************************************************************
2798 MUIM_Setup
2799 **************************************************************************/
2800 IPTR IconList__MUIM_Setup(struct IClass *CLASS, Object *obj, struct MUIP_Setup *message)
2801 {
2802 struct IconList_DATA *data = INST_DATA(CLASS, obj);
2803 struct IconEntry *node = NULL;
2804 IPTR geticon_error = 0, iconlistScreen;
2805
2806 #if defined(DEBUG_ILC_FUNCS)
2807 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2808 #endif
2809
2810 if (!DoSuperMethodA(CLASS, obj, (Msg) message)) return (IPTR)NULL;
2811
2812 iconlistScreen = (IPTR)_screen(obj);
2813 #if defined(DEBUG_ILC_ICONRENDERING)
2814 D(bug("[IconList] %s: IconList Screen @ 0x%p)\n", __PRETTY_FUNCTION__, iconlistScreen));
2815 #endif
2816
2817 DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
2818
2819 /* Get Internal Objects to use if not set .. */
2820 data->icld_DisplayRastPort = NULL;
2821 data->icld_BufferRastPort = NULL;
2822
2823 if (data->icld_IconLabelFont == NULL) data->icld_IconLabelFont = _font(obj);
2824 if (data->icld_IconInfoFont == NULL) data->icld_IconInfoFont = data->icld_IconLabelFont;
2825
2826 /*
2827 * Here we have our font, either from user preferences or from MUI's AreaData.
2828 * It's right time to set up some sizes.
2829 */
2830 CalcHeight(data->icld_LVMAttribs, data->icld_IconLabelFont);
2831 #if defined(DEBUG_ILC_ICONRENDERING)
2832 D(bug("[IconList] %s: Use Font @ 0x%p, RastPort @ 0x%p\n", __PRETTY_FUNCTION__, data->icld_IconLabelFont, data->icld_BufferRastPort ));
2833 #endif
2834
2835 /* Set our base options .. */
2836 data->icld_LabelPen = _pens(obj)[MPEN_SHINE];
2837 data->icld_LabelShadowPen = _pens(obj)[MPEN_SHADOW];
2838 data->icld_InfoPen = _pens(obj)[MPEN_SHINE];
2839 data->icld_InfoShadowPen = _pens(obj)[MPEN_SHADOW];
2840
2841 data->icld__Option_LabelTextMultiLine = 1;
2842 data->icld__Option_LastLabelTextMultiLine = data->icld__Option_LabelTextMultiLine;
2843
2844 data->icld__Option_LabelTextMultiLineOnFocus = FALSE;
2845
2846 data->icld__Option_IconHorizontalSpacing = ILC_ICON_HORIZONTALMARGIN_DEFAULT;
2847 data->icld__Option_IconVerticalSpacing = ILC_ICON_VERTICALMARGIN_DEFAULT;
2848 data->icld__Option_IconImageSpacing = ILC_ICONLABEL_IMAGEMARGIN_DEFAULT;
2849 data->icld__Option_LabelTextHorizontalPadding = ILC_ICONLABEL_HORIZONTALTEXTMARGIN_DEFAULT;
2850 data->icld__Option_LabelTextVerticalPadding = ILC_ICONLABEL_VERTICALTEXTMARGIN_DEFAULT;
2851 data->icld__Option_LabelTextBorderWidth = ILC_ICONLABEL_BORDERWIDTH_DEFAULT;
2852 data->icld__Option_LabelTextBorderHeight = ILC_ICONLABEL_BORDERHEIGHT_DEFAULT;
2853
2854 if (data->icld_LVMAttribs)
2855 {
2856 data->icld_LVMAttribs->lvma_IconDrawer = GetIconTags
2857 (
2858 "WANDERER:Icons/drawer",
2859 (iconlistScreen) ? ICONGETA_Screen : TAG_IGNORE, iconlistScreen,
2860 (iconlistScreen) ? ICONGETA_RemapIcon : TAG_IGNORE, TRUE,
2861 ICONGETA_FailIfUnavailable, TRUE,
2862 ICONGETA_GenerateImageMasks, TRUE,
2863 ICONA_ErrorCode, &geticon_error,
2864 TAG_DONE
2865 );
2866
2867 #if defined(DEBUG_ILC_ICONRENDERING)
2868 if (data->icld_LVMAttribs->lvma_IconDrawer == NULL)
2869 {
2870 D(bug("[IconList] %s: Couldnt get drawer DiskObject! (error code = 0x%p)\n", __PRETTY_FUNCTION__, geticon_error));
2871 }
2872 #endif
2873 data->icld_LVMAttribs->lvma_IconFile = GetIconTags
2874 (
2875 "WANDERER:Icons/file",
2876 (iconlistScreen) ? ICONGETA_Screen : TAG_IGNORE, iconlistScreen,
2877 (iconlistScreen) ? ICONGETA_RemapIcon : TAG_IGNORE, TRUE,
2878 ICONGETA_FailIfUnavailable, TRUE,
2879 ICONGETA_GenerateImageMasks, TRUE,
2880 ICONA_ErrorCode, &geticon_error,
2881 TAG_DONE
2882 );
2883
2884 #if defined(DEBUG_ILC_ICONRENDERING)
2885 if (data->icld_LVMAttribs->lvma_IconFile == NULL)
2886 {
2887 D(bug("[IconList] %s: Couldnt get file DiskObject! (error code = 0x%p)\n", __PRETTY_FUNCTION__, geticon_error));
2888 }
2889 #endif
2890 }
2891
2892 #if defined(__AROS__)
2893 ForeachNode(&data->icld_IconList, node)
2894 #else
2895 Foreach_Node(&data->icld_IconList, node);
2896 #endif
2897 {
2898 if (!node->ie_DiskObj)
2899 {
2900 if (!(node->ie_DiskObj = GetIconTags(node->ie_IconNode.ln_Name,
2901 (iconlistScreen) ? ICONGETA_Screen : TAG_IGNORE, iconlistScreen,
2902 (iconlistScreen) ? ICONGETA_RemapIcon : TAG_IGNORE, TRUE,
2903 ICONGETA_GenerateImageMasks, TRUE,
2904 ICONGETA_FailIfUnavailable, FALSE,
2905 ICONA_ErrorCode, &geticon_error,
2906 TAG_DONE)))
2907 {
2908 #if defined(DEBUG_ILC_ICONRENDERING)
2909 D(bug("[IconList] %s: Failed to obtain Entry '%s's diskobj! (error code = 0x%p)\n", __PRETTY_FUNCTION__, node->ie_IconNode.ln_Name, geticon_error));
2910 #endif
2911 /* We should probably remove this node if the entry cant be obtained ? */
2912 }
2913 }
2914 }
2915 return 1;
2916 }
2917 ///
2918
2919 ///MUIM_Show()
2920 /**************************************************************************
2921 MUIM_Show
2922 **************************************************************************/
2923 IPTR IconList__MUIM_Show(struct IClass *CLASS, Object *obj, struct MUIP_Show *message)
2924 {
2925 struct IconList_DATA *data = INST_DATA(CLASS, obj);
2926 LONG newleft,
2927 newtop;
2928 IPTR rc;
2929
2930 #if defined(DEBUG_ILC_FUNCS)
2931 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
2932 #endif
2933
2934 if ((rc = DoSuperMethodA(CLASS, obj, (Msg)message)))
2935 {
2936 newleft = data->icld_ViewX;
2937 newtop = data->icld_ViewY;
2938
2939 if (newleft + _mwidth(obj) > data->icld_AreaWidth)
2940 newleft = data->icld_AreaWidth - _mwidth(obj);
2941 if (newleft < 0)
2942 newleft = 0;
2943
2944 if (newtop + _mheight(obj) > data->icld_AreaHeight)
2945 newtop = data->icld_AreaHeight - _mheight(obj);
2946 if (newtop < 0)
2947 newtop = 0;
2948
2949 if ((newleft != data->icld_ViewX) || (newtop != data->icld_ViewY))
2950 {
2951 SetAttrs(obj, MUIA_Virtgroup_Left, newleft,
2952 MUIA_Virtgroup_Top, newtop,
2953 TAG_DONE);
2954 }
2955
2956 /* Get Internal Objects to use if not set .. */
2957 if (data->icld_DisplayRastPort == NULL)
2958 {
2959 if (_rp(obj) != NULL)
2960 {
2961 data->icld_DisplayRastPort = CloneRastPort(_rp(obj));
2962 }
2963 #if defined(DEBUG_ILC_ICONRENDERING)
2964 else
2965 {
2966 D(bug("[IconList] IconList__MUIM_Show: ERROR - NULL RastPort!\n"));
2967 }
2968 #endif
2969 }
2970
2971 if (data->icld_DisplayFlags & ICONLIST_DISP_BUFFERED)
2972 {
2973 struct BitMap *bitmap_New = NULL;
2974 struct Layer_Info *li = NULL;
2975
2976 ULONG tmp_RastDepth = GetCyberMapAttr(data->icld_DisplayRastPort->BitMap, CYBRMATTR_DEPTH);
2977 if ((bitmap_New = AllocBitMap(data->icld_ViewWidth,
2978 data->icld_ViewHeight,
2979 tmp_RastDepth,
2980 BMF_CLEAR,
2981 data->icld_DisplayRastPort->BitMap))!=NULL)
2982 {
2983 if ((data->icld_BufferRastPort = CreateRastPort())!=NULL)
2984 {
2985 data->icld_BufferRastPort->BitMap = bitmap_New;
2986 if ((li = NewLayerInfo()))
2987 {
2988 if ((data->icld_BufferRastPort->Layer = CreateUpfrontLayer(li, data->icld_BufferRastPort->BitMap, 0, 0, data->icld_ViewWidth - 1, data->icld_ViewHeight - 1, 0, NULL)))
2989 {
2990 /*
2991 * Mark it as a buffered rastport.
2992 */
2993
2994 #if defined(DEBUG_ILC_ATTRIBS) || defined(DEBUG_ILC_ICONRENDERING)
2995 D(bug("[IconList] %s: FrontRastPort @ %p, New BackLayer @ %p, BackRastport @ %p\n", __PRETTY_FUNCTION__, data->icld_DisplayRastPort, data->icld_BufferRastPort->Layer, data->icld_BufferRastPort));
2996 #endif
2997 SET(obj, MUIA_IconList_BufferRastport, data->icld_BufferRastPort);
2998 data->icld_DrawOffsetX = 0;
2999 data->icld_DrawOffsetY = 0;
3000 }
3001 else
3002 data->icld_BufferRastPort = data->icld_DisplayRastPort;
3003 }
3004 else
3005 data->icld_BufferRastPort = data->icld_DisplayRastPort;
3006 }
3007 else
3008 data->icld_BufferRastPort = data->icld_DisplayRastPort;
3009 }
3010 if (data->icld_BufferRastPort == data->icld_DisplayRastPort)
3011 {
3012 if (bitmap_New) FreeBitMap(bitmap_New);
3013 if (li) DisposeLayerInfo(li);
3014 data->icld_DrawOffsetX = _mleft(obj);
3015 data->icld_DrawOffsetY = _mtop(obj);
3016 }
3017 }
3018 else
3019 {
3020 data->icld_BufferRastPort = data->icld_DisplayRastPort;
3021 data->icld_DrawOffsetX = _mleft(obj);
3022 data->icld_DrawOffsetY = _mtop(obj);
3023 }
3024
3025 if (data->icld_IconLabelFont == NULL) data->icld_IconLabelFont = _font(obj);
3026 if (data->icld_IconInfoFont == NULL) data->icld_IconInfoFont = data->icld_IconLabelFont;
3027 #if defined(DEBUG_ILC_ICONRENDERING)
3028 D(bug("[IconList] IconList__MUIM_Show: Use Font @ 0x%p, RastPort @ 0x%p\n", data->icld_IconLabelFont, data->icld_BufferRastPort ));
3029 #endif
3030
3031 if ((data->icld_BufferRastPort) && (data->icld_IconLabelFont))
3032 SetFont(data->icld_BufferRastPort, data->icld_IconLabelFont);
3033 }
3034 return rc;
3035 }
3036 ///
3037
3038 ///MUIM_Hide()
3039 /**************************************************************************
3040 MUIM_Hide
3041 **************************************************************************/
3042 IPTR IconList__MUIM_Hide(struct IClass *CLASS, Object *obj, struct MUIP_Hide *message)
3043 {
3044 struct IconList_DATA *data = INST_DATA(CLASS, obj);
3045 IPTR rc;
3046
3047 #if defined(DEBUG_ILC_FUNCS)
3048 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
3049 #endif
3050
3051 if ((rc = DoSuperMethodA(CLASS, obj, (Msg)message)))
3052 {
3053 if ((data->icld_BufferRastPort) && (data->icld_BufferRastPort != data->icld_DisplayRastPort))
3054 {
3055 DeleteLayer(0, data->icld_BufferRastPort->Layer);
3056 }
3057
3058 data->icld_BufferRastPort = NULL;
3059
3060 if (data->icld_DisplayRastPort)
3061 FreeRastPort(data->icld_DisplayRastPort);
3062
3063 data->icld_DisplayRastPort = NULL;
3064 }
3065 return rc;
3066 }
3067 ///
3068
3069 ///MUIM_Cleanup()
3070 /**************************************************************************
3071 MUIM_Cleanup
3072 **************************************************************************/
3073 IPTR IconList__MUIM_Cleanup(struct IClass *CLASS, Object *obj, struct MUIP_Cleanup *message)
3074 {
3075 struct IconList_DATA *data = INST_DATA(CLASS, obj);
3076 struct IconEntry *node = NULL;
3077
3078 #if defined(DEBUG_ILC_FUNCS)
3079 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
3080 #endif
3081
3082 #if defined(__AROS__)
3083 ForeachNode(&data->icld_IconList, node)
3084 #else
3085 Foreach_Node(&data->icld_IconList, node);
3086 #endif
3087 {
3088 if (node->ie_DiskObj)
3089 {
3090 FreeDiskObject(node->ie_DiskObj);
3091 node->ie_DiskObj = NULL;
3092 }
3093 }
3094
3095 DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
3096
3097 return DoSuperMethodA(CLASS, obj, (Msg)message);
3098 }
3099 ///
3100
3101 ///MUIM_AskMinMax()
3102 /**************************************************************************
3103 MUIM_AskMinMax
3104 **************************************************************************/
3105 IPTR IconList__MUIM_AskMinMax(struct IClass *CLASS, Object *obj, struct MUIP_AskMinMax *message)
3106 {
3107 ULONG rc = DoSuperMethodA(CLASS, obj, (Msg) message);
3108
3109 #if defined(DEBUG_ILC_FUNCS)
3110 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
3111 #endif
3112
3113 message->MinMaxInfo->MinWidth += 96;
3114 message->MinMaxInfo->MinHeight += 64;
3115
3116 message->MinMaxInfo->DefWidth += 200;
3117 message->MinMaxInfo->DefHeight += 180;
3118
3119 message->MinMaxInfo->MaxWidth = MUI_MAXMAX;
3120 message->MinMaxInfo->MaxHeight = MUI_MAXMAX;
3121
3122 return rc;
3123 }
3124 ///
3125
3126 ///MUIM_Layout()
3127 /**************************************************************************
3128 MUIM_Layout
3129 **************************************************************************/
3130 IPTR IconList__MUIM_Layout(struct IClass *CLASS, Object *obj,struct MUIP_Layout *message)
3131 {
3132 struct IconList_DATA *data = INST_DATA(CLASS, obj);
3133 ULONG rc;
3134
3135 #if defined(DEBUG_ILC_FUNCS)
3136 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
3137 #endif
3138
3139 rc = DoSuperMethodA(CLASS, obj, (Msg)message);
3140
3141 data->icld_ViewWidth = _mwidth(obj);
3142 data->icld_ViewHeight = _mheight(obj);
3143
3144 return rc;
3145 }
3146 ///
3147
3148 static LONG FirstVisibleLine(struct IconList_DATA *data)
3149 {
3150 return data->icld_ViewY / data->icld_LVMAttribs->lmva_RowHeight;
3151 }
3152
3153 static LONG NumVisibleLines(struct IconList_DATA *data)
3154 {
3155 LONG visible = data->icld_ViewHeight + data->icld_LVMAttribs->lmva_RowHeight - 1 +
3156 (data->icld_ViewY % data->icld_LVMAttribs->lmva_RowHeight);
3157
3158 visible /= data->icld_LVMAttribs->lmva_RowHeight;
3159
3160 return visible;
3161 }
3162
3163 static void RenderListViewModeHeaderField(Object *obj, struct IconList_DATA *data,
3164 struct Rectangle *rect, LONG index, BOOL sel)
3165 {
3166 IPTR penFill, penText, penDark, penBright;
3167 struct Rectangle rendRect;
3168 STRPTR text;
3169 struct TextExtent te;
3170 ULONG fit;
3171
3172 if (sel == TRUE)
3173 {
3174 penFill = _pens(obj)[MPEN_HALFSHADOW];
3175 penBright = _pens(obj)[MPEN_SHADOW];
3176 penDark = _pens(obj)[MPEN_HALFSHINE];
3177 }
3178 else
3179 {
3180 penFill = _pens(obj)[MPEN_HALFSHINE];
3181 penBright = _pens(obj)[MPEN_SHINE];
3182 penDark = _pens(obj)[MPEN_HALFSHADOW];
3183 }
3184 penText = _pens(obj)[MPEN_TEXT];
3185
3186 rendRect.MinX = rect->MinX;
3187 rendRect.MaxX = rect->MaxX;
3188 rendRect.MinY = rect->MinY;
3189 rendRect.MaxY = rect->MaxY;
3190
3191 if (data->icld_DisplayRastPort != data->icld_BufferRastPort)
3192 {
3193 rendRect.MinX -= _mleft(obj);
3194 rendRect.MaxX -= _mleft(obj);
3195 rendRect.MinY -= _mtop(obj);
3196 rendRect.MaxY -= _mtop(obj);
3197 }
3198
3199 #if defined(DEBUG_ILC_FUNCS)
3200 D(bug("[IconList]: %s(obj @ 0x%p)\n", __PRETTY_FUNCTION__, obj));
3201 #endif
3202
3203 if (((data->icld_LVMAttribs->lvma_Flags & LVMAF_NOHEADER) == 0) && (index < NUM_COLUMNS))
3204 {
3205 text = data->icld_LVMAttribs->lmva_ColumnTitle[index];
3206
3207 SetAPen(data->icld_BufferRastPort, penFill); /* Background */
3208 RectFill(data->icld_BufferRastPort, rendRect.MinX + 1, rendRect.MinY + 1,
3209 rendRect.MaxX - 1, rendRect.MaxY - 1);
3210
3211 SetAPen(data->icld_BufferRastPort, penBright); /* Top/Left */
3212 RectFill(data->icld_BufferRastPort, rendRect.MinX, rendRect.MinY, rendRect.MinX, rendRect.MaxY);
3213 RectFill(data->icld_BufferRastPort, rendRect.MinX + 1, rendRect.MinY, rendRect.MaxX - 1, rendRect.MinY);
3214
3215 SetAPen(data->icld_BufferRastPort,penDark); /* Bottom/Right */
3216 RectFill(data->icld_BufferRastPort, rendRect.MaxX, rendRect.MinY, rendRect.MaxX, rendRect.MaxY);
3217 RectFill(data->icld_BufferRastPort, rendRect.MinX + 1, rendRect.MaxY, rendRect.MaxX - 1, rendRect.MaxY);
3218
3219 /* Draw the Sort indicator .. */
3220 if (index == data->icld_LVMAttribs->lmva_SortColumn)
3221 {
3222 LONG x = rendRect.MaxX - 4 - 6;
3223 LONG y = (rendRect.MinY + rendRect.MaxY + 1) / 2 - 3;
3224
3225 if (x > rendRect.MinX)
3226 {
3227 SetAPen(data->icld_BufferRastPort, _pens(obj)[sel ? MPEN_SHADOW : MPEN_HALFSHADOW]);
3228 if (data->icld_SortFlags & MUIV_IconList_Sort_Reverse)
3229 {
3230 RectFill(data->icld_BufferRastPort, x, y, x + 5, y + 1);
3231 RectFill(data->icld_BufferRastPort, x + 1, y + 2, x + 4, y + 3);
3232 RectFill(data->icld_BufferRastPort, x + 2, y + 4, x + 3, y + 5);
3233 }
3234 else
3235 {
3236 RectFill(data->icld_BufferRastPort, x, y + 4, x + 5, y + 5);
3237 RectFill(data->icld_BufferRastPort, x + 1, y + 2, x + 4, y + 3);
3238 RectFill(data->icld_BufferRastPort, x + 2, y, x + 3, y + 1);
3239 }
3240 }
3241 }
3242
3243 rendRect.MinX += HEADERENTRY_SPACING_LEFT;
3244 rendRect.MinY += HEADERLINE_SPACING_TOP;
3245 rendRect.MaxX -= HEADERENTRY_SPACING_RIGHT;
3246 rendRect.MaxY -= HEADERLINE_SPACING_BOTTOM;
3247
3248 if (text && text[0])
3249 {
3250
3251 fit = TextFit(data->icld_BufferRastPort, text, strlen(text), &te, NULL, 1,
3252 rendRect.MaxX - rendRect.MinX + 1,
3253 rendRect.MaxY - rendRect.MinY + 1);
3254
3255 if (!fit) return;
3256
3257 SetABPenDrMd(data->icld_BufferRastPort, penText, 0, JAM1);
3258 Move(data->icld_BufferRastPort, rendRect.MinX, rendRect.MinY + data->icld_BufferRastPort->TxBaseline);
3259 Text(data->icld_BufferRastPort, text, fit);
3260 }
3261 }
3262 }
3263
3264 static void RenderListViewModeHeader(Object *obj, struct IconList_DATA *data)
3265 {
3266 struct Rectangle linerect;
3267 LONG x, i;
3268 LONG firstvis, lastvis;
3269
3270 #if defined(DEBUG_ILC_FUNCS)
3271 D(bug("[IconList]: %s(obj @ 0x%p)\n", __PRETTY_FUNCTION__, obj));
3272 #endif
3273
3274 if ((data->icld_LVMAttribs->lvma_Flags & LVMAF_NOHEADER) == 0)
3275 {
3276 linerect.MinX = _mleft(obj) - data->icld_ViewX;
3277 linerect.MaxX = _mright(obj);
3278 linerect.MinY = _mtop(obj);
3279 linerect.MaxY = _mtop(obj) + data->icld_LVMAttribs->lmva_HeaderHeight - 1;
3280
3281 SetFont(data->icld_BufferRastPort, data->icld_IconLabelFont);
3282
3283 x = linerect.MinX + HEADERLINE_SPACING_LEFT;
3284
3285 firstvis = FirstVisibleColumnNumber(data);
3286 lastvis = LastVisibleColumnNumber(data);
3287
3288 for(i = 0; i < NUM_COLUMNS; i++)
3289 {
3290 LONG index = data->icld_LVMAttribs->lmva_ColumnPos[i];
3291
3292 if (!(data->icld_LVMAttribs->lmva_ColumnFlags[index] & LVMCF_COLVISIBLE)) continue;
3293
3294 BOOL outside = FALSE;
3295 struct Rectangle field_rect;
3296
3297 field_rect.MinX = (i == firstvis) ? linerect.MinX : x;
3298 field_rect.MinY = linerect.MinY;
3299 field_rect.MaxX = x + data->icld_LVMAttribs->lmva_ColumnWidth[index] - 1 + ((i == lastvis) ? HEADERLINE_SPACING_RIGHT : 0);
3300 field_rect.MaxY = linerect.MaxY;
3301
3302 /* data->update_rect1 and data->update_rect2 may
3303 point to rectangles to indicate that only icons
3304 in any of this rectangles need to be drawn */
3305 if (data->update_rect1)
3306 {
3307 if (!RectAndRect(&field_rect, data->update_rect1))
3308 outside = TRUE;
3309 }
3310
3311 if (data->update_rect2)
3312 {
3313 if (data->update_rect1)
3314 {
3315 if ((outside == TRUE) && RectAndRect(&field_rect, data->update_rect2))
3316 outside = FALSE;
3317 }
3318 else
3319 {
3320 if (!RectAndRect(&field_rect, data->update_rect2))
3321 outside = TRUE;
3322 }
3323 }
3324
3325 if (outside != TRUE)
3326 {
3327 RenderListViewModeHeaderField(obj, data, &field_rect, index, FALSE);
3328 x += data->icld_LVMAttribs->lmva_ColumnWidth[index];
3329 }
3330 #if defined(DEBUG_ILC_ICONRENDERING)
3331 else
3332 {
3333 D(bug("[IconList] %s: Column '%s' outside of update area .. skipping\n", __PRETTY_FUNCTION__, data->icld_LVMAttribs->lmva_ColumnTitle[i]));
3334 }
3335 #endif
3336 }
3337
3338 if ((data->icld_LVMAttribs->lvma_Flags & LVMAF_HEADERDRAWTOEND) == LVMAF_HEADERDRAWTOEND)
3339 {
3340 x += HEADERLINE_SPACING_RIGHT;
3341
3342 if (x < linerect.MaxX)
3343 {
3344 linerect.MinX = x;
3345
3346 // if (MustRenderRect(data, &linerect))
3347 // {
3348 SetABPenDrMd(data->icld_BufferRastPort, _pens(obj)[MPEN_HALFSHINE], 0, JAM1);
3349 RectFill(data->icld_BufferRastPort, linerect.MinX, linerect.MinY, linerect.MaxX, linerect.MaxY);
3350 // }
3351 }
3352 }
3353 }
3354 }
3355
3356 ///MUIM_Draw()
3357 /**************************************************************************
3358 MUIM_Draw - draw the IconList
3359 **************************************************************************/
3360 IPTR DrawCount;
3361 IPTR IconList__MUIM_Draw(struct IClass *CLASS, Object *obj, struct MUIP_Draw *message)
3362 {
3363 struct IconList_DATA *data = INST_DATA(CLASS, obj);
3364 struct IconEntry *entry = NULL;
3365
3366 APTR clip = NULL;
3367
3368 ULONG update_oldwidth = 0,
3369 update_oldheight = 0;
3370
3371 LONG clear_xoffset = 0,
3372 clear_yoffset = 0;
3373
3374 __unused IPTR draw_id = DrawCount++;
3375
3376 #if defined(DEBUG_ILC_FUNCS)
3377 D(bug("[IconList]: %s(obj @ 0x%p)\n", __PRETTY_FUNCTION__, obj));
3378 #endif
3379 #if defined(DEBUG_ILC_ICONRENDERING)
3380 D(bug("[IconList] %s: id %d\n", __PRETTY_FUNCTION__, draw_id));
3381 #endif
3382
3383 DoSuperMethodA(CLASS, obj, (Msg)message);
3384
3385 if (!(data->icld__Option_IconListFixedBackground))
3386 {
3387 clear_xoffset = data->icld_ViewX;
3388 clear_yoffset = data->icld_ViewY;
3389 }
3390
3391 // If window size changes, only update needed areas
3392 if (data->update_oldwidth == 0) data->update_oldwidth = data->icld_ViewWidth;
3393 if (data->update_oldheight == 0) data->update_oldheight = data->icld_ViewHeight;
3394 if ((data->update_oldwidth != data->icld_ViewWidth) || (data->update_oldheight != data->icld_ViewHeight))
3395 {
3396 if (data->icld_UpdateMode != UPDATE_SCROLL)
3397 {
3398 data->icld_UpdateMode = UPDATE_RESIZE;
3399 update_oldwidth = data->update_oldwidth;
3400 update_oldheight = data->update_oldheight;
3401 data->update_oldwidth = data->icld_ViewWidth;
3402 data->update_oldheight = data->icld_ViewHeight;
3403 }
3404 }
3405
3406 if ((message->flags & MADF_DRAWUPDATE) || (data->icld_UpdateMode == UPDATE_RESIZE))
3407 {
3408 #if defined(DEBUG_ILC_ICONRENDERING)
3409 D(
3410 if (message->flags & MADF_DRAWUPDATE)
3411 {
3412 bug("[IconList] %s#%d: MADF_DRAWUPDATE\n", __PRETTY_FUNCTION__, draw_id);
3413 }
3414 else
3415 {
3416 bug("[IconList] %s#%d: UPDATE_RESIZE\n", __PRETTY_FUNCTION__, draw_id);
3417 }
3418 )
3419 #endif
3420 if ((data->icld_UpdateMode == UPDATE_HEADERENTRY) && ((IPTR)data->update_entry < NUM_COLUMNS)) /* draw the header entry */
3421 {
3422 struct Rectangle field_rect;
3423 LONG index, i, firstvis, lastvis;
3424
3425 firstvis = FirstVisibleColumnNumber(data);
3426 lastvis = LastVisibleColumnNumber(data);
3427
3428 field_rect.MinX = _mleft(obj) - data->icld_ViewX;
3429
3430 field_rect.MinY = _mtop(obj);
3431 field_rect.MaxY = field_rect.MinY + data->icld_LVMAttribs->lmva_HeaderHeight - 1;
3432
3433 for(i = 0; i < NUM_COLUMNS; i++)
3434 {
3435 index = data->icld_LVMAttribs->lmva_ColumnPos[i];
3436 if (!(data->icld_LVMAttribs->lmva_ColumnFlags[index] & LVMCF_COLVISIBLE)) continue;
3437
3438 field_rect.MaxX = field_rect.MinX + data->icld_LVMAttribs->lmva_ColumnWidth[index] - 1;
3439 if (index == lastvis)
3440 field_rect.MaxX += HEADERLINE_SPACING_RIGHT;
3441
3442 if ((IPTR)data->update_entry != index)
3443 {
3444 field_rect.MinX += data->icld_LVMAttribs->lmva_ColumnWidth[index];
3445 if (index == firstvis)
3446 field_rect.MinX += HEADERLINE_SPACING_LEFT;
3447 }
3448 else
3449 break;
3450 }
3451
3452 clip = MUI_AddClipping(muiRenderInfo(obj), _mleft(obj), _mtop(obj), _mright(obj) - _mleft(obj) + 1, data->icld_LVMAttribs->lmva_HeaderHeight);
3453
3454 if (data->icld_LVMAttribs->lmva_LastSelectedColumn == (IPTR)data->update_entry)
3455 RenderListViewModeHeaderField(obj, data, &field_rect, (IPTR)data->update_entry, TRUE);
3456 else
3457 RenderListViewModeHeaderField(obj, data, &field_rect, (IPTR)data->update_entry, FALSE);
3458
3459 data->icld_UpdateMode = 0;
3460 data->update_entry = NULL;
3461
3462 if (data->icld_DisplayRastPort != data->icld_BufferRastPort)
3463 {
3464 #if defined(DEBUG_ILC_ICONRENDERING)
3465 D(bug("[IconList] %s#%d: UPDATE_HEADERENTRY Blitting to front rastport..\n", __PRETTY_FUNCTION__, draw_id));
3466 #endif
3467 BltBitMapRastPort(data->icld_BufferRastPort->BitMap,
3468 field_rect.MinX - _mleft(obj), field_rect.MinY - _mtop(obj),
3469 data->icld_DisplayRastPort,
3470 field_rect.MinX, field_rect.MinY,
3471 field_rect.MaxX - field_rect.MinX + 1, field_rect.MaxY - field_rect.MinY + 1,
3472 0xC0);
3473 }
3474 MUI_RemoveClipping(muiRenderInfo(obj), clip);
3475
3476 goto draw_done;
3477 }
3478 else if ((data->icld_UpdateMode == UPDATE_SINGLEENTRY) && (data->update_entry != NULL)) /* draw only a single entry at update_entry */
3479 {
3480 struct Rectangle rect;
3481
3482 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
3483 {
3484 LONG count = 0, index = -1;
3485
3486 #if defined(DEBUG_ILC_ICONRENDERING)
3487 D(bug("[IconList] %s#%d: UPDATE_SINGLEENTRY + ICONLIST_DISP_MODELIST\n", __PRETTY_FUNCTION__, draw_id));
3488 #endif
3489 rect.MinX = _mleft(obj);
3490 rect.MaxX = _mleft(obj) + _mwidth(obj) - 1;
3491
3492 ForeachNode(&data->icld_IconList, entry)
3493 {
3494 if (entry == data->update_entry)
3495 {
3496 index = count;
3497 break;
3498 }
3499 if (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
3500 {
3501 count++;
3502 }
3503 }
3504
3505 if (index != -1)
3506 {
3507 rect.MinY = _mtop(obj) + data->icld_LVMAttribs->lmva_HeaderHeight - data->icld_ViewY + (index * data->icld_LVMAttribs->lmva_RowHeight);
3508 rect.MaxY = rect.MinY + data->icld_LVMAttribs->lmva_RowHeight - 1;
3509
3510 if ((rect.MaxY < (_mtop(obj) + data->icld_LVMAttribs->lmva_HeaderHeight))
3511 || (rect.MinY > (_mtop(obj) + _mheight(obj) - 1)))
3512 goto draw_done;
3513
3514 if (rect.MinY < (_mtop(obj) + data->icld_LVMAttribs->lmva_HeaderHeight)) rect.MinY = _mtop(obj) + data->icld_LVMAttribs->lmva_HeaderHeight;
3515 if (rect.MaxY > (_mtop(obj) + _mheight(obj) - 1)) rect.MaxY = _mtop(obj) + _mheight(obj) - 1;
3516
3517 clip = MUI_AddClipping(muiRenderInfo(obj), rect.MinX, rect.MinY, rect.MaxX - rect.MinX + 1, rect.MaxY - rect.MinY + 1);
3518
3519 DoMethod(obj, MUIM_DrawBackground,
3520 rect.MinX, rect.MinY,
3521 rect.MaxX - rect.MinX + 1, rect.MaxY - rect.MinY + 1,
3522 clear_xoffset, clear_yoffset,
3523 0);
3524
3525 entry->ie_Flags |= ICONENTRY_FLAG_NEEDSUPDATE;
3526 DoMethod(obj, MUIM_IconList_DrawEntry, data->update_entry, index);
3527 entry->ie_Flags &= ~ICONENTRY_FLAG_NEEDSUPDATE;
3528 data->icld_UpdateMode = 0;
3529 data->update_entry = NULL;
3530 }
3531 }
3532 else
3533 {
3534 #if defined(DEBUG_ILC_ICONRENDERING)
3535 D(bug("[IconList] %s#%d: UPDATE_SINGLEENTRY (entry @ 0x%p)\n", __PRETTY_FUNCTION__, draw_id, data->update_entry));
3536 #endif
3537 IconList_GetIconAreaRectangle(obj, data, data->update_entry, &rect);
3538
3539 rect.MinX += _mleft(obj) + (data->update_entry->ie_IconX - data->icld_ViewX);
3540 rect.MaxX += _mleft(obj) + (data->update_entry->ie_IconX - data->icld_ViewX);
3541 rect.MinY += _mtop(obj) + (data->update_entry->ie_IconY - data->icld_ViewY);
3542 rect.MaxY += _mtop(obj) + (data->update_entry->ie_IconY - data->icld_ViewY);
3543
3544 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
3545 {
3546 if (data->update_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
3547 {
3548 rect.MinX += ((data->icld_IconAreaLargestWidth - data->update_entry->ie_AreaWidth)/2);
3549 rect.MaxX += ((data->icld_IconAreaLargestWidth - data->update_entry->ie_AreaWidth)/2);
3550 }
3551
3552 if (data->update_entry->ie_AreaHeight < data->icld_IconAreaLargestHeight)
3553 {
3554 rect.MinY += ((data->icld_IconAreaLargestHeight - data->update_entry->ie_AreaHeight)/2);
3555 rect.MaxY += ((data->icld_IconAreaLargestHeight - data->update_entry->ie_AreaHeight)/2);
3556 }
3557 }
3558
3559 if (rect.MinX < _mleft(obj)) rect.MinX = _mleft(obj);
3560 if (rect.MaxX > _mright(obj)) rect.MaxX =_mright(obj);
3561 if (rect.MinY < _mtop(obj)) rect.MinY = _mtop(obj);
3562 if (rect.MaxY > _mbottom(obj)) rect.MaxY = _mbottom(obj);
3563
3564 clip = MUI_AddClipping(muiRenderInfo(obj), rect.MinX, rect.MinY, rect.MaxX - rect.MinX + 1, rect.MaxY - rect.MinY + 1);
3565
3566 #if defined(DEBUG_ILC_ICONRENDERING)
3567 D(bug("[IconList] %s#%d: UPDATE_SINGLEENTRY: Calling MUIM_DrawBackground (A)\n", __PRETTY_FUNCTION__, draw_id));
3568 #endif
3569 DoMethod(obj, MUIM_DrawBackground,
3570 rect.MinX, rect.MinY,
3571 rect.MaxX - rect.MinX + 1, rect.MaxY - rect.MinY + 1,
3572 clear_xoffset, clear_yoffset,
3573 0);
3574
3575 /* We could have deleted also other icons so they must be redrawn */
3576 #if defined(__AROS__)
3577 ForeachNode(&data->icld_IconList, entry)
3578 #else
3579 Foreach_Node(&data->icld_IconList, entry);
3580 #endif
3581 {
3582 if ((entry != data->update_entry) && (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE))
3583 {
3584 struct Rectangle rect2;
3585 IconList_GetIconAreaRectangle(obj, data, entry, &rect2);
3586
3587 rect2.MinX += _mleft(obj) - data->icld_ViewX + entry->ie_IconX;
3588 rect2.MaxX += _mleft(obj) - data->icld_ViewX + entry->ie_IconX;
3589 rect2.MinY += _mtop(obj) - data->icld_ViewY + entry->ie_IconY;
3590 rect2.MaxY += _mtop(obj) - data->icld_ViewY + entry->ie_IconY;
3591
3592 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
3593 {
3594 if (entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
3595 {
3596 rect2.MinX += ((data->icld_IconAreaLargestWidth - entry->ie_AreaWidth)/2);
3597 rect2.MaxX += ((data->icld_IconAreaLargestWidth - entry->ie_AreaWidth)/2);
3598 }
3599
3600 if (entry->ie_AreaHeight < data->icld_IconAreaLargestHeight)
3601 {
3602 rect2.MinY += ((data->icld_IconAreaLargestHeight - entry->ie_AreaHeight)/2);
3603 rect2.MaxY += ((data->icld_IconAreaLargestHeight - entry->ie_AreaHeight)/2);
3604 }
3605 }
3606
3607 if (RectAndRect(&rect, &rect2))
3608 {
3609 // Update entry here
3610 entry->ie_Flags |= ICONENTRY_FLAG_NEEDSUPDATE;
3611 DoMethod(obj, MUIM_IconList_DrawEntry, entry, ICONENTRY_DRAWMODE_PLAIN);
3612 DoMethod(obj, MUIM_IconList_DrawEntryLabel, entry, ICONENTRY_DRAWMODE_PLAIN);
3613 entry->ie_Flags &= ~ICONENTRY_FLAG_NEEDSUPDATE;
3614 }
3615 }
3616 }
3617
3618 entry->ie_Flags |= ICONENTRY_FLAG_NEEDSUPDATE;
3619 DoMethod(obj, MUIM_IconList_DrawEntry, data->update_entry, ICONENTRY_DRAWMODE_PLAIN);
3620 DoMethod(obj, MUIM_IconList_DrawEntryLabel, data->update_entry, ICONENTRY_DRAWMODE_PLAIN);
3621 entry->ie_Flags &= ~ICONENTRY_FLAG_NEEDSUPDATE;
3622 data->icld_UpdateMode = 0;
3623 data->update_entry = NULL;
3624 }
3625 if (data->update_entry == NULL)
3626 {
3627 if (data->icld_DisplayRastPort != data->icld_BufferRastPort)
3628 {
3629 #if defined(DEBUG_ILC_ICONRENDERING)
3630 D(bug("[IconList] %s#%d: UPDATE_SINGLEENTRY Blitting to front rastport..\n", __PRETTY_FUNCTION__, draw_id));
3631 #endif
3632 BltBitMapRastPort(data->icld_BufferRastPort->BitMap,
3633 rect.MinX - _mleft(obj), rect.MinY - _mtop(obj),
3634 data->icld_DisplayRastPort,
3635 rect.MinX, rect.MinY,
3636 rect.MaxX - rect.MinX + 1, rect.MaxY - rect.MinY + 1,
3637 0xC0);
3638 }
3639 MUI_RemoveClipping(muiRenderInfo(obj), clip);
3640 }
3641 goto draw_done;
3642 }
3643 else if (data->icld_UpdateMode == UPDATE_SCROLL)
3644 {
3645 struct Region *region = NULL;
3646 struct Rectangle xrect,
3647 yrect;
3648 BOOL scroll_caused_damage = FALSE;
3649
3650 #if defined(DEBUG_ILC_ICONRENDERING)
3651 D(bug("[IconList] %s#%d: UPDATE_SCROLL.\n", __PRETTY_FUNCTION__, draw_id));
3652 #endif
3653
3654 if (!data->icld__Option_IconListFixedBackground)
3655 {
3656 scroll_caused_damage = (_rp(obj)->Layer->Flags & LAYERREFRESH) ? FALSE : TRUE;
3657
3658 data->icld_UpdateMode = 0;
3659
3660 if ((abs(data->update_scrolldx) >= _mwidth(obj)) ||
3661 (abs(data->update_scrolldy) >= _mheight(obj)))
3662 {
3663 #if defined(DEBUG_ILC_ICONRENDERING)
3664 D(bug("[IconList] %s#%d: UPDATE_SCROLL: Moved outside current view -> Causing Redraw .. MADF_DRAWOBJECT\n", __PRETTY_FUNCTION__, draw_id));
3665 #endif
3666 MUI_Redraw(obj, MADF_DRAWOBJECT);
3667 goto draw_done;
3668 }
3669
3670 if (!(region = NewRegion()))
3671 {
3672 #if defined(DEBUG_ILC_ICONRENDERING)
3673 D(bug("[IconList] %s#%d: UPDATE_SCROLL: Couldnt Alloc Region -> Causing Redraw ...MADF_DRAWOBJECT\n", __PRETTY_FUNCTION__, draw_id));
3674 #endif
3675 MUI_Redraw(obj, MADF_DRAWOBJECT);
3676 goto draw_done;
3677 }
3678
3679 if (data->update_scrolldx > 0)
3680 {
3681 xrect.MinX = _mright(obj) - data->update_scrolldx;
3682 xrect.MinY = _mtop(obj);
3683 xrect.MaxX = _mright(obj);
3684 xrect.MaxY = _mbottom(obj);
3685
3686 OrRectRegion(region, &xrect);
3687
3688 data->update_rect1 = &xrect;
3689 }
3690 else if (data->update_scrolldx < 0)
3691 {
3692 xrect.MinX = _mleft(obj);
3693 xrect.MinY = _mtop(obj);
3694 xrect.MaxX = _mleft(obj) - data->update_scrolldx;
3695 xrect.MaxY = _mbottom(obj);
3696
3697 OrRectRegion(region, &xrect);
3698
3699 data->update_rect1 = &xrect;
3700 }
3701
3702 if (data->update_scrolldy > 0)
3703 {
3704 yrect.MinX = _mleft(obj);
3705 yrect.MinY = _mbottom(obj) - data->update_scrolldy;
3706 if (((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
3707 && (yrect.MinY < (_mtop(obj) + data->icld_LVMAttribs->lmva_HeaderHeight)))
3708 {
3709 xrect.MinY = data->icld_LVMAttribs->lmva_HeaderHeight;
3710 }
3711 yrect.MaxX = _mright(obj);
3712 yrect.MaxY = _mbottom(obj);
3713
3714 OrRectRegion(region, &yrect);
3715
3716 data->update_rect2 = &yrect;
3717 }
3718 else if (data->update_scrolldy < 0)
3719 {
3720 yrect.MinX = _mleft(obj);
3721 yrect.MinY = _mtop(obj);
3722 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
3723 {
3724 xrect.MinY += data->icld_LVMAttribs->lmva_HeaderHeight;
3725 }
3726 yrect.MaxX = _mright(obj);
3727 yrect.MaxY = _mtop(obj) - data->update_scrolldy;
3728
3729 OrRectRegion(region, &yrect);
3730
3731 data->update_rect2 = &yrect;
3732 }
3733
3734 #if defined(DEBUG_ILC_ICONRENDERING)
3735 D(bug("[IconList] %s#%d: UPDATE_SCROLL: Scrolling Raster..\n", __PRETTY_FUNCTION__, draw_id));
3736 #endif
3737 if (data->icld_DisplayRastPort == data->icld_BufferRastPort)
3738 {
3739 ScrollRasterBF(data->icld_BufferRastPort,
3740 data->update_scrolldx,
3741 data->update_scrolldy,
3742 _mleft(obj),
3743 _mtop(obj),
3744 _mright(obj),
3745 _mbottom(obj));
3746 }
3747 else
3748 {
3749 ScrollRasterBF(data->icld_BufferRastPort,
3750 data->update_scrolldx,
3751 data->update_scrolldy,
3752 0,
3753 0,
3754 _mwidth(obj) - 1,
3755 _mheight(obj) - 1);
3756 }
3757
3758 scroll_caused_damage = scroll_caused_damage && (_rp(obj)->Layer->Flags & LAYERREFRESH) ? TRUE : FALSE;
3759
3760 clip = MUI_AddClipRegion(muiRenderInfo(obj), region);
3761 }
3762
3763 #if defined(DEBUG_ILC_ICONRENDERING)
3764 D(bug("[IconList] %s#%d: UPDATE_SCROLL: Causing Redraw -> MADF_DRAWOBJECT..\n", __PRETTY_FUNCTION__, draw_id));
3765 #endif
3766 MUI_Redraw(obj, MADF_DRAWOBJECT);
3767
3768 data->update_rect1 = data->update_rect2 = NULL;
3769
3770 if (!data->icld__Option_IconListFixedBackground)
3771 {
3772 MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
3773
3774 if (scroll_caused_damage)
3775 {
3776 if (MUI_BeginRefresh(muiRenderInfo(obj), 0))
3777 {
3778 /* Theoretically it might happen that more damage is caused
3779 after ScrollRaster. By something else, like window movement
3780 in front of our window. Therefore refresh root object of
3781 window, not just this object */
3782
3783 Object *o = NULL;
3784
3785 GET(_win(obj),MUIA_Window_RootObject, &o);
3786 MUI_Redraw(o, MADF_DRAWOBJECT);
3787 #if defined(DEBUG_ILC_ICONRENDERING)
3788 D(bug("[IconList] %s#%d: UPDATE_SCROLL: Causing Redraw -> MADF_DRAWOBJECT..\n", __PRETTY_FUNCTION__, draw_id));
3789 #endif
3790 MUI_EndRefresh(muiRenderInfo(obj), 0);
3791 }
3792 }
3793 }
3794 if (data->icld_DisplayRastPort != data->icld_BufferRastPort)
3795 {
3796 #if defined(DEBUG_ILC_ICONRENDERING)
3797 D(bug("[IconList] %s#%d: UPDATE_SCROLL: Blitting to front rastport..\n", __PRETTY_FUNCTION__, draw_id));
3798 #endif
3799 BltBitMapRastPort(data->icld_BufferRastPort->BitMap,
3800 0, 0,
3801 data->icld_DisplayRastPort,
3802 _mleft(obj), _mtop(obj),
3803 _mwidth(obj), _mheight(obj),
3804 0xC0);
3805 }
3806 goto draw_done;
3807 }
3808 else if (data->icld_UpdateMode == UPDATE_RESIZE)
3809 {
3810 struct Region *region = NULL;
3811 struct Rectangle wrect,
3812 hrect;
3813 ULONG diffw = 0,
3814 diffh = 0;
3815
3816 #if defined(DEBUG_ILC_ICONRENDERING)
3817 D(bug("[IconList] %s#%d: UPDATE_RESIZE.\n", __PRETTY_FUNCTION__, draw_id));
3818 #endif
3819
3820 if ((data->icld_BufferRastPort) && (data->icld_BufferRastPort != data->icld_DisplayRastPort))
3821 {
3822 //Free up the buffers Layer, rastport and bitmap so we can replace them ..
3823 if ((GetBitMapAttr(data->icld_BufferRastPort->BitMap, BMA_WIDTH) != data->icld_ViewWidth)
3824 || (GetBitMapAttr(data->icld_BufferRastPort->BitMap, BMA_HEIGHT) != data->icld_ViewHeight))
3825 {
3826 struct Layer *oldLayer = data->icld_BufferRastPort->Layer;
3827 #if defined(DEBUG_ILC_ATTRIBS) || defined(DEBUG_ILC_ICONRENDERING)
3828 D(bug("[IconList] %s: Destroying old BackLayer\n", __PRETTY_FUNCTION__));
3829 #endif
3830 data->icld_BufferRastPort = data->icld_DisplayRastPort;
3831 DeleteLayer(0, oldLayer);
3832 }
3833
3834 if (data->icld_BufferRastPort == data->icld_DisplayRastPort)
3835 {
3836 struct BitMap *bitmap_New;
3837 ULONG tmp_RastDepth;
3838 struct Layer_Info *li = NULL;
3839
3840 tmp_RastDepth = GetCyberMapAttr(data->icld_DisplayRastPort->BitMap, CYBRMATTR_DEPTH);
3841 if ((bitmap_New = AllocBitMap(data->icld_ViewWidth,
3842 data->icld_ViewHeight,
3843 tmp_RastDepth,
3844 BMF_CLEAR,
3845 data->icld_DisplayRastPort->BitMap)) != NULL)
3846 {
3847 if ((data->icld_BufferRastPort = CreateRastPort()) != NULL)
3848 {
3849 data->icld_BufferRastPort->BitMap = bitmap_New;
3850 if ((li = NewLayerInfo()))
3851 {
3852 if ((data->icld_BufferRastPort->Layer = CreateUpfrontLayer(li, data->icld_BufferRastPort->BitMap, 0, 0, data->icld_ViewWidth - 1, data->icld_ViewHeight - 1, 0, NULL)))
3853 {
3854 /*
3855 * Mark it as a buffered rastport.
3856 */
3857
3858 #if defined(DEBUG_ILC_ATTRIBS) || defined(DEBUG_ILC_ICONRENDERING)
3859 D(bug("[IconList] %s: FrontRastPort @ %p, New BackLayer @ %p, BackRastport @ %p\n", __PRETTY_FUNCTION__, data->icld_DisplayRastPort, data->icld_BufferRastPort->Layer, data->icld_BufferRastPort));
3860 #endif
3861 SET(obj, MUIA_IconList_BufferRastport, data->icld_BufferRastPort);
3862 data->icld_DrawOffsetX = 0;
3863 data->icld_DrawOffsetY = 0;
3864 }
3865 else
3866 data->icld_BufferRastPort = data->icld_DisplayRastPort;
3867 }
3868 else
3869 data->icld_BufferRastPort = data->icld_DisplayRastPort;
3870 }
3871 else
3872 data->icld_BufferRastPort = data->icld_DisplayRastPort;
3873 }
3874
3875 if (data->icld_BufferRastPort == data->icld_DisplayRastPort)
3876 {
3877 if (bitmap_New) FreeBitMap(bitmap_New);
3878 if (li) DisposeLayerInfo(li);
3879 data->icld_DrawOffsetX = _mleft(obj);
3880 data->icld_DrawOffsetY = _mtop(obj);
3881 }
3882 }
3883 }
3884
3885 data->icld_UpdateMode = 0;
3886
3887 if (!data->icld__Option_IconListScaledBackground)
3888 {
3889 if (!(region = NewRegion()))
3890 {
3891 #if defined(DEBUG_ILC_ICONRENDERING)
3892 D(bug("[IconList] %s#%d: UPDATE_RESIZE: Causing Redraw -> MADF_DRAWOBJECT..\n", __PRETTY_FUNCTION__, draw_id));
3893 #endif
3894 MUI_Redraw(obj, MADF_DRAWOBJECT);
3895 goto draw_done;
3896 }
3897
3898 if ( data->icld_ViewWidth > update_oldwidth )
3899 diffw = data->icld_ViewWidth - update_oldwidth;
3900 if ( data->icld_ViewHeight > update_oldheight )
3901 diffh = data->icld_ViewHeight - update_oldheight;
3902
3903 if (diffw)
3904 {
3905 wrect.MinX = _mright(obj) - diffw;
3906 wrect.MinY = _mtop(obj);
3907 wrect.MaxX = _mright(obj);
3908 wrect.MaxY = _mbottom(obj);
3909 OrRectRegion(region, &wrect);
3910 data->update_rect1 = &wrect;
3911 }
3912
3913 if (diffh)
3914 {
3915 hrect.MinX = _mleft(obj);
3916 hrect.MinY = _mbottom(obj) - diffh;
3917 hrect.MaxX = _mright(obj);
3918 hrect.MaxX = _mright(obj);
3919 hrect.MaxY = _mbottom(obj);
3920 OrRectRegion(region, &hrect);
3921 data->update_rect2 = &hrect;
3922 }
3923 if (diffh||diffw)
3924 {
3925 clip = MUI_AddClipRegion(muiRenderInfo(obj), region);
3926 }
3927 else
3928 {
3929 /* View became smaller both in horizontal and vertical direction.
3930 Nothing to do */
3931
3932 DisposeRegion(region);
3933 goto draw_done;
3934 }
3935 }
3936
3937 #if defined(DEBUG_ILC_ICONRENDERING)
3938 D(bug("[IconList] %s#%d: UPDATE_RESIZE: Causing Redraw -> MADF_DRAWOBJECT..\n", __PRETTY_FUNCTION__, draw_id));
3939 #endif
3940 MUI_Redraw(obj, MADF_DRAWOBJECT);
3941
3942 if (!data->icld__Option_IconListScaledBackground)
3943 {
3944 if (diffh||diffw)
3945 {
3946 data->update_rect1 = data->update_rect2 = NULL;
3947 MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
3948 } else DisposeRegion(region);
3949 }
3950
3951 goto draw_done;
3952 }
3953 }
3954
3955 if (message->flags & MADF_DRAWOBJECT)
3956 {
3957 struct Rectangle viewrect;
3958 int current = 0, first = 0, visible = 0;
3959
3960 #if defined(DEBUG_ILC_ICONRENDERING)
3961 D(bug("[IconList] %s#%d: MADF_DRAWOBJECT\n", __PRETTY_FUNCTION__, draw_id));
3962 #endif
3963
3964 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
3965 {
3966 clip = MUI_AddClipping(muiRenderInfo(obj), _mleft(obj), _mtop(obj), _mwidth(obj), data->icld_LVMAttribs->lmva_HeaderHeight);
3967 RenderListViewModeHeader(obj, data);
3968
3969 if (data->icld_DisplayRastPort != data->icld_BufferRastPort)
3970 {
3971 #if defined(DEBUG_ILC_ICONRENDERING)
3972 D(bug("[IconList] %s#%d: MADF_DRAWOBJECT Blitting Header to front rastport..\n", __PRETTY_FUNCTION__, draw_id));
3973 #endif
3974 BltBitMapRastPort(data->icld_BufferRastPort->BitMap,
3975 0, 0,
3976 data->icld_DisplayRastPort,
3977 _mleft(obj), _mtop(obj), _mwidth(obj), data->icld_LVMAttribs->lmva_HeaderHeight,
3978 0xC0);
3979 }
3980
3981 MUI_RemoveClipping(muiRenderInfo(obj), clip);
3982
3983 viewrect.MinY = _mtop(obj) + data->icld_LVMAttribs->lmva_HeaderHeight;
3984
3985 first = FirstVisibleLine(data);
3986 visible = NumVisibleLines(data);
3987
3988 clip = MUI_AddClipping(muiRenderInfo(obj), _mleft(obj), _mtop(obj) + data->icld_LVMAttribs->lmva_HeaderHeight, _mwidth(obj), _mheight(obj) - data->icld_LVMAttribs->lmva_HeaderHeight);
3989 }
3990 else
3991 {
3992 viewrect.MinY = _mtop(obj);
3993 clip = MUI_AddClipping(muiRenderInfo(obj), _mleft(obj), _mtop(obj), _mwidth(obj), _mheight(obj));
3994 }
3995
3996 viewrect.MaxY = _mtop(obj) + _mheight(obj) - 1;
3997 viewrect.MinX = _mleft(obj);
3998 viewrect.MaxX = _mleft(obj) + _mwidth(obj) - 1;
3999
4000 #if defined(DEBUG_ILC_ICONRENDERING)
4001 D(bug("[IconList] %s#%d: MADF_DRAWOBJECT: Calling MUIM_DrawBackground (B)\n", __PRETTY_FUNCTION__, draw_id));
4002 #endif
4003 DoMethod(
4004 obj, MUIM_DrawBackground, viewrect.MinX, viewrect.MinY, (viewrect.MaxX - viewrect.MinX) + 1, (viewrect.MaxY - viewrect.MinY) + 1,
4005 clear_xoffset, clear_yoffset, 0
4006 );
4007 #if defined(__AROS__)
4008 ForeachNode(&data->icld_IconList, entry)
4009 #else
4010 Foreach_Node(&data->icld_IconList, entry);
4011 #endif
4012 {
4013 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
4014 {
4015 if (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
4016 {
4017 if ((current >= first) && (current <= (first + visible)))
4018 {
4019 DoMethod(obj, MUIM_IconList_DrawEntry, entry, current);
4020 }
4021 current++;
4022 }
4023 }
4024 else
4025 {
4026 if ((entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
4027 (entry->ie_DiskObj) &&
4028 (entry->ie_IconX != NO_ICON_POSITION) &&
4029 (entry->ie_IconY != NO_ICON_POSITION))
4030 {
4031 struct Rectangle iconrect;
4032 IconList_GetIconAreaRectangle(obj, data, entry, &iconrect);
4033
4034 iconrect.MinX += viewrect.MinX - data->icld_ViewX + entry->ie_IconX;
4035 iconrect.MaxX += viewrect.MinX - data->icld_ViewX + entry->ie_IconX;
4036 iconrect.MinY += viewrect.MinY - data->icld_ViewY + entry->ie_IconY;
4037 iconrect.MaxY += viewrect.MinY - data->icld_ViewY + entry->ie_IconY;
4038
4039 if (RectAndRect(&viewrect, &iconrect))
4040 {
4041 DoMethod(obj, MUIM_IconList_DrawEntry, entry, ICONENTRY_DRAWMODE_PLAIN);
4042 DoMethod(obj, MUIM_IconList_DrawEntryLabel, entry, ICONENTRY_DRAWMODE_PLAIN);
4043 }
4044 }
4045 }
4046 }
4047
4048 if (data->icld_DisplayRastPort != data->icld_BufferRastPort)
4049 {
4050 #if defined(DEBUG_ILC_ICONRENDERING)
4051 D(bug("[IconList] %s#%d: MADF_DRAWOBJECT: Blitting to front rastport..\n", __PRETTY_FUNCTION__, draw_id));
4052 #endif
4053 BltBitMapRastPort(data->icld_BufferRastPort->BitMap,
4054 0, 0,
4055 data->icld_DisplayRastPort,
4056 _mleft(obj), _mtop(obj),
4057 _mwidth(obj), _mheight(obj),
4058 0xC0);
4059 }
4060
4061 MUI_RemoveClipping(muiRenderInfo(obj), clip);
4062 }
4063 data->icld_UpdateMode = 0;
4064
4065 draw_done:;
4066
4067 #if defined(DEBUG_ILC_ICONRENDERING)
4068 D(bug("[IconList] %s: Draw finished for id %d\n", __PRETTY_FUNCTION__, draw_id));
4069 #endif
4070 return 0;
4071 }
4072 ///
4073
4074 ///IconList__MUIM_IconList_Update()
4075 /**************************************************************************
4076 MUIM_IconList_Refresh
4077 Implemented by subclasses
4078 **************************************************************************/
4079 IPTR IconList__MUIM_IconList_Update(struct IClass *CLASS, Object *obj, struct MUIP_IconList_Update *message)
4080 {
4081 struct IconList_DATA *data = INST_DATA(CLASS, obj);
4082
4083 #if defined(DEBUG_ILC_FUNCS)
4084 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
4085 #endif
4086
4087 data->icld_FocusIcon = NULL;
4088 SET(obj, MUIA_IconList_Changed, TRUE);
4089
4090 return 1;
4091 }
4092 ///
4093
4094 ///MUIM_IconList_Clear()
4095 /**************************************************************************
4096 MUIM_IconList_Clear
4097 **************************************************************************/
4098 IPTR IconList__MUIM_IconList_Clear(struct IClass *CLASS, Object *obj, struct MUIP_IconList_Clear *message)
4099 {
4100 struct IconList_DATA *data = INST_DATA(CLASS, obj);
4101 struct IconEntry *node = NULL;
4102
4103 #if defined(DEBUG_ILC_FUNCS)
4104 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
4105 #endif
4106
4107 while ((node = (struct IconEntry*)RemTail((struct List*)&data->icld_IconList)))
4108 {
4109 DoMethod(obj, MUIM_IconList_DestroyEntry, node);
4110 }
4111
4112 data->icld_SelectionLastClicked = NULL;
4113 data->icld_FocusIcon = NULL;
4114
4115 data->icld_ViewX = data->icld_ViewY = data->icld_AreaWidth = data->icld_AreaHeight = 0;
4116 data->icld_IconAreaLargestWidth = 0;
4117 data->icld_IconAreaLargestHeight = 0;
4118 data->icld_IconLargestHeight = 0;
4119 data->icld_LabelLargestHeight = 0;
4120
4121 #if defined(DEBUG_ILC_ICONRENDERING)
4122 D(bug("[IconList]: %s: call SetSuperAttrs()\n", __PRETTY_FUNCTION__));
4123 #endif
4124 SetSuperAttrs(CLASS, obj, MUIA_Virtgroup_Left, data->icld_ViewX,
4125 MUIA_Virtgroup_Top, data->icld_ViewY,
4126 TAG_DONE);
4127
4128 #if defined(DEBUG_ILC_ICONRENDERING)
4129 D(bug("[IconList]: %s: call SetAttrs()\n", __PRETTY_FUNCTION__));
4130 #endif
4131 SetAttrs(obj, MUIA_Virtgroup_Left, data->icld_ViewX,
4132 MUIA_Virtgroup_Top, data->icld_ViewY,
4133 TAG_DONE);
4134
4135 #if defined(DEBUG_ILC_ICONRENDERING)
4136 D(bug("[IconList]: %s: Set MUIA_IconList_Width and MUIA_IconList_Height\n", __PRETTY_FUNCTION__));
4137 #endif
4138 SetAttrs(obj, MUIA_IconList_Width, data->icld_AreaWidth,
4139 MUIA_IconList_Height, data->icld_AreaHeight,
4140 TAG_DONE);
4141
4142 D(bug("[IconList]: %s: call MUI_Redraw()\n", __PRETTY_FUNCTION__));
4143 MUI_Redraw(obj,MADF_DRAWOBJECT);
4144 return 1;
4145 }
4146 ///
4147
4148 ///IconList__MUIM_IconList_DestroyEntry()
4149 IPTR IconList__MUIM_IconList_DestroyEntry(struct IClass *CLASS, Object *obj, struct MUIP_IconList_DestroyEntry *message)
4150 {
4151 struct IconList_DATA *data = INST_DATA(CLASS, obj);
4152
4153 #if defined(DEBUG_ILC_FUNCS)
4154 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
4155 #endif
4156
4157 if (message->entry)
4158 {
4159 if (message->entry->ie_Flags & ICONENTRY_FLAG_SELECTED)
4160 {
4161 if (data->icld_SelectionLastClicked == message->entry)
4162 {
4163 struct IconList_Entry *nextentry = &message->entry->ie_IconListEntry;
4164
4165 /* get selected entries from SOURCE iconlist */
4166 DoMethod(obj, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&nextentry);
4167 if ((nextentry) && ((IPTR)nextentry != MUIV_IconList_NextIcon_End))
4168 data->icld_SelectionLastClicked = (struct IconEntry *)((IPTR)nextentry - ((IPTR)&message->entry->ie_IconListEntry - (IPTR)message->entry));
4169 else
4170 data->icld_SelectionLastClicked = NULL;
4171 }
4172 if (data->icld_FocusIcon == message->entry)
4173 data->icld_FocusIcon = data->icld_SelectionLastClicked;
4174
4175 Remove(&message->entry->ie_SelectionNode);
4176 }
4177
4178 if (message->entry->ie_TxtBuf_DisplayedLabel)
4179 FreeVecPooled(data->icld_Pool, message->entry->ie_TxtBuf_DisplayedLabel);
4180
4181 if (message->entry->ie_TxtBuf_PROT)
4182 FreePooled(data->icld_Pool, message->entry->ie_TxtBuf_PROT, 8);
4183
4184 if (message->entry->ie_TxtBuf_SIZE)
4185 FreePooled(data->icld_Pool, message->entry->ie_TxtBuf_SIZE, 30);
4186
4187 if (message->entry->ie_TxtBuf_TIME)
4188 FreePooled(data->icld_Pool, message->entry->ie_TxtBuf_TIME, LEN_DATSTRING);
4189
4190 if (message->entry->ie_TxtBuf_DATE)
4191 FreePooled(data->icld_Pool, message->entry->ie_TxtBuf_DATE, LEN_DATSTRING);
4192
4193 if (message->entry->ie_DiskObj)
4194 FreeDiskObject(message->entry->ie_DiskObj);
4195
4196 if (message->entry->ie_FileInfoBlock)
4197 FreeMem(message->entry->ie_FileInfoBlock, sizeof(struct FileInfoBlock));
4198
4199 if (message->entry->ie_IconListEntry.label)
4200 FreePooled(data->icld_Pool, message->entry->ie_IconListEntry.label, strlen(message->entry->ie_IconListEntry.label)+1);
4201
4202 if (message->entry->ie_IconNode.ln_Name)
4203 FreePooled(data->icld_Pool, message->entry->ie_IconNode.ln_Name, strlen(message->entry->ie_IconNode.ln_Name)+1);
4204
4205 FreePooled(data->icld_Pool, message->entry, sizeof(struct IconEntry));
4206 }
4207 return (IPTR)TRUE;
4208 }
4209 ///
4210
4211 ///IconList__MUIM_IconList_PropagateEntryPos()
4212 IPTR IconList__MUIM_IconList_PropagateEntryPos(struct IClass *CLASS, Object *obj,
4213 struct MUIP_IconList_PropagateEntryPos *message)
4214 {
4215 message->entry->ie_ProvidedIconX = message->entry->ie_IconX;
4216 message->entry->ie_ProvidedIconY = message->entry->ie_IconY;
4217
4218 return (IPTR)TRUE;
4219 }
4220
4221 //
4222 ///IconList__MUIM_IconList_CreateEntry()
4223 /**************************************************************************
4224 MUIM_IconList_CreateEntry.
4225 Returns 0 on failure otherwise it returns the icons entry ..
4226 **************************************************************************/
4227 IPTR IconList__MUIM_IconList_CreateEntry(struct IClass *CLASS, Object *obj, struct MUIP_IconList_CreateEntry *message)
4228 {
4229 struct IconList_DATA *data = INST_DATA(CLASS, obj);
4230 struct IconEntry *entry = NULL;
4231 struct DateTime dt;
4232 struct DateStamp now;
4233 UBYTE *sp = NULL;
4234
4235 struct DiskObject *dob = NULL;
4236 struct Rectangle rect;
4237
4238 IPTR geticon_error = 0;
4239
4240 #if defined(DEBUG_ILC_FUNCS)
4241 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
4242 #endif
4243
4244 /*disk object (icon)*/
4245 if (message->entry_dob == NULL)
4246 {
4247 IPTR iconlistScreen = (IPTR)_screen(obj);
4248 D(bug("[IconList] %s: IconList Screen @ 0x%p)\n", __PRETTY_FUNCTION__, iconlistScreen));
4249
4250 dob = GetIconTags
4251 (
4252 message->filename,
4253 (iconlistScreen) ? ICONGETA_Screen : TAG_IGNORE, iconlistScreen,
4254 (iconlistScreen) ? ICONGETA_RemapIcon : TAG_IGNORE, TRUE,
4255 ICONGETA_FailIfUnavailable, FALSE,
4256 ICONGETA_GenerateImageMasks, TRUE,
4257 ICONA_ErrorCode, &geticon_error,
4258 TAG_DONE
4259 );
4260
4261 if (dob == NULL)
4262 {
4263 D(bug("[IconList] %s: Fatal: Couldnt get DiskObject! (error code = 0x%p)\n", __PRETTY_FUNCTION__, geticon_error));
4264
4265 return (IPTR)NULL;
4266 }
4267 }
4268 else
4269 {
4270 dob = message->entry_dob;
4271 }
4272
4273 D(bug("[IconList] %s: DiskObject @ 0x%p\n", __PRETTY_FUNCTION__, dob));
4274
4275 if ((entry = AllocPooled(data->icld_Pool, sizeof(struct IconEntry))) == NULL)
4276 {
4277 D(bug("[IconList] %s: Failed to Allocate Entry Storage!\n", __PRETTY_FUNCTION__));
4278 FreeDiskObject(dob);
4279 return (IPTR)NULL;
4280 }
4281 memset(entry, 0, sizeof(struct IconEntry));
4282 entry->ie_Flags |= ICONENTRY_FLAG_NEEDSUPDATE;
4283 entry->ie_IconListEntry.ile_IconEntry = entry;
4284
4285 /* Allocate Text Buffers */
4286
4287 if ((entry->ie_TxtBuf_DATE = AllocPooled(data->icld_Pool, LEN_DATSTRING)) == NULL)
4288 {
4289 D(bug("[IconList] %s: Failed to Allocate Entry DATE Storage!\n", __PRETTY_FUNCTION__));
4290 DoMethod(obj, MUIM_IconList_DestroyEntry, entry);
4291 return (IPTR)NULL;
4292 }
4293 memset(entry->ie_TxtBuf_DATE, 0, LEN_DATSTRING);
4294
4295 if ((entry->ie_TxtBuf_TIME = AllocPooled(data->icld_Pool, LEN_DATSTRING)) == NULL)
4296 {
4297 D(bug("[IconList] %s: Failed to Allocate Entry TIME string Storage!\n", __PRETTY_FUNCTION__));
4298 DoMethod(obj, MUIM_IconList_DestroyEntry, entry);
4299 return (IPTR)NULL;
4300 }
4301 memset(entry->ie_TxtBuf_TIME, 0, LEN_DATSTRING);
4302
4303 if ((entry->ie_TxtBuf_SIZE = AllocPooled(data->icld_Pool, 30)) == NULL)
4304 {
4305 D(bug("[IconList] %s: Failed to Allocate Entry SIZE string Storage!\n", __PRETTY_FUNCTION__));
4306 DoMethod(obj, MUIM_IconList_DestroyEntry, entry);
4307 return (IPTR)NULL;
4308 }
4309 memset(entry->ie_TxtBuf_SIZE, 0, 30);
4310
4311 if ((entry->ie_TxtBuf_PROT = AllocPooled(data->icld_Pool, 8)) == NULL)
4312 {
4313 D(bug("[IconList] %s: Failed to Allocate Entry PROT Flag string Storage!\n", __PRETTY_FUNCTION__));
4314 DoMethod(obj, MUIM_IconList_DestroyEntry, entry);
4315 return (IPTR)NULL;
4316 }
4317 memset(entry->ie_TxtBuf_PROT, 0, 8);
4318
4319 /*alloc filename*/
4320 if ((entry->ie_IconNode.ln_Name = AllocPooled(data->icld_Pool, strlen(message->filename) + 1)) == NULL)
4321 {
4322 D(bug("[IconList] %s: Failed to Allocate Entry filename string Storage!\n", __PRETTY_FUNCTION__));
4323 DoMethod(obj, MUIM_IconList_DestroyEntry, entry);
4324 return (IPTR)NULL;
4325 }
4326
4327 /*alloc entry label*/
4328 if ((entry->ie_IconListEntry.label = AllocPooled(data->icld_Pool, strlen(message->label) + 1)) == NULL)
4329 {
4330 D(bug("[IconList] %s: Failed to Allocate Entry label string Storage!\n", __PRETTY_FUNCTION__));
4331 DoMethod(obj, MUIM_IconList_DestroyEntry, entry);
4332 return (IPTR)NULL;
4333 }
4334
4335 /*file info block*/
4336 if(message->fib != NULL)
4337 {
4338 if ((entry->ie_FileInfoBlock = AllocMem(sizeof(struct FileInfoBlock), MEMF_CLEAR)) != NULL)
4339 {
4340 CopyMem(message->fib, entry->ie_FileInfoBlock, sizeof(struct FileInfoBlock));
4341
4342 if (entry->ie_FileInfoBlock->fib_DirEntryType > 0)
4343 {
4344 strcpy(entry->ie_TxtBuf_SIZE, "Drawer");
4345 }
4346 else
4347 {
4348 FmtSizeToString(entry->ie_TxtBuf_SIZE, entry->ie_FileInfoBlock->fib_Size);
4349 }
4350
4351 dt.dat_Stamp = entry->ie_FileInfoBlock->fib_Date;
4352 dt.dat_Format = FORMAT_DEF;
4353 dt.dat_Flags = 0;
4354 dt.dat_StrDay = NULL;
4355 dt.dat_StrDate = entry->ie_TxtBuf_DATE;
4356 dt.dat_StrTime = entry->ie_TxtBuf_TIME;
4357
4358 DateToStr(&dt);
4359 DateStamp(&now);
4360
4361 /*if modified today show time, otherwise just show date*/
4362 if (now.ds_Days == entry->ie_FileInfoBlock->fib_Date.ds_Days)
4363 entry->ie_Flags |= ICONENTRY_FLAG_TODAY;
4364 else
4365 entry->ie_Flags &= ~ICONENTRY_FLAG_TODAY;
4366
4367 sp = entry->ie_TxtBuf_PROT;
4368 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_SCRIPT) ? 's' : '-';
4369 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_PURE) ? 'p' : '-';
4370 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_ARCHIVE) ? 'a' : '-';
4371 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_READ) ? '-' : 'r';
4372 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_WRITE) ? '-' : 'w';
4373 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_EXECUTE) ? '-' : 'e';
4374 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_DELETE) ? '-' : 'd';
4375 *sp++ = '\0';
4376
4377 entry->ie_IconListEntry.type = entry->ie_FileInfoBlock->fib_DirEntryType;
4378 }
4379 }
4380 else
4381 {
4382 entry->ie_IconListEntry.type = ST_USERDIR;
4383 }
4384
4385 /* Override type if specified during createntry */
4386 if (message->type != 0)
4387 {
4388 entry->ie_IconListEntry.type = message->type;
4389 D(bug("[IconList] %s: Overide Entry Type. New Type = %x\n", __PRETTY_FUNCTION__, entry->ie_IconListEntry.type));
4390 }
4391 else
4392 {
4393 D(bug("[IconList] %s: Entry Type = %x\n", __PRETTY_FUNCTION__, entry->ie_IconListEntry.type));
4394 }
4395
4396 strcpy(entry->ie_IconNode.ln_Name, message->filename);
4397 strcpy(entry->ie_IconListEntry.label, message->label);
4398
4399 entry->ie_IconListEntry.udata = NULL;
4400
4401 entry->ie_IconX = dob->do_CurrentX;
4402 entry->ie_IconY = dob->do_CurrentY;
4403
4404 DoMethod(obj, MUIM_IconList_PropagateEntryPos, entry);
4405
4406 if (IconList__LabelFunc_CreateLabel(obj, data, entry) != (IPTR)NULL)
4407 {
4408 entry->ie_DiskObj = dob;
4409
4410 /* Use a geticonrectangle routine that gets textwidth! */
4411 IconList_GetIconAreaRectangle(obj, data, entry, &rect);
4412
4413 return (IPTR)entry;
4414 }
4415
4416 DoMethod(obj, MUIM_IconList_DestroyEntry, entry);
4417 return (IPTR)NULL;
4418 }
4419 ///
4420
4421 ///IconList__MUIM_IconList_UpdateEntry()
4422 /**************************************************************************
4423 MUIM_IconList_UpdateEntry.
4424 Returns 0 on failure otherwise it returns the icons entry ..
4425 **************************************************************************/
4426 IPTR IconList__MUIM_IconList_UpdateEntry(struct IClass *CLASS, Object *obj, struct MUIP_IconList_UpdateEntry *message)
4427 {
4428 struct IconList_DATA *data = INST_DATA(CLASS, obj);
4429 // struct DateTime dt;
4430 // struct DateStamp now;
4431 // UBYTE *sp = NULL;
4432
4433 // struct DiskObject *dob = NULL;
4434 struct Rectangle rect;
4435
4436 // IPTR geticon_error = 0;
4437
4438 #if defined(DEBUG_ILC_FUNCS)
4439 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
4440 #endif
4441
4442 /* Update disk object (icon)*/
4443 /* if (message->entry_dob == NULL)
4444 {
4445 IPTR iconlistScreen = _screen(obj);
4446 D(bug("[IconList] %s: IconList Screen @ 0x%p)\n", __PRETTY_FUNCTION__, iconlistScreen));
4447
4448 dob = GetIconTags
4449 (
4450 message->filename,
4451 (iconlistScreen) ? ICONGETA_Screen : TAG_IGNORE, iconlistScreen,
4452 (iconlistScreen) ? ICONGETA_RemapIcon : TAG_IGNORE, TRUE,
4453 ICONGETA_FailIfUnavailable, FALSE,
4454 ICONGETA_GenerateImageMasks, TRUE,
4455 ICONA_ErrorCode, &geticon_error,
4456 TAG_DONE
4457 );
4458
4459 if (dob == NULL)
4460 {
4461 D(bug("[IconList] %s: Fatal: Couldnt get DiskObject! (error code = 0x%p)\n", __PRETTY_FUNCTION__, geticon_error));
4462
4463 return (IPTR)NULL;
4464 }
4465 }
4466 else
4467 {
4468 dob = message->entry_dob;
4469 }
4470
4471 D(bug("[IconList] %s: DiskObject @ 0x%p\n", __PRETTY_FUNCTION__, dob));
4472 */
4473
4474 /* Update filename */
4475 if (strcmp(message->entry->ie_IconNode.ln_Name, message->filename) != 0)
4476 {
4477 message->entry->ie_Flags |= ICONENTRY_FLAG_NEEDSUPDATE;
4478 FreePooled(data->icld_Pool, message->entry->ie_IconNode.ln_Name, strlen(message->entry->ie_IconNode.ln_Name) + 1);
4479 if ((message->entry->ie_IconNode.ln_Name = AllocPooled(data->icld_Pool, strlen(message->filename) + 1)) == NULL)
4480 {
4481 D(bug("[IconList] %s: Failed to Allocate Entry filename string Storage!\n", __PRETTY_FUNCTION__));
4482 DoMethod(obj, MUIM_IconList_DestroyEntry, message->entry);
4483 return (IPTR)NULL;
4484 }
4485 strcpy(message->entry->ie_IconNode.ln_Name, message->filename);
4486 }
4487
4488 /* Update entry label */
4489 if (strcmp(message->entry->ie_IconListEntry.label, message->label) != 0)
4490 {
4491 message->entry->ie_Flags |= ICONENTRY_FLAG_NEEDSUPDATE;
4492 FreePooled(data->icld_Pool, message->entry->ie_IconListEntry.label, strlen(message->entry->ie_IconListEntry.label) + 1);
4493 if ((message->entry->ie_IconListEntry.label = AllocPooled(data->icld_Pool, strlen(message->label) + 1)) == NULL)
4494 {
4495 D(bug("[IconList] %s: Failed to Allocate Entry label string Storage!\n", __PRETTY_FUNCTION__));
4496 DoMethod(obj, MUIM_IconList_DestroyEntry, message->entry);
4497 return (IPTR)NULL;
4498 }
4499 strcpy(message->entry->ie_IconListEntry.label, message->label);
4500 if (IconList__LabelFunc_CreateLabel(obj, data, message->entry) == (IPTR)NULL)
4501 {
4502 D(bug("[IconList] %s: Failed to create label\n", __PRETTY_FUNCTION__));
4503 DoMethod(obj, MUIM_IconList_DestroyEntry, message->entry);
4504 return (IPTR)NULL;
4505 }
4506 }
4507
4508 /* Update file info block */
4509 if(message->fib != NULL)
4510 {
4511 if (!(message->entry->ie_FileInfoBlock))
4512 {
4513 if ((message->entry->ie_FileInfoBlock = AllocMem(sizeof(struct FileInfoBlock), MEMF_CLEAR)) != NULL)
4514 {
4515 CopyMem(message->fib, message->entry->ie_FileInfoBlock, sizeof(struct FileInfoBlock));
4516 }
4517 }
4518
4519 /* if (entry->ie_FileInfoBlock->fib_DirEntryType > 0)
4520 {
4521 strcpy(entry->ie_TxtBuf_SIZE, "Drawer");
4522 }
4523 else
4524 {
4525 FmtSizeToString(entry->ie_TxtBuf_SIZE, entry->ie_FileInfoBlock->fib_Size);
4526 }
4527
4528 dt.dat_Stamp = entry->ie_FileInfoBlock->fib_Date;
4529 dt.dat_Format = FORMAT_DEF;
4530 dt.dat_Flags = 0;
4531 dt.dat_StrDay = NULL;
4532 dt.dat_StrDate = entry->ie_TxtBuf_DATE;
4533 dt.dat_StrTime = entry->ie_TxtBuf_TIME;
4534
4535 DateToStr(&dt);
4536 DateStamp(&now);
4537
4538 //if modified today show time, otherwise just show date
4539 if (now.ds_Days == entry->ie_FileInfoBlock->fib_Date.ds_Days)
4540 entry->ie_Flags |= ICONENTRY_FLAG_TODAY;
4541 else
4542 entry->ie_Flags &= ~ICONENTRY_FLAG_TODAY;
4543
4544 sp = entry->ie_TxtBuf_PROT;
4545 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_SCRIPT) ? 's' : '-';
4546 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_PURE) ? 'p' : '-';
4547 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_ARCHIVE) ? 'a' : '-';
4548 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_READ) ? '-' : 'r';
4549 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_WRITE) ? '-' : 'w';
4550 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_EXECUTE) ? '-' : 'e';
4551 *sp++ = (entry->ie_FileInfoBlock->fib_Protection & FIBF_DELETE) ? '-' : 'd';
4552 *sp++ = '\0';
4553
4554 entry->ie_IconListEntry.type = entry->ie_FileInfoBlock->fib_DirEntryType;
4555 */
4556 }
4557 else
4558 {
4559 if (message->entry->ie_FileInfoBlock)
4560 FreeMem(message->entry->ie_FileInfoBlock, sizeof(struct FileInfoBlock));
4561
4562 if (message->entry->ie_IconListEntry.type != ST_USERDIR)
4563 {
4564 message->entry->ie_Flags |= ICONENTRY_FLAG_NEEDSUPDATE;
4565 message->entry->ie_IconListEntry.type = ST_USERDIR;
4566 }
4567 }
4568
4569 /* Override type if specified */
4570 if ((message->type != 0) && (message->entry->ie_IconListEntry.type != message->type))
4571 {
4572 message->entry->ie_Flags |= ICONENTRY_FLAG_NEEDSUPDATE;
4573 message->entry->ie_IconListEntry.type = message->type;
4574 D(bug("[IconList] %s: Overide Entry Type. New Type = %x\n", __PRETTY_FUNCTION__, message->entry->ie_IconListEntry.type));
4575 }
4576 else
4577 {
4578 D(bug("[IconList] %s: Entry Type = %x\n", __PRETTY_FUNCTION__, message->entry->ie_IconListEntry.type));
4579 }
4580
4581 IconList_GetIconAreaRectangle(obj, data, message->entry, &rect);
4582
4583 return (IPTR)message->entry;
4584 }
4585 ///
4586
4587 ///DoWheelMove()
4588 static void DoWheelMove(struct IClass *CLASS, Object *obj, LONG wheelx, LONG wheely, UWORD qual)
4589 {
4590 struct IconList_DATA *data = INST_DATA(CLASS, obj);
4591
4592 LONG newleft = data->icld_ViewX,
4593 newtop = data->icld_ViewY;
4594
4595 /* Use horizontal scrolling if any of the following cases are true ...
4596
4597 # vertical wheel is used but there's nothing to scroll
4598 (everything is visible already) ..
4599
4600 # vertical wheel is used and one of the ALT keys is down. */
4601
4602 if ((wheely && !wheelx) &&
4603 ((data->icld_AreaHeight <= _mheight(obj)) || (qual & (IEQUALIFIER_LALT | IEQUALIFIER_RALT))))
4604 {
4605 wheelx = wheely; wheely = 0;
4606 }
4607
4608 if (qual & (IEQUALIFIER_CONTROL))
4609 {
4610 if (wheelx < 0) newleft = 0;
4611 if (wheelx > 0) newleft = data->icld_AreaWidth;
4612 if (wheely < 0) newtop = 0;
4613 if (wheely > 0) newtop = data->icld_AreaHeight;
4614 }
4615 else if (qual & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
4616 {
4617 newleft += (wheelx * _mwidth(obj));
4618 newtop += (wheely * _mheight(obj));
4619 }
4620 else
4621 {
4622 newleft += wheelx * 30;
4623 newtop += wheely * 30;
4624 }
4625
4626 if (newleft + _mwidth(obj) > data->icld_AreaWidth)
4627 newleft = data->icld_AreaWidth - _mwidth(obj);
4628 if (newleft < 0)
4629 newleft = 0;
4630
4631 if (newtop + _mheight(obj) > data->icld_AreaHeight)
4632 newtop = data->icld_AreaHeight - _mheight(obj);
4633 if (newtop < 0)
4634 newtop = 0;
4635
4636 if ((newleft != data->icld_ViewX) || (newtop != data->icld_ViewY))
4637 {
4638 SetAttrs(obj, MUIA_Virtgroup_Left, newleft,
4639 MUIA_Virtgroup_Top, newtop,
4640 TAG_DONE);
4641 }
4642 }
4643 ///
4644
4645 /* Notes:
4646 *
4647 * LEFTDOWN
4648 * a) if clicked object is selected, nothing
4649 * b) if clicked object is not selected, unselect all, select object
4650 * c) if no clicked object, start lasso
4651 * LEFTUP
4652 * a) if in lasso, finish lasso
4653 * LEFTDOWN + SHIFT
4654 * a) if object is selected, unselect it (= remove from multiselection)
4655 * b) if object is not selected, select it (= add to multiselection)
4656 *
4657 *
4658 * Expected behaviour:
4659 * a) you can only "remove" multiselection by clicking on not selected object or on space where there is no icon
4660 *
4661 */
4662
4663 static void IconList_HandleNewIconSelection(struct IClass *CLASS, Object *obj, struct MUIP_HandleEvent *message,
4664 struct IconEntry *new_selected, BOOL *doubleclicked)
4665 {
4666 struct IconEntry *node = NULL;
4667 BOOL update_entry = FALSE;
4668 LONG mx = message->imsg->MouseX - _mleft(obj);
4669 LONG my = message->imsg->MouseY - _mtop(obj);
4670 struct IconList_DATA *data = INST_DATA(CLASS, obj);
4671 BOOL nounselection = (new_selected != NULL &&
4672 (new_selected->ie_Flags & ICONENTRY_FLAG_SELECTED)); /* see notes above */
4673
4674
4675 /* Check if this is a double click on icon or empty space */
4676 if ((DoubleClick(data->last_secs, data->last_mics, message->imsg->Seconds, message->imsg->Micros)) && (data->icld_SelectionLastClicked == new_selected))
4677 {
4678 #if defined(DEBUG_ILC_EVENTS)
4679 D(bug("[IconList] %s: Entry double-clicked\n", __PRETTY_FUNCTION__));
4680 #endif
4681 *doubleclicked = TRUE;
4682 }
4683
4684 /* Deselection lopp */
4685 #if defined(__AROS__)
4686 ForeachNode(&data->icld_IconList, node)
4687 #else
4688 Foreach_Node(&data->icld_IconList, node);
4689 #endif
4690 {
4691 if (node->ie_Flags & ICONENTRY_FLAG_VISIBLE)
4692 {
4693 update_entry = FALSE;
4694
4695 /* If node that is being checked is selected and it is not the clicked node
4696 * and no shift pressed and
4697 * clicked node is not part of selection (see notes above) or this is a double click */
4698 if (node->ie_Flags & ICONENTRY_FLAG_SELECTED)
4699 {
4700 if ((new_selected != node) &&
4701 (!(message->imsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))) &&
4702 (!nounselection || *doubleclicked))
4703 {
4704 Remove(&node->ie_SelectionNode);
4705 node->ie_Flags &= ~ICONENTRY_FLAG_SELECTED;
4706 update_entry = TRUE;
4707 }
4708 }
4709
4710 /* Remove focus */
4711 if ((node->ie_Flags & ICONENTRY_FLAG_FOCUS) && (new_selected != node))
4712 {
4713 node->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
4714 update_entry = TRUE;
4715 }
4716
4717 /* Redraw list */
4718 if (update_entry)
4719 {
4720 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
4721 data->update_entry = node;
4722 MUI_Redraw(obj, MADF_DRAWUPDATE);
4723 #if defined(DEBUG_ILC_EVENTS)
4724 D(bug("[IconList] %s: Rendered entry '%s'\n", __PRETTY_FUNCTION__, node->ie_IconListEntry.label));
4725 #endif
4726 }
4727 }
4728 }
4729
4730 if (new_selected != NULL)
4731 {
4732 /* Found clicked entry... */
4733 data->icld_LassoActive = FALSE;
4734 update_entry = FALSE;
4735
4736 if (!(new_selected->ie_Flags & ICONENTRY_FLAG_SELECTED))
4737 {
4738 /* Add new entry to selection */
4739 AddTail(&data->icld_SelectionList, &new_selected->ie_SelectionNode);
4740 new_selected->ie_Flags |= ICONENTRY_FLAG_SELECTED;
4741 update_entry = TRUE;
4742 }
4743 else if ((*doubleclicked == FALSE) && (message->imsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)))
4744 {
4745 /* Unselect previously selected entry */
4746 Remove(&new_selected->ie_SelectionNode);
4747 new_selected->ie_Flags &= ~ICONENTRY_FLAG_SELECTED;
4748 update_entry = TRUE;
4749 }
4750
4751 /* Set focus */
4752 if (!(new_selected->ie_Flags & ICONENTRY_FLAG_FOCUS))
4753 {
4754 new_selected->ie_Flags |= ICONENTRY_FLAG_FOCUS;
4755 data->icld_FocusIcon = new_selected;
4756 update_entry = TRUE;
4757 }
4758
4759 /* Redraw list */
4760 if (update_entry)
4761 {
4762 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
4763 data->update_entry = new_selected;
4764 MUI_Redraw(obj, MADF_DRAWUPDATE);
4765 #if defined(DEBUG_ILC_EVENTS)
4766 D(bug("[IconList] %s: Rendered 'new_selected' entry '%s'\n", __PRETTY_FUNCTION__, new_selected->ie_IconListEntry.label));
4767 #endif
4768 }
4769 }
4770 else
4771 {
4772 struct Window * thisWindow = NULL;
4773 #if defined(DEBUG_ILC_EVENTS) || defined(DEBUG_ILC_LASSO)
4774 D(bug("[IconList] %s: Starting Lasso\n", __PRETTY_FUNCTION__));
4775 #endif
4776 /* No entry clicked on ... Start Lasso-selection */
4777 data->icld_LassoActive = TRUE;
4778 if (!(message->imsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)))
4779 {
4780 data->icld_SelectionLastClicked = NULL;
4781 data->icld_FocusIcon = NULL;
4782 }
4783 data->icld_LassoRectangle.MinX = mx - data->view_rect.MinX + data->icld_ViewX;
4784 data->icld_LassoRectangle.MinY = my - data->view_rect.MinY + data->icld_ViewY;
4785 data->icld_LassoRectangle.MaxX = mx - data->view_rect.MinX + data->icld_ViewX;
4786 data->icld_LassoRectangle.MaxY = my - data->view_rect.MinY + data->icld_ViewY;
4787
4788 /* Draw initial Lasso frame */
4789 IconList_InvertLassoOutlines(obj, data, &data->icld_LassoRectangle);
4790
4791 /* Start handling INTUITICKS */
4792 GET(obj, MUIA_Window, &thisWindow);
4793 if (thisWindow)
4794 {
4795 ModifyIDCMP(thisWindow, (thisWindow->IDCMPFlags|IDCMP_INTUITICKS));
4796 if (!(data->ehn.ehn_Events & IDCMP_INTUITICKS))
4797 {
4798 DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
4799 data->ehn.ehn_Events |= IDCMP_INTUITICKS;
4800 DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
4801 }
4802 }
4803 }
4804 }
4805
4806 ///MUIM_HandleEvent()
4807 /**************************************************************************
4808 MUIM_HandleEvent
4809 **************************************************************************/
4810 IPTR IconList__MUIM_HandleEvent(struct IClass *CLASS, Object *obj, struct MUIP_HandleEvent *message)
4811 {
4812 struct IconList_DATA *data = INST_DATA(CLASS, obj);
4813
4814 #if defined(DEBUG_ILC_FUNCS)
4815 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
4816 #endif
4817
4818 if (message->imsg)
4819 {
4820 LONG mx = message->imsg->MouseX - _mleft(obj);
4821 LONG my = message->imsg->MouseY - _mtop(obj);
4822
4823 LONG wheelx = 0;
4824 LONG wheely = 0;
4825
4826 switch (message->imsg->Class)
4827 {
4828 case IDCMP_NEWSIZE:
4829 bug("[IconList] %s: IDCMP_NEWSIZE\n", __PRETTY_FUNCTION__);
4830 break;
4831
4832 case IDCMP_RAWKEY:
4833 {
4834 #if defined(DEBUG_ILC_EVENTS)
4835 D(bug("[IconList] %s: IDCMP_RAWKEY\n", __PRETTY_FUNCTION__));
4836 #endif
4837 BOOL rawkey_handled = FALSE;
4838
4839 switch(message->imsg->Code)
4840 {
4841 case RAWKEY_NM_WHEEL_UP:
4842 wheely = -1;
4843 rawkey_handled = TRUE;
4844 break;
4845
4846 case RAWKEY_NM_WHEEL_DOWN:
4847 wheely = 1;
4848 rawkey_handled = TRUE;
4849 break;
4850
4851 case RAWKEY_NM_WHEEL_LEFT:
4852 wheelx = -1;
4853 rawkey_handled = TRUE;
4854 break;
4855
4856 case RAWKEY_NM_WHEEL_RIGHT:
4857 wheelx = 1;
4858 rawkey_handled = TRUE;
4859 break;
4860 }
4861
4862 if (rawkey_handled)
4863 {
4864 #if defined(DEBUG_ILC_KEYEVENTS)
4865 D(bug("[IconList] %s: Processing mouse wheel event\n", __PRETTY_FUNCTION__));
4866 #endif
4867 if (_isinobject(message->imsg->MouseX, message->imsg->MouseY) &&
4868 (wheelx || wheely))
4869 {
4870 DoWheelMove(CLASS, obj, wheelx, wheely, message->imsg->Qualifier);
4871 }
4872 }
4873 else if (!(message->imsg->Code & IECODE_UP_PREFIX))
4874 {
4875 LONG new_ViewY = data->icld_ViewY;
4876 struct IconEntry *start_entry = NULL, *active_entry = NULL, *entry_next = NULL;
4877 IPTR start_X = 0, start_Y = 0, active_X = 0, active_Y = 0, next_X = 0, next_Y = 0;
4878 IPTR x_diff = 0;
4879
4880 #if defined(DEBUG_ILC_KEYEVENTS)
4881 D(bug("[IconList] %s: Processing key up event\n", __PRETTY_FUNCTION__));
4882 #endif
4883
4884 switch(message->imsg->Code)
4885 {
4886 case RAWKEY_RETURN:
4887 rawkey_handled = TRUE;
4888
4889 #if defined(DEBUG_ILC_KEYEVENTS)
4890 D(bug("[IconList] %s: RAWKEY_RETURN\n", __PRETTY_FUNCTION__));
4891 #endif
4892
4893 if (data->icld_FocusIcon) active_entry = data->icld_FocusIcon;
4894 else if (data->icld_SelectionLastClicked) active_entry = data->icld_SelectionLastClicked;
4895
4896 if (active_entry)
4897 {
4898 if (!(active_entry->ie_Flags & ICONENTRY_FLAG_SELECTED))
4899 {
4900 active_entry->ie_Flags |= ICONENTRY_FLAG_SELECTED;
4901 AddTail(&data->icld_SelectionList, &active_entry->ie_SelectionNode);
4902 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
4903 data->update_entry = active_entry;
4904 MUI_Redraw(obj, MADF_DRAWUPDATE);
4905 }
4906 data->icld_SelectionLastClicked = active_entry;
4907 data->icld_FocusIcon = active_entry;
4908
4909 SET(obj, MUIA_IconList_DoubleClick, TRUE);
4910 }
4911 break;
4912
4913 case RAWKEY_SPACE:
4914 rawkey_handled = TRUE;
4915
4916 #if defined(DEBUG_ILC_KEYEVENTS)
4917 D(bug("[IconList] %s: RAWKEY_SPACE\n", __PRETTY_FUNCTION__));
4918 #endif
4919
4920 if (data->icld_FocusIcon) active_entry = data->icld_FocusIcon;
4921 else if (data->icld_SelectionLastClicked) active_entry = data->icld_SelectionLastClicked;
4922
4923 if (!(message->imsg->Qualifier & IEQUALIFIER_LSHIFT) && ((data->icld_SelectionLastClicked)||(data->icld_SelectionLastClicked != active_entry)))
4924 {
4925 #if defined(DEBUG_ILC_KEYEVENTS)
4926 D(bug("[IconList] %s: SPACE: Clearing selected icons ..\n", __PRETTY_FUNCTION__));
4927 #endif
4928 DoMethod(obj, MUIM_IconList_UnselectAll);
4929 }
4930
4931 if (active_entry)
4932 {
4933 if (!(active_entry->ie_Flags & ICONENTRY_FLAG_SELECTED))
4934 {
4935 AddTail(&data->icld_SelectionList, &active_entry->ie_SelectionNode);
4936 active_entry->ie_Flags |= ICONENTRY_FLAG_SELECTED;
4937 data->icld_SelectionLastClicked = active_entry;
4938 }
4939 else
4940 {
4941 Remove(&active_entry->ie_SelectionNode);
4942 active_entry->ie_Flags &= ~ICONENTRY_FLAG_SELECTED;
4943 }
4944
4945 data->icld_FocusIcon = active_entry;
4946
4947 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
4948 data->update_entry = active_entry;
4949 MUI_Redraw(obj, MADF_DRAWUPDATE);
4950 }
4951 break;
4952
4953 case RAWKEY_PAGEUP:
4954 rawkey_handled = TRUE;
4955
4956 #if defined(DEBUG_ILC_KEYEVENTS)
4957 D(bug("[IconList] %s: RAWKEY_PAGEUP\n", __PRETTY_FUNCTION__));
4958 #endif
4959
4960 if (data->icld_AreaHeight > data->icld_ViewHeight)
4961 {
4962 new_ViewY -= data->icld_ViewHeight;
4963 if (new_ViewY< 0)
4964 new_ViewY = 0;
4965 }
4966
4967 if (new_ViewY != data->icld_ViewY)
4968 {
4969 SET(obj, MUIA_Virtgroup_Top, new_ViewY);
4970 }
4971 break;
4972
4973 case RAWKEY_PAGEDOWN:
4974 rawkey_handled = TRUE;
4975
4976 #if defined(DEBUG_ILC_KEYEVENTS)
4977 D(bug("[IconList] %s: RAWKEY_PAGEDOWN\n", __PRETTY_FUNCTION__));
4978 #endif
4979
4980 if (data->icld_AreaHeight > data->icld_ViewHeight)
4981 {
4982 new_ViewY += data->icld_ViewHeight;
4983 if (new_ViewY > (data->icld_AreaHeight - data->icld_ViewHeight))
4984 new_ViewY = data->icld_AreaHeight - data->icld_ViewHeight;
4985 }
4986
4987 if (new_ViewY != data->icld_ViewY)
4988 {
4989 SET(obj, MUIA_Virtgroup_Top, new_ViewY);
4990 }
4991 break;
4992
4993 case RAWKEY_UP:
4994 rawkey_handled = TRUE;
4995
4996 #if defined(DEBUG_ILC_KEYEVENTS)
4997 D(bug("[IconList] %s: RAWKEY_UP\n", __PRETTY_FUNCTION__));
4998 #endif
4999
5000 if (data->icld_FocusIcon)
5001 {
5002 start_entry = data->icld_FocusIcon;
5003 #if defined(DEBUG_ILC_KEYEVENTS)
5004 D(bug("[IconList] %s: UP: Clearing existing focused entry @ 0x%p\n", __PRETTY_FUNCTION__, start_entry));
5005 #endif
5006
5007 start_entry->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
5008 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5009 data->update_entry = start_entry;
5010 MUI_Redraw(obj, MADF_DRAWUPDATE);
5011
5012 start_X = start_entry->ie_IconX;
5013 start_Y = start_entry->ie_IconY;
5014 #if defined(DEBUG_ILC_KEYEVENTS)
5015 D(bug("[IconList] %s: UP: start_icon @ 0x%p '%s' - start_X %d, start_Y %d\n", __PRETTY_FUNCTION__, start_entry, start_entry->ie_IconListEntry.label, start_X, start_Y));
5016 #endif
5017 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5018 {
5019 if (start_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5020 {
5021 start_X = start_X - ((data->icld_IconAreaLargestWidth - start_entry->ie_AreaWidth)/2);
5022 #if defined(DEBUG_ILC_KEYEVENTS)
5023 D(bug("[IconList] %s: UP: adjusted start_X for grid = %d\n", __PRETTY_FUNCTION__, start_X));
5024 #endif
5025 }
5026 }
5027
5028 if ((active_entry = Node_PreviousVisible(start_entry)) && !(data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL))
5029 {
5030 //Check if we are at the edge of the entry area ..
5031 #if defined(DEBUG_ILC_KEYEVENTS)
5032 D(bug("[IconList] %s: UP: active_entry @ 0x%p '%s' , X %d, Y %d\n", __PRETTY_FUNCTION__, active_entry, active_entry->ie_IconListEntry.label, active_entry->ie_IconX, active_entry->ie_IconY));
5033 #endif
5034 active_Y = active_entry->ie_IconY;
5035
5036 if (active_Y == start_Y)
5037 {
5038
5039 #if defined(DEBUG_ILC_KEYEVENTS)
5040 D(bug("[IconList] %s: UP: active_entry is on our row (not at the edge)\n", __PRETTY_FUNCTION__));
5041 #endif
5042 entry_next = active_entry;
5043 next_X = entry_next->ie_IconX;
5044 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5045 {
5046 if (entry_next->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5047 next_X = next_X - ((data->icld_IconAreaLargestWidth - entry_next->ie_AreaWidth)/2);
5048 }
5049 }
5050 }
5051 #if defined(DEBUG_ILC_KEYEVENTS)
5052 D(bug("[IconList] %s: UP: using start_X %d, start_Y %d\n", __PRETTY_FUNCTION__, start_X, start_Y));
5053 #endif
5054 }
5055
5056 if (!(message->imsg->Qualifier & IEQUALIFIER_LSHIFT) && ((data->icld_SelectionLastClicked)&&(data->icld_SelectionLastClicked != active_entry)))
5057 {
5058 #if defined(DEBUG_ILC_KEYEVENTS)
5059 D(bug("[IconList] %s: UP: Clearing selected icons ..\n", __PRETTY_FUNCTION__));
5060 #endif
5061 DoMethod(obj, MUIM_IconList_UnselectAll);
5062 }
5063
5064 #if defined(DEBUG_ILC_KEYEVENTS)
5065 D(bug("[IconList] %s: UP: active = 0x%p, next = 0x%p\n", __PRETTY_FUNCTION__, active_entry, entry_next));
5066 #endif
5067 if (!(active_entry))
5068 {
5069 // If nothing is selected we will use the last visible entry ..
5070 active_entry = Node_LastVisible(&data->icld_IconList);
5071 start_X = active_entry->ie_IconX;
5072 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5073 {
5074 if (active_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5075 start_X = start_X - ((data->icld_IconAreaLargestWidth - active_entry->ie_AreaWidth)/2);
5076 }
5077 start_Y = active_entry->ie_IconY;
5078 }
5079
5080 while (active_entry != NULL)
5081 {
5082 #if defined(DEBUG_ILC_KEYEVENTS)
5083 D(bug("[IconList] %s: UP: Checking active @ 0x%p\n", __PRETTY_FUNCTION__, active_entry));
5084 #endif
5085 if (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)
5086 {
5087 // Return the first visible since the list flow direction matches
5088 // our cursor direction
5089 if (active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5090 break;
5091 }
5092 else
5093 {
5094 active_X = active_entry->ie_IconX;
5095
5096 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5097 {
5098 if (active_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5099 x_diff = ((data->icld_IconAreaLargestWidth - active_entry->ie_AreaWidth)/2);
5100 }
5101 active_Y = active_entry->ie_IconY;
5102
5103 if (start_entry)
5104 {
5105 if (entry_next)
5106 {
5107 if ((active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
5108 (active_Y < start_Y) &&
5109 (((active_X - x_diff) >= start_X ) &&
5110 ((active_X - x_diff) <= (start_X + start_entry->ie_AreaWidth + (x_diff*2)))))
5111 {
5112 #if defined(DEBUG_ILC_KEYEVENTS)
5113 D(bug("[IconList] %s: UP: (A) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5114 #endif
5115 break;
5116 }
5117 else if (active_entry == (struct IconEntry *)GetHead(&data->icld_IconList))
5118 {
5119 #if defined(DEBUG_ILC_KEYEVENTS)
5120 D(bug("[IconList] %s: UP: (A) reached list start .. restarting from the end ..\n", __PRETTY_FUNCTION__));
5121 #endif
5122 start_X = next_X;
5123
5124 if ((entry_next = Node_PreviousVisible(entry_next)))
5125 {
5126 if (entry_next->ie_IconX > start_X)
5127 entry_next = NULL;
5128 else
5129 {
5130 next_X = entry_next->ie_IconX;
5131 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5132 {
5133 if (entry_next->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5134 next_X = next_X - ((data->icld_IconAreaLargestWidth - entry_next->ie_AreaWidth)/2);
5135 }
5136 }
5137 }
5138 start_Y = 0;
5139 #if defined(DEBUG_ILC_KEYEVENTS)
5140 D(bug("[IconList] %s: UP: (A) startx = %d, start_Y = %d, next_X = %d, entry_next @ 0x%p\n", __PRETTY_FUNCTION__, start_X, start_Y, next_X, entry_next));
5141 #endif
5142 active_entry = Node_LastVisible(&data->icld_IconList);
5143 }
5144 }
5145 else
5146 {
5147 if ((active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
5148 (active_Y < start_Y) &&
5149 ((active_X + x_diff) < (start_X + start_entry->ie_AreaWidth + x_diff)))
5150 {
5151 #if defined(DEBUG_ILC_KEYEVENTS)
5152 D(bug("[IconList] %s: UP: (B) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5153 #endif
5154 break;
5155 }
5156 }
5157 }
5158 else
5159 {
5160 if (active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5161 {
5162 #if defined(DEBUG_ILC_KEYEVENTS)
5163 D(bug("[IconList] %s: UP: (C) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5164 #endif
5165 break;
5166 }
5167 }
5168 }
5169 active_entry = (struct IconEntry *)(((struct Node *)active_entry)->ln_Pred);
5170 }
5171
5172 if (!(active_entry))
5173 {
5174 #if defined(DEBUG_ILC_KEYEVENTS)
5175 D(bug("[IconList] %s: UP: No Next UP Node - Getting Last visible entry ..\n", __PRETTY_FUNCTION__));
5176 #endif
5177 /* We didnt find a "next UP" entry so just use the last visible */
5178 active_entry = Node_LastVisible(&data->icld_IconList);
5179 }
5180
5181 if (active_entry)
5182 {
5183 if (!(active_entry->ie_Flags & ICONENTRY_FLAG_FOCUS))
5184 {
5185 active_entry->ie_Flags |= ICONENTRY_FLAG_FOCUS;
5186 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5187 data->update_entry = active_entry;
5188 MUI_Redraw(obj, MADF_DRAWUPDATE);
5189 }
5190 }
5191 data->icld_FocusIcon = active_entry;
5192 break;
5193
5194 case RAWKEY_DOWN:
5195 rawkey_handled = TRUE;
5196
5197 #if defined(DEBUG_ILC_KEYEVENTS)
5198 D(bug("[IconList] %s: RAWKEY_DOWN\n", __PRETTY_FUNCTION__));
5199 #endif
5200 if (data->icld_FocusIcon)
5201 {
5202 start_entry = data->icld_FocusIcon;
5203 #if defined(DEBUG_ILC_KEYEVENTS)
5204 D(bug("[IconList] %s: DOWN: Clearing existing focused entry @ 0x%p\n", __PRETTY_FUNCTION__, start_entry));
5205 #endif
5206
5207 start_entry->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
5208 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5209 data->update_entry = start_entry;
5210 MUI_Redraw(obj, MADF_DRAWUPDATE);
5211
5212 start_X = start_entry->ie_IconX;
5213 start_Y = start_entry->ie_IconY;
5214 #if defined(DEBUG_ILC_KEYEVENTS)
5215 D(bug("[IconList] %s: DOWN: start_icon @ 0x%p '%s' - start_X %d, start_Y %d\n", __PRETTY_FUNCTION__, start_entry, start_entry->ie_IconListEntry.label, start_X, start_Y));
5216 #endif
5217 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5218 {
5219 if (start_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5220 {
5221 start_X = start_X - ((data->icld_IconAreaLargestWidth - start_entry->ie_AreaWidth)/2);
5222 #if defined(DEBUG_ILC_KEYEVENTS)
5223 D(bug("[IconList] %s: DOWN: adjusted start_X for grid = %d\n", __PRETTY_FUNCTION__, start_X));
5224 #endif
5225 }
5226 }
5227
5228 if ((active_entry = Node_NextVisible(start_entry)) &&
5229 (!(data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)))
5230 {
5231 #if defined(DEBUG_ILC_KEYEVENTS)
5232 D(bug("[IconList] %s: DOWN: active_entry @ 0x%p '%s' , X %d, Y %d\n", __PRETTY_FUNCTION__, active_entry, active_entry->ie_IconListEntry.label, active_entry->ie_IconX, active_entry->ie_IconY));
5233 #endif
5234 active_Y = active_entry->ie_IconY;
5235
5236 if (active_Y == start_Y)
5237 {
5238
5239 #if defined(DEBUG_ILC_KEYEVENTS)
5240 D(bug("[IconList] %s: DOWN: active_entry is on our row (not at the edge)\n", __PRETTY_FUNCTION__));
5241 #endif
5242 entry_next = active_entry;
5243 next_X = entry_next->ie_IconX;
5244 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5245 {
5246 if (entry_next->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5247 next_X = next_X - ((data->icld_IconAreaLargestWidth - entry_next->ie_AreaWidth)/2);
5248 }
5249 }
5250 }
5251 #if defined(DEBUG_ILC_KEYEVENTS)
5252 D(bug("[IconList] %s: DOWN: using start_X %d, start_Y %d\n", __PRETTY_FUNCTION__, start_X, start_Y));
5253 #endif
5254 }
5255
5256 if (!(message->imsg->Qualifier & IEQUALIFIER_LSHIFT) && ((data->icld_SelectionLastClicked)&&(data->icld_SelectionLastClicked != active_entry)))
5257 {
5258 #if defined(DEBUG_ILC_KEYEVENTS)
5259 D(bug("[IconList] %s: DOWN: Clearing selected icons ..\n", __PRETTY_FUNCTION__));
5260 #endif
5261 DoMethod(obj, MUIM_IconList_UnselectAll);
5262 }
5263
5264 #if defined(DEBUG_ILC_KEYEVENTS)
5265 D(bug("[IconList] %s: DOWN: active = 0x%p, next = 0x%p\n", __PRETTY_FUNCTION__, active_entry, entry_next));
5266 #endif
5267 if (!(active_entry))
5268 {
5269 // If nothing is selected we will use the First visible entry ..
5270 active_entry = Node_FirstVisible(&data->icld_IconList);
5271 start_X = active_entry->ie_IconX;
5272 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5273 {
5274 if (active_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5275 start_X = start_X - ((data->icld_IconAreaLargestWidth - active_entry->ie_AreaWidth)/2);
5276 }
5277 start_Y = active_entry->ie_IconY;
5278 }
5279
5280 while (active_entry != NULL)
5281 {
5282 #if defined(DEBUG_ILC_KEYEVENTS)
5283 D(bug("[IconList] %s: DOWN: Checking active @ 0x%p\n", __PRETTY_FUNCTION__, active_entry));
5284 #endif
5285 if (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)
5286 {
5287 if (active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5288 break;
5289 }
5290 else
5291 {
5292 active_X = active_entry->ie_IconX;
5293
5294 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5295 {
5296 if (active_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5297 x_diff = ((data->icld_IconAreaLargestWidth - active_entry->ie_AreaWidth)/2);
5298 }
5299 active_Y = active_entry->ie_IconY;
5300
5301 if (start_entry)
5302 {
5303 if (entry_next)
5304 {
5305 if ((active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
5306 (active_Y > start_Y) &&
5307 (((active_X - x_diff) >= start_X ) &&
5308 ((active_X - x_diff) <= (start_X + start_entry->ie_AreaWidth + (x_diff*2)))))
5309 {
5310 #if defined(DEBUG_ILC_KEYEVENTS)
5311 D(bug("[IconList] %s: DOWN: (A) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5312 #endif
5313 break;
5314 }
5315 else if (active_entry == (struct IconEntry *)GetTail(&data->icld_IconList))
5316 {
5317 #if defined(DEBUG_ILC_KEYEVENTS)
5318 D(bug("[IconList] %s: DOWN: (A) reached list end .. starting at the beginng ..\n", __PRETTY_FUNCTION__));
5319 #endif
5320 start_X = entry_next->ie_IconX;
5321 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5322 {
5323 if (entry_next->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5324 start_X = start_X - ((data->icld_IconAreaLargestWidth - entry_next->ie_AreaWidth)/2);
5325 }
5326
5327 if ((entry_next = (struct IconEntry *)Node_NextVisible(entry_next)))
5328 {
5329 if (entry_next->ie_IconX < start_X)
5330 entry_next = NULL;
5331 else
5332 {
5333 next_X = entry_next->ie_IconX;
5334 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5335 {
5336 if (entry_next->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5337 next_X = next_X + ((data->icld_IconAreaLargestWidth - entry_next->ie_AreaWidth)/2);
5338 }
5339 }
5340 }
5341 start_Y = 0;
5342 #if defined(DEBUG_ILC_KEYEVENTS)
5343 D(bug("[IconList] %s: DOWN: (A) startx = %d, start_Y = %d, next_X = %d, entry_next @ 0x%p\n", __PRETTY_FUNCTION__, start_X, start_Y, next_X, entry_next));
5344 #endif
5345 active_entry = Node_FirstVisible(&data->icld_IconList);
5346 }
5347 }
5348 else
5349 {
5350 if ((active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
5351 (active_Y > start_Y) &&
5352 (active_X > start_X - 1))
5353 {
5354 #if defined(DEBUG_ILC_KEYEVENTS)
5355 D(bug("[IconList] %s: DOWN: (B) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5356 #endif
5357 break;
5358 }
5359 }
5360 }
5361 else
5362 {
5363 if (active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5364 {
5365 #if defined(DEBUG_ILC_KEYEVENTS)
5366 D(bug("[IconList] %s: DOWN: (C) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5367 #endif
5368 break;
5369 }
5370 }
5371 }
5372 active_entry = (struct IconEntry *)GetSucc(&active_entry->ie_IconNode);
5373 }
5374
5375 if (!(active_entry))
5376 {
5377 #if defined(DEBUG_ILC_KEYEVENTS)
5378 D(bug("[IconList] %s: DOWN: No Next DOWN Node - Getting first visable entry ..\n", __PRETTY_FUNCTION__));
5379 #endif
5380 /* We didnt find a "next DOWN" entry so just use the first visible */
5381 active_entry = Node_FirstVisible(&data->icld_IconList);
5382 }
5383
5384 if (active_entry)
5385 {
5386 if (!(active_entry->ie_Flags & ICONENTRY_FLAG_FOCUS))
5387 {
5388 active_entry->ie_Flags |= ICONENTRY_FLAG_FOCUS;
5389 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5390 data->update_entry = active_entry;
5391 MUI_Redraw(obj, MADF_DRAWUPDATE);
5392 }
5393 }
5394 data->icld_FocusIcon = active_entry;
5395 break;
5396
5397 case RAWKEY_LEFT:
5398 rawkey_handled = TRUE;
5399
5400 #if defined(DEBUG_ILC_KEYEVENTS)
5401 D(bug("[IconList] %s: RAWKEY_LEFT\n", __PRETTY_FUNCTION__));
5402 #endif
5403 if (data->icld_FocusIcon)
5404 {
5405 start_entry = data->icld_FocusIcon;
5406 #if defined(DEBUG_ILC_KEYEVENTS)
5407 D(bug("[IconList] %s: LEFT: Clearing existing focused entry @ 0x%p\n", __PRETTY_FUNCTION__, start_entry));
5408 #endif
5409
5410 start_entry->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
5411 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5412 data->update_entry = start_entry;
5413 MUI_Redraw(obj, MADF_DRAWUPDATE);
5414
5415 start_X = start_entry->ie_IconX;
5416 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5417 {
5418 if (start_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5419 start_X = start_X - ((data->icld_IconAreaLargestWidth - start_entry->ie_AreaWidth)/2);
5420 }
5421 start_Y = start_entry->ie_IconY;
5422
5423 #if defined(DEBUG_ILC_KEYEVENTS)
5424 D(bug("[IconList] %s: LEFT: start_X %d, start_Y %d\n", __PRETTY_FUNCTION__, start_X, start_Y));
5425 #endif
5426
5427 if (!(active_entry = Node_NextVisible(start_entry)) && (!(data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)))
5428 {
5429 active_entry = (struct IconEntry *)GetHead(&data->icld_IconList);
5430 #if defined(DEBUG_ILC_KEYEVENTS)
5431 D(bug("[IconList] %s: LEFT: Start at the beginning (Active @ 0x%p) using entry X + Width\n", __PRETTY_FUNCTION__, active_entry));
5432 #endif
5433 start_X = start_X + start_entry->ie_AreaWidth;
5434 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5435 {
5436 if (start_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5437 start_X = start_X + ((data->icld_IconAreaLargestWidth - start_entry->ie_AreaWidth)/2);
5438 }
5439
5440 start_Y = 0;
5441 entry_next = NULL;
5442 }
5443 else if (active_entry && (!(data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)))
5444 {
5445 #if defined(DEBUG_ILC_KEYEVENTS)
5446 D(bug("[IconList] %s: LEFT: Active @ 0x%p, X %d\n", __PRETTY_FUNCTION__, active_entry, active_entry->ie_IconX));
5447 #endif
5448 if ((entry_next = Node_NextVisible(start_entry)))
5449 {
5450 #if defined(DEBUG_ILC_KEYEVENTS)
5451 D(bug("[IconList] %s: LEFT: Next @ 0x%p, X %d\n", __PRETTY_FUNCTION__, entry_next, entry_next->ie_IconX));
5452 #endif
5453
5454 if (entry_next->ie_IconX < start_X)
5455 entry_next = NULL;
5456 else
5457 {
5458 next_X = entry_next->ie_IconX;
5459 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5460 {
5461 if (entry_next->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5462 next_X = next_X - ((data->icld_IconAreaLargestWidth - entry_next->ie_AreaWidth)/2);
5463 }
5464 }
5465 }
5466 }
5467 #if defined(DEBUG_ILC_KEYEVENTS)
5468 D(bug("[IconList] %s: LEFT: using start_X %d, start_Y %d\n", __PRETTY_FUNCTION__, start_X, start_Y));
5469 #endif
5470 }
5471
5472 if (!(message->imsg->Qualifier & IEQUALIFIER_LSHIFT) && ((data->icld_SelectionLastClicked)&&(data->icld_SelectionLastClicked != active_entry)))
5473 {
5474 #if defined(DEBUG_ILC_KEYEVENTS)
5475 D(bug("[IconList] %s: LEFT: Clearing selected icons ..\n", __PRETTY_FUNCTION__));
5476 #endif
5477 DoMethod(obj, MUIM_IconList_UnselectAll);
5478 }
5479
5480 #if defined(DEBUG_ILC_KEYEVENTS)
5481 D(bug("[IconList] %s: LEFT: active = 0x%p, next = 0x%p\n", __PRETTY_FUNCTION__, active_entry, entry_next));
5482 #endif
5483
5484 if (!(active_entry))
5485 {
5486 active_entry = (struct IconEntry *)GetHead(&data->icld_IconList);
5487 }
5488
5489 while (active_entry != NULL)
5490 {
5491 #if defined(DEBUG_ILC_KEYEVENTS)
5492 D(bug("[IconList] %s: LEFT: Checking active @ 0x%p\n", __PRETTY_FUNCTION__, active_entry));
5493 #endif
5494 if (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)
5495 {
5496 if (active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5497 break;
5498 }
5499 else
5500 {
5501 LONG active_entry_X = active_entry->ie_IconX;
5502 LONG active_entry_Y;
5503 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5504 {
5505 if (active_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5506 active_entry_X = active_entry_X - ((data->icld_IconAreaLargestWidth - active_entry->ie_AreaWidth)/2);
5507 }
5508 active_entry_Y = active_entry->ie_IconY;
5509
5510 if (start_entry)
5511 {
5512 if (entry_next)
5513 {
5514 if ((active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
5515 (active_entry_Y > start_Y) &&
5516 ((active_entry_X > start_X - 1) &&
5517 (active_entry_X < next_X)))
5518 {
5519 #if defined(DEBUG_ILC_KEYEVENTS)
5520 D(bug("[IconList] %s: LEFT: (A) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5521 #endif
5522 break;
5523 }
5524 else if (active_entry == (struct IconEntry *)GetTail(&data->icld_IconList))
5525 {
5526 #if defined(DEBUG_ILC_KEYEVENTS)
5527 D(bug("[IconList] %s: LEFT: (A) reached list end .. starting at the beginng ..\n", __PRETTY_FUNCTION__));
5528 #endif
5529 start_X = entry_next->ie_IconX;
5530 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5531 {
5532 if (entry_next->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5533 start_X = start_X - ((data->icld_IconAreaLargestWidth - entry_next->ie_AreaWidth)/2);
5534 }
5535
5536 if ((entry_next = Node_NextVisible(entry_next)))
5537 {
5538 if (entry_next->ie_IconX < start_X)
5539 entry_next = NULL;
5540 else
5541 {
5542 next_X = entry_next->ie_IconX;
5543 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5544 {
5545 if (entry_next->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5546 next_X = next_X + ((data->icld_IconAreaLargestWidth - entry_next->ie_AreaWidth)/2);
5547 }
5548 }
5549 }
5550 start_Y = 0;
5551 #if defined(DEBUG_ILC_KEYEVENTS)
5552 D(bug("[IconList] %s: LEFT: (A) startx = %d, start_Y = %d, next_X = %d, entry_next @ 0x%p\n", __PRETTY_FUNCTION__, start_X, start_Y, next_X, entry_next));
5553 #endif
5554 active_entry = (struct IconEntry *)GetHead(&data->icld_IconList);
5555 }
5556 }
5557 else
5558 {
5559 if ((active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
5560 (active_entry_Y > start_Y) &&
5561 (active_entry_X > start_X - 1))
5562 {
5563 #if defined(DEBUG_ILC_KEYEVENTS)
5564 D(bug("[IconList] %s: LEFT: (B) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5565 #endif
5566 break;
5567 }
5568 }
5569 }
5570 else
5571 {
5572 if (active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5573 {
5574 #if defined(DEBUG_ILC_KEYEVENTS)
5575 D(bug("[IconList] %s: LEFT: (C) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5576 #endif
5577 break;
5578 }
5579 }
5580 }
5581 active_entry = (struct IconEntry *)GetSucc(&active_entry->ie_IconNode);
5582 }
5583
5584 if (!(active_entry))
5585 {
5586 #if defined(DEBUG_ILC_KEYEVENTS)
5587 D(bug("[IconList] %s: LEFT: No Next LEFT Node - Getting first visable entry ..\n", __PRETTY_FUNCTION__));
5588 #endif
5589 /* We didnt find a "next LEFT" entry so just use the last visible */
5590 active_entry = (struct IconEntry *)GetHead(&data->icld_IconList);
5591 while ((active_entry != NULL) &&(!(active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)))
5592 {
5593 active_entry = (struct IconEntry *)GetSucc(&active_entry->ie_IconNode);
5594 }
5595 }
5596
5597 if (active_entry)
5598 {
5599 if (!(active_entry->ie_Flags & ICONENTRY_FLAG_FOCUS))
5600 {
5601 active_entry->ie_Flags |= ICONENTRY_FLAG_FOCUS;
5602 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5603 data->update_entry = active_entry;
5604 MUI_Redraw(obj, MADF_DRAWUPDATE);
5605 }
5606 }
5607 data->icld_FocusIcon = active_entry;
5608 break;
5609
5610 case RAWKEY_RIGHT:
5611 rawkey_handled = TRUE;
5612
5613 #if defined(DEBUG_ILC_KEYEVENTS)
5614 D(bug("[IconList] %s: RAWKEY_RIGHT\n", __PRETTY_FUNCTION__));
5615 #endif
5616
5617 if (data->icld_FocusIcon)
5618 {
5619 start_entry = data->icld_FocusIcon;
5620 #if defined(DEBUG_ILC_KEYEVENTS)
5621 D(bug("[IconList] %s: RIGHT: Clearing existing focused entry @ 0x%p\n", __PRETTY_FUNCTION__, start_entry));
5622 #endif
5623 start_entry->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
5624 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5625 data->update_entry = start_entry;
5626 MUI_Redraw(obj, MADF_DRAWUPDATE);
5627
5628 start_X = start_entry->ie_IconX;
5629 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5630 {
5631 if (start_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5632 start_X = start_X - ((data->icld_IconAreaLargestWidth - start_entry->ie_AreaWidth)/2);
5633 }
5634 start_Y = start_entry->ie_IconY;
5635
5636 #if defined(DEBUG_ILC_KEYEVENTS)
5637 D(bug("[IconList] %s: RIGHT: start_X %d, start_Y %d\n", __PRETTY_FUNCTION__, start_X, start_Y));
5638 #endif
5639 if (!(active_entry = Node_NextVisible(start_entry)) && (!(data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL)))
5640 {
5641 active_entry = (struct IconEntry *)GetHead(&data->icld_IconList);
5642 #if defined(DEBUG_ILC_KEYEVENTS)
5643 D(bug("[IconList] %s: RIGHT: Start at the beginning (Active @ 0x%p) using entry X + Width\n", __PRETTY_FUNCTION__, active_entry));
5644 #endif
5645 start_X = 0;
5646 start_Y = start_Y + start_entry->ie_AreaHeight;
5647 entry_next = NULL;
5648 }
5649 else if (active_entry && (data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL))
5650 {
5651 #if defined(DEBUG_ILC_KEYEVENTS)
5652 D(bug("[IconList] %s: RIGHT: Active @ 0x%p, X %d\n", __PRETTY_FUNCTION__, active_entry, active_entry->ie_IconX));
5653 #endif
5654 if ((entry_next = Node_NextVisible(start_entry)))
5655 {
5656 #if defined(DEBUG_ILC_KEYEVENTS)
5657 D(bug("[IconList] %s: RIGHT: Next @ 0x%p, X %d\n", __PRETTY_FUNCTION__, entry_next, entry_next->ie_IconX));
5658 #endif
5659
5660 if (entry_next->ie_IconY < start_Y)
5661 entry_next = NULL;
5662 else
5663 next_Y = entry_next->ie_IconY;
5664 }
5665 }
5666 #if defined(DEBUG_ILC_KEYEVENTS)
5667 D(bug("[IconList] %s: RIGHT: using start_X %d, start_Y %d\n", __PRETTY_FUNCTION__, start_X, start_Y));
5668 #endif
5669 }
5670
5671 if (!(message->imsg->Qualifier & IEQUALIFIER_LSHIFT) && ((data->icld_SelectionLastClicked)&&(data->icld_SelectionLastClicked != active_entry)))
5672 {
5673 #if defined(DEBUG_ILC_KEYEVENTS)
5674 D(bug("[IconList] %s: RIGHT: Clearing selected icons ..\n", __PRETTY_FUNCTION__));
5675 #endif
5676 DoMethod(obj, MUIM_IconList_UnselectAll);
5677 }
5678
5679 #if defined(DEBUG_ILC_KEYEVENTS)
5680 D(bug("[IconList] %s: RIGHT: active = 0x%p, next = 0x%p\n", __PRETTY_FUNCTION__, active_entry, entry_next));
5681 #endif
5682
5683 if (!(active_entry))
5684 {
5685 active_entry = (struct IconEntry *)GetHead(&data->icld_IconList);
5686 }
5687
5688 while (active_entry != NULL)
5689 {
5690 #if defined(DEBUG_ILC_KEYEVENTS)
5691 D(bug("[IconList] %s: RIGHT: Checking active @ 0x%p\n", __PRETTY_FUNCTION__, active_entry));
5692 #endif
5693 if (!(data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL))
5694 {
5695 if (active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5696 break;
5697 }
5698 else
5699 {
5700 LONG active_entry_X = active_entry->ie_IconX;
5701 LONG active_entry_Y;
5702 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
5703 {
5704 if (active_entry->ie_AreaWidth < data->icld_IconAreaLargestWidth)
5705 active_entry_X = active_entry_X - ((data->icld_IconAreaLargestWidth - active_entry->ie_AreaWidth)/2);
5706 }
5707 active_entry_Y = active_entry->ie_IconY;
5708
5709 if (start_entry)
5710 {
5711 if (entry_next)
5712 {
5713 if ((active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
5714 (active_entry_X > start_X) &&
5715 ((active_entry_Y > start_Y - 1) &&
5716 (active_entry_Y < next_Y)))
5717 {
5718 #if defined(DEBUG_ILC_KEYEVENTS)
5719 D(bug("[IconList] %s: RIGHT: (A) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5720 #endif
5721 break;
5722 }
5723 else if (active_entry == (struct IconEntry *)GetTail(&data->icld_IconList))
5724 {
5725 #if defined(DEBUG_ILC_KEYEVENTS)
5726 D(bug("[IconList] %s: RIGHT: (A) reached list end .. starting at the beginng ..\n", __PRETTY_FUNCTION__));
5727 #endif
5728 start_Y = entry_next->ie_IconY;
5729
5730 if ((entry_next = Node_NextVisible(entry_next)))
5731 {
5732 if (entry_next->ie_IconY < start_Y)
5733 entry_next = NULL;
5734 else
5735 {
5736 next_Y = entry_next->ie_IconY;
5737 }
5738 }
5739 start_Y = 0;
5740 #if defined(DEBUG_ILC_KEYEVENTS)
5741 D(bug("[IconList] %s: RIGHT: (A) startx = %d, start_Y = %d, next_X = %d, entry_next @ 0x%p\n", __PRETTY_FUNCTION__, start_X, start_Y, next_X, entry_next));
5742 #endif
5743 active_entry = (struct IconEntry *)GetHead(&data->icld_IconList);
5744 }
5745 }
5746 else
5747 {
5748 if ((active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
5749 (active_entry_X > start_X) &&
5750 (active_entry_Y > start_Y - 1))
5751 {
5752 #if defined(DEBUG_ILC_KEYEVENTS)
5753 D(bug("[IconList] %s: RIGHT: (B) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5754 #endif
5755 break;
5756 }
5757 }
5758 }
5759 else
5760 {
5761 if (active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5762 {
5763 #if defined(DEBUG_ILC_KEYEVENTS)
5764 D(bug("[IconList] %s: RIGHT: (C) entry 0x%p matches\n", __PRETTY_FUNCTION__, active_entry));
5765 #endif
5766 break;
5767 }
5768 }
5769 }
5770 active_entry = (struct IconEntry *)GetSucc(&active_entry->ie_IconNode);
5771 }
5772
5773 if (!(active_entry))
5774 {
5775 #if defined(DEBUG_ILC_KEYEVENTS)
5776 D(bug("[IconList] %s: RIGHT: No Next RIGHT Node - Getting first visable entry ..\n", __PRETTY_FUNCTION__));
5777 #endif
5778 /* We didnt find a "next RIGHT" entry so just use the first visible */
5779 active_entry = (struct IconEntry *)GetHead(&data->icld_IconList);
5780 while ((active_entry != NULL) &&(!(active_entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)))
5781 {
5782 active_entry = (struct IconEntry *)GetSucc(&active_entry->ie_IconNode);
5783 }
5784 }
5785
5786 if (active_entry)
5787 {
5788 if (!(active_entry->ie_Flags & ICONENTRY_FLAG_FOCUS))
5789 {
5790 active_entry->ie_Flags |= ICONENTRY_FLAG_FOCUS;
5791 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5792 data->update_entry = active_entry;
5793 MUI_Redraw(obj, MADF_DRAWUPDATE);
5794 }
5795 }
5796 data->icld_FocusIcon = active_entry;
5797 break;
5798
5799 case RAWKEY_HOME:
5800 rawkey_handled = TRUE;
5801
5802 #if defined(DEBUG_ILC_KEYEVENTS)
5803 D(bug("[IconList] %s: RAWKEY_HOME\n", __PRETTY_FUNCTION__));
5804 #endif
5805
5806 if (data->icld_FocusIcon)
5807 {
5808 data->icld_FocusIcon->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
5809 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5810 data->update_entry = data->icld_FocusIcon;
5811 MUI_Redraw(obj, MADF_DRAWUPDATE);
5812 }
5813
5814 active_entry = Node_FirstVisible(&data->icld_IconList);
5815
5816 if ((active_entry) && (!(active_entry->ie_Flags & ICONENTRY_FLAG_FOCUS)))
5817 {
5818 active_entry->ie_Flags |= ICONENTRY_FLAG_FOCUS;
5819 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5820 data->update_entry = active_entry;
5821 MUI_Redraw(obj, MADF_DRAWUPDATE);
5822 }
5823 data->icld_FocusIcon = active_entry;
5824 break;
5825
5826 case RAWKEY_END:
5827 rawkey_handled = TRUE;
5828
5829 #if defined(DEBUG_ILC_KEYEVENTS)
5830 D(bug("[IconList] %s: RAWKEY_END\n", __PRETTY_FUNCTION__));
5831 #endif
5832
5833 if (data->icld_FocusIcon)
5834 {
5835 data->icld_FocusIcon->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
5836 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5837 data->update_entry = data->icld_FocusIcon;
5838 MUI_Redraw(obj, MADF_DRAWUPDATE);
5839 }
5840
5841 active_entry = Node_LastVisible(&data->icld_IconList);
5842
5843 if ((active_entry) && (!(active_entry->ie_Flags & ICONENTRY_FLAG_FOCUS)))
5844 {
5845 active_entry->ie_Flags |= ICONENTRY_FLAG_FOCUS;
5846 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
5847 data->update_entry = active_entry;
5848 MUI_Redraw(obj, MADF_DRAWUPDATE);
5849 }
5850 data->icld_FocusIcon = active_entry;
5851 break;
5852 }
5853 }
5854 if (rawkey_handled) return MUI_EventHandlerRC_Eat;
5855 }
5856 break;
5857
5858 case IDCMP_MOUSEBUTTONS:
5859 #if defined(DEBUG_ILC_EVENTS)
5860 D(bug("[IconList] %s: IDCMP_MOUSEBUTTONS\n", __PRETTY_FUNCTION__));
5861 #endif
5862 if (message->imsg->Code == SELECTDOWN)
5863 {
5864 /* Check if mouse pressed on iconlist area */
5865 if (mx >= 0 && mx < _width(obj) && my >= 0 && my < _height(obj))
5866 {
5867 BOOL doubleclicked = FALSE; /* both icon and empty space */
5868 struct IconEntry *node = NULL;
5869 struct IconEntry *new_selected = NULL;
5870
5871 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
5872 {
5873 /* LIST-VIEW HANDLING */
5874
5875 LONG clickColumn = -1;
5876
5877 LONG x = _mleft(obj) - data->icld_ViewX + LINE_SPACING_LEFT;
5878 LONG index, w, i;
5879
5880 /* Find column in which click happened */
5881 for(i = 0; i < NUM_COLUMNS; i++)
5882 {
5883 index = data->icld_LVMAttribs->lmva_ColumnPos[i];
5884
5885 if (!(data->icld_LVMAttribs->lmva_ColumnFlags[index] & LVMCF_COLVISIBLE)) continue;
5886
5887 w = data->icld_LVMAttribs->lmva_ColumnWidth[index];
5888
5889 if ((mx >= x) && (mx < x + w))
5890 {
5891 clickColumn = index;
5892 break;
5893 }
5894 x += w;
5895 }
5896
5897 if (((data->icld_LVMAttribs->lvma_Flags & LVMAF_NOHEADER) == 0) && (my <= data->icld_LVMAttribs->lmva_HeaderHeight))
5898 {
5899 /* Click on header, update list */
5900 data->icld_LVMAttribs->lmva_LastSelectedColumn = clickColumn;
5901
5902 data->icld_UpdateMode = UPDATE_HEADERENTRY;
5903 data->update_entry = (APTR)(IPTR)clickColumn;
5904
5905 MUI_Redraw(obj, MADF_DRAWUPDATE);
5906
5907 }
5908 else
5909 {
5910 LONG current = 0, index = (my - data->icld_LVMAttribs->lmva_HeaderHeight + data->icld_ViewY) / data->icld_LVMAttribs->lmva_RowHeight;
5911
5912 /* Check if clicked on entry */
5913 ForeachNode(&data->icld_IconList, node)
5914 {
5915 if (node->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5916 {
5917 /* Is this node clicked? */
5918 if (current == index)
5919 {
5920 new_selected = node;
5921 break;
5922 }
5923
5924 current++;
5925 }
5926 }
5927
5928 /* Handle actions */
5929 IconList_HandleNewIconSelection(CLASS, obj, message, new_selected, &doubleclicked);
5930 }
5931 }
5932 else
5933 {
5934 /* ICON-VIEW HANDLING */
5935
5936 struct Rectangle rect;
5937
5938 /* Check if clicked on entry */
5939 #if defined(__AROS__)
5940 ForeachNode(&data->icld_IconList, node)
5941 #else
5942 Foreach_Node(&data->icld_IconList, node);
5943 #endif
5944 {
5945 if (node->ie_Flags & ICONENTRY_FLAG_VISIBLE)
5946 {
5947 /* Is this node clicked? */
5948 rect.MinX = node->ie_IconX;
5949 rect.MaxX = node->ie_IconX + node->ie_AreaWidth - 1;
5950 rect.MinY = node->ie_IconY;
5951 rect.MaxY = node->ie_IconY + node->ie_AreaHeight - 1;
5952
5953 if ((data->icld__Option_IconListMode == ICON_LISTMODE_GRID) &&
5954 (node->ie_AreaWidth < data->icld_IconAreaLargestWidth))
5955 {
5956 rect.MinX += ((data->icld_IconAreaLargestWidth - node->ie_AreaWidth)/2);
5957 rect.MaxX += ((data->icld_IconAreaLargestWidth - node->ie_AreaWidth)/2);
5958 }
5959
5960 if ((((mx + data->icld_ViewX) >= rect.MinX) && ((mx + data->icld_ViewX) <= rect.MaxX )) &&
5961 (((my + data->icld_ViewY) >= rect.MinY) && ((my + data->icld_ViewY) <= rect.MaxY )))
5962 {
5963 new_selected = node;
5964 #if defined(DEBUG_ILC_EVENTS)
5965 D(bug("[IconList] %s: Entry '%s' clicked on ..\n", __PRETTY_FUNCTION__, node->ie_IconListEntry.label));
5966 #endif
5967 break;
5968 }
5969 }
5970 }
5971
5972 /* Handle actions */
5973 IconList_HandleNewIconSelection(CLASS, obj, message, new_selected, &doubleclicked);
5974 }
5975
5976 if (new_selected && (new_selected->ie_Flags & ICONENTRY_FLAG_SELECTED))
5977 data->icld_SelectionLastClicked = new_selected;
5978 else
5979 data->icld_SelectionLastClicked = NULL;
5980
5981 data->click_x = mx;
5982 data->click_y = my;
5983
5984 SET(obj, MUIA_IconList_SelectionChanged, TRUE);
5985
5986 data->icld_ClickEvent.shift = !!(message->imsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT));
5987 data->icld_ClickEvent.entry = data->icld_SelectionLastClicked ? &data->icld_SelectionLastClicked->ie_IconListEntry : NULL;
5988 SET(obj, MUIA_IconList_Clicked, (IPTR)&data->icld_ClickEvent);
5989
5990 if (doubleclicked)
5991 {
5992 SET(obj, MUIA_IconList_DoubleClick, TRUE);
5993 }
5994
5995 if ((!data->mouse_pressed) &&
5996 (!doubleclicked || (doubleclicked && (data->icld_SelectionLastClicked == NULL))))
5997 {
5998 data->last_secs = message->imsg->Seconds;
5999 data->last_mics = message->imsg->Micros;
6000
6001 /* After a double click you often open a new window
6002 * and since Zune doesn't not support the faking
6003 * of SELECTUP events only change the Events
6004 * if not doubleclicked on an icon */
6005
6006 data->mouse_pressed |= LEFT_BUTTON;
6007
6008 /* Start listening to mouse events */
6009 if (!(data->ehn.ehn_Events & IDCMP_MOUSEMOVE))
6010 {
6011 DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
6012 data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
6013 DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
6014 }
6015 }
6016
6017 return MUI_EventHandlerRC_Eat;
6018 }
6019 }
6020 else if (message->imsg->Code == MIDDLEDOWN)
6021 {
6022 if (!data->mouse_pressed)
6023 {
6024 data->mouse_pressed |= MIDDLE_BUTTON;
6025
6026 data->click_x = data->icld_ViewX + mx;
6027 data->click_y = data->icld_ViewY + my;
6028
6029 /* Start listening to mouse events */
6030 if (!(data->ehn.ehn_Events & IDCMP_MOUSEMOVE))
6031 {
6032 DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
6033 data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
6034 DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
6035 }
6036 }
6037 }
6038 else
6039 {
6040 if (message->imsg->Code == SELECTUP)
6041 {
6042 if (data->icld_LassoActive == TRUE)
6043 {
6044 #if defined(DEBUG_ILC_EVENTS) || defined(DEBUG_ILC_LASSO)
6045 D(bug("[IconList] %s: Removing Lasso\n", __PRETTY_FUNCTION__));
6046 #endif
6047 /* End Lasso-selection */
6048 struct Rectangle old_lasso;
6049 struct IconEntry *node = NULL;
6050 struct Window *thisWindow = NULL;
6051
6052 /* Stop handling INTUITICKS */
6053 GET(obj, MUIA_Window, &thisWindow);
6054 if (thisWindow)
6055 {
6056 ModifyIDCMP(thisWindow, (thisWindow->IDCMPFlags & ~(IDCMP_INTUITICKS)));
6057 if ((data->ehn.ehn_Events & IDCMP_INTUITICKS))
6058 {
6059 DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
6060 data->ehn.ehn_Events &= ~IDCMP_INTUITICKS;
6061 DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
6062 }
6063 }
6064 /* Clear Lasso Frame.. */
6065 GetAbsoluteLassoRect(data, &old_lasso);
6066 IconList_InvertLassoOutlines(obj, data, &old_lasso);
6067
6068 data->icld_LassoActive = FALSE;
6069
6070 /* Remove Lasso flag from affected icons.. */
6071 #if defined(__AROS__)
6072 ForeachNode(&data->icld_IconList, node)
6073 #else
6074 Foreach_Node(&data->icld_IconList, node);
6075 #endif
6076 {
6077 if (node->ie_Flags & ICONENTRY_FLAG_LASSO)
6078 {
6079 node->ie_Flags &= ~ICONENTRY_FLAG_LASSO;
6080 }
6081 }
6082 SET(obj, MUIA_IconList_SelectionChanged, TRUE);
6083 }
6084 else if (data->icld_LVMAttribs->lmva_LastSelectedColumn != -1)
6085 {
6086 ULONG orig_sortflags = data->icld_SortFlags;
6087
6088 if (data->icld_LVMAttribs->lmva_SortColumn == data->icld_LVMAttribs->lmva_LastSelectedColumn)
6089 {
6090 if (data->icld_SortFlags & MUIV_IconList_Sort_Reverse)
6091 data->icld_SortFlags &= ~MUIV_IconList_Sort_Reverse;
6092 else
6093 data->icld_SortFlags |= MUIV_IconList_Sort_Reverse;
6094 }
6095
6096 switch (data->icld_LVMAttribs->lmva_LastSelectedColumn)
6097 {
6098 case INDEX_NAME:
6099 data->icld_SortFlags &= ~MUIV_IconList_Sort_Orders;
6100 data->icld_SortFlags |= MUIV_IconList_Sort_ByName;
6101 break;
6102
6103 case INDEX_SIZE:
6104 data->icld_SortFlags &= ~MUIV_IconList_Sort_Orders;
6105 data->icld_SortFlags |= MUIV_IconList_Sort_BySize;
6106 break;
6107
6108 case INDEX_LASTACCESS:
6109 data->icld_SortFlags &= ~MUIV_IconList_Sort_Orders;
6110 data->icld_SortFlags |= MUIV_IconList_Sort_ByDate;
6111 break;
6112 }
6113
6114 if (orig_sortflags != data->icld_SortFlags)
6115 {
6116 data->icld_LVMAttribs->lmva_SortColumn = data->icld_LVMAttribs->lmva_LastSelectedColumn;
6117
6118 data->icld_LVMAttribs->lmva_LastSelectedColumn = -1;
6119 }
6120 DoMethod(obj, MUIM_IconList_Sort);
6121
6122 }
6123
6124 data->mouse_pressed &= ~LEFT_BUTTON;
6125 }
6126
6127 if (message->imsg->Code == MIDDLEUP)
6128 {
6129 data->mouse_pressed &= ~MIDDLE_BUTTON;
6130 }
6131
6132 /* Stop listening to mouse move events is no buttons pressed */
6133 if ((data->ehn.ehn_Events & IDCMP_MOUSEMOVE) && !data->mouse_pressed)
6134 {
6135 DoMethod(_win(obj),MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
6136 data->ehn.ehn_Events &= ~IDCMP_MOUSEMOVE;
6137 DoMethod(_win(obj),MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
6138 }
6139 }
6140 break;
6141
6142 case IDCMP_INTUITICKS:
6143 {
6144 #if defined(DEBUG_ILC_EVENTS)
6145 D(bug("[IconList] %s: IDCMP_INTUITICKS (%d, %d)\n", __PRETTY_FUNCTION__, mx, my));
6146 #endif
6147 if ((data->icld_LassoActive == FALSE)||(!(data->mouse_pressed & LEFT_BUTTON)))
6148 {
6149 break;
6150 }
6151 if (((mx >= 0) && (mx <= _mwidth(obj))) &&
6152 ((my >= 0) && (my <= _mheight(obj))))
6153 break;
6154 }
6155
6156 case IDCMP_MOUSEMOVE:
6157 #if defined(DEBUG_ILC_EVENTS)
6158 D(bug("[IconList] %s: IDCMP_MOUSEMOVE\n", __PRETTY_FUNCTION__));
6159 #endif
6160 if (data->mouse_pressed & LEFT_BUTTON)
6161 {
6162 LONG move_x = mx;
6163 LONG move_y = my;
6164
6165 if (data->icld_SelectionLastClicked && (data->icld_LassoActive == FALSE) &&
6166 ((abs(move_x - data->click_x) >= 2) || (abs(move_y - data->click_y) >= 2)))
6167 {
6168 LONG touch_x, touch_y;
6169
6170 /* Entry(s) being dragged .... */
6171 DoMethod(_win(obj),MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
6172 data->ehn.ehn_Events &= ~IDCMP_MOUSEMOVE;
6173 DoMethod(_win(obj),MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
6174
6175 data->mouse_pressed &= ~LEFT_BUTTON;
6176
6177 /* Pass view relative coords */
6178 touch_x = move_x + data->icld_ViewX;
6179 touch_y = move_y + data->icld_ViewY;
6180 DoMethod(obj,MUIM_DoDrag, touch_x, touch_y, 0);
6181 }
6182 else if (data->icld_LassoActive == TRUE)
6183 {
6184 #if defined(DEBUG_ILC_EVENTS) || defined(DEBUG_ILC_LASSO)
6185 D(bug("[IconList] %s: Update Lasso\n", __PRETTY_FUNCTION__));
6186 #endif
6187 /* Lasso active */
6188 struct Rectangle new_lasso,
6189 old_lasso;
6190 struct Rectangle iconrect;
6191
6192 struct IconEntry *node = NULL;
6193 // struct IconEntry *new_selected = NULL;
6194
6195 /* Remove previous Lasso frame */
6196 GetAbsoluteLassoRect(data, &old_lasso);
6197 IconList_InvertLassoOutlines(obj, data, &old_lasso);
6198
6199 /* if the mouse leaves our visible area scroll the view */
6200 if (mx < 0 || mx >= _mwidth(obj) || my < 0 || my >= _mheight(obj))
6201 {
6202 LONG newleft = data->icld_ViewX;
6203 LONG newtop = data->icld_ViewY;
6204
6205 if (mx >= _mwidth(obj)) newleft += (mx - _mwidth(obj));
6206 else if (mx < 0) newleft += mx;
6207 if (my >= _mheight(obj)) newtop += (my - _mheight(obj));
6208 else if (my < 0) newtop += my;
6209
6210 if (newleft + _mwidth(obj) > data->icld_AreaWidth) newleft = data->icld_AreaWidth - _mwidth(obj);
6211 if (newleft < 0) newleft = 0;
6212
6213 if (newtop + _mheight(obj) > data->icld_AreaHeight) newtop = data->icld_AreaHeight - _mheight(obj);
6214 if (newtop < 0) newtop = 0;
6215
6216 if ((newleft != data->icld_ViewX) || (newtop != data->icld_ViewY))
6217 {
6218 SetAttrs(obj, MUIA_Virtgroup_Left, newleft, MUIA_Virtgroup_Top, newtop, TAG_DONE);
6219 }
6220 }
6221
6222 /* update Lasso coordinates */
6223 data->icld_LassoRectangle.MaxX = mx - data->view_rect.MinX + data->icld_ViewX;
6224 data->icld_LassoRectangle.MaxY = my - data->view_rect.MinY + data->icld_ViewY;
6225
6226 /* get absolute Lasso coordinates */
6227 GetAbsoluteLassoRect(data, &new_lasso);
6228
6229 LONG current = 0, startIndex = 0, endIndex = 0;
6230
6231 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
6232 {
6233 LONG minY = data->icld_LassoRectangle.MinY,
6234 maxY = data->icld_LassoRectangle.MaxY;
6235
6236 if (minY > maxY)
6237 {
6238 minY ^= maxY;
6239 maxY ^= minY;
6240 minY ^= maxY;
6241 }
6242
6243 startIndex = ((minY + 1) - data->icld_LVMAttribs->lmva_HeaderHeight) / data->icld_LVMAttribs->lmva_RowHeight;
6244 endIndex = ((maxY - 1) - data->icld_LVMAttribs->lmva_HeaderHeight) / data->icld_LVMAttribs->lmva_RowHeight;
6245 }
6246
6247 #if defined(__AROS__)
6248 ForeachNode(&data->icld_IconList, node)
6249 #else
6250 Foreach_Node(&data->icld_IconList, node);
6251 #endif
6252 {
6253 IPTR update_entry = (IPTR)NULL;
6254
6255 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
6256 {
6257 if (node->ie_Flags & ICONENTRY_FLAG_VISIBLE)
6258 {
6259 update_entry = FALSE;
6260
6261 if ((current >= startIndex) && (current <= endIndex))
6262 {
6263 //Entry is inside our lasso ..
6264 if (!(node->ie_Flags & ICONENTRY_FLAG_LASSO))
6265 {
6266 /* check if entry was already selected before */
6267 if (node->ie_Flags & ICONENTRY_FLAG_SELECTED)
6268 {
6269 Remove(&node->ie_SelectionNode);
6270 node->ie_Flags &= ~ICONENTRY_FLAG_SELECTED;
6271 }
6272 else
6273 {
6274 AddTail(&data->icld_SelectionList, &node->ie_SelectionNode);
6275 node->ie_Flags |= ICONENTRY_FLAG_SELECTED;
6276 }
6277 node->ie_Flags |= ICONENTRY_FLAG_LASSO;
6278 update_entry = (IPTR)node;
6279 }
6280 }
6281 else if (node->ie_Flags & ICONENTRY_FLAG_LASSO)
6282 {
6283 //Entry is no longer inside our lasso - revert its selected state
6284 if (node->ie_Flags & ICONENTRY_FLAG_SELECTED)
6285 {
6286 Remove(&node->ie_SelectionNode);
6287 node->ie_Flags &= ~ICONENTRY_FLAG_SELECTED;
6288 }
6289 else
6290 {
6291 AddTail(&data->icld_SelectionList, &node->ie_SelectionNode);
6292 node->ie_Flags |= ICONENTRY_FLAG_SELECTED;
6293 }
6294 node->ie_Flags &= ~ICONENTRY_FLAG_LASSO;
6295 update_entry = (IPTR)node;
6296 }
6297
6298 current++;
6299 }
6300 }
6301 else
6302 {
6303 if (node->ie_Flags & ICONENTRY_FLAG_VISIBLE)
6304 {
6305 iconrect.MinX = node->ie_IconX;
6306 iconrect.MaxX = node->ie_IconX + node->ie_AreaWidth - 1;
6307 iconrect.MinY = node->ie_IconY;
6308 iconrect.MaxY = node->ie_IconY + node->ie_AreaHeight - 1;
6309 if ((data->icld__Option_IconListMode == ICON_LISTMODE_GRID) &&
6310 (node->ie_AreaWidth < data->icld_IconAreaLargestWidth))
6311 {
6312 iconrect.MinX += ((data->icld_IconAreaLargestWidth - node->ie_AreaWidth)/2);
6313 iconrect.MaxX += ((data->icld_IconAreaLargestWidth - node->ie_AreaWidth)/2);
6314 }
6315
6316 if ((((new_lasso.MaxX + data->icld_ViewX) >= iconrect.MinX) && ((new_lasso.MinX + data->icld_ViewX) <= iconrect.MaxX)) &&
6317 (((new_lasso.MaxY + data->icld_ViewY) >= iconrect.MinY) && ((new_lasso.MinY + data->icld_ViewY) <= iconrect.MaxY)))
6318 {
6319 //Entry is inside our lasso ..
6320 if (!(node->ie_Flags & ICONENTRY_FLAG_LASSO))
6321 {
6322 /* check if entry was already selected before */
6323 if (node->ie_Flags & ICONENTRY_FLAG_SELECTED)
6324 {
6325 Remove(&node->ie_SelectionNode);
6326 node->ie_Flags &= ~ICONENTRY_FLAG_SELECTED;
6327 }
6328 else
6329 {
6330 AddTail(&data->icld_SelectionList, &node->ie_SelectionNode);
6331 node->ie_Flags |= ICONENTRY_FLAG_SELECTED;
6332 }
6333 node->ie_Flags |= ICONENTRY_FLAG_LASSO;
6334 update_entry = (IPTR)node;
6335 }
6336 }
6337 else if (node->ie_Flags & ICONENTRY_FLAG_LASSO)
6338 {
6339 //Entry is no longer inside our lasso - revert its selected state
6340 if (node->ie_Flags & ICONENTRY_FLAG_SELECTED)
6341 {
6342 Remove(&node->ie_SelectionNode);
6343 node->ie_Flags &= ~ICONENTRY_FLAG_SELECTED;
6344 }
6345 else
6346 {
6347 AddTail(&data->icld_SelectionList, &node->ie_SelectionNode);
6348 node->ie_Flags |= ICONENTRY_FLAG_SELECTED;
6349 }
6350 node->ie_Flags &= ~ICONENTRY_FLAG_LASSO;
6351 update_entry = (IPTR)node;
6352 }
6353 }
6354 }
6355 if (update_entry)
6356 {
6357 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
6358 data->update_entry = (struct IconEntry *)update_entry;
6359 MUI_Redraw(obj, MADF_DRAWUPDATE);
6360 }
6361 }
6362 /* Draw Lasso frame */
6363 IconList_InvertLassoOutlines(obj, data, &new_lasso);
6364 }
6365
6366 return MUI_EventHandlerRC_Eat;
6367 }
6368 else if (data->mouse_pressed & MIDDLE_BUTTON)
6369 {
6370 /* Content is being scrolled */
6371 LONG newleft, newtop;
6372
6373 newleft = data->click_x - mx;
6374 newtop = data->click_y - my;
6375
6376 if (newleft + _mwidth(obj) > data->icld_AreaWidth) newleft = data->icld_AreaWidth - _mwidth(obj);
6377 if (newleft < 0) newleft = 0;
6378
6379 if (newtop + _mheight(obj) > data->icld_AreaHeight) newtop = data->icld_AreaHeight - _mheight(obj);
6380 if (newtop < 0) newtop = 0;
6381
6382 if ((newleft != data->icld_ViewX) || (newtop != data->icld_ViewY))
6383 {
6384 SetAttrs(obj, MUIA_Virtgroup_Left, newleft,
6385 MUIA_Virtgroup_Top, newtop,
6386 TAG_DONE);
6387 }
6388
6389 return MUI_EventHandlerRC_Eat;
6390 }
6391
6392 break;
6393 }
6394 }
6395
6396 return 0;
6397 }
6398 ///
6399
6400 ///MUIM_IconList_NextIcon()
6401 /**************************************************************************
6402 MUIM_IconList_NextIcon
6403 **************************************************************************/
6404 IPTR IconList__MUIM_IconList_NextIcon(struct IClass *CLASS, Object *obj, struct MUIP_IconList_NextIcon *message)
6405 {
6406 struct IconList_DATA *data = INST_DATA(CLASS, obj);
6407 struct IconEntry *node = NULL;
6408 struct IconList_Entry *ent = NULL;
6409 IPTR node_successor = (IPTR)NULL;
6410
6411 if (message->entry == NULL) return (IPTR)NULL;
6412 ent = *message->entry;
6413
6414 #if defined(DEBUG_ILC_FUNCS)
6415 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
6416 #endif
6417
6418 if ((IPTR)ent == (IPTR)MUIV_IconList_NextIcon_Start)
6419 {
6420 D(bug("[IconList] %s: Finding First Entry ..\n", __PRETTY_FUNCTION__));
6421 if (message->nextflag == MUIV_IconList_NextIcon_Selected)
6422 {
6423 node = (struct IconEntry *)GetHead(&data->icld_SelectionList);
6424 if (node != NULL)
6425 {
6426 node = (struct IconEntry *)((IPTR)node - ((IPTR)&node->ie_SelectionNode - (IPTR)node));
6427 }
6428 }
6429 else if (message->nextflag == MUIV_IconList_NextIcon_Visible)
6430 {
6431 node = (struct IconEntry *)GetHead(&data->icld_IconList);
6432 while (node != NULL)
6433 {
6434 if (node->ie_Flags & ICONENTRY_FLAG_VISIBLE)
6435 break;
6436
6437 node = (struct IconEntry *)GetSucc(&node->ie_IconNode);
6438 }
6439 }
6440 }
6441 else if ((IPTR)ent != (IPTR)MUIV_IconList_NextIcon_End)
6442 {
6443 node = (struct IconEntry *)((IPTR)ent - ((IPTR)&node->ie_IconListEntry - (IPTR)node));
6444 if (message->nextflag == MUIV_IconList_NextIcon_Selected)
6445 {
6446 node_successor = (IPTR)GetSucc(&node->ie_SelectionNode);
6447 if (node_successor != (IPTR)NULL)
6448 node = (struct IconEntry *)((IPTR)node_successor - ((IPTR)&node->ie_SelectionNode - (IPTR)node));
6449 else
6450 {
6451 D(bug("[IconList] %s: GetSucc() == NULL\n", __PRETTY_FUNCTION__));
6452 node = NULL;
6453 }
6454 }
6455 else if (message->nextflag == MUIV_IconList_NextIcon_Visible)
6456 {
6457 node = (struct IconEntry *)GetSucc(&node->ie_IconNode);
6458 while (node != NULL)
6459 {
6460 if (node->ie_Flags & ICONENTRY_FLAG_VISIBLE)
6461 break;
6462
6463 node = (struct IconEntry *)GetSucc(&node->ie_IconNode);
6464 }
6465 }
6466 }
6467
6468 if (node == NULL)
6469 {
6470 D(bug("[IconList] %s: Returning MUIV_IconList_NextIcon_End\n", __PRETTY_FUNCTION__));
6471
6472 *message->entry = (struct IconList_Entry *)MUIV_IconList_NextIcon_End;
6473 }
6474 else
6475 {
6476 D(bug("[IconList] %s: Returning entry for '%s'\n", __PRETTY_FUNCTION__, node->ie_IconListEntry.label));
6477
6478 *message->entry = &node->ie_IconListEntry;
6479 }
6480
6481 return (IPTR)NULL;
6482 }
6483 ///
6484
6485 ///MUIM_IconList_GetIconPrivate()
6486 /**************************************************************************
6487 MUIM_IconList_GetIconPrivate
6488 **************************************************************************/
6489 IPTR IconList__MUIM_IconList_GetIconPrivate(struct IClass *CLASS, Object *obj, struct MUIP_IconList_GetIconPrivate *message)
6490 {
6491 // struct IconList_DATA *data = INST_DATA(CLASS, obj);
6492 struct IconEntry *node = NULL;
6493
6494 if (message->entry == NULL) return (IPTR)NULL;
6495
6496 node = (struct IconEntry *)((IPTR)message->entry - ((IPTR)&node->ie_IconListEntry - (IPTR)node));
6497
6498 return (IPTR)node;
6499 }
6500
6501 ///MUIM_CreateDragImage()
6502 /**************************************************************************
6503 MUIM_CreateDragImage
6504 **************************************************************************/
6505 IPTR IconList__MUIM_CreateDragImage(struct IClass *CLASS, Object *obj, struct MUIP_CreateDragImage *message)
6506 {
6507 struct IconList_DATA *data = INST_DATA(CLASS, obj);
6508 struct MUI_DragImage *img = NULL;
6509 LONG first_x = -1,
6510 first_y = -1;
6511 BOOL transp = XGET(obj, MUIA_IconList_DragImageTransparent);
6512
6513 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ICONDRAGDROP)
6514 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
6515 #endif
6516
6517 if (!(data->icld_SelectionLastClicked))
6518 DoSuperMethodA(CLASS, obj, (Msg)message);
6519
6520 if ((img = (struct MUI_DragImage *)AllocVec(sizeof(struct MUIP_CreateDragImage), MEMF_CLEAR)))
6521 {
6522 struct Node *node = NULL;
6523 struct IconEntry *entry = NULL;
6524
6525 #if defined(CREATE_FULL_DRAGIMAGE)
6526 #if defined(__AROS__)
6527 ForeachNode(&data->icld_SelectionList, node)
6528 #else
6529 Foreach_Node(&data->icld_SelectionList, node);
6530 #endif
6531 {
6532 entry = (struct IconEntry *)((IPTR)node - ((IPTR)&entry->ie_SelectionNode - (IPTR)entry));
6533 if ((entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) && (entry->ie_Flags & ICONENTRY_FLAG_SELECTED))
6534 {
6535 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) != ICONLIST_DISP_MODELIST)
6536 {
6537 if ((first_x == -1) || ((first_x != -1) && (entry->ie_IconX < first_x))) first_x = entry->ie_IconX;
6538 if ((first_y == -1) || ((first_y != -1) && (entry->ie_IconY < first_y))) first_y = entry->ie_IconY;
6539
6540 if (data->icld__Option_IconListMode == ICON_LISTMODE_ROUGH)
6541 {
6542 if ((entry->ie_IconX + entry->ie_AreaWidth) > img->width) img->width = entry->ie_IconX + entry->ie_AreaWidth;
6543 if ((entry->ie_IconY + entry->ie_AreaHeight) > img->height) img->height = entry->ie_IconY + entry->ie_AreaHeight;
6544 }
6545
6546 if (data->icld__Option_IconListMode == ICON_LISTMODE_GRID)
6547 {
6548 if ((entry->ie_IconX + data->icld_IconAreaLargestWidth) > img->width) img->width = entry->ie_IconX + data->icld_IconAreaLargestWidth;
6549 if ((entry->ie_IconY + data->icld_IconAreaLargestHeight) > img->height) img->height = entry->ie_IconY + data->icld_IconAreaLargestHeight;
6550 }
6551 }
6552 else
6553 {
6554 img->height += data->icld_LVMAttribs->lmva_RowHeight;
6555 }
6556 }
6557 }
6558 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
6559 {
6560 first_x = 0;
6561 first_y = -message->touchy;
6562 img->width = data->icld_LVMAttribs->lmva_ColumnWidth[data->icld_LVMAttribs->lmva_ColumnPos[INDEX_TYPE]] +
6563 data->icld_LVMAttribs->lmva_ColumnWidth[data->icld_LVMAttribs->lmva_ColumnPos[INDEX_NAME]];
6564 img->height += 2;
6565 }
6566 else
6567 {
6568 img->width = (img->width - first_x) + 2;
6569 img->height = (img->height - first_y) + 2;
6570 }
6571 #else
6572 entry = data->icld_SelectionLastClicked;
6573 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
6574 {
6575 img->width = _mright(obj) - _mleft(obj);
6576 img->height = data->icld_LVMAttribs->lmva_RowHeight;
6577 first_x = 0;
6578 first_y = 0;
6579 }
6580 else
6581 {
6582 img->width = entry->ie_IconWidth;
6583 img->height = entry->ie_IconHeight;
6584 first_x = entry->ie_IconX;
6585 first_y = entry->ie_IconY;
6586 }
6587 #endif
6588
6589 if (transp)
6590 {
6591 /* Request 32-bit, because the image will have alpha channel */
6592 img->bm = AllocBitMap(img->width, img->height, 32, BMF_CLEAR, NULL);
6593 }
6594 else
6595 {
6596 LONG depth = GetBitMapAttr(_screen(obj)->RastPort.BitMap, BMA_DEPTH);
6597 img->bm = AllocBitMap(img->width, img->height, depth, BMF_CLEAR, _screen(obj)->RastPort.BitMap);
6598 }
6599
6600 if (img->bm)
6601 {
6602 struct RastPort temprp;
6603 InitRastPort(&temprp);
6604 temprp.BitMap = img->bm;
6605 ULONG minY = 0;
6606
6607 #if defined(CREATE_FULL_DRAGIMAGE)
6608 ForeachNode(&data->icld_SelectionList, node)
6609 {
6610 entry = (struct IconEntry *)((IPTR)node - ((IPTR)&entry->ie_SelectionNode - (IPTR)entry));
6611 if ((entry->ie_Flags & ICONENTRY_FLAG_VISIBLE) && (entry->ie_Flags & ICONENTRY_FLAG_SELECTED))
6612 {
6613 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
6614 {
6615 struct Rectangle field_rect;
6616 ULONG selected = entry->ie_Flags & ICONENTRY_FLAG_SELECTED;
6617 entry->ie_Flags &= ~ICONENTRY_FLAG_SELECTED; /* Drawing as not selected actually looks better */
6618
6619 field_rect.MinX = 0; field_rect.MaxX = img->width - 1;
6620 field_rect.MinY = minY; field_rect.MaxY = field_rect.MinY + data->icld_LVMAttribs->lmva_RowHeight - 1;
6621 RenderEntryField(obj, data, entry, &field_rect, INDEX_TYPE, TRUE, FALSE, &temprp);
6622
6623 field_rect.MinX = data->icld_LVMAttribs->lmva_ColumnWidth[data->icld_LVMAttribs->lmva_ColumnPos[INDEX_TYPE]] - 1;
6624 field_rect.MaxX = img->width - 1;
6625 field_rect.MinY = minY; field_rect.MaxY = field_rect.MinY + data->icld_LVMAttribs->lmva_RowHeight - 1;
6626 RenderEntryField(obj, data, entry, &field_rect, INDEX_NAME, FALSE, FALSE, &temprp);
6627
6628 minY += data->icld_LVMAttribs->lmva_RowHeight;
6629
6630 entry->ie_Flags |= selected;
6631 }
6632 else
6633 {
6634 LONG offsetx , offsety;
6635
6636 IconList_GetIconImageOffsets(data, entry, &offsetx, &offsety);
6637
6638 DrawIconStateA
6639 (
6640 &temprp, entry->ie_DiskObj, NULL,
6641 (entry->ie_IconX + 1) - first_x + offsetx, (entry->ie_IconY + 1) - first_y + offsety,
6642 IDS_SELECTED,
6643 __iconList_DrawIconStateTags
6644 );
6645 }
6646 }
6647 }
6648 #else
6649 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
6650 {
6651 SetABPenDrMd(&temprp, _pens(obj)[MPEN_SHINE], 0, JAM1);
6652 RectFill(&temprp, 0, 0, img->width, img->height);
6653 }
6654 else
6655 {
6656 DrawIconStateA
6657 (
6658 &temprp, entry->ie_DiskObj, NULL,
6659 0, 0,
6660 IDS_SELECTED,
6661 __iconList_DrawIconStateTags
6662 );
6663 }
6664 #endif
6665 if (transp)
6666 RastPortSetAlpha(&temprp, data->click_x, data->click_y, img->width, img->height, 0xC0, RPALPHAFLAT);
6667 DeinitRastPort(&temprp);
6668 }
6669
6670 /* Convert view relative coords to drag image relative. This is done because the "object" that is being
6671 * dragged is virtual (its a collection of icons) and the coords passed to DoDrag are not relative to this
6672 * "object"
6673 */
6674 img->touchx = first_x + message->touchx;
6675 img->touchy = first_y + message->touchy;
6676
6677 if (transp)
6678 img->flags = MUIF_DRAGIMAGE_SOURCEALPHA;
6679 else
6680 img->flags = 0;
6681 }
6682 return (IPTR)img;
6683 }
6684 ///
6685
6686 ///MUIM_DeleteDragImage()
6687 /**************************************************************************
6688 MUIM_DeleteDragImage
6689 **************************************************************************/
6690 IPTR IconList__MUIM_DeleteDragImage(struct IClass *CLASS, Object *obj, struct MUIP_DeleteDragImage *message)
6691 {
6692 struct IconList_DATA *data = INST_DATA(CLASS, obj);
6693
6694 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ICONDRAGDROP)
6695 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
6696 #endif
6697
6698 if (!(data->icld_SelectionLastClicked)) return DoSuperMethodA(CLASS,obj,(Msg)message);
6699
6700 if (message->di)
6701 {
6702 if (message->di->bm)
6703 FreeBitMap(message->di->bm);
6704 FreeVec(message->di);
6705 }
6706 return (IPTR)NULL;
6707 }
6708 ///
6709
6710 ///MUIM_DragQuery()
6711 /**************************************************************************
6712 MUIM_DragQuery
6713 **************************************************************************/
6714 IPTR IconList__MUIM_DragQuery(struct IClass *CLASS, Object *obj, struct MUIP_DragQuery *message)
6715 {
6716 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ICONDRAGDROP)
6717 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
6718 #endif
6719
6720 /* TODO: highlight the possible drop target entry .. */
6721
6722 if (message->obj == obj)
6723 return MUIV_DragQuery_Accept;
6724 else
6725 {
6726 BOOL is_iconlist = FALSE;
6727 struct IClass *msg_cl = OCLASS(message->obj);
6728
6729 while (msg_cl)
6730 {
6731 if (msg_cl == CLASS)
6732 {
6733 is_iconlist = TRUE;
6734 break;
6735 }
6736 msg_cl = msg_cl->cl_Super;
6737 }
6738 if (is_iconlist)
6739 return MUIV_DragQuery_Accept;
6740 }
6741
6742 return MUIV_DragQuery_Refuse;
6743 }
6744 ///
6745
6746 ///MUIM_DragDrop()
6747 /**************************************************************************
6748 MUIM_DragDrop
6749 **************************************************************************/
6750 IPTR IconList__MUIM_DragDrop(struct IClass *CLASS, Object *obj, struct MUIP_DragDrop *message)
6751 {
6752 struct IconList_DATA *data = INST_DATA(CLASS, obj);
6753
6754 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ICONDRAGDROP)
6755 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
6756 #endif
6757
6758 struct IconList_Entry *entry = (IPTR)MUIV_IconList_NextIcon_Start;
6759
6760 if (data->icld_DragDropEvent)
6761 {
6762 struct IconList_Drop_SourceEntry *clean_node;
6763 #if defined(DEBUG_ILC_ICONDRAGDROP)
6764 D(bug("[IconList] %s: Cleaning existing IconList_Drop_Event @ %p\n", __PRETTY_FUNCTION__, data->icld_DragDropEvent));
6765 #endif
6766 while ((clean_node = (struct IconList_Drop_SourceEntry *)RemTail(&data->icld_DragDropEvent->drop_SourceList)) != NULL)
6767 {
6768 FreeVec(clean_node->dropse_Node.ln_Name);
6769 FreeMem(clean_node, sizeof(struct IconList_Drop_SourceEntry));
6770 }
6771 if (data->icld_DragDropEvent->drop_TargetPath) FreeVec(data->icld_DragDropEvent->drop_TargetPath);
6772 FreeMem(data->icld_DragDropEvent, sizeof(struct IconList_Drop_Event));
6773 data->icld_DragDropEvent = NULL;
6774 }
6775
6776 /* SANITY CHECK: Get first selected entry from SOURCE iconlist */
6777 DoMethod(message->obj, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
6778
6779 if ((entry) && ((IPTR)entry != MUIV_IconList_NextIcon_End))
6780 {
6781 /* Ok.. atleast one entry was dropped .. */
6782 char tmp_dirbuff[256];
6783 BPTR tmp_dirlock = (BPTR) NULL;
6784
6785 BOOL iconMove = FALSE;
6786 struct IconEntry *node = NULL;
6787 struct IconEntry *drop_target_node = NULL;
6788 STRPTR directory_path = NULL;
6789 struct IconList_Drop_Event *dragDropEvent = NULL;
6790
6791 GET(obj, MUIA_IconDrawerList_Drawer, &directory_path);
6792
6793 /* Properly expand the name incase it uses devices rather than volumes */
6794 if (directory_path != NULL)
6795 {
6796 tmp_dirlock = Lock(directory_path, SHARED_LOCK);
6797 if (tmp_dirlock)
6798 {
6799 if (NameFromLock(tmp_dirlock, tmp_dirbuff, 256) != 0)
6800 {
6801 directory_path = tmp_dirbuff;
6802 }
6803 UnLock(tmp_dirlock);
6804 }
6805 }
6806 if ((dragDropEvent = AllocMem(sizeof(struct IconList_Drop_Event), MEMF_CLEAR)) == NULL)
6807 {
6808 #if defined(DEBUG_ILC_ICONDRAGDROP)
6809 D(bug("[IconList] %s: Failed to allocate IconList_Drop_Event Storage!\n", __PRETTY_FUNCTION__));
6810 #endif
6811 goto dragdropdone;
6812 }
6813 #if defined(DEBUG_ILC_ICONDRAGDROP)
6814 D(bug("[IconList] %s: Allocated IconList_Drop_Event @ %p\n", __PRETTY_FUNCTION__, dragDropEvent));
6815 #endif
6816
6817 NewList(&dragDropEvent->drop_SourceList);
6818
6819 /* go through list and check if dropped on entry */
6820 int rowCount = 0;
6821
6822 #if defined(__AROS__)
6823 ForeachNode(&data->icld_IconList, node)
6824 #else
6825 Foreach_Node(&data->icld_IconList, node);
6826 #endif
6827 {
6828 if ((data->icld_DisplayFlags & ICONLIST_DISP_MODELIST) == ICONLIST_DISP_MODELIST)
6829 {
6830 if (node->ie_Flags & ICONENTRY_FLAG_VISIBLE)
6831 {
6832 ULONG rowTop = _mtop(obj) + (rowCount * data->icld_LVMAttribs->lmva_RowHeight);
6833 rowTop += data->icld_LVMAttribs->lmva_HeaderHeight;
6834
6835 if (((message->x > _mleft(obj)) && (message->x < _mright(obj)))
6836 && ((message->y > rowTop) && (message->y < (rowTop + data->icld_LVMAttribs->lmva_RowHeight))))
6837 {
6838 drop_target_node = node;
6839 break;
6840 }
6841
6842 rowCount++;
6843 }
6844 }
6845 else
6846 {
6847 struct Rectangle iconbox;
6848 LONG click_x = message->x - _mleft(obj);
6849 LONG click_y = message->y - _mtop(obj);
6850 iconbox.MinX = node->ie_IconX - data->icld_ViewX;
6851 iconbox.MaxX = (node->ie_IconX + node->ie_AreaWidth) - data->icld_ViewX;
6852 iconbox.MinY = node->ie_IconY - data->icld_ViewY;
6853 iconbox.MaxY = (node->ie_IconY + node->ie_AreaHeight)- data->icld_ViewY;
6854
6855 if ((node->ie_Flags & ICONENTRY_FLAG_VISIBLE) &&
6856 (click_x >= iconbox.MinX) &&
6857 (click_x < iconbox.MaxX) &&
6858 (click_y >= iconbox.MinY) &&
6859 (click_y < iconbox.MaxY))
6860 {
6861 drop_target_node = node;
6862 break;
6863 }
6864 }
6865 }
6866
6867 /* Additional filter - if same window and the target entry is selected (==dragged), then it was intended as a move */
6868 if ((message->obj == obj) && (drop_target_node) && (drop_target_node->ie_Flags & ICONENTRY_FLAG_SELECTED))
6869 drop_target_node = NULL;
6870
6871 if ((drop_target_node != NULL) &&
6872 ((drop_target_node->ie_IconListEntry.type == ST_SOFTLINK) ||
6873 (drop_target_node->ie_IconListEntry.type == ST_ROOT) ||
6874 (drop_target_node->ie_IconListEntry.type == ST_USERDIR) ||
6875 (drop_target_node->ie_IconListEntry.type == ST_LINKDIR) ||
6876 (drop_target_node->ie_IconListEntry.type == ST_FILE) ||
6877 (drop_target_node->ie_IconListEntry.type == ST_LINKFILE)))
6878 {
6879 /* Dropped on some entry */
6880 if ((drop_target_node->ie_IconListEntry.type != ST_ROOT) && (drop_target_node->ie_IconListEntry.type != ST_SOFTLINK))
6881 {
6882 if (directory_path)
6883 {
6884 int fulllen = strlen(directory_path) + strlen(drop_target_node->ie_IconListEntry.label) + 2;
6885
6886 if ((dragDropEvent->drop_TargetPath = AllocVec(fulllen, MEMF_CLEAR)) == NULL)
6887 {
6888 bug("[IconList] %s: Failed to allocate IconList_Drop_Event->drop_TargetPath Storage!\n", __PRETTY_FUNCTION__);
6889 goto dragdropdone;
6890 }
6891 strcpy(dragDropEvent->drop_TargetPath, directory_path);
6892 AddPart(dragDropEvent->drop_TargetPath, drop_target_node->ie_IconListEntry.label, fulllen);
6893 }
6894 else
6895 goto dragdropdone;
6896 }
6897 else
6898 {
6899 if ((dragDropEvent->drop_TargetPath = AllocVec(strlen(drop_target_node->ie_IconListEntry.label) + 1, MEMF_CLEAR)) == NULL)
6900 {
6901 bug("[IconList] %s: Failed to allocate IconList_Drop_Event->drop_TargetPath Storage!\n", __PRETTY_FUNCTION__);
6902 goto dragdropdone;
6903 }
6904 strcpy(dragDropEvent->drop_TargetPath, drop_target_node->ie_IconListEntry.label);
6905 }
6906
6907 #if defined(DEBUG_ILC_ICONDRAGDROP)
6908 D(bug("[IconList] %s: Target Entry Full Path = '%s'\n", __PRETTY_FUNCTION__, dragDropEvent->drop_TargetPath));
6909 #endif
6910 /* mark the Entry the selection was dropped on*/
6911 //drop_target_node->ie_Flags |= ICONENTRY_FLAG_SELECTED;
6912 //data->icld_UpdateMode = UPDATE_SINGLEENTRY;
6913 //data->update_entry = drop_target_node;
6914 //MUI_Redraw(obj,MADF_DRAWUPDATE);
6915 }
6916 else
6917 {
6918 /* Not dropped on entry -> get path of DESTINATION iconlist */
6919 /* Note: directory_path is NULL when dropped on Wanderer's desktop */
6920 if ((message->obj != obj) && directory_path)
6921 {
6922 #if defined(DEBUG_ILC_ICONDRAGDROP)
6923 D(bug("[IconList] %s: drop entry: Icons dropped in window '%s'\n", __PRETTY_FUNCTION__, directory_path));
6924 #endif
6925 /* copy path */
6926 if ((dragDropEvent->drop_TargetPath = AllocVec(strlen(directory_path) + 1, MEMF_CLEAR)) != NULL)
6927 {
6928 strcpy(dragDropEvent->drop_TargetPath, directory_path);
6929 }
6930 else
6931 {
6932 #if defined(DEBUG_ILC_ICONDRAGDROP)
6933 D(bug("[IconList] %s: Failed to allocate IconList_Drop_Event->drop_TargetPath Storage!\n", __PRETTY_FUNCTION__));
6934 #endif
6935 goto dragdropdone;
6936 }
6937 }
6938 else if (message->obj == obj)
6939 {
6940 #if defined(DEBUG_ILC_ICONDRAGDROP)
6941 D(bug("[IconList] %s: drop entry: Entry Move detected ..\n", __PRETTY_FUNCTION__));
6942 #endif
6943 iconMove = TRUE;
6944
6945 /* Adjust entry posiions .. */
6946 #if defined(DEBUG_ILC_ICONDRAGDROP)
6947 D(bug("[IconList] %s: drop entry: message x,y = %d, %d click = %d, %d..\n", __PRETTY_FUNCTION__, message->x, message->y, data->click_x, data->click_y));
6948 #endif
6949 LONG offset_x = message->x - (data->click_x + _mleft(obj));
6950 LONG offset_y = message->y - (data->click_y + _mtop(obj));
6951
6952 entry = (IPTR)MUIV_IconList_NextIcon_Start;
6953 while ((IPTR)entry != MUIV_IconList_NextIcon_End)
6954 {
6955 DoMethod(message->obj, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
6956
6957 if ((IPTR)entry != MUIV_IconList_NextIcon_End)
6958 {
6959 entry->ile_IconEntry->ie_IconX += offset_x;
6960 entry->ile_IconEntry->ie_IconY += offset_y;
6961 /* Remember new position as provided */
6962 DoMethod(obj, MUIM_IconList_PropagateEntryPos, entry->ile_IconEntry);
6963 }
6964 SET(obj, MUIA_IconList_IconMoved, (IPTR)entry); // Now notify
6965 }
6966 MUI_Redraw(obj,MADF_DRAWOBJECT);
6967 DoMethod(obj, MUIM_IconList_CoordsSort);
6968 }
6969 else
6970 {
6971 #if defined(DEBUG_ILC_ICONDRAGDROP)
6972 D(bug("[IconList] %s: Icons Dropped on Wanderer Desktop (unhandled)!\n", __PRETTY_FUNCTION__));
6973 #endif
6974 iconMove = TRUE;
6975 }
6976 }
6977
6978
6979 if (!(iconMove))
6980 {
6981 int copycount = 0;
6982 /* Create list of entries to copy .. */
6983 entry = (IPTR)MUIV_IconList_NextIcon_Start;
6984 while ((IPTR)entry != MUIV_IconList_NextIcon_End)
6985 {
6986 DoMethod(message->obj, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
6987
6988 if ((IPTR)entry != MUIV_IconList_NextIcon_End)
6989 {
6990 struct IconList_Drop_SourceEntry *sourceEntry = NULL;
6991 sourceEntry = AllocMem(sizeof(struct IconList_Drop_SourceEntry), MEMF_CLEAR);
6992 if ((entry->type != ST_ROOT) && (entry->type != ST_SOFTLINK))
6993 {
6994 int fulllen = 0;
6995 char *path = NULL;
6996
6997 GET(message->obj, MUIA_IconDrawerList_Drawer, &path);
6998 /* Properly expand the location incase it uses devices rather than volumes */
6999 if (path != NULL)
7000 {
7001 tmp_dirlock = Lock(path, SHARED_LOCK);
7002 if (tmp_dirlock)
7003 {
7004 if (NameFromLock(tmp_dirlock, tmp_dirbuff, 256))
7005 {
7006 path = tmp_dirbuff;
7007 }
7008 UnLock(tmp_dirlock);
7009 }
7010
7011 if (strcasecmp(dragDropEvent->drop_TargetPath, path) != 0)
7012 {
7013 fulllen = strlen(path) + strlen(entry->ile_IconEntry->ie_IconNode.ln_Name) + 2;
7014 sourceEntry->dropse_Node.ln_Name = AllocVec(fulllen, MEMF_CLEAR);
7015 strcpy(sourceEntry->dropse_Node.ln_Name, path);
7016 AddPart(sourceEntry->dropse_Node.ln_Name, entry->label, fulllen);
7017 #if defined(DEBUG_ILC_ICONDRAGDROP)
7018 D(bug("[IconList] %s: Source Entry (Full Path) = '%s'\n", __PRETTY_FUNCTION__, sourceEntry->dropse_Node.ln_Name));
7019 #endif
7020 }
7021 }
7022 }
7023 else
7024 {
7025 sourceEntry->dropse_Node.ln_Name = AllocVec(strlen(entry->label) + 1, MEMF_CLEAR);
7026 strcpy(sourceEntry->dropse_Node.ln_Name, entry->label);
7027 #if defined(DEBUG_ILC_ICONDRAGDROP)
7028 D(bug("[IconList] %s: Source Entry = '%s'\n", __PRETTY_FUNCTION__, sourceEntry->dropse_Node.ln_Name));
7029 #endif
7030 }
7031
7032 if ((sourceEntry->dropse_Node.ln_Name != NULL) && (strcasecmp(dragDropEvent->drop_TargetPath, sourceEntry->dropse_Node.ln_Name) != 0))
7033 {
7034 copycount += 1;
7035 AddTail(&dragDropEvent->drop_SourceList, &sourceEntry->dropse_Node);
7036 }
7037 else
7038 {
7039 #if defined(DEBUG_ILC_ICONDRAGDROP)
7040 D(bug("[IconList] %s: Source == Dest, Skipping!\n", __PRETTY_FUNCTION__));
7041 #endif
7042 if ( sourceEntry->dropse_Node.ln_Name) FreeVec(sourceEntry->dropse_Node.ln_Name);
7043 FreeMem(sourceEntry, sizeof(struct IconList_Drop_SourceEntry));
7044 }
7045 }
7046 }
7047 if (copycount > 0)
7048 {
7049 dragDropEvent->drop_TargetObj = obj;
7050
7051 #if defined(DEBUG_ILC_ICONDRAGDROP)
7052 D(bug("[IconList] %s: Causing DROP notification..\n", __PRETTY_FUNCTION__));
7053 #endif
7054 SET(obj, MUIA_IconList_IconsDropped, (IPTR)dragDropEvent);
7055 DoMethod(obj, MUIM_IconList_CoordsSort);
7056 }
7057 else
7058 {
7059 if (dragDropEvent->drop_TargetPath) FreeVec(dragDropEvent->drop_TargetPath);
7060 FreeMem(dragDropEvent, sizeof(struct IconList_Drop_Event));
7061 }
7062 }
7063 }
7064 else
7065 {
7066 #if defined(DEBUG_ILC_ICONDRAGDROP)
7067 D(bug("[IconList] %s: BUG - DragDrop received with no source icons!\n", __PRETTY_FUNCTION__));
7068 #endif
7069 NNSET(obj, MUIA_IconList_IconsDropped, (IPTR)NULL);
7070 }
7071
7072 dragdropdone:
7073 return DoSuperMethodA(CLASS, obj, (Msg)message);
7074 }
7075 ///
7076
7077 ///MUIM_UnselectAll()
7078 /**************************************************************************
7079 MUIM_UnselectAll
7080 **************************************************************************/
7081 IPTR IconList__MUIM_IconList_UnselectAll(struct IClass *CLASS, Object *obj, Msg message)
7082 {
7083 struct IconList_DATA *data = INST_DATA(CLASS, obj);
7084 struct Node *node = NULL, *next_node = NULL;
7085 BOOL changed = FALSE;
7086
7087 #if defined(DEBUG_ILC_FUNCS)
7088 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
7089 #endif
7090
7091 data->icld_SelectionLastClicked = NULL;
7092 data->icld_FocusIcon = NULL;
7093 #if defined(__AROS__)
7094 ForeachNodeSafe(&data->icld_SelectionList, node, next_node)
7095 #else
7096 Foreach_NodeSafe(&data->icld_SelectionList, node, next_node);
7097 #endif
7098 {
7099 struct IconEntry *entry = (struct IconEntry *)((IPTR)node - ((IPTR)&entry->ie_SelectionNode - (IPTR)entry));
7100 BOOL update_entry = FALSE;
7101
7102 if (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
7103 {
7104 if (entry->ie_Flags & ICONENTRY_FLAG_SELECTED)
7105 {
7106 Remove(node);
7107 entry->ie_Flags &= ~ICONENTRY_FLAG_SELECTED;
7108 update_entry = TRUE;
7109 }
7110 if (entry->ie_Flags & ICONENTRY_FLAG_FOCUS)
7111 {
7112 entry->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
7113 update_entry = TRUE;
7114 }
7115 }
7116
7117 if (update_entry)
7118 {
7119 changed = TRUE;
7120 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
7121 data->update_entry = entry;
7122 MUI_Redraw(obj, MADF_DRAWUPDATE);
7123 }
7124 }
7125
7126 if (changed)
7127 SET(obj, MUIA_IconList_SelectionChanged, TRUE);
7128
7129 return 1;
7130 }
7131 ///
7132
7133 ///MUIM_SelectAll()
7134 /**************************************************************************
7135 MUIM_SelectAll
7136 **************************************************************************/
7137 IPTR IconList__MUIM_IconList_SelectAll(struct IClass *CLASS, Object *obj, Msg message)
7138 {
7139 struct IconList_DATA *data = INST_DATA(CLASS, obj);
7140 struct IconEntry *node = NULL;
7141 BOOL changed = FALSE;
7142
7143 #if defined(DEBUG_ILC_FUNCS)
7144 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
7145 #endif
7146
7147 node = (struct IconEntry *)GetHead(&data->icld_IconList);
7148
7149 while (node != NULL)
7150 {
7151 if (node->ie_Flags & ICONENTRY_FLAG_VISIBLE)
7152 {
7153 BOOL update_entry = FALSE;
7154
7155 if (!(node->ie_Flags & ICONENTRY_FLAG_SELECTED))
7156 {
7157 AddTail(&data->icld_SelectionList, &node->ie_SelectionNode);
7158 node->ie_Flags |= ICONENTRY_FLAG_SELECTED;
7159 update_entry = TRUE;
7160
7161 data->icld_SelectionLastClicked = node;
7162 }
7163 else if (node->ie_Flags & ICONENTRY_FLAG_FOCUS)
7164 {
7165 node->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
7166 update_entry = TRUE;
7167 }
7168
7169 if (update_entry)
7170 {
7171 changed = TRUE;
7172 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
7173 data->update_entry = node;
7174 MUI_Redraw(obj, MADF_DRAWUPDATE);
7175 }
7176 }
7177 node = (struct IconEntry *)GetSucc(&node->ie_IconNode);
7178 }
7179
7180 if ((data->icld_SelectionLastClicked) && (data->icld_SelectionLastClicked != data->icld_FocusIcon))
7181 {
7182 data->icld_FocusIcon = data->icld_SelectionLastClicked;
7183 if (!(data->icld_FocusIcon->ie_Flags & ICONENTRY_FLAG_FOCUS))
7184 {
7185 data->icld_FocusIcon->ie_Flags &= ~ICONENTRY_FLAG_FOCUS;
7186 data->icld_FocusIcon->ie_Flags |= ICONENTRY_FLAG_FOCUS;
7187 data->icld_UpdateMode = UPDATE_SINGLEENTRY;
7188 data->update_entry = data->icld_FocusIcon;
7189 MUI_Redraw(obj, MADF_DRAWUPDATE);
7190 }
7191 }
7192
7193 if (changed)
7194 SET(obj, MUIA_IconList_SelectionChanged, TRUE);
7195
7196 return 1;
7197 }
7198 ///
7199
7200 ///IconList__MUIM_IconList_CoordsSort()
7201 IPTR IconList__MUIM_IconList_CoordsSort(struct IClass *CLASS, Object *obj, struct MUIP_IconList_Sort *message)
7202 {
7203 struct IconList_DATA *data = INST_DATA(CLASS, obj);
7204
7205 struct IconEntry *entry = NULL,
7206 *test_icon = NULL;
7207
7208 struct List list_VisibleIcons;
7209 struct List list_HiddenIcons;
7210 // struct List list_UnplacedIcons;
7211
7212 /*
7213 perform a quick sort of the iconlist based on entry coords
7214 this method DOESNT cause any visual output.
7215 */
7216 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ICONSORTING)
7217 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
7218 #endif
7219
7220 NewList((struct List*)&list_VisibleIcons);
7221 NewList((struct List*)&list_HiddenIcons);
7222
7223 /*move list into our local list struct(s)*/
7224 while ((entry = (struct IconEntry *)RemTail((struct List*)&data->icld_IconList)))
7225 {
7226 if (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
7227 {
7228 AddHead((struct List*)&list_VisibleIcons, (struct Node *)&entry->ie_IconNode);
7229 }
7230 else
7231 AddHead((struct List*)&list_HiddenIcons, (struct Node *)&entry->ie_IconNode);
7232 }
7233
7234 while ((entry = (struct IconEntry *)RemTail((struct List*)&list_VisibleIcons)))
7235 {
7236 if ((test_icon = (struct IconEntry *)GetTail(&data->icld_IconList)) != NULL)
7237 {
7238 while (test_icon != NULL)
7239 {
7240 if (((data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL) && (test_icon->ie_IconX > entry->ie_IconX)) ||
7241 (!(data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL) && (test_icon->ie_IconY > entry->ie_IconY)))
7242 {
7243 test_icon = (struct IconEntry *)GetPred(&test_icon->ie_IconNode);
7244 continue;
7245 }
7246 else break;
7247 }
7248
7249 while (test_icon != NULL)
7250 {
7251 if (((data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL) && (test_icon->ie_IconY > entry->ie_IconY)) ||
7252 (!(data->icld_DisplayFlags & ICONLIST_DISP_VERTICAL) && (test_icon->ie_IconX > entry->ie_IconX)))
7253 {
7254 test_icon = (struct IconEntry *)GetPred(&test_icon->ie_IconNode);
7255 continue;
7256 }
7257 else break;
7258 }
7259 Insert((struct List*)&data->icld_IconList, (struct Node *)&entry->ie_IconNode, (struct Node *)&test_icon->ie_IconNode);
7260 }
7261 else
7262 AddTail((struct List*)&data->icld_IconList, (struct Node *)&entry->ie_IconNode);
7263 }
7264 #if defined(DEBUG_ILC_ICONSORTING)
7265 D(bug("[IconList] %s: Done\n", __PRETTY_FUNCTION__));
7266 #endif
7267
7268 while ((entry = (struct IconEntry *)RemTail((struct List*)&list_HiddenIcons)))
7269 {
7270 AddTail((struct List*)&data->icld_IconList, (struct Node *)&entry->ie_IconNode);
7271 }
7272
7273 #if defined(DEBUG_ILC_ICONSORTING_DUMP)
7274 #if defined(__AROS__)
7275 ForeachNode(&data->icld_IconList, entry)
7276 #else
7277 Foreach_Node(&data->icld_IconList, entry);
7278 #endif
7279 {
7280 D(bug("[IconList] %s: %d %d '%s'\n", __PRETTY_FUNCTION__, entry->ie_IconX, entry->ie_IconY, entry->ie_IconListEntry.label));
7281 }
7282 #endif
7283
7284 return TRUE;
7285 }
7286 ///
7287
7288 ///MUIM_Sort()
7289 /**************************************************************************
7290 MUIM_Sort - sortsort
7291 **************************************************************************/
7292 IPTR IconList__MUIM_IconList_Sort(struct IClass *CLASS, Object *obj, struct MUIP_IconList_Sort *message)
7293 {
7294 struct IconList_DATA *data = INST_DATA(CLASS, obj);
7295 struct IconEntry *entry = NULL,
7296 *icon1 = NULL,
7297 *icon2 = NULL;
7298
7299 struct List list_VisibleIcons,
7300 list_SortedIcons,
7301 list_HiddenIcons;
7302
7303 BOOL sortme, reversable = TRUE, enqueue = FALSE;
7304 int i, visible_count = 0;
7305
7306 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ICONSORTING)
7307 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
7308 #endif
7309
7310 /* Reset incase view options have changed .. */
7311 data->icld_IconAreaLargestWidth = 0;
7312 data->icld_IconAreaLargestHeight = 0;
7313 data->icld_IconLargestHeight = 0;
7314 data->icld_LabelLargestHeight = 0;
7315
7316 #if defined(DEBUG_ILC_ICONSORTING)
7317 D(bug("[IconList] %s: Sort-Flags : %x\n", __PRETTY_FUNCTION__, (data->icld_SortFlags & MUIV_IconList_Sort_MASK)));
7318 #endif
7319 NewList((struct List*)&list_VisibleIcons);
7320 NewList((struct List*)&list_SortedIcons);
7321 NewList((struct List*)&list_HiddenIcons);
7322
7323 /*move list into our local list struct(s)*/
7324 while ((entry = (struct IconEntry *)RemTail((struct List*)&data->icld_IconList)))
7325 {
7326 if (!(entry->ie_Flags & ICONENTRY_FLAG_HASICON))
7327 {
7328 if (data->icld_DisplayFlags & ICONLIST_DISP_SHOWINFO)
7329 {
7330 if (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
7331 {
7332 entry->ie_Flags &= ~(ICONENTRY_FLAG_VISIBLE|ICONENTRY_FLAG_NEEDSUPDATE);
7333 }
7334 }
7335 else if (!(entry->ie_Flags & ICONENTRY_FLAG_VISIBLE))
7336 {
7337 entry->ie_Flags |= (ICONENTRY_FLAG_VISIBLE|ICONENTRY_FLAG_NEEDSUPDATE);
7338 }
7339 }
7340 else
7341 {
7342 if (!(entry->ie_Flags & ICONENTRY_FLAG_VISIBLE))
7343 {
7344 entry->ie_Flags |= (ICONENTRY_FLAG_VISIBLE|ICONENTRY_FLAG_NEEDSUPDATE);
7345 }
7346 }
7347
7348 /* Now we have fixed visibility lets dump them into the correct list for sorting */
7349 if (entry->ie_Flags & ICONENTRY_FLAG_VISIBLE)
7350 {
7351 if(entry->ie_AreaWidth > data->icld_IconAreaLargestWidth) data->icld_IconAreaLargestWidth = entry->ie_AreaWidth;
7352 if(entry->ie_AreaHeight > data->icld_IconAreaLargestHeight) data->icld_IconAreaLargestHeight = entry->ie_AreaHeight;
7353 if(entry->ie_IconHeight > data->icld_IconLargestHeight) data->icld_IconLargestHeight = entry->ie_IconHeight;
7354 if((entry->ie_AreaHeight - entry->ie_IconHeight) > data->icld_LabelLargestHeight) data->icld_LabelLargestHeight = entry->ie_AreaHeight - entry->ie_IconHeight;
7355
7356 if (((data->icld_SortFlags & MUIV_IconList_Sort_AutoSort) == 0) && (entry->ie_ProvidedIconX == NO_ICON_POSITION))
7357 AddTail((struct List*)&list_VisibleIcons, (struct Node *)&entry->ie_IconNode);
7358 else
7359 AddHead((struct List*)&list_VisibleIcons, (struct Node *)&entry->ie_IconNode);
7360 visible_count++;
7361 }
7362 else
7363 {
7364 if (entry->ie_Flags & ICONENTRY_FLAG_SELECTED)
7365 {
7366 Remove(&entry->ie_SelectionNode);
7367 }
7368 entry->ie_Flags &= ~(ICONENTRY_FLAG_SELECTED|ICONENTRY_FLAG_FOCUS);
7369 if (data->icld_SelectionLastClicked == entry) data->icld_SelectionLastClicked = NULL;
7370 if (data->icld_FocusIcon == entry) data->icld_FocusIcon = data->icld_SelectionLastClicked;
7371 AddHead((struct List*)&list_HiddenIcons, (struct Node *)&entry->ie_IconNode);
7372 }
7373 }
7374
7375 /* Copy each visible entry back to the main list, sorting as we go*/
7376 while ((entry = (struct IconEntry *)RemHead((struct List*)&list_VisibleIcons)))
7377 {
7378 icon1 = (struct IconEntry *)GetHead(&list_SortedIcons);
7379 icon2 = NULL;
7380
7381 sortme = FALSE;
7382
7383 if (visible_count > 1)
7384 {
7385 #if defined(DEBUG_ILC_ICONSORTING)
7386 D(bug("[IconList] %s: - %s %s %s %i\n", __PRETTY_FUNCTION__, entry->ie_IconListEntry.label, entry->ie_TxtBuf_DATE, entry->ie_TxtBuf_TIME, entry->ie_FileInfoBlock->fib_Size));
7387 #endif
7388 while (icon1)
7389 {
7390 if(((icon1->ie_IconListEntry.type == ST_ROOT) || (icon1->ie_IconListEntry.type == ST_LINKDIR) || (icon1->ie_IconListEntry.type == ST_LINKFILE))
7391 || (data->icld_SortFlags & MUIV_IconList_Sort_DrawersMixed))
7392 {
7393 /*volume list or drawers mixed*/
7394 sortme = TRUE;
7395 }
7396 else
7397 {
7398 /*drawers first*/
7399 if ((icon1->ie_IconListEntry.type == ST_USERDIR) && (entry->ie_IconListEntry.type == ST_USERDIR))
7400 {
7401 sortme = TRUE;
7402 }
7403 else
7404 {
7405 if ((icon1->ie_IconListEntry.type != ST_USERDIR) && (entry->ie_IconListEntry.type != ST_USERDIR))
7406 sortme = TRUE;
7407 else
7408 {
7409 /* we are the first drawer to arrive or we need to insert ourselves
7410 due to being sorted to the end of the drawers*/
7411
7412 if ((!icon2 || icon2->ie_IconListEntry.type == ST_USERDIR) &&
7413 (entry->ie_IconListEntry.type == ST_USERDIR) &&
7414 (icon1->ie_IconListEntry.type != ST_USERDIR))
7415 {
7416 #if defined(DEBUG_ILC_ICONSORTING)
7417 D(bug("[IconList] %s: force %s\n", __PRETTY_FUNCTION__, entry->ie_IconListEntry.label));
7418 #endif
7419 break;
7420 }
7421 }
7422 }
7423 }
7424
7425 if (sortme)
7426 {
7427 i = 0;
7428
7429 if ((data->icld_SortFlags & MUIV_IconList_Sort_AutoSort) == 0)
7430 {
7431 if ((entry->ie_ProvidedIconX != NO_ICON_POSITION) && (entry->ie_ProvidedIconY != NO_ICON_POSITION))
7432 {
7433 i = 1;
7434 }
7435 }
7436
7437 if (i == 0)
7438 {
7439 if (data->icld_SortFlags & MUIV_IconList_Sort_ByDate)
7440 {
7441 /* Sort by Date */
7442 i = CompareDates((const struct DateStamp *)&entry->ie_FileInfoBlock->fib_Date,(const struct DateStamp *)&icon1->ie_FileInfoBlock->fib_Date);
7443 }
7444 else if (data->icld_SortFlags & MUIV_IconList_Sort_BySize)
7445 {
7446 /* Sort by Size .. */
7447 i = entry->ie_FileInfoBlock->fib_Size - icon1->ie_FileInfoBlock->fib_Size;
7448 }
7449 else if ((data->icld_SortFlags & MUIV_IconList_Sort_ByType) && ((entry->ie_IconListEntry.type == ST_FILE) || (entry->ie_IconListEntry.type == ST_USERDIR)))
7450 {
7451 /* Sort by Type .. */
7452 /* TODO: Sort icons based on type using datatypes */
7453 }
7454 else
7455 {
7456 /* Sort by Name .. */
7457 i = Stricmp(entry->ie_IconListEntry.label, icon1->ie_IconListEntry.label);
7458 if ((data->icld_SortFlags & MUIV_IconList_Sort_DrawersMixed) == 0) enqueue = TRUE;
7459 }
7460 }
7461
7462 if ((reversable) && data->icld_SortFlags & MUIV_IconList_Sort_Reverse)
7463 {
7464 if (i > 0)
7465 break;
7466 }
7467 else if (i < 0)
7468 break;
7469 }
7470 icon2 = icon1;
7471 icon1 = (struct IconEntry *)GetSucc(&icon1->ie_IconNode);
7472 }
7473 }
7474 Insert((struct List*)&list_SortedIcons, (struct Node *)&entry->ie_IconNode, (struct Node *)&icon2->ie_IconNode);
7475 }
7476 if (enqueue)
7477 {
7478 /* Quickly resort based on node priorities .. */
7479 while ((entry = (struct IconEntry *)RemHead((struct List*)&list_SortedIcons)))
7480 {
7481 Enqueue((struct List*)&data->icld_IconList, (struct Node *)&entry->ie_IconNode);
7482 }
7483 }
7484 else
7485 {
7486 while ((entry = (struct IconEntry *)RemHead((struct List*)&list_SortedIcons)))
7487 {
7488 AddTail((struct List*)&data->icld_IconList, (struct Node *)&entry->ie_IconNode);
7489 }
7490 }
7491
7492 DoMethod(obj, MUIM_IconList_PositionIcons);
7493 MUI_Redraw(obj, MADF_DRAWOBJECT);
7494
7495 if ((data->icld_SortFlags & MUIV_IconList_Sort_Orders) != 0)
7496 {
7497 DoMethod(obj, MUIM_IconList_CoordsSort);
7498
7499 /* leave hidden icons on a seperate list to speed up normal list parsing ? */
7500 while ((entry = (struct IconEntry *)RemHead((struct List*)&list_HiddenIcons)))
7501 {
7502 AddTail((struct List*)&data->icld_IconList, (struct Node *)&entry->ie_IconNode);
7503 }
7504 }
7505 SET(obj, MUIA_IconList_Changed, TRUE);
7506
7507 return 1;
7508 }
7509 ///
7510
7511 ///MUIM_DragReport()
7512 /**************************************************************************
7513 MUIM_DragReport. Since MUI doesn't change the drop object if the dragged
7514 object is moved above another window (while still in the bounds of the
7515 orginal drop object) we must do it here manually to be compatible with
7516 MUI. Maybe Zune should fix this bug somewhen.
7517 **************************************************************************/
7518 IPTR IconList__MUIM_DragReport(struct IClass *CLASS, Object *obj, struct MUIP_DragReport *message)
7519 {
7520 struct Window *wnd = _window(obj);
7521 struct Layer *l = NULL;
7522
7523 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ICONDRAGDROP)
7524 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
7525 #endif
7526
7527 l = WhichLayer(&wnd->WScreen->LayerInfo, wnd->LeftEdge + message->x, wnd->TopEdge + message->y);
7528
7529 if (l != wnd->WLayer) return MUIV_DragReport_Abort;
7530
7531 return MUIV_DragReport_Continue;
7532 }
7533 ///
7534
7535 ///MUIM_IconList_UnknownDropDestination()
7536 /**************************************************************************
7537 MUIM_IconList_UnknownDropDestination
7538 **************************************************************************/
7539 IPTR IconList__MUIM_UnknownDropDestination(struct IClass *CLASS, Object *obj, struct MUIP_UnknownDropDestination *message)
7540 {
7541 #if defined(DEBUG_ILC_FUNCS) || defined(DEBUG_ILC_ICONDRAGDROP)
7542 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
7543 #endif
7544 #if defined(DEBUG_ILC_ICONDRAGDROP)
7545 D(bug("[IconList] %s: icons dropped on custom window \n", __PRETTY_FUNCTION__));
7546 #endif
7547
7548 SET(obj, MUIA_IconList_AppWindowDrop, (IPTR)message); /* Now notify */
7549
7550 return (IPTR)NULL;
7551 }
7552 ///
7553
7554 ///MUIM_IconList_MakeEntryVisible()
7555 /**************************************************************************
7556 Move the visible area so that the selected entry becomes visible ..
7557 **************************************************************************/
7558 IPTR IconList__MUIM_IconList_MakeEntryVisible(struct IClass *CLASS, Object *obj, struct MUIP_IconList_MakeEntryVisible *message)
7559 {
7560 struct IconList_DATA *data = INST_DATA(CLASS, obj);
7561 BOOL viewmoved = FALSE;
7562 struct Rectangle iconrect, viewrect;
7563
7564 #if defined(DEBUG_ILC_FUNCS)
7565 D(bug("[IconList]: %s()\n", __PRETTY_FUNCTION__));
7566 #endif
7567
7568 viewrect.MinX = data->icld_ViewX;
7569 viewrect.MaxX = data->icld_ViewX + data->icld_AreaWidth;
7570 viewrect.MinY = data->icld_ViewY;
7571 viewrect.MaxY = data->icld_ViewY + data->icld_AreaHeight;
7572
7573 IconList_GetIconAreaRectangle(obj, data, message->entry, &iconrect);
7574
7575 if (!(RectAndRect(&viewrect, &iconrect)))
7576 {
7577 viewmoved = TRUE;
7578 if (message->entry->ie_IconX < data->icld_ViewX)
7579 data->icld_ViewX = message->entry->ie_IconX;
7580 else if (message->entry->ie_IconX > (data->icld_ViewX + data->icld_AreaWidth))
7581 data->icld_ViewX = (message->entry->ie_IconX + message->entry->ie_AreaWidth) - data->icld_AreaWidth;
7582
7583 if (message->entry->ie_IconY < data->icld_ViewY)
7584 data->icld_ViewY = message->entry->ie_IconX;
7585 else if (message->entry->ie_IconY > (data->icld_ViewY + data->icld_AreaHeight))
7586 data->icld_ViewY = (message->entry->ie_IconY + message->entry->ie_AreaHeight) - data->icld_AreaHeight;
7587 }
7588
7589 if (viewmoved)
7590 {
7591 #if defined(DEBUG_ILC_ICONRENDERING)
7592 D(bug("[IconList]: %s: call SetSuperAttrs()\n", __PRETTY_FUNCTION__));
7593 #endif
7594 SetSuperAttrs(CLASS, obj, MUIA_Virtgroup_Left, data->icld_ViewX,
7595 MUIA_Virtgroup_Top, data->icld_ViewY,
7596 TAG_DONE);
7597
7598 #if defined(DEBUG_ILC_ICONRENDERING)
7599 D(bug("[IconList]: %s: call SetAttrs()\n", __PRETTY_FUNCTION__));
7600 #endif
7601 SetAttrs(obj, MUIA_Virtgroup_Left, data->icld_ViewX,
7602 MUIA_Virtgroup_Top, data->icld_ViewY,
7603 TAG_DONE);
7604
7605 #if defined(DEBUG_ILC_ICONRENDERING)
7606 D(bug("[IconList]: %s: call MUI_Redraw()\n", __PRETTY_FUNCTION__));
7607 #endif
7608 MUI_Redraw(obj,MADF_DRAWOBJECT);
7609 }
7610 return 1;
7611 }
7612
7613 #if defined(WANDERER_BUILTIN_ICONLIST)
7614 BOOPSI_DISPATCHER(IPTR,IconList_Dispatcher, CLASS, obj, message)
7615 {
7616 #if defined(__AROS__)
7617 switch (message->MethodID)
7618 #else
7619 struct IClass *CLASS = cl;
7620 Msg message = msg;
7621
7622 switch (msg->MethodID)
7623 #endif
7624 {
7625 case OM_NEW: return IconList__OM_NEW(CLASS, obj, (struct opSet *)message);
7626 case OM_DISPOSE: return IconList__OM_DISPOSE(CLASS, obj, message);
7627 case OM_SET: return IconList__OM_SET(CLASS, obj, (struct opSet *)message);
7628 case OM_GET: return IconList__OM_GET(CLASS, obj, (struct opGet *)message);
7629 case OM_ADDMEMBER:
7630 case MUIM_Family_AddTail: return IconList__MUIM_Family_AddTail(CLASS, obj, (APTR)message);
7631 case MUIM_Family_AddHead: return IconList__MUIM_Family_AddHead(CLASS, obj, (APTR)message);
7632 case OM_REMMEMBER:
7633 case MUIM_Family_Remove: return IconList__MUIM_Family_Remove(CLASS, obj, (APTR)message);
7634
7635 case MUIM_Setup: return IconList__MUIM_Setup(CLASS, obj, (struct MUIP_Setup *)message);
7636
7637 case MUIM_Show: return IconList__MUIM_Show(CLASS,obj, (struct MUIP_Show *)message);
7638 case MUIM_Hide: return IconList__MUIM_Hide(CLASS,obj, (struct MUIP_Hide *)message);
7639 case MUIM_Cleanup: return IconList__MUIM_Cleanup(CLASS, obj, (struct MUIP_Cleanup *)message);
7640 case MUIM_AskMinMax: return IconList__MUIM_AskMinMax(CLASS, obj, (struct MUIP_AskMinMax *)message);
7641 case MUIM_Draw: return IconList__MUIM_Draw(CLASS, obj, (struct MUIP_Draw *)message);
7642 #if defined(__AROS__)
7643 case MUIM_Layout: return IconList__MUIM_Layout(CLASS, obj, (struct MUIP_Layout *)message);
7644 #endif
7645 case MUIM_HandleEvent: return IconList__MUIM_HandleEvent(CLASS, obj, (struct MUIP_HandleEvent *)message);
7646 case MUIM_CreateDragImage: return IconList__MUIM_CreateDragImage(CLASS, obj, (APTR)message);
7647 case MUIM_DeleteDragImage: return IconList__MUIM_DeleteDragImage(CLASS, obj, (APTR)message);
7648 case MUIM_DragQuery: return IconList__MUIM_DragQuery(CLASS, obj, (APTR)message);
7649 case MUIM_DragReport: return IconList__MUIM_DragReport(CLASS, obj, (APTR)message);
7650 case MUIM_DragDrop: return IconList__MUIM_DragDrop(CLASS, obj, (APTR)message);
7651 #if defined(__AROS__)
7652 case MUIM_UnknownDropDestination: return IconList__MUIM_UnknownDropDestination(CLASS, obj, (APTR)message);
7653 #endif
7654 case MUIM_IconList_Update: return IconList__MUIM_IconList_Update(CLASS, obj, (APTR)message);
7655 case MUIM_IconList_Clear: return IconList__MUIM_IconList_Clear(CLASS, obj, (APTR)message);
7656 case MUIM_IconList_RethinkDimensions: return IconList__MUIM_IconList_RethinkDimensions(CLASS, obj, (APTR)message);
7657 case MUIM_IconList_CreateEntry: return IconList__MUIM_IconList_CreateEntry(CLASS, obj, (APTR)message);
7658 case MUIM_IconList_UpdateEntry: return IconList__MUIM_IconList_UpdateEntry(CLASS, obj, (APTR)message);
7659 case MUIM_IconList_DestroyEntry: return IconList__MUIM_IconList_DestroyEntry(CLASS, obj, (APTR)message);
7660 case MUIM_IconList_DrawEntry: return IconList__MUIM_IconList_DrawEntry(CLASS, obj, (APTR)message);
7661 case MUIM_IconList_DrawEntryLabel: return IconList__MUIM_IconList_DrawEntryLabel(CLASS, obj, (APTR)message);
7662 case MUIM_IconList_NextIcon: return IconList__MUIM_IconList_NextIcon(CLASS, obj, (APTR)message);
7663 case MUIM_IconList_GetIconPrivate: return IconList__MUIM_IconList_GetIconPrivate(CLASS, obj, (APTR)message);
7664 case MUIM_IconList_UnselectAll: return IconList__MUIM_IconList_UnselectAll(CLASS, obj, (APTR)message);
7665 case MUIM_IconList_Sort: return IconList__MUIM_IconList_Sort(CLASS, obj, (APTR)message);
7666 case MUIM_IconList_CoordsSort: return IconList__MUIM_IconList_CoordsSort(CLASS, obj, (APTR)message);
7667 case MUIM_IconList_PositionIcons: return IconList__MUIM_IconList_PositionIcons(CLASS, obj, (APTR)message);
7668 case MUIM_IconList_SelectAll: return IconList__MUIM_IconList_SelectAll(CLASS, obj, (APTR)message);
7669 case MUIM_IconList_MakeEntryVisible: return IconList__MUIM_IconList_MakeEntryVisible(CLASS, obj, (APTR)message);
7670 }
7671
7672 return DoSuperMethodA(CLASS, obj, message);
7673 }
7674 BOOPSI_DISPATCHER_END
7675
7676 #if defined(__AROS__)
7677 /* Class descriptor. */
7678 const struct __MUIBuiltinClass _MUI_IconList_desc = {
7679 MUIC_IconList,
7680 MUIC_Area,
7681 sizeof(struct IconList_DATA),
7682 (void*)IconList_Dispatcher
7683 };
7684 #endif
7685 #endif /* WANDERER_BUILTIN_ICONLIST */
7686
7687 #if !defined(__AROS__)
7688 struct MUI_CustomClass *initIconListClass(void)
7689 {
7690 return (struct MUI_CustomClass *) MUI_CreateCustomClass(NULL, MUIC_Area, NULL, sizeof(struct IconList_DATA), ENTRY(IconList_Dispatcher));
7691 }
7692 #endif
Mirror of AROS' svn.