?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't call InvertPixelArray with negative width and/or height.
[tangerine.git] / workbench / libs / muimaster / classes / iconlist.c
blob0ba6aa074d1c836e126bea05826eb2b8b92e181d
1
2 /*
3 Copyright 2002-2006, The AROS Development Team. All rights reserved.
4 $Id$
5 */
6
7 #include <string.h>
8 #include <stdlib.h>
9 #include <stdio.h>
10 #include <string.h>
11 #include <math.h>
12
13 #include <dos/dos.h>
14 #include <dos/datetime.h>
15
16 #include <exec/memory.h>
17 #include <graphics/gfx.h>
18 #include <graphics/view.h>
19 #include <graphics/rpattr.h>
20 #include <workbench/icon.h>
21 #include <workbench/workbench.h>
22 #include <devices/rawkeycodes.h>
23 #include <clib/alib_protos.h>
24 #include <proto/exec.h>
25 #include <proto/graphics.h>
26 #include <proto/utility.h>
27 #include <proto/dos.h>
28 #include <proto/intuition.h>
29 #include <proto/icon.h>
30 #include <proto/layers.h>
31 #include <proto/muimaster.h>
32 #include <proto/dos.h>
33 #include <proto/iffparse.h>
34 #include <prefs/prefhdr.h>
35 #include <prefs/wanderer.h>
36 #include <proto/cybergraphics.h>
37
38 #define DEBUG 0
39 #include <aros/debug.h>
40
41 #define MYDEBUG
42 #include "debug.h"
43 #include "mui.h"
44 #include "muimaster_intern.h"
45 #include "support.h"
46 #include "imspec.h"
47 #include "iconlist.h"
48 #include "../../../system/Wanderer/wandererprefs.h"
49 #include "../../../system/Wanderer/wanderer.h"
50
51 extern struct Library *MUIMasterBase;
52
53 #ifndef NO_ICON_POSITION
54 #define NO_ICON_POSITION (0x8000000) /* belongs to workbench/workbench.h */
55 #endif
56
57 #ifdef __AROS__
58 #define dol_Name dol_OldName /* This doesn't work really */
59 #endif
60
61 #define UPDATE_SINGLEICON 1
62 #define UPDATE_SCROLL 2
63 #define UPDATE_SORT 3
64 #define UPDATE_RESCALE 4
65
66 #define LEFT_BUTTON 1
67 #define RIGHT_BUTTON 2
68 #define MIDDLE_BUTTON 4
69
70 #define ICONLIST_TEXTMARGIN 5
71
72 #define ICON_LISTMODE_GRID 0
73 #define ICON_LISTMODE_ROUGH 1
74
75 #define ICON_TEXTMODE_OUTLINE 0
76 #define ICON_TEXTMODE_PLAIN 1
77 #define ICON_TEXTMODE_DROPSHADOW 2
78
79 #define ICON_TEXTMAXLEN_DEFAULT 15
80 #define ICONLIST_DRAWMODE_NORMAL 1
81 #define ICONLIST_DRAWMODE_FAST 2
82
83 struct IconEntry
84 {
85 struct MinNode node;
86 struct IconList_Entry entry;
87
88 struct DiskObject *dob; /* The icons disk objects */
89
90 struct FileInfoBlock fib;
91 UBYTE datebuf[LEN_DATSTRING];
92 UBYTE timebuf[LEN_DATSTRING];
93 UBYTE sizebuf[30];
94 UBYTE protbuf[8];
95
96 int x,y;
97 int width,height;
98 int realWidth,realHeight; /* <- includes textwidth and everything */
99 int selected;
100 };
101
102 struct MUI_IconData
103 {
104 APTR pool; /* Pool to allocate data from */
105
106 struct MinList icon_list; /* IconEntry */
107 int view_x,view_y; /* the leftmost/upper coordinates of the view */
108 int view_width,view_height; /* dimensions of the view (_mwidth(obj) and _mheight(obj)) */
109 int width,height; /* The whole width/height */
110 int mouse_pressed;
111
112 struct TextFont *IconFont;
113
114 struct MUI_EventHandlerNode ehn;
115
116 LONG touch_x;
117 LONG touch_y;
118
119 LONG click_x;
120 LONG click_y;
121
122 struct IconEntry *first_selected; /* the icon which has been selected first or NULL */
123
124 /* DoubleClick stuff */
125 ULONG last_secs;
126 ULONG last_mics;
127 struct IconEntry *last_selected;
128
129 /* Notify stuff */
130 struct IconList_Drop drop_entry; /* the icon where the icons have been dropped */
131 struct IconList_Click icon_click;
132
133 /* Internal Sorting related stuff */
134
135 ULONG sort_bits;
136 ULONG max_x;
137 ULONG max_y;
138
139 /* How to show the iconlist */
140 UBYTE wpd_IconListMode;
141 UBYTE wpd_IconTextMode;
142 ULONG wpd_IconTextMaxLen;
143
144 /* lasso data */
145 BOOL lasso_active;
146 struct Rectangle lasso_rect;
147
148 /* Render stuff */
149
150 /* values for update */
151 /* UPDATE_SINGLEICON = draw the given single icon only */
152 /* UPDATE_SCROLL = scroll the view by update_scrolldx/update_scrolldy */
153 /* UPDATE_RESCALE = rescaling window and update only new parts */
154
155 ULONG update;
156 WORD update_scrolldx;
157 WORD update_scrolldy;
158 WORD update_oldwidth;
159 WORD update_oldheight;
160
161 struct IconEntry *update_icon;
162 struct Rectangle *update_rect1;
163 struct Rectangle *update_rect2;
164 struct Rectangle view_rect;
165
166 ULONG textWidth; /* Whole textwidth for icon in pixels */
167
168 BOOL buffered;
169 };
170
171 /**************************************************************************
172
173 **************************************************************************/
174 int RectAndRect(struct Rectangle *a, struct Rectangle *b)
175 {
176 if ((a->MinX > b->MaxX) || (a->MinY > b->MaxY) || (a->MaxX < b->MinX) || (a->MaxY < b->MinY))
177 return 0;
178 return 1;
179 }
180
181 /**************************************************************************
182 get positive lasso coords
183 **************************************************************************/
184 static void GetAbsoluteLassoRect(struct MUI_IconData *data, struct Rectangle *lasso_rect)
185 {
186 WORD minx = data->lasso_rect.MinX;
187 WORD miny = data->lasso_rect.MinY;
188 WORD maxx = data->lasso_rect.MaxX;
189 WORD maxy = data->lasso_rect.MaxY;
190
191 if (minx > maxx)
192 {
193 /* Swap minx, maxx */
194 minx ^= maxx;
195 maxx ^= minx;
196 minx ^= maxx;
197 }
198
199 if (miny > maxy)
200 {
201 /* Swap miny, maxy */
202 miny ^= maxy;
203 maxy ^= miny;
204 miny ^= maxy;
205 }
206
207 lasso_rect->MinX = data->view_rect.MinX - data->view_x + minx;
208 lasso_rect->MinY = data->view_rect.MinY - data->view_y + miny;
209 lasso_rect->MaxX = data->view_rect.MinX - data->view_x + maxx;
210 lasso_rect->MaxY = data->view_rect.MinY - data->view_y + maxy;
211 }
212
213 static void InvertPixelRect(struct RastPort *rp, WORD minx, WORD miny, WORD maxx, WORD maxy)
214 {
215 if (maxx < minx)
216 {
217 /* Swap minx, maxx */
218 minx ^= maxx;
219 maxx ^= minx;
220 minx ^= maxx;
221 }
222
223 if (maxy < miny)
224 {
225 /* Swap miny, maxy */
226 miny ^= maxy;
227 maxy ^= miny;
228 miny ^= maxy;
229 }
230
231 InvertPixelArray(rp, minx, miny, maxx - minx + 1, maxy - miny + 1);
232 }
233
234 /**************************************************************************
235 Simple lasso drawing by inverting area outlines
236 **************************************************************************/
237 void InvertLassoOutlines(Object *obj, struct Rectangle *rect)
238 {
239 struct Rectangle lasso;
240
241 /* get abolute iconlist coords */
242 lasso.MinX = rect->MinX + _mleft(obj);
243 lasso.MaxX = rect->MaxX + _mleft(obj);
244 lasso.MinY = rect->MinY + _mtop(obj);
245 lasso.MaxY = rect->MaxY + _mtop(obj);
246
247 /* check for vertical borders */
248 if ( lasso.MinX < _mleft(obj) ) lasso.MinX += _mleft(obj) - lasso.MinX;
249 if ( lasso.MaxX > _mright(obj) ) lasso.MaxX -= lasso.MaxX - _mright(obj) - 2;
250
251 /* horizontal lasso lines */
252 if ( lasso.MinY > _mtop(obj) ) InvertPixelRect( _rp(obj), lasso.MinX, lasso.MinY, lasso.MaxX-1, lasso.MinY + 1);
253 else lasso.MinY += _mtop(obj) - lasso.MinY;
254 if ( lasso.MaxY < _mbottom(obj) ) InvertPixelRect( _rp(obj), lasso.MinX, lasso.MaxY, lasso.MaxX-1, lasso.MaxY + 1);
255 else lasso.MaxY -= lasso.MaxY - _mbottom(obj) - 2;
256
257 /* vertical lasso lines */
258 if ( lasso.MinX > _mleft(obj) ) InvertPixelRect( _rp(obj), lasso.MinX, lasso.MinY, lasso.MinX + 1, lasso.MaxY-1 );
259 if ( lasso.MaxX < _mright(obj) ) InvertPixelRect( _rp(obj), lasso.MaxX, lasso.MinY, lasso.MaxX + 1, lasso.MaxY-1 );
260
261 }
262
263 /**************************************************************************
264 As we don't use the label drawing of icon.library we also have to do
265 this by hand
266 **************************************************************************/
267 static void IconList_GetIconRectangle(Object *obj, struct MUI_IconData *data, struct IconEntry *icon, struct Rectangle *rect)
268 {
269 /*
270 Get basic width/height
271 */
272 GetIconRectangleA(NULL,icon->dob,NULL,rect,NULL);
273 icon->realWidth = rect->MaxX - rect->MinX + 1;
274 icon->realHeight = rect->MaxY - rect->MinY + 1;
275
276 /*
277 Get icon box width including text width
278 */
279 if (icon->entry.label)
280 {
281 SetFont(_rp(obj), data->IconFont);
282
283 ULONG textlength = strlen(icon->entry.label);
284 if ( !data->wpd_IconTextMaxLen ) data->wpd_IconTextMaxLen = ICON_TEXTMAXLEN_DEFAULT;
285 if ( textlength > data->wpd_IconTextMaxLen ) textlength = data->wpd_IconTextMaxLen;
286
287 LONG txwidth = TextLength(_rp(obj), icon->entry.label, textlength) + 3;
288
289 if ( txwidth > icon->realWidth ) icon->realWidth = txwidth;
290
291 icon->realHeight += data->IconFont->tf_YSize + ICONLIST_TEXTMARGIN;
292 }
293
294 /*
295 Date/size sorting has the date/size appended under the icon label
296 only list regular files like this (drawers have no size/date output)
297 */
298 if(
299 icon->entry.type != WBDRAWER &&
300 ((data->sort_bits & ICONLIST_SORT_BY_SIZE) || (data->sort_bits & ICONLIST_SORT_BY_DATE))
301 )
302 {
303 icon->realHeight += data->IconFont->tf_YSize + ( ICONLIST_TEXTMARGIN * 2 );
304 }
305
306 /*
307 Store
308 */
309 icon->width = rect->MaxX - rect->MinX + 1;
310 icon->height = rect->MaxY - rect->MinY + 1;
311 rect->MaxX = rect->MinX + icon->realWidth - 1;
312 rect->MaxY = rect->MinY + icon->realHeight - 1;
313 }
314
315 /**************************************************************************
316 Draw the icon at its position
317 **************************************************************************/
318
319 #define DRAWICON_TESTDRAW TRUE
320 #define DRAWICON_DODRAW FALSE
321
322 static BOOL IconList_DrawIcon(Object *obj, struct MUI_IconData *data, struct IconEntry *icon,
323 struct RastPort *rp, BOOL onlytest)
324 {
325 struct Rectangle iconrect;
326 struct Rectangle objrect;
327
328 LONG tx,ty,offsetx,offsety;
329 LONG txwidth; // txheight;
330
331 STRPTR buf = NULL;
332
333 /* Get the dimensions and affected area of icon */
334 IconList_GetIconRectangle(obj, data, icon, &iconrect);
335
336 /* Add the relative position offset of the icon */
337 offsetx = _mleft(obj) - data->view_x + icon->x;
338 offsety = _mtop(obj) - data->view_y + icon->y;
339
340 iconrect.MinX += offsetx;
341 iconrect.MinY += offsety;
342 iconrect.MaxX += offsetx;
343 iconrect.MaxY += offsety;
344
345 /* Add the relative position of the window */
346 objrect.MinX = _mleft(obj);
347 objrect.MinY = _mtop(obj);
348 objrect.MaxX = _mright(obj);
349 objrect.MaxY = _mbottom(obj);
350
351 if (!RectAndRect(&iconrect, &objrect)) return FALSE;
352
353 /* data->update_rect1 and data->update_rect2 may
354 point to rectangles to indicate that only icons
355 in any of this rectangles need to be drawn */
356
357 if (data->update_rect1 && data->update_rect2)
358 {
359 if (!RectAndRect(&iconrect, data->update_rect1) &&
360 !RectAndRect(&iconrect, data->update_rect2)) return FALSE;
361 }
362 else if (data->update_rect1)
363 {
364 if (!RectAndRect(&iconrect, data->update_rect1)) return FALSE;
365 }
366 else if (data->update_rect2)
367 {
368 if (!RectAndRect(&iconrect, data->update_rect2)) return FALSE;
369 }
370
371 if (onlytest) return TRUE;
372
373 if (rp == NULL)
374 {
375 rp = _rp(obj);
376 }
377 else
378 {
379 iconrect.MinX -= offsetx;
380 iconrect.MinY -= offsety;
381 iconrect.MaxX -= offsetx;
382 iconrect.MaxY -= offsety;
383 }
384
385 SetABPenDrMd(rp,_pens(obj)[MPEN_TEXT],0,JAM1);
386
387 // Center icon
388 ULONG iconX = iconrect.MinX + ((icon->realWidth - icon->width )/2);
389 ULONG iconY = iconrect.MinY;
390
391 #ifndef __AROS__
392 DrawIconState
393 (
394 rp ? rp : rp, icon->dob, NULL,
395 iconX, iconY,
396 icon->selected ? IDS_SELECTED : IDS_NORMAL,
397 ICONDRAWA_EraseBackground, FALSE,
398 TAG_DONE
399 );
400 #else
401 DrawIconStateA
402 (
403 rp ? rp : rp, icon->dob, NULL,
404 iconX,
405 iconY,
406 icon->selected ? IDS_SELECTED : IDS_NORMAL,
407 TAG_DONE
408 );
409 #endif
410
411 if (icon->entry.label) buf = AllocVec ( 255, MEMF_CLEAR );
412
413 if (icon->entry.label && buf)
414 {
415 ULONG nameLength = strlen(icon->entry.label);
416
417 SetFont(rp, data->IconFont);
418
419 if ( nameLength > data->wpd_IconTextMaxLen )
420 txwidth = TextLength(rp, icon->entry.label, data->wpd_IconTextMaxLen);
421 else txwidth = TextLength(rp, icon->entry.label, nameLength);
422
423 memset( buf, 0 , sizeof( buf ) );
424
425 ULONG len = data->wpd_IconTextMaxLen;
426 // Make sure the maxlen is at least the length of ".."
427 if ( len < 2 ) len = 2;
428
429 if(nameLength > len)
430 {
431 strncpy(buf, icon->entry.label, len - 2);
432 strcat(buf , "..");
433 nameLength = len;
434 }
435 else
436 {
437 strncpy( buf, icon->entry.label, nameLength );
438 }
439
440 tx = iconrect.MinX + ((iconrect.MaxX - iconrect.MinX + 1 - txwidth)/2);
441 ty = iconY + icon->height + data->IconFont->tf_Baseline;
442
443 switch ( data->wpd_IconTextMode )
444 {
445 case ICON_TEXTMODE_DROPSHADOW:
446 case ICON_TEXTMODE_PLAIN:
447 SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
448 Move(rp, tx, ty);
449 Text(rp, buf, nameLength);
450 break;
451
452 default:
453 // Outline mode:
454
455 SetSoftStyle(rp, FSF_BOLD, FSF_BOLD);
456 SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
457
458 Move(rp, tx + 1, ty ); Text(rp, buf, nameLength);
459 Move(rp, tx - 1, ty ); Text(rp, buf, nameLength);
460 Move(rp, tx, ty + 1); Text(rp, buf, nameLength);
461 Move(rp, tx, ty - 1); Text(rp, buf, nameLength);
462
463 SetAPen(rp, _pens(obj)[MPEN_SHINE]);
464 Move(rp, tx, ty);
465 Text(rp, buf, nameLength);
466 SetSoftStyle(rp, FS_NORMAL, AskSoftStyle(rp));
467 break;
468 }
469
470 /*date/size sorting has the date/size appended under the icon label*/
471
472 if( icon->entry.type != WBDRAWER && ((data->sort_bits & ICONLIST_SORT_BY_SIZE) || (data->sort_bits & ICONLIST_SORT_BY_DATE)) )
473 {
474 if( (data->sort_bits & ICONLIST_SORT_BY_SIZE) && !(data->sort_bits & ICONLIST_SORT_BY_DATE) )
475 {
476 int i = icon->fib.fib_Size;
477
478 /*show byte size for small files*/
479 if( i > 9999 )
480 sprintf( buf , "%ld KB" , (LONG)(i/1024) );
481 else
482 sprintf( buf , "%ld B" , (LONG)i );
483 }
484 else
485 {
486 if( !(data->sort_bits & ICONLIST_SORT_BY_SIZE) && (data->sort_bits & ICONLIST_SORT_BY_DATE) )
487 {
488 struct DateStamp now;
489 DateStamp(&now);
490
491 /*if modified today show time, otherwise just show date*/
492 if( now.ds_Days == icon->fib.fib_Date.ds_Days )
493 sprintf( buf , "%s" ,icon->timebuf );
494 else
495 sprintf( buf , "%s" ,icon->datebuf );
496 }
497 }
498
499 nameLength = strlen(buf);
500
501 ULONG textwidth = TextLength(rp, buf, nameLength);
502 tx = iconrect.MinX + ((iconrect.MaxX - iconrect.MinX + 1 - textwidth)/2);
503 ty = iconY + icon->height + data->IconFont->tf_YSize + ICONLIST_TEXTMARGIN + data->IconFont->tf_Baseline;
504
505 switch ( data->wpd_IconTextMode )
506 {
507 case ICON_TEXTMODE_DROPSHADOW:
508 case ICON_TEXTMODE_PLAIN:
509 SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
510 Move(rp, tx, ty); Text(rp, buf, nameLength);
511 break;
512
513 default:
514 // Outline mode..
515 SetSoftStyle(rp, FSF_BOLD, FSF_BOLD);
516 SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
517
518 Move(rp, tx + 1, ty ); Text(rp, buf, nameLength);
519 Move(rp, tx - 1, ty ); Text(rp, buf, nameLength);
520 Move(rp, tx, ty + 1); Text(rp, buf, nameLength);
521 Move(rp, tx, ty - 1); Text(rp, buf, nameLength);
522
523 SetAPen(rp, _pens(obj)[MPEN_SHINE]);
524 Move(rp, tx, ty);
525 Text(rp, buf, nameLength);
526 SetSoftStyle(rp, FS_NORMAL, AskSoftStyle(rp));
527 break;
528 }
529 }
530 }
531 // Free up icontext memory
532
533 FreeVec ( buf );
534
535 return TRUE;
536 }
537
538 /**************************************************************************
539
540 **************************************************************************/
541 static void IconList_RethinkDimensions(Object *obj, struct MUI_IconData *data, struct IconEntry *singleicon)
542 {
543 struct IconEntry *icon;
544 WORD maxx = data->width - 1, maxy = data->height - 1;
545
546 if (!(_flags(obj)&MADF_SETUP)) return;
547
548 icon = singleicon ? singleicon : List_First(&data->icon_list);
549
550 while (icon)
551 {
552 if (icon->dob && icon->x != NO_ICON_POSITION && icon->y != NO_ICON_POSITION)
553 {
554 struct Rectangle icon_rect;
555
556 IconList_GetIconRectangle(obj, data, icon, &icon_rect);
557
558 icon_rect.MinX += icon->x;
559 icon_rect.MaxX += icon->x;
560 icon_rect.MinY += icon->y;
561 icon_rect.MaxY += icon->y;
562
563 if (icon_rect.MaxX > maxx) maxx = icon_rect.MaxX;
564 if (icon_rect.MaxY > maxy) maxy = icon_rect.MaxY;
565
566 }
567
568 if (singleicon) break;
569
570 icon = Node_Next(icon);
571 }
572
573 /* update our view when max x/y have changed */
574 if (maxx + 1 != data->width)
575 {
576 data->width = maxx + 1;
577 set(obj, MUIA_IconList_Width, data->width);
578 }
579 if (maxy + 1 != data->height)
580 {
581 data->height = maxy + 1;
582 set(obj, MUIA_IconList_Height, data->height);
583 }
584
585 }
586
587 /**************************************************************************
588 Checks weather we can place a icon with the given dimesions at the
589 suggested positions.
590
591 atx and aty are absolute positions
592 **************************************************************************/
593 /*
594 static int IconList_CouldPlaceIcon(Object *obj, struct MUI_IconData *data, struct IconEntry *toplace, int atx, int aty)
595 {
596 struct IconEntry *icon;
597 struct Rectangle toplace_rect;
598
599 IconList_GetIconRectangle(obj, toplace, &toplace_rect);
600 toplace_rect.MinX += atx;
601 toplace_rect.MaxX += atx;
602 toplace_rect.MinY += aty;
603 toplace_rect.MaxY += aty;
604
605 icon = List_First(&data->icon_list);
606 while (icon)
607 {
608 if (icon->dob && icon->x != NO_ICON_POSITION && icon->y != NO_ICON_POSITION)
609 {
610 struct Rectangle icon_rect;
611 IconList_GetIconRectangle(obj, icon, &icon_rect);
612 icon_rect.MinX += icon->x;
613 icon_rect.MaxX += icon->x;
614 icon_rect.MinY += icon->y;
615 icon_rect.MaxY += icon->y;
616
617 if (RectAndRect(&icon_rect, &toplace_rect))
618 return FALSE; *//* There is already an icon on this place *//*
619 }
620 icon = Node_Next(icon);
621 }
622 return 1;
623 }
624 */
625
626 /**************************************************************************
627 Place the icon at atx and aty.
628
629 atx and aty are absolute positions
630 **************************************************************************/
631 /*
632 static void IconList_PlaceIcon(Object *obj, struct MUI_IconData *data, struct IconEntry *toplace, int atx, int aty)
633 {
634 #if 0
635 struct Rectangle toplace_rect;
636
637 IconList_GetIconRectangle(obj, toplace, &toplace_rect);
638 toplace_rect.MinX += atx + data->view_x;
639 toplace_rect.MaxX += atx + data->view_x;
640 toplace_rect.MinY += aty + data->view_y;
641 toplace_rect.MaxY += aty + data->view_y;
642 #endif
643 toplace->x = atx;
644 toplace->y = aty;
645 #if 0
646 *//* update our view *//*
647 if (toplace_rect.MaxX - data->view_x > data->width)
648 {
649 data->width = toplace_rect.MaxX - data->view_x;
650 set(obj, MUIA_IconList_Width, data->width);
651 }
652
653 if (toplace_rect.MaxY - data->view_y > data->height)
654 {
655 data->height = toplace_rect.MaxY - data->view_y;
656 set(obj, MUIA_IconList_Height, data->height);
657 }
658 #endif
659 }
660 */
661 /**************************************************************************
662 MUIM_PositionIcons - Place icons with NO_ICON_POSITION coords somewhere
663 **************************************************************************/
664
665 IPTR IconList__MUIM_PositionIcons(struct IClass *cl, Object *obj, struct MUIP_IconList_PositionIcons *msg)
666 {
667 struct MUI_IconData *data = INST_DATA(cl, obj);
668 struct IconEntry *icon;
669
670 int spacing = 4;
671 int top = spacing;
672 int left = spacing;
673 int gridx = 32;
674 int gridy = 32;
675 int cur_x = spacing;
676 int cur_y = spacing;
677 int maxw = 0; // There two are the max icon width recorded in a column
678 int maxh = 0; // or the max icon height recorded in a row depending
679 int listMode = (int)data->wpd_IconListMode;
680
681 BOOL next = TRUE;
682 int maxWidth = 0, maxHeight = 0;
683 icon = List_First(&data->icon_list);
684
685 // If going by grid, first traverse and find the highest w/h
686 if ( listMode == ICON_LISTMODE_GRID )
687 {
688 while (icon != NULL)
689 {
690 struct Rectangle iconrect;
691 IconList_GetIconRectangle(obj, data, icon, &iconrect);
692 if ( icon->realWidth > maxWidth )
693 maxWidth = icon->realWidth;
694 if ( icon->realHeight > maxHeight )
695 maxHeight = icon->realHeight;
696 icon = Node_Next(icon);
697 }
698 }
699
700 // Now go to the actual positioning
701 icon = List_First(&data->icon_list);
702 while (icon != NULL)
703 {
704 if (icon->dob != NULL)
705 {
706 icon->x = cur_x;
707 icon->y = cur_y;
708
709 if ( listMode == ICON_LISTMODE_GRID )
710 {
711 gridx = maxWidth + spacing;
712 gridy = maxHeight + spacing;
713 // center icons on grid
714 icon->x += ( maxWidth - icon->realWidth ) / 2;
715 icon->y += ( maxHeight - icon->realHeight ) / 2;
716 }
717 else
718 {
719 // Update the realWidth/realHeight values every time we position an icon!
720 struct Rectangle iconrect;
721 IconList_GetIconRectangle(obj, data, icon, &iconrect);
722 gridx = icon->realWidth + spacing;
723 gridy = icon->realHeight + spacing;
724 }
725
726 if( data->sort_bits & ICONLIST_DISP_VERTICAL )
727 {
728 if ( maxw < gridx ) maxw = gridx;
729 cur_y += gridy;
730
731 if (cur_y >= data->view_height )
732 {
733 next = FALSE;
734 cur_x += maxw;
735 cur_y = top;
736 }
737 }
738 else
739 {
740 if ( maxh < gridy ) maxh = gridy;
741 cur_x += gridx;
742
743 if (cur_x >= data->view_width )
744 {
745 next = FALSE;
746 cur_x = left;
747 cur_y += maxh;
748 }
749 }
750 }
751 if ( next )
752 icon = Node_Next(icon);
753 next = TRUE;
754 }
755 IconList_RethinkDimensions(obj, data, NULL);
756 return 0;
757 }
758
759 /*static void IconList_FixNoPositionIcons(Object *obj, struct MUI_IconData *data)
760 {
761 struct IconEntry *icon;
762 int cur_x = data->view_x + 36;
763 int cur_y = data->view_y + 4;
764
765 icon = List_First(&data->icon_list);
766 while (icon)
767 {
768 if (icon->dob && icon->x == NO_ICON_POSITION && icon->y == NO_ICON_POSITION)
769 {
770 int loops = 0;
771 int cur_x_save = cur_x;
772 int cur_y_save = cur_y;
773 struct Rectangle icon_rect;
774
775 IconList_GetIconRectangle(obj, icon, &icon_rect);
776 icon_rect.MinX += cur_x - icon->width/2 + data->view_x;
777 if (icon_rect.MinX < 0)
778 cur_x -= icon_rect.MinX;
779
780 while (!IconList_CouldPlaceIcon(obj, data, icon, cur_x - icon->width/2, cur_y) && loops < 5000)
781 {
782 cur_y++;
783
784 if (cur_y + icon->height > data->view_x + data->view_height) *//* on both sides -1 *//*
785 {
786 cur_x += 72;
787 cur_y = data->view_y + 4;
788 }
789 }
790
791 IconList_PlaceIcon(obj, data, icon, cur_x - icon->width/2, cur_y);
792
793 if (icon_rect.MinX < 0)
794 {
795 cur_x = cur_x_save;
796 cur_y = cur_y_save;
797 }
798 }
799 icon = Node_Next(icon);
800 }
801
802 IconList_RethinkDimensions(obj, data, NULL);
803 }
804 */
805 /**************************************************************************
806 OM_NEW
807 **************************************************************************/
808 IPTR IconList__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
809 {
810 struct MUI_IconData *data;
811 //struct TagItem *tag, *tags;
812 struct TextFont *WindowFont = NULL;
813
814 WindowFont = (struct TextFont *) GetTagData(MUIA_Font, (IPTR) NULL, msg->ops_AttrList);
815
816 obj = (Object *)DoSuperNewTags(cl, obj, NULL,
817 MUIA_Dropable, TRUE,
818 MUIA_Font, MUIV_Font_Tiny,
819 TAG_MORE, (IPTR) msg->ops_AttrList);
820 if (!obj) return FALSE;
821
822 data = INST_DATA(cl, obj);
823 data->last_selected = NULL;
824
825 // Get some initial values
826 data->wpd_IconListMode = GetTagData(MUIA_IconList_ListMode, 0, msg->ops_AttrList);
827 data->wpd_IconTextMode = GetTagData(MUIA_IconList_TextMode, 0, msg->ops_AttrList);
828 data->wpd_IconTextMaxLen = GetTagData(MUIA_IconList_TextMaxLen, 0, msg->ops_AttrList);
829 if ( data->wpd_IconTextMaxLen <= 0 )
830 data->wpd_IconTextMaxLen = ICON_TEXTMAXLEN_DEFAULT;
831
832 data->buffered = (BOOL) GetTagData(MUIA_IconList_DoubleBuffered, 0, msg->ops_AttrList);
833
834 NewList((struct List*)&data->icon_list);
835
836 set(obj,MUIA_FillArea,FALSE);
837
838 if (WindowFont == NULL) data->IconFont = _font(obj);
839 else data->IconFont = WindowFont;
840
841 D(bug("[iconlist] Used Font = %x\n", data->IconFont));
842
843 data->pool = CreatePool(0,4096,4096);
844 if (!data->pool)
845 {
846 CoerceMethod(cl,obj,OM_DISPOSE);
847 return (IPTR)NULL;
848 }
849
850 data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY;
851 data->ehn.ehn_Priority = 0;
852 data->ehn.ehn_Flags = 0;
853 data->ehn.ehn_Object = obj;
854 data->ehn.ehn_Class = cl;
855
856 data->sort_bits = 0;
857
858 return (IPTR)obj;
859 }
860
861 /**************************************************************************
862 OM_DISPOSE
863 **************************************************************************/
864 IPTR IconList__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
865 {
866 struct MUI_IconData *data = INST_DATA(cl, obj);
867 struct IconEntry *node;
868
869 node = List_First(&data->icon_list);
870 while (node)
871 {
872 if (node->dob) FreeDiskObject(node->dob);
873 node = Node_Next(node);
874 }
875
876 if (data->pool) DeletePool(data->pool);
877
878 DoSuperMethodA(cl,obj,msg);
879 return 0;
880 }
881
882
883 /**************************************************************************
884 OM_SET
885 **************************************************************************/
886 IPTR IconList__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
887 {
888 struct MUI_IconData *data = INST_DATA(cl, obj);
889 struct TagItem *tag, *tags;
890 WORD oldleft = data->view_x, oldtop = data->view_y;
891 WORD oldwidth = data->view_width, oldheight = data->view_height;
892
893 /* parse initial taglist */
894 for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags)); )
895 {
896 switch (tag->ti_Tag)
897 {
898 case MUIA_Font:
899 data->IconFont = (struct TextFont*)tag->ti_Data;
900 break;
901
902 case MUIA_IconList_Left:
903 if (data->view_x != tag->ti_Data)
904 data->view_x = tag->ti_Data;
905 break;
906
907 case MUIA_IconList_ListMode:
908 data->wpd_IconListMode = tag->ti_Data;
909 break;
910
911 case MUIA_IconList_TextMode:
912 data->wpd_IconTextMode = tag->ti_Data;
913 break;
914
915 case MUIA_IconList_TextMaxLen:
916 data->wpd_IconTextMaxLen = tag->ti_Data;
917 break;
918
919 case MUIA_IconList_Top:
920 if (data->view_y != tag->ti_Data)
921 data->view_y = tag->ti_Data;
922 break;
923 }
924 }
925
926 if ((oldleft != data->view_x) || (oldtop != data->view_y))
927 {
928 data->update = UPDATE_SCROLL;
929 data->update_scrolldx = data->view_x - oldleft;
930 data->update_scrolldy = data->view_y - oldtop;
931 MUI_Redraw(obj, MADF_DRAWUPDATE);
932 }
933
934 return DoSuperMethodA(cl, obj, (Msg)msg);
935 }
936
937 /**************************************************************************
938 OM_GET
939 **************************************************************************/
940 IPTR IconList__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
941 {
942 /* small macro to simplify return value storage */
943 #define STORE *(msg->opg_Storage)
944 struct MUI_IconData *data = INST_DATA(cl, obj);
945
946 switch (msg->opg_AttrID)
947 {
948 case MUIA_IconList_Left: STORE = data->view_x; return 1;
949 case MUIA_IconList_Top: STORE = data->view_y; return 1;
950 case MUIA_IconList_Width: STORE = data->width; return 1;
951 case MUIA_IconList_Height: STORE = data->height; return 1;
952 case MUIA_IconList_IconsDropped: STORE = (IPTR)&data->drop_entry; return 1;
953 case MUIA_IconList_Clicked: STORE = (ULONG)&data->icon_click; return 1;
954 case MUIA_IconList_ListMode: STORE = (ULONG)&data->wpd_IconListMode; return 1;
955 case MUIA_IconList_TextMode: STORE = (ULONG)&data->wpd_IconTextMode; return 1;
956 case MUIA_IconList_TextMaxLen: STORE = (ULONG)&data->wpd_IconTextMaxLen; return 1;
957 }
958
959 if (DoSuperMethodA(cl, obj, (Msg) msg))
960 return 1;
961 return 0;
962 #undef STORE
963 }
964
965 /**************************************************************************
966 MUIM_Setup
967 **************************************************************************/
968 IPTR IconList__MUIM_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
969 {
970 struct MUI_IconData *data = INST_DATA(cl, obj);
971 struct IconEntry *node;
972
973 if (!DoSuperMethodA(cl, obj, (Msg) msg)) return 0;
974
975 DoMethod(_win(obj),MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
976
977 Object *prefs = (Object *) XGET(_app(obj), MUIA_Wanderer_Prefs);
978 data->wpd_IconListMode = XGET(prefs, MUIA_WandererPrefs_Icon_ListMode);
979 data->wpd_IconTextMode = XGET(prefs, MUIA_WandererPrefs_Icon_TextMode);
980 data->wpd_IconTextMaxLen = XGET(prefs, MUIA_WandererPrefs_Icon_TextMaxLen);
981
982 node = List_First(&data->icon_list);
983 while (node)
984 {
985 if (!node->dob)
986 {
987 node->dob = GetIconTags
988 (
989 node->entry.filename,
990 ICONGETA_FailIfUnavailable, FALSE,
991 ICONGETA_Label, (IPTR) node->entry.label,
992 TAG_DONE
993 );
994 }
995 node = Node_Next(node);
996 }
997 return 1;
998 }
999
1000 /**************************************************************************
1001 MUIM_Show
1002 **************************************************************************/
1003 IPTR IconList__MUIM_Show(struct IClass *cl, Object *obj, struct MUIP_Show *msg)
1004 {
1005 struct MUI_IconData *data = INST_DATA(cl, obj);
1006 WORD newleft, newtop;
1007 IPTR rc;
1008
1009 rc = DoSuperMethodA(cl, obj, (Msg)msg);
1010
1011 newleft = data->view_x;
1012 newtop = data->view_y;
1013
1014 if (newleft + _mwidth(obj) > data->width) newleft = data->width - _mwidth(obj);
1015 if (newleft < 0) newleft = 0;
1016
1017 if (newtop + _mheight(obj) > data->height) newtop = data->height - _mheight(obj);
1018 if (newtop < 0) newtop = 0;
1019
1020 if ((newleft != data->view_x) || (newtop != data->view_y))
1021 {
1022 SetAttrs(obj, MUIA_IconList_Left, newleft,
1023 MUIA_IconList_Top, newtop,
1024 TAG_DONE);
1025 }
1026
1027 SetFont(_rp(obj), data->IconFont);
1028 return rc;
1029 }
1030
1031
1032 /**************************************************************************
1033 MUIM_Cleanup
1034 **************************************************************************/
1035 IPTR IconList__MUIM_Cleanup(struct IClass *cl, Object *obj, struct MUIP_Cleanup *msg)
1036 {
1037 struct MUI_IconData *data = INST_DATA(cl, obj);
1038
1039 struct IconEntry *node;
1040
1041 node = List_First(&data->icon_list);
1042 while (node)
1043 {
1044 if (node->dob)
1045 {
1046 FreeDiskObject(node->dob);
1047 node->dob = NULL;
1048 }
1049 node = Node_Next(node);
1050 }
1051
1052 DoMethod(_win(obj),MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
1053 return DoSuperMethodA(cl, obj, (Msg) msg);
1054 }
1055
1056 /**************************************************************************
1057 MUIM_AskMinMax
1058 **************************************************************************/
1059 IPTR IconList__MUIM_AskMinMax(struct IClass *cl, Object *obj, struct MUIP_AskMinMax *msg)
1060 {
1061 ULONG rc = DoSuperMethodA(cl, obj, (Msg) msg);
1062
1063 msg->MinMaxInfo->MinWidth += 96;
1064 msg->MinMaxInfo->MinHeight += 64;
1065
1066 msg->MinMaxInfo->DefWidth += 200;
1067 msg->MinMaxInfo->DefHeight += 180;
1068
1069 msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
1070 msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
1071
1072 return rc;
1073 }
1074
1075 /**************************************************************************
1076 MUIM_Layout
1077 **************************************************************************/
1078 IPTR IconList__MUIM_Layout(struct IClass *cl, Object *obj,struct MUIP_Layout *msg)
1079 {
1080 struct MUI_IconData *data = INST_DATA(cl, obj);
1081 ULONG rc = DoSuperMethodA(cl,obj,(Msg)msg);
1082 data->view_width = _mwidth(obj);
1083 data->view_height = _mheight(obj);
1084 return rc;
1085 }
1086
1087 /**************************************************************************
1088 MUIM_Draw - draw the IconList
1089 **************************************************************************/
1090 IPTR IconList__MUIM_Draw(struct IClass *cl, Object *obj, struct MUIP_Draw *msg)
1091 {
1092 struct MUI_IconData *data = INST_DATA(cl, obj);
1093 APTR clip;
1094 struct IconEntry *icon;
1095 BOOL buffereddraw = FALSE;
1096 BOOL updateall = FALSE;
1097 ULONG update_oldwidth = 0, update_oldheight = 0;
1098 DoSuperMethodA(cl, obj, (Msg) msg);
1099
1100 // If window size changes, only update needed areas
1101 if (data->update_oldwidth == 0) data->update_oldwidth = data->view_width;
1102 if (data->update_oldheight == 0) data->update_oldheight = data->view_height;
1103 if (data->update_oldwidth != data->view_width || data->update_oldheight != data->view_height)
1104 {
1105 if ( data->update != UPDATE_SCROLL )
1106 {
1107 data->update = UPDATE_RESCALE;
1108 update_oldwidth = data->update_oldwidth;
1109 update_oldheight = data->update_oldheight;
1110 data->update_oldwidth = data->view_width;
1111 data->update_oldheight = data->view_height;
1112 }
1113 }
1114
1115 if (msg->flags & MADF_DRAWUPDATE || data->update == UPDATE_RESCALE)
1116 {
1117 if (data->update == UPDATE_SINGLEICON) /* draw only a single icon at update_icon */
1118 {
1119 struct Rectangle rect;
1120
1121 IconList_GetIconRectangle(obj, data, data->update_icon, &rect);
1122
1123 rect.MinX += _mleft(obj) - data->view_x + data->update_icon->x;
1124 rect.MaxX += _mleft(obj) - data->view_x + data->update_icon->x;
1125 rect.MinY += _mtop(obj) - data->view_y + data->update_icon->y;
1126 rect.MaxY += _mtop(obj) - data->view_y + data->update_icon->y;
1127
1128 clip = MUI_AddClipping(muiRenderInfo(obj), _mleft(obj), _mtop(obj), _mwidth(obj), _mheight(obj));
1129
1130 #if 1
1131 DoMethod(
1132 obj, MUIM_DrawBackground,
1133 rect.MinX, rect.MinY,
1134 rect.MaxX - rect.MinX + 1, rect.MaxY - rect.MinY + 1,
1135 data->view_x + (rect.MinX - _mleft(obj)), data->view_y + (rect.MinY - _mtop(obj)),
1136 0
1137 );
1138 #else
1139 DoMethod(obj, MUIM_DrawBackground, _mleft(obj), _mtop(obj),
1140 _mwidth(obj), _mheight(obj),
1141 data->view_x, data->view_y, 0);
1142 #endif
1143
1144 /* We could have deleted also other icons so they must be redrawn */
1145 icon = List_First(&data->icon_list);
1146 while (icon)
1147 {
1148 if (icon != data->update_icon)
1149 {
1150 struct Rectangle rect2;
1151 IconList_GetIconRectangle(obj, data, icon, &rect2);
1152
1153 rect2.MinX += _mleft(obj) - data->view_x + icon->x;
1154 rect2.MaxX += _mleft(obj) - data->view_x + icon->x;
1155 rect2.MinY += _mtop(obj) - data->view_y + icon->y;
1156 rect2.MaxY += _mtop(obj) - data->view_y + icon->y;
1157
1158 if (RectAndRect(&rect,&rect2))
1159 {
1160 // Update icon here
1161 IconList_DrawIcon(obj, data, icon, NULL, DRAWICON_DODRAW);
1162 }
1163 }
1164 icon = Node_Next(icon);
1165 }
1166
1167 IconList_DrawIcon(obj, data, data->update_icon, NULL, DRAWICON_DODRAW);
1168 data->update = 0;
1169 MUI_RemoveClipping(muiRenderInfo(obj),clip);
1170 return 0;
1171 }
1172 else if (data->update == UPDATE_SCROLL)
1173 {
1174 struct Region *region;
1175 struct Rectangle xrect, yrect;
1176 BOOL scroll_caused_damage;
1177
1178 //if (data->buffered)
1179 // updateall = TRUE;
1180
1181 scroll_caused_damage = (_rp(obj)->Layer->Flags & LAYERREFRESH) ? FALSE : TRUE;
1182
1183 data->update = 0;
1184
1185 if (!updateall)
1186 {
1187
1188 if ((abs(data->update_scrolldx) >= _mwidth(obj)) ||
1189 (abs(data->update_scrolldy) >= _mheight(obj)))
1190 {
1191 MUI_Redraw(obj, MADF_DRAWOBJECT);
1192 return 0;
1193 }
1194
1195 region = NewRegion();
1196 if (!region)
1197 {
1198 MUI_Redraw(obj, MADF_DRAWOBJECT);
1199 return 0;
1200 }
1201
1202 if (data->update_scrolldx > 0)
1203 {
1204 xrect.MinX = _mright(obj) - data->update_scrolldx;
1205 xrect.MinY = _mtop(obj);
1206 xrect.MaxX = _mright(obj);
1207 xrect.MaxY = _mbottom(obj);
1208
1209 OrRectRegion(region, &xrect);
1210
1211 data->update_rect1 = &xrect;
1212 }
1213 else if (data->update_scrolldx < 0)
1214 {
1215 xrect.MinX = _mleft(obj);
1216 xrect.MinY = _mtop(obj);
1217 xrect.MaxX = _mleft(obj) - data->update_scrolldx;
1218 xrect.MaxY = _mbottom(obj);
1219
1220 OrRectRegion(region, &xrect);
1221
1222 data->update_rect1 = &xrect;
1223 }
1224
1225 if (data->update_scrolldy > 0)
1226 {
1227 yrect.MinX = _mleft(obj);
1228 yrect.MinY = _mbottom(obj) - data->update_scrolldy;
1229 yrect.MaxX = _mright(obj);
1230 yrect.MaxY = _mbottom(obj);
1231
1232 OrRectRegion(region, &yrect);
1233
1234 data->update_rect2 = &yrect;
1235 }
1236 else if (data->update_scrolldy < 0)
1237 {
1238 yrect.MinX = _mleft(obj);
1239 yrect.MinY = _mtop(obj);
1240 yrect.MaxX = _mright(obj);
1241 yrect.MaxY = _mtop(obj) - data->update_scrolldy;
1242
1243 OrRectRegion(region, &yrect);
1244
1245 data->update_rect2 = &yrect;
1246 }
1247
1248 ScrollRasterBF(_rp(obj),
1249 data->update_scrolldx,
1250 data->update_scrolldy,
1251 _mleft(obj),
1252 _mtop(obj),
1253 _mright(obj),
1254 _mbottom(obj));
1255
1256 scroll_caused_damage = scroll_caused_damage && (_rp(obj)->Layer->Flags & LAYERREFRESH) ? TRUE : FALSE;
1257
1258 clip = MUI_AddClipRegion(muiRenderInfo(obj), region);
1259
1260 MUI_Redraw(obj, MADF_DRAWOBJECT);
1261
1262 data->update_rect1 = data->update_rect2 = NULL;
1263
1264 MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
1265
1266 if (scroll_caused_damage)
1267 {
1268 if (MUI_BeginRefresh(muiRenderInfo(obj), 0))
1269 {
1270 /* Theoretically it might happen that more damage is caused
1271 after ScrollRaster. By something else, like window movement
1272 in front of our window. Therefore refresh root object of
1273 window, not just this object */
1274
1275 Object *o = NULL;
1276
1277 get(_win(obj),MUIA_Window_RootObject, &o);
1278 MUI_Redraw(o, MADF_DRAWOBJECT);
1279
1280 MUI_EndRefresh(muiRenderInfo(obj), 0);
1281 }
1282 }
1283
1284 return 0;
1285 }
1286 }
1287 else if (data->update == UPDATE_RESCALE)
1288 {
1289 struct Region *region;
1290 struct Rectangle wrect, hrect;
1291 ULONG diffw = 0, diffh = 0;
1292
1293 if (data->buffered)
1294 updateall = TRUE;
1295
1296 data->update = 0;
1297
1298 if (!updateall)
1299 {
1300 if (!(region = NewRegion()))
1301 {
1302 MUI_Redraw(obj, MADF_DRAWOBJECT);
1303 return 0;
1304 }
1305
1306 if ( data->view_width > update_oldwidth )
1307 diffw = data->view_width - update_oldwidth;
1308 if ( data->view_height > update_oldheight )
1309 diffh = data->view_height - update_oldheight;
1310
1311 if (diffw)
1312 {
1313 wrect.MinX = _mright(obj) - diffw;
1314 wrect.MinY = _mtop(obj);
1315 wrect.MaxX = _mright(obj);
1316 wrect.MaxY = _mbottom(obj);
1317 OrRectRegion(region, &wrect);
1318 data->update_rect1 = &wrect;
1319 }
1320
1321 if (diffh)
1322 {
1323 hrect.MinX = _mleft(obj);
1324 hrect.MinY = _mbottom(obj) - diffh;
1325 hrect.MaxX = _mright(obj);
1326 hrect.MaxY = _mbottom(obj);
1327 OrRectRegion(region, &hrect);
1328 data->update_rect2 = &hrect;
1329 }
1330
1331 if (diffh||diffw)
1332 {
1333 clip = MUI_AddClipRegion(muiRenderInfo(obj), region);
1334 MUI_Redraw(obj, MADF_DRAWOBJECT);
1335 data->update_rect1 = data->update_rect2 = NULL;
1336 MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
1337 } else DisposeRegion(region);
1338
1339 return 0;
1340 }
1341 }
1342
1343 }
1344 else updateall = TRUE;
1345
1346 if (updateall)
1347 {
1348 struct Region *reg = NULL;
1349
1350 if (data->buffered) reg = NewRegion();
1351
1352 if (reg)
1353 {
1354 struct Rectangle rect = {_mleft(obj), _mtop(obj), _mright(obj), _mbottom(obj)};
1355 if (OrRectRegion(reg, &rect))
1356 {
1357 BOOL ok = TRUE;
1358 icon = List_First(&data->icon_list);
1359 while (icon && ok)
1360 {
1361 if (icon->dob && icon->x != NO_ICON_POSITION && icon->y != NO_ICON_POSITION)
1362 {
1363 struct Rectangle iconrect;
1364
1365 /* Get the dimensions and affected area of icon */
1366 IconList_GetIconRectangle(obj, data, icon, &iconrect);
1367
1368 /* Add the relative position offset of the icon */
1369 iconrect.MinX += _mleft(obj) - data->view_x + icon->x;
1370 iconrect.MaxX += _mleft(obj) - data->view_x + icon->x;
1371 iconrect.MinY += _mtop(obj) - data->view_y + icon->y;
1372 iconrect.MaxY += _mtop(obj) - data->view_y + icon->y;
1373
1374 if(ClearRectRegion(reg, &iconrect)==0) ok = FALSE;
1375 }
1376 icon = Node_Next(icon);
1377 }
1378 if (!ok)
1379 {
1380 DisposeRegion(reg);
1381 reg = NULL;
1382 }
1383 }
1384 else
1385 {
1386 DisposeRegion(reg);
1387 reg = NULL;
1388 }
1389 }
1390
1391 if (reg)
1392 {
1393 buffereddraw = TRUE;
1394 clip = MUI_AddClipRegion(muiRenderInfo(obj), reg);
1395 }
1396
1397 DoMethod(
1398 obj, MUIM_DrawBackground, _mleft(obj), _mtop(obj), _mwidth(obj), _mheight(obj),
1399 data->view_x, data->view_y, 0
1400 );
1401
1402 if (reg) MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
1403 }
1404
1405
1406 /* At we see if there any Icons without proper position, this is the wrong place here,
1407 * it should be done after all icons have been loaded */
1408
1409 /*ric - no need!: IconList_FixNoPositionIcons(obj, data);*/
1410
1411 clip = MUI_AddClipping(muiRenderInfo(obj), _mleft(obj), _mtop(obj), _mwidth(obj), _mheight(obj));
1412
1413 icon = List_First(&data->icon_list);
1414 while (icon)
1415 {
1416 if (icon->dob && icon->x != NO_ICON_POSITION && icon->y != NO_ICON_POSITION)
1417 {
1418 if (buffereddraw && IconList_DrawIcon(obj, data, icon, NULL, DRAWICON_TESTDRAW))
1419 {
1420 struct Rectangle ir;
1421
1422 /* Get the dimensions and affected area of icon */
1423 IconList_GetIconRectangle(obj, data, icon, &ir);
1424
1425 /* Add the relative position offset of the icon */
1426
1427 ir.MinX += _mleft(obj) - data->view_x + icon->x;
1428 ir.MaxX += _mleft(obj) - data->view_x + icon->x;
1429 ir.MinY += _mtop(obj) - data->view_y + icon->y;
1430 ir.MaxY += _mtop(obj) - data->view_y + icon->y;
1431
1432 struct RastPort *mrp = CreateRastPort();
1433 if (mrp)
1434 {
1435 mrp->BitMap = AllocBitMap(ir.MaxX-ir.MinX+1, ir.MaxY-ir.MinY+1, 1, BMF_INTERLEAVED|BMF_MINPLANES, _rp(obj)->BitMap);
1436 if (mrp->BitMap)
1437 {
1438 DoMethod(
1439 obj, MUIM_DrawBackgroundBuffered, mrp,
1440 ir.MinX, ir.MinY,
1441 ir.MaxX - ir.MinX + 1, ir.MaxY - ir.MinY + 1,
1442 data->view_x + (ir.MinX - _mleft(obj)), data->view_y + (ir.MinY - _mtop(obj)),
1443 0
1444 );
1445 }
1446 else
1447 {
1448 FreeRastPort(mrp);
1449 mrp = NULL;
1450 }
1451 }
1452 if (mrp)
1453 {
1454 struct Rectangle clip;
1455
1456 clip.MinX = 0;
1457 clip.MinY = 0;
1458 clip.MaxX = ir.MaxX-ir.MinX;
1459 clip.MaxY = ir.MaxY-ir.MinY;
1460
1461 SetRPAttrs(mrp, RPTAG_ClipRectangle, (IPTR)&clip, RPTAG_ClipRectangleFlags, 0, TAG_DONE);
1462
1463 IconList_DrawIcon(obj, data, icon, mrp, DRAWICON_DODRAW);
1464 BltBitMapRastPort(mrp->BitMap, 0, 0, _rp(obj), ir.MinX, ir.MinY, ir.MaxX-ir.MinX+1, ir.MaxY-ir.MinY+1, 0xc0);
1465 FreeBitMap(mrp->BitMap);
1466 FreeRastPort(mrp);
1467
1468 }
1469 else
1470 {
1471 DoMethod(
1472 obj, MUIM_DrawBackground,
1473 ir.MinX, ir.MinY,
1474 ir.MaxX - ir.MinX + 1, ir.MaxY - ir.MinY + 1,
1475 data->view_x + (ir.MinX - _mleft(obj)), data->view_y + (ir.MinY - _mtop(obj)),
1476 0
1477 );
1478 IconList_DrawIcon(obj, data, icon, NULL, DRAWICON_DODRAW);
1479 }
1480 } else IconList_DrawIcon(obj, data, icon, NULL, DRAWICON_DODRAW);
1481
1482 }
1483 icon = Node_Next(icon);
1484 }
1485
1486 MUI_RemoveClipping(muiRenderInfo(obj),clip);
1487
1488 data->update = 0;
1489
1490 return 0;
1491 }
1492
1493 /**************************************************************************
1494 MUIM_IconList_Refresh
1495 Implemented by subclasses
1496 **************************************************************************/
1497 IPTR IconList__MUIM_Update(struct IClass *cl, Object *obj, struct MUIP_IconList_Update *msg)
1498 {
1499 return 1;
1500 }
1501
1502 /**************************************************************************
1503 MUIM_IconList_Clear
1504 **************************************************************************/
1505 IPTR IconList__MUIM_Clear(struct IClass *cl, Object *obj, struct MUIP_IconList_Clear *msg)
1506 {
1507 struct MUI_IconData *data = INST_DATA(cl, obj);
1508 struct IconEntry *node;
1509
1510 while ((node = (struct IconEntry*)RemTail((struct List*)&data->icon_list)))
1511 {
1512 if (node->dob) FreeDiskObject(node->dob);
1513 if (node->entry.label) FreePooled(data->pool,node->entry.label,strlen(node->entry.label)+1);
1514 if (node->entry.filename) FreePooled(data->pool,node->entry.filename,strlen(node->entry.filename)+1);
1515 FreePooled(data->pool,node,sizeof(struct IconEntry));
1516 }
1517
1518 data->first_selected = NULL;
1519 data->view_x = data->view_y = data->width = data->height = 0;
1520 /*data->sort_bits = 0;*/
1521
1522 data->max_x = data->max_y = 32; /*default icon size*/
1523
1524 SetAttrs(obj, MUIA_IconList_Left, data->view_x,
1525 MUIA_IconList_Top, data->view_y,
1526 MUIA_IconList_Width, data->width,
1527 MUIA_IconList_Height, data->height,
1528 TAG_DONE);
1529
1530 MUI_Redraw(obj,MADF_DRAWOBJECT);
1531 return 1;
1532 }
1533
1534 /**************************************************************************
1535 MUIM_IconList_Add.
1536 Returns 0 on failure otherwise 1
1537 **************************************************************************/
1538 IPTR IconList__MUIM_Add(struct IClass *cl, Object *obj, struct MUIP_IconList_Add *msg)
1539 {
1540 struct MUI_IconData *data = INST_DATA(cl, obj);
1541 struct IconEntry *entry;
1542 struct DateTime dt;
1543 UBYTE *sp;
1544
1545 struct DiskObject *dob;
1546 struct Rectangle rect;
1547
1548 /*disk object (icon)*/
1549 dob = GetIconTags
1550 (
1551 msg->filename,
1552 ICONGETA_FailIfUnavailable, FALSE,
1553 ICONGETA_Label, (IPTR) msg->label,
1554 TAG_DONE
1555 );
1556
1557 if (!dob) return 0;
1558
1559 if (!(entry = AllocPooled(data->pool,sizeof(struct IconEntry))))
1560 {
1561 FreeDiskObject(dob);
1562 return 0;
1563 }
1564
1565 memset(entry,0,sizeof(struct IconEntry));
1566
1567 /*alloc filename*/
1568 if (!(entry->entry.filename = AllocPooled(data->pool,strlen(msg->filename)+1)))
1569 {
1570 FreePooled(data->pool,entry,sizeof(struct IconEntry));
1571 FreeDiskObject(dob);
1572 return 0;
1573 }
1574
1575 /*alloc icon label*/
1576 if (!(entry->entry.label = AllocPooled(data->pool,strlen(msg->label)+1)))
1577 {
1578 FreePooled(data->pool,entry->entry.filename,strlen(entry->entry.filename)+1);
1579 FreePooled(data->pool,entry,sizeof(struct IconEntry));
1580 FreeDiskObject(dob);
1581 return 0;
1582 }
1583
1584 /*file info block*/
1585 if( msg->fib )
1586 {
1587 entry->fib = *msg->fib;
1588
1589 if (entry->fib.fib_DirEntryType > 0)
1590 {
1591 strcpy(entry->sizebuf, "Drawer");
1592 }
1593 else
1594 {
1595 sprintf(entry->sizebuf, "%ld", entry->fib.fib_Size);
1596 }
1597
1598 dt.dat_Stamp = entry->fib.fib_Date;
1599 dt.dat_Format = FORMAT_DEF;
1600 dt.dat_Flags = 0;
1601 dt.dat_StrDay = NULL;
1602 dt.dat_StrDate = entry->datebuf;
1603 dt.dat_StrTime = entry->timebuf;
1604
1605 DateToStr(&dt);
1606
1607 sp = entry->protbuf;
1608 *sp++ = (entry->fib.fib_Protection & FIBF_SCRIPT) ? 's' : '-';
1609 *sp++ = (entry->fib.fib_Protection & FIBF_PURE) ? 'p' : '-';
1610 *sp++ = (entry->fib.fib_Protection & FIBF_ARCHIVE) ? 'a' : '-';
1611 *sp++ = (entry->fib.fib_Protection & FIBF_READ) ? '-' : 'r';
1612 *sp++ = (entry->fib.fib_Protection & FIBF_WRITE) ? '-' : 'w';
1613 *sp++ = (entry->fib.fib_Protection & FIBF_EXECUTE) ? '-' : 'e';
1614 *sp++ = (entry->fib.fib_Protection & FIBF_DELETE) ? '-' : 'd';
1615 *sp++ = '\0';
1616
1617 entry->entry.type = entry->fib.fib_DirEntryType;
1618
1619 }
1620 else
1621 {
1622 entry->entry.type = ST_USERDIR;
1623 }
1624
1625 strcpy(entry->entry.filename,msg->filename);
1626 strcpy(entry->entry.label,msg->label);
1627
1628 entry->dob = dob;
1629 entry->entry.udata = NULL;
1630 entry->x = dob->do_CurrentX;
1631 entry->y = dob->do_CurrentY;
1632
1633 /* Use a geticonrectanble routine that gets textwidth! */
1634 IconList_GetIconRectangle(obj, data, entry, &rect);
1635
1636
1637 entry->width = rect.MaxX - rect.MinX + 1;
1638 entry->height = rect.MaxY - rect.MinY + 1;
1639
1640 /*D(bug("add %s %i\n" , entry->entry.label , (entry->entry.type & 255) ));*/
1641
1642 /*hack, force grid to recognise largest icon!*/
1643 if( entry->width > data->max_x ) data->max_x = entry->width;
1644 if( entry->height > data->max_y ) data->max_y = entry->height;
1645
1646 AddHead((struct List*)&data->icon_list,(struct Node*)entry);
1647
1648 return 1;
1649 }
1650 /*
1651 fib_DirEntryType,ST_USERDIR; LONG type
1652 */
1653
1654 static void DoWheelMove(struct IClass *cl, Object *obj, LONG wheelx, LONG wheely,
1655 UWORD qual)
1656 {
1657 struct MUI_IconData *data = INST_DATA(cl, obj);
1658
1659 WORD newleft = data->view_x;
1660 WORD newtop = data->view_y;
1661
1662 /* If vertical wheel is used but there's nothing to scroll
1663 vertically (everything visible already), scroll horizontally. */
1664
1665 if (wheely && !wheelx && data->height <= _mheight(obj))
1666 {
1667 wheelx = wheely; wheely = 0;
1668 }
1669
1670 /* If vertical wheel is used and one of the ALT keys is down,
1671 scroll horizontally */
1672
1673 if (wheely && !wheelx && (qual & (IEQUALIFIER_LALT | IEQUALIFIER_RALT)))
1674 {
1675 wheelx = wheely; wheely = 0;
1676 }
1677
1678 if (qual & (IEQUALIFIER_CONTROL))
1679 {
1680 if (wheelx < 0) newleft = 0;
1681 if (wheelx > 0) newleft = data->width;
1682 if (wheely < 0) newtop = 0;
1683 if (wheely > 0) newtop = data->height;
1684 }
1685 else if (qual & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
1686 {
1687 newleft += (wheelx * _mwidth(obj));
1688 newtop += (wheely * _mheight(obj));
1689 }
1690 else
1691 {
1692 newleft += wheelx * 30;
1693 newtop += wheely * 30;
1694 }
1695
1696 if (newleft + _mwidth(obj) > data->width) newleft = data->width - _mwidth(obj);
1697 if (newleft < 0) newleft = 0;
1698
1699 if (newtop + _mheight(obj) > data->height) newtop = data->height - _mheight(obj);
1700 if (newtop < 0) newtop = 0;
1701
1702 if ((newleft != data->view_x) || (newtop != data->view_y))
1703 {
1704 SetAttrs(obj, MUIA_IconList_Left, newleft,
1705 MUIA_IconList_Top, newtop,
1706 TAG_DONE);
1707 }
1708
1709 }
1710
1711 /**************************************************************************
1712 MUIM_HandleEvent
1713 **************************************************************************/
1714 IPTR IconList__MUIM_HandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
1715 {
1716 struct MUI_IconData *data = INST_DATA(cl, obj);
1717
1718 if (msg->imsg)
1719 {
1720 LONG mx = msg->imsg->MouseX - _mleft(obj);
1721 LONG my = msg->imsg->MouseY - _mtop(obj);
1722 LONG wheelx = 0;
1723 LONG wheely = 0;
1724
1725 switch (msg->imsg->Class)
1726 {
1727 case IDCMP_RAWKEY:
1728 {
1729 switch(msg->imsg->Code)
1730 {
1731 case RAWKEY_NM_WHEEL_UP:
1732 wheely = -1;
1733 break;
1734
1735 case RAWKEY_NM_WHEEL_DOWN:
1736 wheely = 1;
1737 break;
1738
1739 case RAWKEY_NM_WHEEL_LEFT:
1740 wheelx = -1;
1741 break;
1742
1743 case RAWKEY_NM_WHEEL_RIGHT:
1744 wheelx = 1;
1745 break;
1746 }
1747 }
1748
1749 if (_isinobject(msg->imsg->MouseX, msg->imsg->MouseY) &&
1750 (wheelx || wheely))
1751 {
1752 DoWheelMove(cl, obj, wheelx, wheely, msg->imsg->Qualifier);
1753 }
1754 break;
1755
1756 case IDCMP_MOUSEBUTTONS:
1757
1758 if (msg->imsg->Code == SELECTDOWN)
1759 {
1760 /* check if mouse pressed on iconlist area */
1761 if (mx >= 0 && mx < _width(obj) && my >= 0 && my < _height(obj))
1762 {
1763 struct IconEntry *node;
1764 struct IconEntry *new_selected = NULL;
1765
1766 int selections = 0;
1767
1768 data->first_selected = NULL;
1769
1770 /* check if clicked on icon */
1771 node = List_First(&data->icon_list);
1772 while (node)
1773 {
1774 /* count all OLD selections */
1775 if (node->selected) selections++;
1776
1777 if (mx >= node->x - data->view_x && mx < node->x - data->view_x + node->realWidth &&
1778 my >= node->y - data->view_y && my < node->y - data->view_y + node->realHeight && !new_selected)
1779 {
1780 new_selected = node;
1781
1782 if (!node->selected)
1783 {
1784 node->selected = 1;
1785 data->update = UPDATE_SINGLEICON;
1786 data->update_icon = node;
1787 MUI_Redraw(obj,MADF_DRAWUPDATE);
1788 }
1789
1790 data->first_selected = node;
1791 }
1792
1793 node = Node_Next(node);
1794 }
1795
1796
1797 /* if not cliked on icon set lasso as active */
1798 if (!new_selected)
1799 {
1800 data->lasso_active = TRUE;
1801 data->lasso_rect.MinX = mx - data->view_rect.MinX + data->view_x;
1802 data->lasso_rect.MinY = my - data->view_rect.MinY + data->view_y;
1803 data->lasso_rect.MaxX = mx - data->view_rect.MinX + data->view_x;
1804 data->lasso_rect.MaxY = my - data->view_rect.MinY + data->view_y;
1805
1806 /* deselect old selection */
1807 DoMethod(obj,MUIM_IconList_UnselectAll);
1808
1809 /* draw initial lasso */
1810 InvertLassoOutlines(obj, &data->lasso_rect);
1811
1812 }
1813 else
1814 {
1815 data->lasso_active = FALSE;
1816
1817 /* remove last single selection if clicked on different file*/
1818 if (data->last_selected && new_selected != data->last_selected && selections < 2)
1819 {
1820 data->last_selected->selected = 0;
1821 data->update = UPDATE_SINGLEICON;
1822 data->update_icon = data->last_selected;
1823 MUI_Redraw(obj,MADF_DRAWUPDATE);
1824 }
1825 }
1826
1827 data->icon_click.shift = !!(msg->imsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT));
1828 data->icon_click.entry = new_selected?&new_selected->entry:NULL;
1829 set(obj,MUIA_IconList_Clicked,(IPTR)&data->icon_click);
1830
1831 if (DoubleClick(data->last_secs, data->last_mics, msg->imsg->Seconds, msg->imsg->Micros) && data->last_selected == new_selected)
1832 {
1833 set(obj,MUIA_IconList_DoubleClick, TRUE);
1834 data->last_selected = NULL;
1835 }
1836 else if (!data->mouse_pressed)
1837 {
1838 data->last_selected = new_selected;
1839 data->last_secs = msg->imsg->Seconds;
1840 data->last_mics = msg->imsg->Micros;
1841
1842 /* After a double click you often open a new window
1843 * and since Zune doesn't not support the faking
1844 * of SELECTUP events only change the Events
1845 * if not doubleclicked */
1846
1847 data->mouse_pressed |= LEFT_BUTTON;
1848
1849 if (!(data->ehn.ehn_Events & IDCMP_MOUSEMOVE))
1850 {
1851 DoMethod(_win(obj),MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
1852 data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
1853 DoMethod(_win(obj),MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
1854 }
1855 }
1856
1857 data->click_x = mx;
1858 data->click_y = my;
1859
1860 return 0;
1861 }
1862 }
1863 else if (msg->imsg->Code == MIDDLEDOWN)
1864 {
1865 if (!data->mouse_pressed)
1866 {
1867 data->mouse_pressed |= MIDDLE_BUTTON;
1868
1869 data->click_x = data->view_x + mx;
1870 data->click_y = data->view_y + my;
1871
1872 if (!(data->ehn.ehn_Events & IDCMP_MOUSEMOVE))
1873 {
1874 DoMethod(_win(obj),MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
1875 data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
1876 DoMethod(_win(obj),MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
1877 }
1878 }
1879 }
1880 else
1881 {
1882 if (msg->imsg->Code == SELECTUP)
1883 {
1884
1885 /* check if mose released on iconlist aswell */
1886 if (mx >= 0 && mx < _width(obj) && my >= 0 && my < _height(obj) && data->lasso_active == FALSE)
1887 {
1888 struct IconEntry *node;
1889 struct IconEntry *new_selected = NULL;
1890
1891 data->first_selected = NULL;
1892
1893 node = List_First(&data->icon_list);
1894 while (node)
1895 {
1896
1897 /* unselect all other nodes if mouse released on icon and lasso was not selected during mouse press */
1898 if ( ( node->selected && data->lasso_active == FALSE) &&
1899 ( mx < node->x - data->view_x || mx > node->x - data->view_x + node->realWidth ||
1900 my < node->y - data->view_y || my > node->y - data->view_y + node->realHeight ) )
1901
1902 {
1903 node->selected = 0;
1904 data->update = UPDATE_SINGLEICON;
1905 data->update_icon = node;
1906 MUI_Redraw(obj,MADF_DRAWUPDATE);
1907 }
1908
1909 node = Node_Next(node);
1910 }
1911
1912 }
1913
1914 /* stop lasso selection/drawing now */
1915 if (data->lasso_active == TRUE)
1916 {
1917 /* make lasso disappear again */
1918 struct Rectangle old_lasso;
1919 GetAbsoluteLassoRect(data, &old_lasso);
1920 InvertLassoOutlines(obj, &old_lasso);
1921
1922 data->lasso_active = FALSE;
1923 }
1924
1925 data->mouse_pressed &= ~LEFT_BUTTON;
1926 }
1927
1928 if (msg->imsg->Code == MIDDLEUP)
1929 {
1930 data->mouse_pressed &= ~MIDDLE_BUTTON;
1931 }
1932
1933 if ((data->ehn.ehn_Events & IDCMP_MOUSEMOVE) && !data->mouse_pressed)
1934 {
1935 DoMethod(_win(obj),MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
1936 data->ehn.ehn_Events &= ~IDCMP_MOUSEMOVE;
1937 DoMethod(_win(obj),MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
1938 }
1939 }
1940 break;
1941
1942 case IDCMP_MOUSEMOVE:
1943
1944 if (data->mouse_pressed & LEFT_BUTTON)
1945 {
1946 int move_x = mx;
1947 int move_y = my;
1948
1949 /* check if clicked on icon, or update lasso coords if lasso activated */
1950 if (
1951 data->first_selected && data->lasso_active == FALSE &&
1952 (abs(move_x - data->click_x) >= 2 || abs(move_y - data->click_y) >= 2)
1953 )
1954 {
1955 DoMethod(_win(obj),MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
1956 data->ehn.ehn_Events &= ~IDCMP_MOUSEMOVE;
1957 DoMethod(_win(obj),MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
1958
1959 data->mouse_pressed &= ~LEFT_BUTTON;
1960
1961 data->touch_x = move_x + data->view_x - data->first_selected->x;
1962 data->touch_y = move_y + data->view_y - data->first_selected->y;
1963 DoMethod(obj,MUIM_DoDrag, data->touch_x, data->touch_y, 0);
1964 }
1965 else if (data->lasso_active == TRUE) /* if no icon selected start lasso */
1966 {
1967 struct Rectangle new_lasso, old_lasso;
1968 struct IconEntry *node;
1969 struct IconEntry *new_selected = NULL;
1970
1971 /* unmark old lasso area */
1972 GetAbsoluteLassoRect(data, &old_lasso);
1973 InvertLassoOutlines(obj, &old_lasso);
1974
1975 /* if mouse leaves iconlist area during lasso mode, scroll view */
1976 if (mx < 0 || mx > _width(obj) || my < 0 || my > _height(obj))
1977 {
1978 WORD newleft = data->view_x;
1979 WORD newtop = data->view_y;
1980
1981 if (data->click_x < mx) newleft += 5;
1982 else newleft -= 5;
1983 if (data->click_y < my) newtop += 5;
1984 else newtop -= 5;
1985
1986 if (newleft + _mwidth(obj) > data->width) newleft = data->width - _mwidth(obj);
1987 if (newleft < 0) newleft = 0;
1988
1989 if (newtop + _mheight(obj) > data->height) newtop = data->height - _mheight(obj);
1990 if (newtop < 0) newtop = 0;
1991
1992 if ((newleft != data->view_x) || (newtop != data->view_y))
1993 {
1994 SetAttrs(obj, MUIA_IconList_Left, newleft, MUIA_IconList_Top, newtop, TAG_DONE);
1995 }
1996
1997 }
1998
1999 /* update lasso coordinates */
2000 data->lasso_rect.MaxX = mx - data->view_rect.MinX + data->view_x;
2001 data->lasso_rect.MaxY = my - data->view_rect.MinY + data->view_y;
2002
2003 /* get absolute lasso coordinates */
2004 GetAbsoluteLassoRect(data, &new_lasso);
2005
2006 data->first_selected = NULL;
2007
2008 node = List_First(&data->icon_list);
2009 while (node)
2010 {
2011
2012 /* check if clicked on icon */
2013 if (new_lasso.MaxX >= node->x - data->view_x
2014 && new_lasso.MinX < node->x - data->view_x + node->realWidth &&
2015 new_lasso.MaxY >= node->y - data->view_y
2016 && new_lasso.MinY < node->y - data->view_y + node->realHeight)
2017 {
2018 new_selected = node;
2019
2020 /* check if icon was already selected before */
2021 if (!node->selected)
2022 {
2023 node->selected = 1;
2024 data->update = UPDATE_SINGLEICON;
2025 data->update_icon = node;
2026 data->last_selected = node; // <- I'm the latest addition to your flock! =)
2027 MUI_Redraw(obj,MADF_DRAWUPDATE);
2028 }
2029
2030 data->first_selected = node;
2031
2032 }
2033 else
2034 {
2035 if (node->selected) /* if not catched by lasso and selected before -> unselect */
2036 {
2037 node->selected = 0;
2038 data->update = UPDATE_SINGLEICON;
2039 data->update_icon = node;
2040 MUI_Redraw(obj,MADF_DRAWUPDATE);
2041 }
2042 }
2043
2044 node = Node_Next(node);
2045 }
2046
2047 /* set lasso borders */
2048 InvertLassoOutlines(obj, &new_lasso);
2049
2050 }
2051
2052 return 0;
2053 }
2054 else if (data->mouse_pressed & MIDDLE_BUTTON)
2055 {
2056 WORD newleft, newtop;
2057
2058 newleft = data->click_x - mx;
2059 newtop = data->click_y - my;
2060
2061 if (newleft + _mwidth(obj) > data->width) newleft = data->width - _mwidth(obj);
2062 if (newleft < 0) newleft = 0;
2063
2064 if (newtop + _mheight(obj) > data->height) newtop = data->height - _mheight(obj);
2065 if (newtop < 0) newtop = 0;
2066
2067 if ((newleft != data->view_x) || (newtop != data->view_y))
2068 {
2069 SetAttrs(obj, MUIA_IconList_Left, newleft,
2070 MUIA_IconList_Top, newtop,
2071 TAG_DONE);
2072 }
2073
2074 return 0;
2075 }
2076
2077 break;
2078 }
2079 }
2080
2081 return 0;
2082 }
2083
2084 /**************************************************************************
2085 MUIM_IconList_NextSelected
2086 **************************************************************************/
2087 IPTR IconList__MUIM_NextSelected(struct IClass *cl, Object *obj, struct MUIP_IconList_NextSelected *msg)
2088 {
2089 struct MUI_IconData *data = INST_DATA(cl, obj);
2090 struct IconEntry *node;
2091 struct IconList_Entry *ent;
2092
2093 if (!msg->entry) return (IPTR)NULL;
2094 ent = *msg->entry;
2095
2096 if (((IPTR)ent) == MUIV_IconList_NextSelected_Start)
2097 {
2098 if (!(node = data->last_selected))
2099 {
2100 D(bug("[IconList] No selected entries!!!\n"));
2101 *msg->entry = (struct IconList_Entry*)MUIV_IconList_NextSelected_End;
2102 }
2103 else
2104 {
2105 /* get the first selected entry in list */
2106 node = List_First(&data->icon_list);
2107 while (!node->selected)
2108 {
2109 node = Node_Next(node);
2110 }
2111
2112 *msg->entry = &node->entry;
2113 }
2114 return 0;
2115 }
2116
2117 node = List_First(&data->icon_list); /* not really necessary but it avoids compiler warnings */
2118
2119 node = (struct IconEntry*)(((char*)ent) - ((char*)(&node->entry) - (char*)node));
2120 node = Node_Next(node);
2121
2122 while (node)
2123 {
2124 if (node->selected)
2125 {
2126 *msg->entry = &node->entry;
2127 return 0;
2128 }
2129 node = Node_Next(node);
2130 }
2131
2132 *msg->entry = (struct IconList_Entry*)MUIV_IconList_NextSelected_End;
2133
2134 return (IPTR)NULL;
2135 }
2136
2137 /**************************************************************************
2138 MUIM_CreateDragImage
2139 **************************************************************************/
2140 IPTR IconList__MUIM_CreateDragImage(struct IClass *cl, Object *obj, struct MUIP_CreateDragImage *msg)
2141 {
2142 struct MUI_IconData *data = INST_DATA(cl, obj);
2143 struct MUI_DragImage *img = NULL;
2144
2145 if (!data->first_selected) DoSuperMethodA(cl,obj,(Msg)msg);
2146
2147 if ((img = (struct MUI_DragImage *)AllocVec(sizeof(struct MUIP_CreateDragImage),MEMF_CLEAR)))
2148 {
2149 struct IconEntry *node;
2150 LONG depth = GetBitMapAttr(_screen(obj)->RastPort.BitMap,BMA_DEPTH);
2151
2152 node = data->first_selected;
2153
2154 img->width = node->width;
2155 img->height = node->height;
2156
2157 if ((img->bm = AllocBitMap(img->width,img->height,depth,BMF_MINPLANES|BMF_CLEAR,_screen(obj)->RastPort.BitMap)))
2158 {
2159 struct RastPort temprp;
2160 InitRastPort(&temprp);
2161 temprp.BitMap = img->bm;
2162
2163 #ifndef __AROS__
2164 DrawIconState(&temprp,node->dob,NULL,0,0, node->selected?IDS_SELECTED:IDS_NORMAL, ICONDRAWA_EraseBackground, TRUE, TAG_DONE);
2165 #else
2166 DrawIconStateA(&temprp,node->dob,NULL,0,0, node->selected?IDS_SELECTED:IDS_NORMAL, NULL);
2167 #endif
2168 DeinitRastPort(&temprp);
2169 }
2170
2171 img->touchx = msg->touchx;
2172 img->touchy = msg->touchy;
2173 img->flags = 0;
2174 }
2175 return (ULONG)img;
2176 }
2177
2178 /**************************************************************************
2179 MUIM_DeleteDragImage
2180 **************************************************************************/
2181 IPTR IconList__MUIM_DeleteDragImage(struct IClass *cl, Object *obj, struct MUIP_DeleteDragImage *msg)
2182 {
2183 struct MUI_IconData *data = INST_DATA(cl, obj);
2184
2185 if (!data->first_selected) return DoSuperMethodA(cl,obj,(Msg)msg);
2186
2187 if (msg->di)
2188 {
2189 if (msg->di->bm)
2190 FreeBitMap(msg->di->bm);
2191 FreeVec(msg->di);
2192 }
2193 return (IPTR)NULL;
2194 }
2195
2196 /**************************************************************************
2197 MUIM_DragQuery
2198 **************************************************************************/
2199 IPTR IconList__MUIM_DragQuery(struct IClass *cl, Object *obj, struct MUIP_DragQuery *msg)
2200 {
2201 if (msg->obj == obj) return MUIV_DragQuery_Accept;
2202 else
2203 {
2204 int is_iconlist = 0;
2205 struct IClass *msg_cl = OCLASS(msg->obj);
2206
2207 while (msg_cl)
2208 {
2209 if (msg_cl == cl)
2210 {
2211 is_iconlist = 1;
2212 break;
2213 }
2214 msg_cl = msg_cl->cl_Super;
2215 }
2216 if (is_iconlist) return MUIV_DragQuery_Accept;
2217 }
2218
2219 return MUIV_DragQuery_Refuse;
2220 }
2221
2222 /**************************************************************************
2223 MUIM_DragDrop
2224 **************************************************************************/
2225 IPTR IconList__MUIM_DragDrop(struct IClass *cl, Object *obj, struct MUIP_DragDrop *msg)
2226 {
2227 struct MUI_IconData *data = INST_DATA(cl, obj);
2228
2229 /* check if dropped on same iconlist object */
2230 if (msg->obj == obj)
2231 {
2232 struct IconEntry *icon = data->first_selected;
2233
2234 if (icon)
2235 {
2236 struct Rectangle old, new;
2237 struct Region *region;
2238 APTR clip = NULL;
2239
2240 /* icon moved, dropped in the same window */
2241 set(obj, MUIA_IconList_IconsMoved, (IPTR) &(data->first_selected->entry)); /* Now notify */
2242 D( bug("[ICONLIST] move entry: %s dropped in same window\n", data->first_selected->entry.filename); )
2243
2244 IconList_GetIconRectangle(obj, data, icon, &old);
2245
2246 old.MinX += _mleft(obj) - data->view_x + icon->x;
2247 old.MaxX += _mleft(obj) - data->view_x + icon->x;
2248 old.MinY += _mtop(obj) - data->view_y + icon->y;
2249 old.MaxY += _mtop(obj) - data->view_y + icon->y;
2250
2251 icon->x = msg->x - _mleft(obj) + data->view_x - data->touch_x;
2252 icon->y = msg->y - _mtop(obj) + data->view_y - data->touch_y;
2253
2254 IconList_RethinkDimensions(obj, data, data->first_selected);
2255
2256 IconList_GetIconRectangle(obj, data, data->first_selected, &new);
2257
2258 new.MinX += _mleft(obj) - data->view_x + icon->x;
2259 new.MaxX += _mleft(obj) - data->view_x + icon->x;
2260 new.MinY += _mtop(obj) - data->view_y + icon->y;
2261 new.MaxY += _mtop(obj) - data->view_y + icon->y;
2262
2263 region = NewRegion();
2264 if (region)
2265 {
2266 OrRectRegion(region, &old);
2267 OrRectRegion(region, &new);
2268 clip = MUI_AddClipRegion(muiRenderInfo(obj), region);
2269 }
2270
2271 MUI_Redraw(obj,MADF_DRAWOBJECT);
2272
2273 if (region)
2274 {
2275 MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
2276 }
2277
2278 }
2279 }
2280 else
2281 {
2282
2283 struct IconEntry *icon;
2284 struct IconList_Entry *entry = (APTR) MUIV_IconList_NextSelected_Start;
2285
2286 /* get selected entries from SOURCE iconlist */
2287 DoMethod(msg->obj, MUIM_IconList_NextSelected, (IPTR) &entry);
2288
2289 /* check if dropped on an icon on the iconlist area */
2290 if (entry)
2291 {
2292
2293 /* check if dropped on a drawer */
2294 struct IconEntry *node;
2295 struct IconEntry *drop_target_node = NULL;
2296
2297 /* go through list and check if dropped on icon */
2298 node = List_First(&data->icon_list);
2299 while (node)
2300 {
2301 if (msg->x >= node->x - data->view_x &&
2302 msg->x < node->x - data->view_x + node->realWidth &&
2303 msg->y >= node->y - data->view_y + _mtop(obj) &&
2304 msg->y < node->y - data->view_y + node->realHeight + _mtop(obj) && !drop_target_node)
2305 {
2306 drop_target_node = node;
2307 }
2308
2309 node = Node_Next(node);
2310 }
2311
2312
2313 /* get path to destination directory */
2314 STRPTR directory_path = XGET(obj, MUIA_IconDrawerList_Drawer);
2315
2316 /* check if dropped on a root drive -
2317 last condition is a hack, based upon another hack (adding ":Disk" to rootdrive name)
2318 since ST_ROOT seems not to be set properly right now (?) */
2319 if (drop_target_node && ( drop_target_node->entry.type == ST_ROOT
2320 || ( !strcmp(drop_target_node->entry.filename+strlen(drop_target_node->entry.filename)-5,":Disk") ) ) )
2321 {
2322 int tmplen = 0;
2323
2324 /* avoid copying "Disk" (hack anyway?!) from root drive name, eg. "Ram Disk:Disk"*/
2325 tmplen = strlen(drop_target_node->entry.filename) - 4;
2326
2327 /* copy path of dir icon dropped on */
2328 strncpy(data->drop_entry.destination_string, drop_target_node->entry.filename, tmplen);
2329
2330 /* mark the drive the icon was dropped on*/
2331 drop_target_node->selected = 1;
2332 data->update = UPDATE_SINGLEICON;
2333 data->update_icon = drop_target_node;
2334 MUI_Redraw(obj,MADF_DRAWUPDATE);
2335
2336 D( bug("[ICONLIST] drop entry: %s dropped on disk icon %s\n", entry->filename, drop_target_node->entry.filename); )
2337 }
2338 /* check if dropped on a drawer icon in iconlist */
2339 else if (drop_target_node && drop_target_node->entry.type == ST_USERDIR )
2340 {
2341 /* copy path of dir icon dropped on */
2342 strcpy(data->drop_entry.destination_string, drop_target_node->entry.filename);
2343
2344 /* mark the directory the icon was dropped on*/
2345 drop_target_node->selected = 1;
2346 data->update = UPDATE_SINGLEICON;
2347 data->update_icon = drop_target_node;
2348 MUI_Redraw(obj,MADF_DRAWUPDATE);
2349
2350 D( bug("[ICONLIST] drop entry: %s dropped on dir %s icon in window %s\n", entry->filename, drop_target_node->entry.filename, directory_path); )
2351 }
2352 else
2353 {
2354 /* not dropped on icon -> get path of DESTINATION iconlist */
2355 D( bug("[ICONLIST] drop entry: %s dropped in window %s\n", entry->filename, directory_path); )
2356 /* copy path */
2357 strcpy(data->drop_entry.destination_string, directory_path);
2358 }
2359
2360 /* copy relevant data to drop entry */
2361 data->drop_entry.source_iconlistobj = (IPTR)msg->obj;
2362 data->drop_entry.destination_iconlistobj = (IPTR)obj;
2363
2364 /* return drop entry */
2365 set(obj, MUIA_IconList_IconsDropped, (IPTR)&data->drop_entry); /* Now notify */
2366 }
2367 else
2368 {
2369 /* no drop entry */
2370 set(obj, MUIA_IconList_IconsDropped, (IPTR)NULL); /* Now notify */
2371 }
2372
2373 }
2374 return DoSuperMethodA(cl,obj,(Msg)msg);
2375 }
2376
2377 /**************************************************************************
2378 MUIM_UnselectAll
2379 **************************************************************************/
2380 IPTR IconList__MUIM_UnselectAll(struct IClass *cl, Object *obj, Msg msg)
2381 {
2382 struct MUI_IconData *data = INST_DATA(cl, obj);
2383 struct IconEntry *node;
2384
2385 node = List_First(&data->icon_list);
2386 while (node)
2387 {
2388 if (node->selected)
2389 {
2390 node->selected = 0;
2391 data->update = UPDATE_SINGLEICON;
2392 data->update_icon = node;
2393 MUI_Redraw(obj,MADF_DRAWUPDATE);
2394 }
2395 node = Node_Next(node);
2396 }
2397 data->first_selected = NULL;
2398 data->last_selected = NULL;
2399 return 1;
2400 }
2401
2402 /**************************************************************************
2403 MUIM_SelectAll
2404 **************************************************************************/
2405 IPTR IconList__MUIM_SelectAll(struct IClass *cl, Object *obj, Msg msg)
2406 {
2407 struct MUI_IconData *data = INST_DATA(cl, obj);
2408 struct IconEntry *node;
2409
2410 node = List_First(&data->icon_list);
2411 data->first_selected = node;
2412 while (node)
2413 {
2414 if (!node->selected)
2415 {
2416 node->selected = 1;
2417 data->update = UPDATE_SINGLEICON;
2418 data->update_icon = node;
2419 data->last_selected = node;
2420 MUI_Redraw(obj,MADF_DRAWUPDATE);
2421 }
2422 node = Node_Next(node);
2423 }
2424
2425 return 1;
2426 }
2427
2428 struct MUI_IconDrawerData
2429 {
2430 char *drawer;
2431 };
2432
2433 /**************************************************************************
2434 Read icons in
2435 **************************************************************************/
2436 static int ReadIcons(struct IClass *cl, Object *obj)
2437 {
2438 struct MUI_IconDrawerData *data = INST_DATA(cl, obj);
2439 BPTR lock;
2440 char filename[256];
2441
2442 if (!data->drawer)
2443 return 1;
2444
2445 lock = Lock(data->drawer, SHARED_LOCK);
2446
2447 if (lock)
2448 {
2449 struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
2450 if (fib)
2451 {
2452 if (Examine(lock, fib))
2453 {
2454 while(ExNext(lock, fib))
2455 {
2456 int len;
2457
2458 strcpy(filename,fib->fib_FileName);
2459 len = strlen(filename);
2460
2461 if (len >= 5)
2462 {
2463 /* reject all .info files, so we have a Show All mode */
2464 if (!Stricmp(&filename[len-5],".info"))
2465 continue;
2466 }
2467
2468 if (Stricmp(filename,"Disk")) /* skip disk.info */
2469 {
2470 char buf[ 512 ];
2471 strcpy(buf,data->drawer);
2472 AddPart(buf,filename,sizeof(buf));
2473 DoMethod(obj,MUIM_IconList_Add,(IPTR)buf,(IPTR)filename,(IPTR) fib);
2474 }
2475 }
2476 }
2477
2478 FreeDosObject(DOS_FIB, fib);
2479 }
2480
2481 UnLock(lock);
2482 }
2483
2484 return 1;
2485 }
2486
2487 /*
2488 static int OLDReadIcons(struct IClass *cl, Object *obj)
2489 {
2490 struct MUI_IconDrawerData *data = INST_DATA(cl, obj);
2491 BPTR lock;
2492
2493 struct ExAllControl *eac;
2494 struct ExAllData *entry;
2495 void *ead;
2496 LONG more;
2497 BPTR olddir;
2498 //char pattern[40];
2499 char filename[256];
2500
2501 if (!data->drawer) return 1;
2502 lock = Lock(data->drawer,ACCESS_READ);
2503 if (!lock) return 0;
2504
2505 eac = (struct ExAllControl*)AllocDosObject(DOS_EXALLCONTROL,NULL);
2506 if (!eac)
2507 {
2508 UnLock(lock);
2509 return 0;
2510 }
2511
2512 ead = AllocVec(1024,0);
2513 if (!ead)
2514 {
2515 FreeDosObject(DOS_EXALLCONTROL,eac);
2516 UnLock(lock);
2517 return 0;
2518 }
2519
2520 *//*
2521 ParsePatternNoCase("#?.info",pattern,sizeof(pattern));
2522 eac->eac_MatchString = pattern;
2523 *//*
2524 #ifdef __AROS__
2525 #warning AROS ExAll() doesnt support eac_MatchString
2526 #endif
2527 eac->eac_MatchString = NULL;
2528 eac->eac_LastKey = 0;
2529
2530 olddir = CurrentDir(lock);
2531
2532 do
2533 {
2534 more = ExAll(lock,ead,1024,ED_TYPE,eac);
2535 if ((!more) && (IoErr() != ERROR_NO_MORE_ENTRIES)) break;
2536 if (eac->eac_Entries == 0) continue;
2537
2538 entry = (struct ExAllData*)ead;
2539 do
2540 {
2541 int len;
2542
2543 strcpy(filename,entry->ed_Name);
2544
2545 *//*
2546 // if we only display icons
2547
2548 filename[strlen(filename)-5]=0;
2549 *//*
2550 len = strlen(filename);
2551 if (len >= 5)
2552 {
2553 *//* reject all .info files, so we have a Show All mode *//*
2554 if (!Stricmp(&filename[len-5],".info"))
2555 continue;
2556 }
2557
2558 if (Stricmp(filename,"Disk")) *//* skip disk.info *//*
2559 {
2560 char buf[512];
2561 strcpy(buf,data->drawer);
2562 AddPart(buf,filename,sizeof(buf));
2563
2564 if (!(DoMethod(obj,MUIM_IconList_Add,(IPTR)buf,(IPTR)filename,entry->ed_Type,NULL *//* udata *//*)))
2565 {
2566 }
2567 }
2568 } while ((entry = entry->ed_Next));
2569 } while (more);
2570
2571 CurrentDir(olddir);
2572
2573 FreeVec(ead);
2574 FreeDosObject(DOS_EXALLCONTROL,eac);
2575 UnLock(lock);
2576 return 1;
2577 }
2578
2579 */
2580 /**************************************************************************
2581 MUIM_Sort - sortsort
2582 **************************************************************************/
2583 IPTR IconList__MUIM_Sort(struct IClass *cl, Object *obj, struct MUIP_IconList_Sort *msg)
2584 {
2585 struct MUI_IconData *data = INST_DATA(cl, obj);
2586 struct IconEntry *entry,*icon1,*icon2;
2587 struct MinList list;
2588 int sortme;
2589 int i;
2590
2591 NewList((struct List*)&list);
2592
2593 /*move list int out local list struct*/
2594 while( (entry = (struct IconEntry *)RemTail((struct List*)&data->icon_list)) )
2595 AddHead( (struct List*)&list , (struct Node *)entry );
2596
2597 /*now copy each one back to the main list, sorting as we go*/
2598 entry = List_First(&list);
2599
2600 while((entry = (struct IconEntry *)RemTail((struct List*)&list)))
2601 {
2602 icon1 = List_First(&data->icon_list);
2603 icon2 = NULL;
2604 sortme = 0;
2605
2606 /*D(bug(" - %s %s %s %i\n",entry->entry.label,entry->datebuf,entry->timebuf,entry->fib.fib_Size));*/
2607
2608 while( icon1 )
2609 {
2610
2611 /*drawers mixed*/
2612 if( data->sort_bits & ICONLIST_SORT_DRAWERS_MIXED )
2613 {
2614 sortme = 1;
2615 }
2616 else
2617 /*drawers first*/
2618 {
2619 if( icon1->entry.type == WBDRAWER && entry->entry.type == WBDRAWER )
2620 {
2621 sortme = 1;
2622 }
2623 else
2624 {
2625 if( icon1->entry.type != WBDRAWER && entry->entry.type != WBDRAWER )
2626 sortme = 1;
2627 else
2628 {
2629 /*we are the first drawer to arrive or we need to insert ourselves due to being sorted to the end of the drawers*/
2630 if( (!icon2 || icon2->entry.type == WBDRAWER) && entry->entry.type == WBDRAWER && icon1->entry.type != WBDRAWER )
2631 {
2632 /*D(bug("force %s\n"),entry->entry.label);*/
2633 break;
2634 }
2635 }
2636 }
2637 }
2638
2639 if(sortme)
2640 {
2641 i = 0;
2642
2643 /*date*/
2644 if( (data->sort_bits & ICONLIST_SORT_BY_DATE) && !(data->sort_bits & ICONLIST_SORT_BY_SIZE) )
2645 {
2646 i = CompareDates((const struct DateStamp *)&entry->fib.fib_Date,(const struct DateStamp *)&icon1->fib.fib_Date);
2647 /*D(bug(" - %i\n",i));*/
2648 }
2649 else
2650 {
2651 /*size*/
2652 if( (data->sort_bits & ICONLIST_SORT_BY_SIZE) && !(data->sort_bits & ICONLIST_SORT_BY_DATE) )
2653 {
2654 i = entry->fib.fib_Size - icon1->fib.fib_Size;
2655 /*D(bug(" - %i\n",i));*/
2656
2657 }
2658 else
2659 /*type*/
2660 if( data->sort_bits & (ICONLIST_SORT_BY_DATE | ICONLIST_SORT_BY_SIZE) )
2661 {
2662
2663 }
2664 else
2665 /*name*/
2666 {
2667 i = Stricmp(entry->entry.label,icon1->entry.label);
2668 }
2669 }
2670
2671 if ( !(data->sort_bits & ICONLIST_SORT_REVERSE) && i<0 )
2672 break;
2673
2674 if ( (data->sort_bits & ICONLIST_SORT_REVERSE) && i>0)
2675 break;
2676
2677
2678 }
2679
2680 icon2 = icon1;
2681 icon1 = Node_Next( icon1 );
2682 }
2683
2684 Insert( (struct List*)&data->icon_list , (struct Node *)entry , (struct Node *)icon2 );
2685 }
2686
2687 /*debug, stomp it back in in reverse order instead
2688 while( (entry = (struct IconEntry *)RemTail((struct List*)&list)) )
2689 AddTail( (struct List*)&data->icon_list , (struct Node *)entry );
2690 */
2691
2692 DoMethod(obj,MUIM_IconList_PositionIcons);
2693 MUI_Redraw(obj,MADF_DRAWOBJECT);
2694
2695 return 1;
2696 }
2697
2698 /**************************************************************************
2699 MUIM_SetSortBits - set our sorting bits
2700 **************************************************************************/
2701 IPTR IconList__MUIM_SetSortBits(struct IClass *cl, Object *obj, struct MUIP_IconList_SetSortBits *msg)
2702 {
2703 struct MUI_IconData *data = INST_DATA(cl, obj);
2704 data->sort_bits = msg->sort_bits;
2705 return 1;
2706 }
2707
2708 /**************************************************************************
2709 MUIM_GetSortBits - return our sorting bits
2710 **************************************************************************/
2711 IPTR IconList__MUIM_GetSortBits(struct IClass *cl, Object *obj, struct MUIP_IconList_GetSortBits *msg)
2712 {
2713 struct MUI_IconData *data = INST_DATA(cl, obj);
2714 return data->sort_bits;
2715 }
2716
2717 /**************************************************************************
2718 MUIM_DragReport. Since MUI doesn't change the drop object if the dragged
2719 object is moved above another window (while still in the bounds of the
2720 orginal drop object) we must do it here manually to be compatible with
2721 MUI. Maybe Zune should fix this bug somewhen.
2722 **************************************************************************/
2723 IPTR IconList__MUIM_DragReport(struct IClass *cl, Object *obj, struct MUIP_DragReport *msg)
2724 {
2725 struct Window *wnd = _window(obj);
2726 struct Layer *l;
2727
2728 l = WhichLayer(&wnd->WScreen->LayerInfo, wnd->LeftEdge + msg->x, wnd->TopEdge + msg->y);
2729 if (l != wnd->WLayer) return MUIV_DragReport_Abort;
2730 return MUIV_DragReport_Continue;
2731 }
2732
2733 /**************************************************************************
2734 MUIM_IconList_UnknownDropDestination
2735 **************************************************************************/
2736
2737 IPTR IconList__MUIM_UnknownDropDestination(struct IClass *cl, Object *obj, struct MUIP_UnknownDropDestination *msg)
2738 {
2739 D(bug("[ICONLIST] icons dropped on custom window \n");)
2740 set(obj, MUIA_IconList_AppWindowDrop, (IPTR)msg); /* Now notify */
2741
2742 return 0;
2743 }
2744
2745 /*************************************************************************/
2746
2747 BOOPSI_DISPATCHER(IPTR,IconList_Dispatcher, cl, obj, msg)
2748 {
2749 switch (msg->MethodID)
2750 {
2751 case OM_NEW: return IconList__OM_NEW(cl, obj, (struct opSet *)msg);
2752 case OM_DISPOSE: return IconList__OM_DISPOSE(cl,obj, msg);
2753 case OM_SET: return IconList__OM_SET(cl,obj,(struct opSet *)msg);
2754 case OM_GET: return IconList__OM_GET(cl,obj,(struct opGet *)msg);
2755
2756 case MUIM_Setup: return IconList__MUIM_Setup(cl,obj,(struct MUIP_Setup *)msg);
2757
2758 case MUIM_Show: return IconList__MUIM_Show(cl,obj,(struct MUIP_Show *)msg);
2759 case MUIM_Cleanup: return IconList__MUIM_Cleanup(cl,obj,(struct MUIP_Cleanup *)msg);
2760 case MUIM_AskMinMax: return IconList__MUIM_AskMinMax(cl,obj,(struct MUIP_AskMinMax *)msg);
2761 case MUIM_Draw: return IconList__MUIM_Draw(cl,obj,(struct MUIP_Draw *)msg);
2762 case MUIM_Layout: return IconList__MUIM_Layout(cl,obj,(struct MUIP_Layout *)msg);
2763 case MUIM_HandleEvent: return IconList__MUIM_HandleEvent(cl,obj,(struct MUIP_HandleEvent *)msg);
2764 case MUIM_CreateDragImage: return IconList__MUIM_CreateDragImage(cl,obj,(APTR)msg);
2765 case MUIM_DeleteDragImage: return IconList__MUIM_DeleteDragImage(cl,obj,(APTR)msg);
2766 case MUIM_DragQuery: return IconList__MUIM_DragQuery(cl,obj,(APTR)msg);
2767 case MUIM_DragReport: return IconList__MUIM_DragReport(cl,obj,(APTR)msg);
2768 case MUIM_DragDrop: return IconList__MUIM_DragDrop(cl,obj,(APTR)msg);
2769 case MUIM_UnknownDropDestination: return IconList__MUIM_UnknownDropDestination(cl,obj,(APTR)msg);
2770 case MUIM_IconList_Update: return IconList__MUIM_Update(cl,obj,(APTR)msg);
2771 case MUIM_IconList_Clear: return IconList__MUIM_Clear(cl,obj,(APTR)msg);
2772 case MUIM_IconList_Add: return IconList__MUIM_Add(cl,obj,(APTR)msg);
2773 case MUIM_IconList_NextSelected: return IconList__MUIM_NextSelected(cl,obj,(APTR)msg);
2774 case MUIM_IconList_UnselectAll: return IconList__MUIM_UnselectAll(cl,obj,(APTR)msg);
2775 case MUIM_IconList_Sort: return IconList__MUIM_Sort(cl,obj,(APTR)msg);
2776 case MUIM_IconList_GetSortBits: return IconList__MUIM_GetSortBits(cl,obj,(APTR)msg);
2777 case MUIM_IconList_SetSortBits: return IconList__MUIM_SetSortBits(cl,obj,(APTR)msg);
2778 case MUIM_IconList_PositionIcons: return IconList__MUIM_PositionIcons(cl,obj,(APTR)msg);
2779 case MUIM_IconList_SelectAll: return IconList__MUIM_SelectAll(cl,obj,(APTR)msg);
2780 }
2781
2782 return DoSuperMethodA(cl, obj, msg);
2783 }
2784 BOOPSI_DISPATCHER_END
2785
2786
2787 /**************************************************************************
2788 OM_NEW
2789 **************************************************************************/
2790 IPTR IconDrawerList__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
2791 {
2792 struct MUI_IconDrawerData *data;
2793 struct TagItem *tag, *tags;
2794
2795 obj = (Object *)DoSuperNewTags(cl, obj, NULL,
2796 TAG_MORE, (IPTR) msg->ops_AttrList);
2797 if (!obj) return FALSE;
2798
2799 data = INST_DATA(cl, obj);
2800
2801 /* parse initial taglist */
2802 for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags)); )
2803 {
2804 switch (tag->ti_Tag)
2805 {
2806 case MUIA_IconDrawerList_Drawer:
2807 data->drawer = StrDup((char*)tag->ti_Data);
2808 break;
2809 }
2810 }
2811
2812 return (IPTR)obj;
2813 }
2814
2815 /**************************************************************************
2816 OM_DISPOSE
2817 **************************************************************************/
2818 IPTR IconDrawerList__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
2819 {
2820 struct MUI_IconDrawerData *data = INST_DATA(cl, obj);
2821
2822 if (data->drawer) FreeVec(data->drawer);
2823 return DoSuperMethodA(cl,obj,msg);
2824 }
2825
2826 /**************************************************************************
2827 OM_SET
2828 **************************************************************************/
2829 IPTR IconDrawerList__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
2830 {
2831 struct MUI_IconDrawerData *data = INST_DATA(cl, obj);
2832 struct TagItem *tag, *tags;
2833
2834 /* parse initial taglist */
2835 for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags)); )
2836 {
2837 switch (tag->ti_Tag)
2838 {
2839 case MUIA_IconDrawerList_Drawer:
2840 if (data->drawer) FreeVec(data->drawer);
2841 data->drawer = StrDup((char*)tag->ti_Data);
2842 DoMethod(obj,MUIM_IconList_Update);
2843 break;
2844 }
2845 }
2846
2847 return DoSuperMethodA(cl, obj, (Msg)msg);
2848 }
2849
2850 /**************************************************************************
2851 OM_GET
2852 **************************************************************************/
2853 IPTR IconDrawerList__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
2854 {
2855 /* small macro to simplify return value storage */
2856 #define STORE *(msg->opg_Storage)
2857 struct MUI_IconDrawerData *data = INST_DATA(cl, obj);
2858
2859 switch (msg->opg_AttrID)
2860 {
2861 case MUIA_IconDrawerList_Drawer: STORE = (unsigned long)data->drawer; return 1;
2862 }
2863
2864 if (DoSuperMethodA(cl, obj, (Msg) msg)) return 1;
2865 return 0;
2866 #undef STORE
2867 }
2868
2869 /**************************************************************************
2870 MUIM_IconList_Update
2871 **************************************************************************/
2872 IPTR IconDrawerList__MUIM_Update(struct IClass *cl, Object *obj, struct MUIP_IconList_Update *msg)
2873 {
2874 //struct MUI_IconDrawerData *data = INST_DATA(cl, obj);
2875 //struct IconEntry *node;
2876 // struct MUI_IconData *data = INST_DATA(cl, obj);
2877
2878 DoMethod(obj,MUIM_IconList_Clear);
2879
2880 /* If not in setup do nothing */
2881 if (!(_flags(obj)&MADF_SETUP)) return 1;
2882 ReadIcons(cl,obj);
2883
2884 /*_Sort takes care of icon placement and redrawing for us*/
2885 DoMethod(obj,MUIM_IconList_Sort);
2886 return 1;
2887 }
2888
2889
2890 BOOPSI_DISPATCHER(IPTR, IconDrawerList_Dispatcher, cl, obj, msg)
2891 {
2892 switch (msg->MethodID)
2893 {
2894 case OM_NEW: return IconDrawerList__OM_NEW(cl, obj, (struct opSet *)msg);
2895 case OM_DISPOSE: return IconDrawerList__OM_DISPOSE(cl,obj,msg);
2896 case OM_SET: return IconDrawerList__OM_SET(cl, obj, (struct opSet *)msg);
2897 case OM_GET: return IconDrawerList__OM_GET(cl, obj, (struct opGet *)msg);
2898 case MUIM_IconList_Update: return IconDrawerList__MUIM_Update(cl,obj,(APTR)msg);
2899 }
2900 return DoSuperMethodA(cl, obj, msg);
2901 }
2902 BOOPSI_DISPATCHER_END
2903
2904 /* sba: taken from SimpleFind3 */
2905
2906 struct NewDosList
2907 {
2908 struct MinList list;
2909 APTR pool;
2910 };
2911
2912 struct NewDosNode
2913 {
2914 struct MinNode node;
2915 STRPTR name;
2916 STRPTR device;
2917 struct MsgPort *port;
2918 };
2919
2920 static struct NewDosList *DosList_Create(void)
2921 {
2922 APTR pool = CreatePool(MEMF_PUBLIC,4096,4096);
2923 if (pool)
2924 {
2925 struct NewDosList *ndl = (struct NewDosList*)AllocPooled(pool,sizeof(struct NewDosList));
2926 if (ndl)
2927 {
2928 struct DosList *dl;
2929
2930 NewList((struct List*)ndl);
2931 ndl->pool = pool;
2932
2933 dl = LockDosList(LDF_VOLUMES|LDF_READ);
2934 while(( dl = NextDosEntry(dl, LDF_VOLUMES)))
2935 {
2936 STRPTR name;
2937 #ifndef __AROS__
2938 UBYTE *dosname = (UBYTE*)BADDR(dl->dol_Name);
2939 LONG len = dosname[0];
2940 dosname++;
2941 #else
2942 UBYTE *dosname = dl->dol_DevName;
2943 LONG len = strlen(dosname);
2944 #endif
2945
2946 if ((name = (STRPTR)AllocPooled(pool, len+1)))
2947 {
2948 struct NewDosNode *ndn;
2949
2950 name[len] = 0;
2951 strncpy(name,dosname,len);
2952
2953 if ((ndn = (struct NewDosNode*)AllocPooled(pool, sizeof(*ndn))))
2954 {
2955 D(bug("[Wanderer]: DosList_Create: adding node for '%s'\n", name));
2956 ndn->name = name;
2957 ndn->device = NULL;
2958 #ifndef __AROS__
2959 ndn->port = dl->dol_Task;
2960 #else
2961 ndn->port = NULL;
2962 #endif
2963
2964 /*
2965 struct IOStdReq *vol_tmp_ioreq=NULL;
2966 struct MsgPort *vol_tmp_mp=NULL;
2967
2968 mp = CreateMsgPort();
2969 if (mp)
2970 {
2971 ioreq = (struct IOStdReq *)CreateIORequest(mp, sizeof(struct IOStdReq));
2972 if (ioreq)
2973 {
2974 ioreq->iotd_Req.io_Length = sizeof(struct Interrupt);
2975 ioreq->iotd_Req.io_Data = (APTR)Wanderer_VolumeInterrupt;
2976 ioreq->iotd_Req.io_Command = TD_ADDCHANGEINT;
2977 SendIO((struct IORequest *)DiskIO);
2978 }
2979 } */
2980
2981 AddTail((struct List*)ndl,(struct Node*)ndn);
2982 }
2983 }
2984 }
2985 UnLockDosList(LDF_VOLUMES|LDF_READ);
2986
2987 #ifndef __AROS__
2988 dl = LockDosList(LDF_DEVICES|LDF_READ);
2989 while(( dl = NextDosEntry(dl, LDF_DEVICES)))
2990 {
2991 struct NewDosNode *ndn;
2992
2993 if (!dl->dol_Task) continue;
2994
2995 ndn = (struct NewDosNode*)List_First(ndl);
2996 while ((ndn))
2997 {
2998 if (dl->dol_Task == ndn->port)
2999 {
3000 STRPTR name;
3001 UBYTE *dosname = (UBYTE*)BADDR(dl->dol_Name);
3002 LONG len = dosname[0];
3003
3004 if ((name = (STRPTR)AllocPooled(pool, len+1)))
3005 {
3006 name[len] = 0;
3007 strncpy(name,&dosname[1],len);
3008 }
3009
3010 ndn->device = name;
3011 break;
3012 }
3013
3014 ndn = (struct NewDosNode*)Node_Next(ndn);
3015 }
3016 }
3017 UnLockDosList(LDF_DEVICES|LDF_READ);
3018 #endif
3019
3020 return ndl;
3021 }
3022 DeletePool(pool);
3023 }
3024 return NULL;
3025 }
3026
3027 static void DosList_Dispose(struct NewDosList *ndl)
3028 {
3029 if (ndl && ndl->pool) DeletePool(ndl->pool);
3030 }
3031 /* sba: End SimpleFind3 */
3032
3033
3034 struct MUI_IconVolumneData
3035 {
3036 int dummy;
3037 };
3038
3039 /**************************************************************************
3040 OM_NEW
3041 **************************************************************************/
3042 IPTR IconVolumeList__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
3043 {
3044 struct MUI_IconDrawerData *data;
3045 struct TagItem *tag, *tags;
3046
3047 obj = (Object *)DoSuperNewTags(cl, obj, NULL,
3048 TAG_MORE, (IPTR) msg->ops_AttrList);
3049 if (!obj) return FALSE;
3050
3051 data = INST_DATA(cl, obj);
3052
3053 /* parse initial taglist */
3054 for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags)); )
3055 {
3056 switch (tag->ti_Tag)
3057 {
3058 }
3059 }
3060
3061 return (IPTR)obj;
3062 }
3063
3064 /**************************************************************************
3065 MUIM_IconList_Update
3066 **************************************************************************/
3067 IPTR IconVolumeList__MUIM_Update(struct IClass *cl, Object *obj, struct MUIP_IconList_Update *msg)
3068 {
3069 //struct MUI_IconVolumeData *data = INST_DATA(cl, obj);
3070 //struct IconEntry *node;
3071 struct NewDosList *ndl;
3072 DoMethod(obj,MUIM_IconList_Clear);
3073
3074 /* If not in setup do nothing */
3075 if (!(_flags(obj)&MADF_SETUP)) return 1;
3076
3077 if ((ndl = DosList_Create()))
3078 {
3079 struct NewDosNode *nd = List_First(ndl);
3080 while (nd)
3081 {
3082 char buf[300];
3083 if (nd->name)
3084 {
3085 strcpy(buf,nd->name);
3086 strcat(buf,":Disk");
3087
3088 if (!(DoMethod(obj,MUIM_IconList_Add,(IPTR)buf,(IPTR)nd->name, (IPTR)NULL)))
3089 {
3090 }
3091
3092 }
3093 nd = Node_Next(nd);
3094 }
3095 DosList_Dispose(ndl);
3096 }
3097
3098 /*deault display bits*/
3099 ULONG sort_bits = ICONLIST_DISP_VERTICAL;
3100
3101 DoMethod(obj,MUIM_IconList_SetSortBits,sort_bits);
3102 DoMethod(obj,MUIM_IconList_Sort);
3103
3104 return 1;
3105 }
3106
3107
3108 BOOPSI_DISPATCHER(IPTR, IconVolumeList_Dispatcher, cl, obj, msg)
3109 {
3110 switch (msg->MethodID)
3111 {
3112 case OM_NEW: return IconVolumeList__OM_NEW(cl, obj, (struct opSet *)msg);
3113 case MUIM_IconList_Update: return IconVolumeList__MUIM_Update(cl,obj,(APTR)msg);
3114 }
3115
3116 return DoSuperMethodA(cl, obj, msg);
3117 }
3118 BOOPSI_DISPATCHER_END
3119
3120 /*
3121 * Class descriptor.
3122 */
3123 const struct __MUIBuiltinClass _MUI_IconList_desc = {
3124 MUIC_IconList,
3125 MUIC_Area,
3126 sizeof(struct MUI_IconData),
3127 (void*)IconList_Dispatcher
3128 };
3129
3130 const struct __MUIBuiltinClass _MUI_IconDrawerList_desc = {
3131 MUIC_IconDrawerList,
3132 MUIC_IconList,
3133 sizeof(struct MUI_IconDrawerData),
3134 (void*)IconDrawerList_Dispatcher
3135 };
3136
3137 const struct __MUIBuiltinClass _MUI_IconVolumeList_desc = {
3138 MUIC_IconVolumeList,
3139 MUIC_IconList,
3140 sizeof(struct MUI_IconVolumneData),
3141 (void*)IconVolumeList_Dispatcher
3142 };
3143
A totally sweet operating system