?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Simple test for asyncio.library.
[AROS-Contrib.git] / gfx / mysticview / src / MysticView.c
blob6e7ed25a190d4b5f9976c65da1b52bcde3ba2df0
1 /*********************************************************************
2 ----------------------------------------------------------------------
3
4 MysticView
5
6 todo:
7 - dateikommentar?!
8 - overwrite requester! -> save list, save preset
9 - "Drag'n'Drop Append"
10 - viewheight <= 0 abfangen!
11 - newpichandler(): pichandler zurücksetzen, nicht dauernd
12 neu erzeugen
13 - picture statistiks
14
15 not yet:
16 - auf arrows klicken -> scroll
17 - doppelklick zoom
18 - im pip scrollen
19 - cursor greifen
20
21 ideen:
22 - markieren
23 - clearbutton
24 - das neuronale netz über eine public semaphore allen
25 instanzen gleichzeitig zur verfügung stellen
26 - "private" screen: scrollvport refresh usw. !
27 - picture info konfigurierbar
28 - database features (double, similar)
29 - recent pfade
30 - directory browse mode
31 - shellkommando auf tasten
32 - DEFAULTTOOL option
33
34 ------------------------------------------------------ tabsize = 4 ---
35 *********************************************************************/
36
37 #include <stdio.h>
38 #include <string.h>
39 #include <stdlib.h>
40 #include <math.h>
41
42 #include <assert.h>
43
44 #include <dos/rdargs.h>
45 #include <exec/memory.h>
46 #include <workbench/startup.h>
47 #include <workbench/workbench.h>
48 #include <utility/hooks.h>
49 #include <utility/tagitem.h>
50 #include <guigfx/guigfx.h>
51 #include <clib/macros.h>
52 #include <libraries/gadtools.h>
53 #ifndef NO_SCREENNOTIFY
54 #include <libraries/screennotify.h>
55 #endif
56 #include <libraries/commodities.h>
57 #include <libraries/mysticview.h>
58
59 #include <proto/intuition.h>
60 #include <proto/exec.h>
61 #include <proto/dos.h>
62 #include <proto/utility.h>
63 #include <proto/guigfx.h>
64 #include <proto/render.h>
65 #include <proto/icon.h>
66 #include <proto/gadtools.h>
67 #ifndef NO_NEWICONS
68 #include <proto/newicon.h>
69 #endif
70 #include <proto/commodities.h>
71 #include <proto/wb.h>
72 #include <proto/mysticview.h>
73 #include <proto/graphics.h>
74 #ifndef NO_POPUPMENU
75 #include <proto/pm.h>
76 #endif
77 #include <proto/layers.h>
78
79 #ifndef NO_POPUPMENU
80 #include <libraries/pm.h>
81 #endif
82
83 #ifdef __MORPHOS__
84 #include <public/proto/libamiga/amiga_protos.h>
85 #else
86 #include <clib/alib_protos.h>
87 #endif
88
89 #include "Mystic_Global.h"
90 #include "Mystic_InitExit.h"
91 #include "Mystic_Subtask.h"
92 #include "Mystic_Tools.h"
93 #include "Mystic_Timing.h"
94 #include "Mystic_Window.h"
95 #include "Mystic_Screen.h"
96 #include "Mystic_Settings.h"
97 #include "Mystic_FileHandling.h"
98
99 #include "Mystic_HandlerWrapper.h"
100
101 #include "Mystic_Keyfile.h"
102 #include "Mystic_Icons.h"
103 #include "Mystic_Functions.h"
104
105 #include "Mystic_Texts.h"
106 #include "Mystic_Neuromancer.h"
107 #include "Mystic_Gadgets.h"
108
109 #include "MysticView.h"
110
111 #include "Mystic_Debug.h"
112
113 long __stack = MAINSTACK;
114
115
116
117 /*******************************************************************
118 --------------------------------------------------------------------
119
120 various helper functions
121
122 --------------------------------------------------------------------
123 *******************************************************************/
124
125
126 /*------------------------------------------------------------------
127
128 success = FormatInfoText(deststring, formatstring, args)
129
130 formatstring: args[0] string %p pathname
131 args[1] string %f filename
132 args[2] int %w width
133 args[3] int %h height
134 args[4] int %d depth
135 args[5] string %n formatname
136
137 ------------------------------------------------------------------*/
138
139 BOOL FormatInfoText(char *deststring, char *formatstring, APTR *args)
140 {
141 APTR argarray[10];
142 char *fstring;
143 BOOL error = TRUE;
144
145 if ((fstring = _StrDup(formatstring)))
146 {
147 char *p = fstring, c, d;
148 int argcount = 0;
149
150 error = FALSE;
151
152 while ((c = *p))
153 {
154 if (c == '%' && (d = p[1]))
155 {
156 switch (d)
157 {
158 case 'p':
159 error = args[0] == NULL;
160 argarray[argcount++] = args[0];
161 p[1] = 's';
162 break;
163 case 'f':
164 error = args[1] == NULL;
165 argarray[argcount++] = args[1];
166 p[1] = 's';
167 break;
168 case 'w':
169 error = args[2] == 0;
170 argarray[argcount++] = args[2];
171 p[1] = 'd';
172 break;
173 case 'h':
174 error = args[3] == 0;
175 argarray[argcount++] = args[3];
176 p[1] = 'd';
177 break;
178 case 'd':
179 error = args[4] == 0;
180 argarray[argcount++] = args[4];
181 p[1] = 'd';
182 break;
183 case 'n':
184 error = args[5] == NULL;
185 argarray[argcount++] = args[5];
186 p[1] = 's';
187 break;
188 default:
189 break;
190 }
191 }
192 p++;
193 }
194
195 if (deststring && !error)
196 {
197 if (argcount <= 10)
198 {
199 sprintf(deststring, fstring,
200 argarray[0], argarray[1], argarray[2], argarray[3], argarray[4],
201 argarray[5], argarray[6], argarray[7], argarray[8], argarray[9]);
202 }
203 else
204 {
205 *deststring = 0;
206 }
207 }
208
209 Free(fstring);
210 }
211
212 return (BOOL)(!error);
213 }
214
215
216
217
218
219
220
221 /*------------------------------------------------------------------
222
223 changes = FilterFilePatternList(&fplist, &settings)
224
225 parse a filepattern-list for listfiles and presetfiles.
226
227 - the first listfile encountered determines a new list
228 (if it can be loaded successfully).
229 return value will be |= 1
230
231 - the first preset-file encountered determines a new
232 set of settings.
233 return value will be |= 2
234
235 ------------------------------------------------------------------*/
236
237 ULONG FilterFilePatternList(char ***array, struct mainsettings **settings)
238 {
239 ULONG ret = 0;
240
241 if (*array)
242 {
243 struct List *list;
244
245 if ((list = CreateListFromArray(*array)))
246 {
247 struct Node *node = list->lh_Head, *nextnode;
248 BOOL checksettings = (settings != NULL);
249 BOOL checklistfile = TRUE;
250 char **newfilepatternlist = NULL;
251
252 while ((nextnode = node->ln_Succ) && (checklistfile || checksettings))
253 {
254 char **tt;
255 if ((tt = GetToolTypes(node->ln_Name)))
256 {
257 if (checksettings)
258 {
259 if (GetBooleanSetting(tt, "MYSTICVIEW_PRESET", FALSE))
260 {
261 struct mainsettings *newsettings;
262 if ((newsettings = LoadPreset(node->ln_Name, *settings)))
263 {
264 DeleteMainSettings(*settings);
265 *settings = newsettings;
266 ret |= 2;
267 Remove(node);
268 DeleteNode(node);
269 checksettings = FALSE;
270 }
271 }
272 }
273 if (checklistfile)
274 {
275 if (GetBooleanSetting(tt, "MYSTICVIEW_LISTFILE", FALSE))
276 {
277 if ((newfilepatternlist = LoadStringList(node->ln_Name)))
278 {
279 Remove(node);
280 DeleteNode(node);
281 checklistfile = FALSE;
282 }
283 }
284 }
285 DeleteStringList(tt);
286 }
287 node = nextnode;
288 }
289
290 if (newfilepatternlist)
291 {
292 DeleteStringList(*array);
293 *array = newfilepatternlist;
294 ret |= 1;
295 }
296 else
297 {
298 if (CountListEntries(list) > 0)
299 {
300 char **newarray;
301 if ((newarray = CreateArrayFromList(list)))
302 {
303 DeleteStringList(*array);
304 *array = newarray;
305 }
306 }
307 else
308 {
309 DeleteStringList(*array);
310 *array = NULL;
311 }
312 }
313
314 DeleteList(list);
315 }
316 }
317
318 return ret;
319 }
320
321
322
323 /*------------------------------------------------------------------
324
325 success = SaveListFile(mview, list, filename, defaulttool)
326
327 ------------------------------------------------------------------*/
328
329 BOOL SaveListFile(struct mview *mv, char **list, char *filename, char *deftool)
330 {
331 BOOL success = FALSE;
332 BOOL icon = TRUE;
333
334 if (filename && list)
335 {
336 FILE *fp;
337 char **t = list;
338
339 if ((fp = fopen(filename, "wb")))
340 {
341 success = TRUE;
342
343 while (*t && success)
344 {
345 success = (fprintf(fp, "%s%c", *t, 10) >= 0);
346 t++;
347 }
348
349 fclose(fp);
350 }
351
352 if (success)
353 {
354 if (icon)
355 {
356 // put icon.
357
358 if (mv->diskobject)
359 {
360 char **tt;
361
362 if ((tt = CreateStringList(1)))
363 {
364 char *backdeftool;
365 char **backtt;
366 UBYTE backtype;
367
368 tt[0] = _StrDup("MYSTICVIEW_LISTFILE=YES");
369
370 backdeftool = mv->diskobject->do_DefaultTool;
371 backtt = (char **)mv->diskobject->do_ToolTypes;
372 backtype = mv->diskobject->do_Type;
373
374 mv->diskobject->do_Type = WBPROJECT;
375 mv->diskobject->do_ToolTypes = (STRPTR *)tt;
376 mv->diskobject->do_DefaultTool = deftool;
377
378 PutDiskObject(filename, mv->diskobject);
379
380 mv->diskobject->do_Type = backtype;
381 mv->diskobject->do_ToolTypes = (STRPTR *)backtt;
382 mv->diskobject->do_DefaultTool = backdeftool;
383
384 DeleteStringList(tt);
385 }
386 }
387 }
388 }
389 }
390
391 return success;
392 }
393
394
395 /*--------------------------------------------------------------------
396
397 GetErrorText(errorcode)
398
399 --------------------------------------------------------------------*/
400
401 char *GetErrorText(LONG error)
402 {
403 char *errortext = NULL;
404
405 switch (error)
406 {
407 case 0:
408 break;
409
410 case ERROR_NO_FREE_STORE:
411 errortext = "Not enough memory";
412 break;
413
414 case ERROR_OBJECT_TOO_LARGE:
415 errortext = "Object too large";
416 break;
417
418 case ERROR_OBJECT_NOT_FOUND:
419 errortext = "Object not found";
420 break;
421
422 case ERROR_DELETE_PROTECTED:
423 errortext = "Object is delete protected";
424 break;
425
426 case ERROR_WRITE_PROTECTED:
427 errortext = "Object is write protected";
428 break;
429
430 case ERROR_READ_PROTECTED:
431 errortext = "Object is read protected";
432 break;
433
434 case ERROR_NOT_A_DOS_DISK:
435 errortext = "Not a DOS disk";
436 break;
437
438 case ERROR_NO_DISK:
439 errortext = "No disk";
440 break;
441
442 case ERROR_OBJECT_IN_USE:
443 errortext = "Object in use";
444 break;
445
446 case ERROR_DISK_NOT_VALIDATED:
447 errortext = "Disk not validated";
448 break;
449
450 case ERROR_DISK_WRITE_PROTECTED:
451 errortext = "Disk write protected";
452 break;
453
454 case ERROR_OBJECT_WRONG_TYPE:
455 errortext = "Object is not recognized";
456 break;
457
458 default:
459 errortext = "Unknown error";
460 break;
461 }
462
463 return errortext;
464 }
465
466
467
468 /*--------------------------------------------------------------------
469
470 Train(mv, settings, viewdata)
471 teach the neural net the current displaymode
472
473 displaymode = Recall(mv, settings, viewdata)
474 let the neural net choose a displaymode
475
476 --------------------------------------------------------------------*/
477
478 void Train(struct mview *mv, struct mainsettings *settings, struct viewdata *viewdata)
479 {
480 if (settings && viewdata)
481 {
482 if (settings->autodisplaymode)
483 {
484 MVNeuro_Train(mv->screen, mv->window, settings,
485 viewdata, viewdata->showpic);
486 }
487 }
488 }
489
490 int Recall(struct mview *mv, struct mainsettings *settings, struct viewdata *viewdata)
491 {
492 int displaymode = settings->displaymode;
493
494 if (settings && viewdata)
495 {
496 if (settings->autodisplaymode)
497 {
498 int dispmode;
499 if (MVNeuro_RecallDisplayMode(&dispmode, mv->screen, mv->window, settings,
500 viewdata, viewdata->showpic))
501 {
502 displaymode = dispmode;
503 }
504 }
505 }
506
507 return displaymode;
508 }
509
510
511
512
513 /*******************************************************************
514 --------------------------------------------------------------------
515
516 buttons
517
518 --------------------------------------------------------------------
519 *******************************************************************/
520
521
522 /*--------------------------------------------------------------------
523
524 ReleaseButtons(buttons)
525
526 --------------------------------------------------------------------*/
527
528 void ReleaseButtons(struct MVButtons *buttons)
529 {
530 if (buttons)
531 {
532 FreeBitMap(buttons->animbitmap);
533 buttons->animbitmap = NULL;
534 FreeBitMap(buttons->bitmap);
535 buttons->bitmap = NULL;
536 ReleaseDrawHandle(buttons->drawhandle);
537 buttons->drawhandle = NULL;
538 }
539 }
540
541
542 /*--------------------------------------------------------------------
543
544 AnimateButtons(viewdata, buttons, reset)
545
546 --------------------------------------------------------------------*/
547
548 void AnimateButtons(struct viewdata *viewdata, struct MVButtons *buttons, BOOL reset)
549 {
550 if (buttons)
551 {
552 int newanimframe;
553
554 if (reset)
555 {
556 newanimframe = 0;
557 }
558 else
559 {
560 newanimframe = (buttons->animframe + 1) % ANIMFRAMES;
561 }
562
563 if (newanimframe != buttons->animframe)
564 {
565 buttons->animframe = newanimframe;
566
567 if (buttons->bitmap && buttons->animbitmap)
568 {
569 BltBitMap(buttons->animbitmap, 0, ANIMHEIGHT * buttons->animframe,
570 buttons->bitmap,
571 (buttons->gadgetwidth - ANIMWIDTH) / 2,
572 (buttons->gadgetheight - ANIMHEIGHT) / 2,
573 ANIMWIDTH, ANIMHEIGHT, 0xc0, 0xff, NULL);
574
575 BltBitMap(buttons->animbitmap, 0, ANIMHEIGHT * buttons->animframe,
576 buttons->bitmap,
577 (buttons->gadgetwidth - ANIMWIDTH) / 2 + 1,
578 buttons->gadgetheight + (buttons->gadgetheight - ANIMHEIGHT) / 2 + 1,
579 ANIMWIDTH, ANIMHEIGHT, 0xc0, 0xff, NULL);
580 }
581 }
582
583 ObtainSemaphore(&viewdata->rastlock);
584
585 DrawFakeGadget(buttons->gadgetlist->window, buttons->gadgets[GAD_OPEN],
586 buttons->gadgetlist->x, buttons->gadgetlist->y, buttons->bitmap);
587
588 ReleaseSemaphore(&viewdata->rastlock);
589 }
590 }
591
592
593 /*--------------------------------------------------------------------
594
595 success = ObtainButtons(viewdata, buttons, window)
596
597 --------------------------------------------------------------------*/
598
599 BOOL ObtainButtons(struct viewdata *viewdata, struct MVButtons *buttons, struct Window *win)
600 {
601 BOOL success = FALSE;
602
603 if (buttons && win)
604 {
605 ReleaseButtons(buttons);
606
607 ObtainSemaphore(&viewdata->rastlock);
608
609 buttons->drawhandle = ObtainDrawHandle(buttons->psm,
610 win->RPort, win->WScreen->ViewPort.ColorMap,
611 GGFX_AutoDither, FALSE,
612 GGFX_DitherMode, DITHERMODE_NONE,
613 OBP_Precision, PRECISION_GUI, TAG_DONE);
614
615 ReleaseSemaphore(&viewdata->rastlock);
616
617 if (buttons->drawhandle)
618 {
619 buttons->animbitmap = CreatePictureBitMap(buttons->drawhandle,
620 buttons->animpic, NULL);
621
622 buttons->animframe = -1;
623
624 buttons->bitmap = CreatePictureBitMap(buttons->drawhandle,
625 buttons->pic, NULL);
626
627 if (buttons->bitmap && buttons->animbitmap)
628 {
629 AnimateButtons(viewdata, buttons, TRUE);
630 success = TRUE;
631 }
632 }
633 }
634
635 if (!success)
636 {
637 ReleaseButtons(buttons);
638 }
639
640 return success;
641 }
642
643
644 /*--------------------------------------------------------------------
645
646 DeleteButtons(buttons)
647
648 --------------------------------------------------------------------*/
649
650 void DeleteButtons(struct MVButtons *buttons)
651 {
652 if (buttons)
653 {
654 DeleteFakeGadgetList(buttons->gadgetlist);
655 buttons->gadgetlist = NULL;
656 ReleaseButtons(buttons);
657 DeletePenShareMap(buttons->psm);
658 Free(buttons);
659 }
660 }
661
662
663 /*--------------------------------------------------------------------
664
665 buttons = CreateButtons(buttonpic, animpic, mvwindow)
666
667 --------------------------------------------------------------------*/
668
669 struct MVButtons *CreateButtons(PICTURE *pic, PICTURE *animpic, struct mvwindow *win)
670 {
671 struct MVButtons *buttons;
672 BOOL success = FALSE;
673
674 if ((buttons = Malloclear(sizeof(struct MVButtons))))
675 {
676 if ((buttons->pic = pic))
677 {
678 buttons->animpic = animpic;
679
680 GetPictureAttrs(buttons->pic, PICATTR_Width, (IPTR)&buttons->width,
681 PICATTR_Height, (IPTR)&buttons->height, TAG_DONE);
682
683 buttons->gadgetwidth = buttons->width / 8;
684 buttons->gadgetheight = buttons->height / 4;
685
686 if ((buttons->psm = CreatePenShareMap(GGFX_HSType, HSTYPE_15BIT_TURBO, TAG_DONE)))
687 {
688 AddPicture(buttons->psm, buttons->pic, NULL);
689 AddPicture(buttons->psm, buttons->animpic, NULL);
690 }
691
692 if ((buttons->gadgetlist = CreateFakeGadgetList(win->window, TAG_END)))
693 {
694 success = TRUE;
695
696 if (success)
697 {
698 if ((buttons->gadgets[GAD_OPEN] = CreateFakeGadget(
699 GAD_OPEN, FGADTYPE_PUSH,
700 FGDT_WIDTH, buttons->gadgetwidth,
701 FGDT_HEIGHT, buttons->gadgetheight,
702 FGDT_BITMAP, (IPTR)buttons->bitmap,
703 FGDT_PICX_INACTIVE, buttons->gadgetwidth * 0,
704 FGDT_PICY_INACTIVE, buttons->gadgetheight * 0,
705 FGDT_PICX_PRESSED, buttons->gadgetwidth * 0,
706 FGDT_PICY_PRESSED, buttons->gadgetheight * 1,
707 FGDT_PICX_ROLLOVER, buttons->gadgetwidth * 0,
708 FGDT_PICY_ROLLOVER, buttons->gadgetheight * 0,
709 TAG_DONE)))
710 {
711 AddFakeGadget(buttons->gadgetlist, buttons->gadgets[GAD_OPEN]);
712 success = TRUE;
713 }
714 }
715 if (success)
716 {
717 if ((buttons->gadgets[GAD_RESTART] = CreateFakeGadget(
718 GAD_RESTART, FGADTYPE_PUSH,
719 FGDT_WIDTH, buttons->gadgetwidth,
720 FGDT_HEIGHT, buttons->gadgetheight,
721 FGDT_BITMAP, (IPTR)buttons->bitmap,
722 FGDT_PICX_INACTIVE, buttons->gadgetwidth * 1,
723 FGDT_PICY_INACTIVE, buttons->gadgetheight * 0,
724 FGDT_PICX_PRESSED, buttons->gadgetwidth * 1,
725 FGDT_PICY_PRESSED, buttons->gadgetheight * 1,
726 FGDT_PICX_ROLLOVER, buttons->gadgetwidth * 1,
727 FGDT_PICY_ROLLOVER, buttons->gadgetheight * 0,
728 TAG_DONE)))
729 {
730 AddFakeGadget(buttons->gadgetlist, buttons->gadgets[GAD_RESTART]);
731 success = TRUE;
732 }
733 }
734 if (success)
735 {
736 if ((buttons->gadgets[GAD_PREV] = CreateFakeGadget(
737 GAD_PREV, FGADTYPE_PUSH,
738 FGDT_WIDTH, buttons->gadgetwidth,
739 FGDT_HEIGHT, buttons->gadgetheight,
740 FGDT_BITMAP, (IPTR)buttons->bitmap,
741 FGDT_PICX_INACTIVE, buttons->gadgetwidth * 2,
742 FGDT_PICY_INACTIVE, buttons->gadgetheight * 0,
743 FGDT_PICX_PRESSED, buttons->gadgetwidth * 2,
744 FGDT_PICY_PRESSED, buttons->gadgetheight * 1,
745 FGDT_PICX_ROLLOVER, buttons->gadgetwidth * 2,
746 FGDT_PICY_ROLLOVER, buttons->gadgetheight * 0,
747 TAG_DONE)))
748 {
749 AddFakeGadget(buttons->gadgetlist, buttons->gadgets[GAD_PREV]);
750 success = TRUE;
751 }
752 }
753 if (success)
754 {
755 if ((buttons->gadgets[GAD_NEXT] = CreateFakeGadget(
756 GAD_NEXT, FGADTYPE_PUSH,
757 FGDT_WIDTH, buttons->gadgetwidth,
758 FGDT_HEIGHT, buttons->gadgetheight,
759 FGDT_BITMAP, (IPTR)buttons->bitmap,
760 FGDT_PICX_INACTIVE, buttons->gadgetwidth * 3,
761 FGDT_PICY_INACTIVE, buttons->gadgetheight * 0,
762 FGDT_PICX_PRESSED, buttons->gadgetwidth * 3,
763 FGDT_PICY_PRESSED, buttons->gadgetheight * 1,
764 FGDT_PICX_ROLLOVER, buttons->gadgetwidth * 3,
765 FGDT_PICY_ROLLOVER, buttons->gadgetheight * 0,
766 TAG_DONE)))
767 {
768 AddFakeGadget(buttons->gadgetlist, buttons->gadgets[GAD_NEXT]);
769 success = TRUE;
770 }
771 }
772 if (success)
773 {
774 if ((buttons->gadgets[GAD_SLIDE] = CreateFakeGadget(
775 GAD_SLIDE, FGADTYPE_TOGGLE,
776 FGDT_WIDTH, buttons->gadgetwidth,
777 FGDT_HEIGHT, buttons->gadgetheight,
778 FGDT_BITMAP, (IPTR)buttons->bitmap,
779 FGDT_PICX_INACTIVE, buttons->gadgetwidth * 4,
780 FGDT_PICY_INACTIVE, buttons->gadgetheight * 0,
781 FGDT_PICX_PRESSED, buttons->gadgetwidth * 4,
782 FGDT_PICY_PRESSED, buttons->gadgetheight * 1,
783 FGDT_PICX_ROLLOVER, buttons->gadgetwidth * 4,
784 FGDT_PICY_ROLLOVER, buttons->gadgetheight * 0,
785 FGDT_PICX_ACTIVE, buttons->gadgetwidth * 4,
786 FGDT_PICY_ACTIVE, buttons->gadgetheight * 2,
787 FGDT_PICX_ACTIVEPRESSED, buttons->gadgetwidth * 4,
788 FGDT_PICY_ACTIVEPRESSED, buttons->gadgetheight * 3,
789 FGDT_PICX_ACTIVEROLLOVER, buttons->gadgetwidth * 4,
790 FGDT_PICY_ACTIVEROLLOVER, buttons->gadgetheight * 2,
791 TAG_DONE)))
792 {
793 AddFakeGadget(buttons->gadgetlist, buttons->gadgets[GAD_SLIDE]);
794 success = TRUE;
795 }
796 }
797 if (success)
798 {
799 if ((buttons->gadgets[GAD_LOOP] = CreateFakeGadget(
800 GAD_LOOP, FGADTYPE_TOGGLE,
801 FGDT_WIDTH, buttons->gadgetwidth,
802 FGDT_HEIGHT, buttons->gadgetheight,
803 FGDT_BITMAP, (IPTR)buttons->bitmap,
804 FGDT_PICX_INACTIVE, buttons->gadgetwidth * 5,
805 FGDT_PICY_INACTIVE, buttons->gadgetheight * 0,
806 FGDT_PICX_PRESSED, buttons->gadgetwidth * 5,
807 FGDT_PICY_PRESSED, buttons->gadgetheight * 1,
808 FGDT_PICX_ROLLOVER, buttons->gadgetwidth * 5,
809 FGDT_PICY_ROLLOVER, buttons->gadgetheight * 0,
810 FGDT_PICX_ACTIVE, buttons->gadgetwidth * 5,
811 FGDT_PICY_ACTIVE, buttons->gadgetheight * 2,
812 FGDT_PICX_ACTIVEPRESSED, buttons->gadgetwidth * 5,
813 FGDT_PICY_ACTIVEPRESSED, buttons->gadgetheight * 3,
814 FGDT_PICX_ACTIVEROLLOVER, buttons->gadgetwidth * 5,
815 FGDT_PICY_ACTIVEROLLOVER, buttons->gadgetheight * 2,
816 TAG_DONE)))
817 {
818 AddFakeGadget(buttons->gadgetlist, buttons->gadgets[GAD_LOOP]);
819 success = TRUE;
820 }
821 }
822 if (success)
823 {
824 if ((buttons->gadgets[GAD_DISPLAYMODE] = CreateFakeGadget(
825 GAD_DISPLAYMODE, FGADTYPE_TOGGLE,
826 FGDT_WIDTH, buttons->gadgetwidth,
827 FGDT_HEIGHT, buttons->gadgetheight,
828 FGDT_BITMAP, (IPTR)buttons->bitmap,
829 FGDT_PICX_INACTIVE, buttons->gadgetwidth * 6,
830 FGDT_PICY_INACTIVE, buttons->gadgetheight * 0,
831 FGDT_PICX_PRESSED, buttons->gadgetwidth * 6,
832 FGDT_PICY_PRESSED, buttons->gadgetheight * 1,
833 FGDT_PICX_ROLLOVER, buttons->gadgetwidth * 6,
834 FGDT_PICY_ROLLOVER, buttons->gadgetheight * 0,
835 FGDT_PICX_ACTIVE, buttons->gadgetwidth * 6,
836 FGDT_PICY_ACTIVE, buttons->gadgetheight * 2,
837 FGDT_PICX_ACTIVEPRESSED, buttons->gadgetwidth * 6,
838 FGDT_PICY_ACTIVEPRESSED, buttons->gadgetheight * 3,
839 FGDT_PICX_ACTIVEROLLOVER, buttons->gadgetwidth * 6,
840 FGDT_PICY_ACTIVEROLLOVER, buttons->gadgetheight * 2,
841 TAG_DONE)))
842 {
843 AddFakeGadget(buttons->gadgetlist, buttons->gadgets[GAD_DISPLAYMODE]);
844 success = TRUE;
845 }
846 }
847 if (success)
848 {
849 if ((buttons->gadgets[GAD_RESET] = CreateFakeGadget(
850 GAD_RESET, FGADTYPE_PUSH,
851 FGDT_WIDTH, buttons->gadgetwidth,
852 FGDT_HEIGHT, buttons->gadgetheight,
853 FGDT_BITMAP, (IPTR)buttons->bitmap,
854 FGDT_PICX_INACTIVE, buttons->gadgetwidth * 7,
855 FGDT_PICY_INACTIVE, buttons->gadgetheight * 0,
856 FGDT_PICX_PRESSED, buttons->gadgetwidth * 7,
857 FGDT_PICY_PRESSED, buttons->gadgetheight * 1,
858 FGDT_PICX_ROLLOVER, buttons->gadgetwidth * 7,
859 FGDT_PICY_ROLLOVER, buttons->gadgetheight * 0,
860 TAG_DONE)))
861 {
862 AddFakeGadget(buttons->gadgetlist, buttons->gadgets[GAD_RESET]);
863 success = TRUE;
864 }
865 }
866 }
867 }
868 }
869
870 if (!success)
871 {
872 DeleteButtons(buttons);
873 buttons = NULL;
874 }
875
876 return buttons;
877 }
878
879
880 /*--------------------------------------------------------------------
881
882 DrawButtons(viewdata, win, buttons)
883
884 --------------------------------------------------------------------*/
885
886 void DrawButtons(struct viewdata *viewdata, struct mvwindow *win, struct MVButtons *buttons)
887 {
888 if (buttons && win)
889 {
890 int height;
891
892 if (!buttons->bitmap)
893 {
894 ObtainButtons(viewdata, buttons, win->window);
895 }
896
897 ObtainSemaphore(&viewdata->rastlock);
898
899 UpdateWindowParameters(win);
900
901 height = MAX(buttons->gadgetheight + BUTTON_VSPACE * 2, ANIMHEIGHT);
902
903 SetAPen(win->window->RPort, win->backpen);
904 RectFill(win->window->RPort, win->innerleft, win->innertop,
905 win->innerleft + win->innerwidth - 1,
906 win->innertop + height - 1);
907
908 if (buttons->bitmap)
909 {
910 int x;
911 float width;
912
913 width = buttons->gadgetwidth * GAD_NUM;
914 width = MAX((float) win->innerwidth * 0.45, width);
915 width = MIN(width, win->innerwidth - BUTTON_HSPACE * 2);
916
917 x = (win->innerwidth - (int)width) / 2;
918
919 LayoutFakeGadgetList(buttons->gadgetlist, ORIENTATION_RIGHT,
920 (int) width, height - 2 * BUTTON_VSPACE,
921 x,
922 win->innertop + (height - buttons->gadgetheight) / 2);
923
924 // AnimateButtons(viewdata, buttons, TRUE);
925
926 DrawFakeGadgetList(buttons->gadgetlist, buttons->bitmap);
927 }
928
929 ReleaseSemaphore(&viewdata->rastlock);
930 }
931 }
932
933
934 /*--------------------------------------------------------------------
935
936 SetButtonSettings(viewdata, window, buttons, settings, always)
937
938 --------------------------------------------------------------------*/
939
940 void SetButtonSettings(struct viewdata *viewdata, struct mvwindow *win, struct MVButtons *buttons, struct mainsettings *settings, BOOL always)
941 {
942 if (buttons)
943 {
944 int change = 0;
945
946 if (settings->slideshow != buttons->gadgets[GAD_SLIDE]->togglestatus)
947 {
948 buttons->gadgets[GAD_SLIDE]->togglestatus = settings->slideshow;
949 change++;
950 }
951
952 if (settings->loop != buttons->gadgets[GAD_LOOP]->togglestatus)
953 {
954 buttons->gadgets[GAD_LOOP]->togglestatus = settings->loop;
955 change++;
956 }
957
958 if (settings->displaymode !=
959 (buttons->gadgets[GAD_DISPLAYMODE]->togglestatus ?
960 MVDISPMODE_KEEPASPECT_MIN : MVDISPMODE_IGNOREASPECT))
961 {
962 buttons->gadgets[GAD_DISPLAYMODE]->togglestatus =
963 settings->displaymode == MVDISPMODE_KEEPASPECT_MIN ? TRUE : FALSE;
964 change++;
965 }
966
967 if ((change || always) && settings->showbuttons)
968 {
969 DrawButtons(viewdata, win, buttons);
970 }
971 }
972 }
973
974
975 /*******************************************************************
976 --------------------------------------------------------------------
977
978 VIEWDATA
979
980 --------------------------------------------------------------------
981 *******************************************************************/
982
983 /*--------------------------------------------------------------------
984
985 DeleteViewData(viewdata)
986
987 --------------------------------------------------------------------*/
988
989 void DeleteViewData(struct viewdata *viewdata)
990 {
991 if (viewdata)
992 {
993 CloseTrigger(viewdata->trigger);
994 FreeSignal(viewdata->picturevisiblesignal);
995 DeletePicHandler(viewdata->pichandler);
996 Free(viewdata->pathname);
997 Free(viewdata->filename);
998 Free(viewdata->formatname);
999 Free(viewdata);
1000 }
1001 }
1002
1003
1004 /*--------------------------------------------------------------------
1005
1006 viewdata = CreateViewData(startfilepatternlist)
1007
1008 --------------------------------------------------------------------*/
1009
1010 struct viewdata *CreateViewData(char **startfilepatternlist)
1011 {
1012 struct viewdata *viewdata;
1013
1014 if ((viewdata = Malloclear(sizeof(struct viewdata))))
1015 {
1016 viewdata->zoom = 1;
1017 viewdata->destzoom = 1;
1018 viewdata->xpos = .5;
1019 viewdata->destxpos = .5;
1020 viewdata->ypos = .5;
1021 viewdata->destypos = .5;
1022 viewdata->angle = 0;
1023 viewdata->oldzoom = viewdata->zoom;
1024 viewdata->oldxpos = viewdata->xpos;
1025 viewdata->oldypos = viewdata->ypos;
1026 viewdata->startfilepatternlist = startfilepatternlist;
1027
1028 viewdata->trigger = CreateTrigger();
1029 viewdata->picturevisiblesignal = AllocSignal(-1);
1030
1031 InitSemaphore(&viewdata->rastlock);
1032
1033 if (!viewdata->trigger || viewdata->picturevisiblesignal == (UBYTE)-1)
1034 {
1035 DeleteViewData(viewdata);
1036 viewdata = NULL;
1037 }
1038 }
1039
1040 return viewdata;
1041 }
1042
1043
1044 #define SMOOTHCUTOFF (0.0005)
1045
1046 /*--------------------------------------------------------------------
1047
1048 ApplyViewData(struct viewdata *viewdata, settings, BOOL check)
1049
1050 --------------------------------------------------------------------*/
1051
1052 void ApplyViewData(struct viewdata *viewdata, struct mainsettings *settings, BOOL check)
1053 {
1054 BOOL delay_smooth = FALSE;
1055 float deltazoom, deltaxpos, deltaypos;
1056 float xpos, ypos, zoom;
1057 int angle;
1058 ULONG *tagptr = viewdata->tagbuffer;
1059 int changecount = 0;
1060
1061 assert(viewdata);
1062 assert(viewdata->view);
1063
1064 viewdata->destzoom = RNG(0.1f, viewdata->destzoom, 10.0f);
1065 viewdata->destxpos = RNG(0.0f, viewdata->destxpos, 1.0f);
1066 viewdata->destypos = RNG(0.0f, viewdata->destypos, 1.0f);
1067
1068 if (settings->smoothdisplay)
1069 {
1070 deltazoom = viewdata->destzoom - viewdata->zoom;
1071 if (ABS(deltazoom) > SMOOTHCUTOFF)
1072 {
1073 deltazoom /= 2;
1074 viewdata->zoom += deltazoom;
1075 delay_smooth = TRUE;
1076 }
1077 else
1078 {
1079 viewdata->zoom = viewdata->destzoom;
1080 }
1081
1082 deltaxpos = viewdata->destxpos - viewdata->xpos;
1083 if (ABS(deltaxpos) > SMOOTHCUTOFF)
1084 {
1085 deltaxpos /= 2;
1086 viewdata->xpos += deltaxpos;
1087 delay_smooth = TRUE;
1088 }
1089 else
1090 {
1091 viewdata->xpos = viewdata->destxpos;
1092 }
1093
1094 deltaypos = viewdata->destypos - viewdata->ypos;
1095 if (ABS(deltaypos) > SMOOTHCUTOFF)
1096 {
1097 deltaypos /= 2;
1098 viewdata->ypos += deltaypos;
1099 delay_smooth = TRUE;
1100 }
1101 else
1102 {
1103 viewdata->ypos = viewdata->destypos;
1104 }
1105 }
1106 else
1107 {
1108 viewdata->zoom = viewdata->destzoom;
1109 viewdata->xpos = viewdata->destxpos;
1110 viewdata->ypos = viewdata->destypos;
1111 }
1112
1113 xpos = RNG(0.0, viewdata->xpos, 1.0);
1114 ypos = RNG(0.0, viewdata->ypos, 1.0);
1115 zoom = RNG(0.1, viewdata->zoom, 10);
1116 angle = viewdata->angle;
1117
1118 if (!check || ABS(xpos - viewdata->oldxpos) > SMOOTHCUTOFF)
1119 {
1120 *tagptr++ = MVIEW_XPos;
1121 *tagptr++ = (ULONG) (xpos * 65536);
1122 changecount++;
1123 }
1124 viewdata->oldxpos = xpos;
1125
1126 if (!check || ABS(ypos - viewdata->oldypos) > SMOOTHCUTOFF)
1127 {
1128 *tagptr++ = MVIEW_YPos;
1129 *tagptr++ = (ULONG) (ypos * 65536);
1130 changecount++;
1131 }
1132 viewdata->oldypos = ypos;
1133
1134 if (!check || ABS(zoom - viewdata->oldzoom) > SMOOTHCUTOFF)
1135 {
1136 *tagptr++ = MVIEW_Zoom;
1137 *tagptr++ = (ULONG) (zoom * 65536);
1138 changecount++;
1139 }
1140 viewdata->oldzoom = zoom;
1141
1142 if (!check || (angle - viewdata->oldangle))
1143 {
1144 *tagptr++ = MVIEW_Rotation;
1145 *tagptr++ = angle;
1146 viewdata->oldangle = angle;
1147 changecount++;
1148 }
1149
1150 if (changecount)
1151 {
1152 *tagptr = TAG_DONE;
1153
1154 MV_SetAttrsA(viewdata->view, (struct TagItem *) viewdata->tagbuffer);
1155
1156 if (delay_smooth)
1157 {
1158 Delay(1);
1159 }
1160 }
1161 }
1162
1163
1164 /*--------------------------------------------------------------------
1165
1166 char *SetPicInfoText(viewdata, pic, settings)
1167
1168 --------------------------------------------------------------------*/
1169
1170 char *SetPicInfoText(struct viewdata *viewdata, PICTURE *pic, struct mainsettings *settings)
1171 {
1172 char *pitext = NULL;
1173
1174 if (viewdata && settings)
1175 {
1176 if (settings->picinfo && viewdata->pichandler)
1177 {
1178 int maxpic, currentpic, status;
1179 BOOL infotext = FALSE;
1180
1181 viewdata->statustext[0] = 0;
1182 viewdata->picturetext[0] = 0;
1183
1184 if (pic)
1185 {
1186 APTR args[6];
1187 ULONG w = 0, h = 0, d = 0;
1188 ULONG p;
1189 GetPictureAttrs(pic,
1190 PICATTR_Width, (IPTR)&w, PICATTR_Height, (IPTR)&h, PICATTR_PixelFormat, (IPTR)&p,
1191 TAG_DONE);
1192 d = p == PIXFMT_CHUNKY_CLUT ? 8 : 24;
1193
1194 args[0] = viewdata->pathname;
1195 args[1] = viewdata->filename;
1196 args[2] = (APTR) (IPTR) w;
1197 args[3] = (APTR) (IPTR) h;
1198 args[4] = (APTR) (IPTR) d;
1199 args[5] = viewdata->formatname;
1200
1201 infotext = FormatInfoText(viewdata->picturetext, settings->picformat, args);
1202 }
1203
1204
1205 maxpic = GetTotalPicNumber(viewdata->pichandler);
1206 currentpic = GetCurrentPicNumber(viewdata->pichandler);
1207 status = GetPicHandlerStatus(viewdata->pichandler);
1208
1209
1210 if (maxpic == 0)
1211 {
1212 sprintf(viewdata->statustext, MVTEXT_STAT_NOPIX);
1213 }
1214 else if (viewdata->pichandler->errortext)
1215 {
1216 char *errortext = GetErrorText(viewdata->pichandler->error);
1217
1218 if (errortext)
1219 {
1220 sprintf(viewdata->statustext, "%s - %s", viewdata->pichandler->errortext, errortext);
1221 }
1222 else
1223 {
1224 sprintf(viewdata->statustext, "%s", viewdata->pichandler->errortext);
1225 }
1226 }
1227 else if (infotext)
1228 {
1229 if (maxpic > 1)
1230 {
1231 if (settings->slideshow)
1232 {
1233 if (status & PICHSTATUS_LOADING)
1234 {
1235 char *text = viewdata->isdirectory ?
1236 MVTEXT_STAT_SLIDESHOWLOADING_DIR :
1237 MVTEXT_STAT_SLIDESHOWLOADING;
1238
1239 sprintf(viewdata->statustext, text, currentpic + 1, maxpic, viewdata->picturetext);
1240 }
1241 else
1242 {
1243 char *text = viewdata->isdirectory ?
1244 MVTEXT_STAT_SLIDESHOW_DIR :
1245 MVTEXT_STAT_SLIDESHOW;
1246
1247 sprintf(viewdata->statustext, text, currentpic + 1, maxpic, viewdata->picturetext);
1248 }
1249 }
1250 else
1251 {
1252 if (status & PICHSTATUS_LOADING)
1253 {
1254 char *text = viewdata->isdirectory ?
1255 MVTEXT_STAT_MULTILOADING_DIR :
1256 MVTEXT_STAT_MULTILOADING;
1257
1258 sprintf(viewdata->statustext, text, currentpic + 1, maxpic, viewdata->picturetext);
1259 }
1260 else
1261 {
1262 char *text = viewdata->isdirectory ?
1263 MVTEXT_STAT_MULTI_DIR :
1264 MVTEXT_STAT_MULTI;
1265
1266 sprintf(viewdata->statustext, text, currentpic + 1, maxpic, viewdata->picturetext);
1267 }
1268 }
1269 }
1270 else
1271 {
1272 if (status & PICHSTATUS_LOADING)
1273 {
1274 char *text = viewdata->isdirectory ?
1275 MVTEXT_STAT_NORMALLOADING_DIR :
1276 MVTEXT_STAT_NORMALLOADING;
1277
1278 sprintf(viewdata->statustext, text, viewdata->picturetext);
1279 }
1280 else
1281 {
1282 char *text = viewdata->isdirectory ?
1283 MVTEXT_STAT_NORMAL_DIR :
1284 MVTEXT_STAT_NORMAL;
1285
1286 sprintf(viewdata->statustext, text, viewdata->picturetext);
1287 }
1288 }
1289 }
1290 else
1291 {
1292 if (maxpic > 1)
1293 {
1294 if (status & PICHSTATUS_LOADING)
1295 {
1296 sprintf(viewdata->statustext, MVTEXT_STAT_SCANNINGLOADING, (long)maxpic);
1297 }
1298 else
1299 {
1300 sprintf(viewdata->statustext, MVTEXT_STAT_SCANNING, (long)maxpic);
1301 }
1302 }
1303 else
1304 {
1305 if (status & PICHSTATUS_LOADING)
1306 {
1307 sprintf(viewdata->statustext, MVTEXT_STAT_LOADING_ONE);
1308 }
1309 }
1310 }
1311
1312
1313 if (strlen(viewdata->statustext))
1314 {
1315 pitext = viewdata->statustext;
1316 }
1317 }
1318 else
1319 {
1320 pitext = NULL; //"text disabled / no pichandler";
1321 }
1322 }
1323
1324 return pitext;
1325 }
1326
1327
1328 /*--------------------------------------------------------------------
1329
1330 DeleteViewPic(viewdata, defaultpic, settings)
1331
1332 --------------------------------------------------------------------*/
1333
1334 void DeleteViewPic(struct viewdata *viewdata, PICTURE *defaultpic, struct mainsettings *settings)
1335 {
1336 if (viewdata)
1337 {
1338 MV_SetAttrs(viewdata->view,
1339 MVIEW_Text, (IPTR)SetPicInfoText(viewdata, defaultpic, settings),
1340 MVIEW_Picture, (IPTR)defaultpic, TAG_DONE);
1341
1342 viewdata->showpic = NULL;
1343 ReleasePic(viewdata->pichandler);
1344 }
1345 }
1346
1347
1348
1349 /*--------------------------------------------------------------------
1350
1351 newpicsignal = NewPicHandler(viewdata, filepatternlist, settings)
1352
1353 --------------------------------------------------------------------*/
1354
1355 ULONG NewPicHandler(struct viewdata *viewdata, char **filepatternlist, struct mainsettings *settings, PICTURE *defaultpic)
1356 {
1357 if (viewdata)
1358 {
1359 DeletePicHandler(viewdata->pichandler);
1360 viewdata->pichandler = NULL;
1361
1362 if (filepatternlist)
1363 {
1364 DeleteViewPic(viewdata, NULL, settings);
1365 }
1366 else
1367 {
1368 DeleteViewPic(viewdata, defaultpic, settings);
1369 }
1370
1371 viewdata->pichandler = CreatePicHandler(filepatternlist,
1372 settings->asyncscanning,
1373 PICH_SimpleScanning, settings->simplescanning,
1374 PICH_Reject, (IPTR)settings->rejectpattern,
1375 PICH_SortMode, settings->sortmode,
1376 PICH_SortReverse, settings->reverse,
1377 PICH_BufferPercent, settings->bufferpercent,
1378 PICH_AutoCrop, settings->autocrop,
1379 PICH_IncludeDirs, settings->browsemode,
1380 PICH_Recursive, settings->browsemode ? FALSE : settings->recursive,
1381 TAG_DONE);
1382
1383 return NewPicSignal(viewdata->pichandler);
1384 }
1385 else
1386 {
1387 return 0;
1388 }
1389 }
1390
1391
1392
1393 /*--------------------------------------------------------------------
1394
1395 SetViewText(viewdata, text)
1396
1397 --------------------------------------------------------------------*/
1398
1399 void SetViewText(struct viewdata *viewdata, char *text)
1400 {
1401 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)text, TAG_DONE);
1402 }
1403
1404
1405
1406 /*--------------------------------------------------------------------
1407
1408 ResetDisplaySettings(viewdata, yesorno)
1409
1410 --------------------------------------------------------------------*/
1411
1412 void ResetDisplaySettings(struct viewdata *viewdata, BOOL reset)
1413 {
1414 if (reset)
1415 {
1416 viewdata->destzoom = 1;
1417 viewdata->destxpos = .5;
1418 viewdata->destypos = .5;
1419 viewdata->angle = 0;
1420 }
1421 }
1422
1423
1424
1425
1426 /*******************************************************************
1427 --------------------------------------------------------------------
1428
1429 menu functions
1430
1431 --------------------------------------------------------------------
1432 *******************************************************************/
1433
1434 /*--------------------------------------------------------------------
1435
1436 newmenu = CreateNewMenuItems(num, commandkeys, strings, emptystring, idlist)
1437
1438 DeleteNewMenuItems(newmenuitems)
1439
1440 --------------------------------------------------------------------*/
1441
1442 void DeleteNewMenuItems(struct NewMenu *newmenu)
1443 {
1444 struct NewMenu *n;
1445
1446 if ((n = newmenu))
1447 {
1448 do
1449 {
1450 if (newmenu->nm_Label != NM_BARLABEL)
1451 {
1452 Free((APTR)newmenu->nm_Label);
1453 }
1454 Free((APTR)newmenu->nm_CommKey);
1455
1456 } while (newmenu++->nm_Type != NM_END);
1457
1458 Free(n);
1459 }
1460 }
1461
1462
1463 struct NewMenu *CreateNewMenuItems(int num, char **commkeys,
1464 char **strings, char *nostring, APTR *idlist)
1465 {
1466 int i;
1467 struct NewMenu *newitems, *nm;
1468 BOOL error = TRUE;
1469
1470 if ((newitems = Malloclear(sizeof(struct NewMenu) * (num + 2))))
1471 {
1472 error = FALSE;
1473 nm = newitems;
1474
1475 for (i = 0; i < (num + 1) && !error; ++i)
1476 {
1477 if (i == num) /* last entry */
1478 {
1479 nm->nm_Type = NM_END;
1480 }
1481 else
1482 {
1483 error = TRUE;
1484
1485 nm->nm_Type = NM_SUB;
1486 nm->nm_MutualExclude = 0;
1487 nm->nm_UserData = *idlist++;
1488
1489 if (!(*strings))
1490 {
1491 nm->nm_Label = _StrDup(nostring);
1492 }
1493 else if ((STRPTR)(*strings) == NM_BARLABEL)
1494 {
1495 nm->nm_Label = NM_BARLABEL;
1496 }
1497 else
1498 {
1499 nm->nm_Label = _StrDup(*strings);
1500 }
1501
1502 strings++;
1503
1504 nm->nm_Flags = NM_COMMANDSTRING;
1505 if (commkeys)
1506 {
1507 char *c = *commkeys;
1508 if (c[0] == '_')
1509 {
1510 c++;
1511 nm->nm_Flags = 0;
1512 }
1513 nm->nm_CommKey = _StrDup(c);
1514 commkeys++;
1515 }
1516 else
1517 {
1518 nm->nm_CommKey = _StrDup("");
1519 }
1520
1521 if (nm->nm_Label && nm->nm_CommKey)
1522 {
1523 error = FALSE;
1524 }
1525 }
1526 nm++;
1527 }
1528 }
1529
1530 if (!error)
1531 {
1532 return newitems;
1533 }
1534 else
1535 {
1536 DeleteNewMenuItems(newitems);
1537 return NULL;
1538 }
1539 }
1540
1541
1542 /*--------------------------------------------------------------------
1543
1544 SetupPathMenus(mv, settings);
1545 FreePathMenus(mv);
1546
1547 create path menus
1548
1549 --------------------------------------------------------------------*/
1550
1551 void FreePathMenus(struct mview *mv)
1552 {
1553 if (mv)
1554 {
1555 struct MenuItem *it;
1556
1557 if ((it = FindMenuItem(mv->window->menu, MITEM_COPYTOPATH))) it->SubItem = NULL;
1558 if ((it = FindMenuItem(mv->window->menu, MITEM_MOVETOPATH))) it->SubItem = NULL;
1559
1560 if (mv->copypathmenuitems)
1561 FreeMenus((struct Menu *) mv->copypathmenuitems);
1562 mv->copypathmenuitems = NULL;
1563
1564 if (mv->movepathmenuitems)
1565 FreeMenus((struct Menu *) mv->movepathmenuitems);
1566 mv->movepathmenuitems = NULL;
1567
1568 DeleteNewMenuItems(mv->copynewmenuarray); mv->copynewmenuarray = NULL;
1569 DeleteNewMenuItems(mv->movenewmenuarray); mv->movenewmenuarray = NULL;
1570 }
1571 }
1572
1573 void SetupPathMenus(struct mview *mv, struct pathsettings *settings)
1574 {
1575 BOOL success = FALSE;
1576
1577 if (mv && settings)
1578 {
1579 if (mv->window)
1580 {
1581 if (mv->window->menu)
1582 {
1583 char *menuarray[12];
1584 menuarray[0] = settings->copypath;
1585 menuarray[1] = NM_BARLABEL;
1586 menuarray[2] = settings->destpath[0];
1587 menuarray[3] = settings->destpath[1];
1588 menuarray[4] = settings->destpath[2];
1589 menuarray[5] = settings->destpath[3];
1590 menuarray[6] = settings->destpath[4];
1591 menuarray[7] = settings->destpath[5];
1592 menuarray[8] = settings->destpath[6];
1593 menuarray[9] = settings->destpath[7];
1594 menuarray[10] = settings->destpath[8];
1595 menuarray[11] = settings->destpath[9];
1596
1597
1598 ClearMenuStrip(mv->window->window);
1599
1600 FreePathMenus(mv);
1601
1602 {
1603 ULONG ids[12] = {MITEM_COPYTO, MITEM_DUMMY, MITEM_COPY1, MITEM_COPY1 + 1, MITEM_COPY1 + 2, MITEM_COPY1 + 3, MITEM_COPY1 + 4,
1604 MITEM_COPY1 + 5, MITEM_COPY1 + 6, MITEM_COPY1 + 7, MITEM_COPY1 + 8, MITEM_COPY1 + 9};
1605 char *commkeys[12] = {"_C", "", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10"};
1606 if ((mv->copynewmenuarray = CreateNewMenuItems(12, commkeys, menuarray, "(...)", (APTR *) ids)))
1607 {
1608 if ((mv->copypathmenuitems = (struct MenuItem *) CreateMenus(mv->copynewmenuarray, NULL)))
1609 {
1610 if (LayoutMenuItems(mv->copypathmenuitems, mv->screen->visualinfo,
1611 GTMN_NewLookMenus, TRUE, TAG_DONE))
1612 {
1613 success = TRUE;
1614 }
1615 }
1616 }
1617 }
1618
1619 if (success)
1620 {
1621 ULONG ids[12] = {MITEM_MOVETO, MITEM_DUMMY, MITEM_MOVE1, MITEM_MOVE1 + 1, MITEM_MOVE1 + 2, MITEM_MOVE1 + 3, MITEM_MOVE1 + 4,
1622 MITEM_MOVE1 + 5, MITEM_MOVE1 + 6, MITEM_MOVE1 + 7, MITEM_MOVE1 + 8, MITEM_MOVE1 + 9};
1623 char *commkeys[12] = {"_M", "", "SHIFT F1", "SHIFT F2", "SHIFT F3", "SHIFT F4", "SHIFT F5", "SHIFT F6", "SHIFT F7", "SHIFT F8", "SHIFT F9", "SHIFT F10"};
1624 success = FALSE;
1625 if ((mv->movenewmenuarray = CreateNewMenuItems(12, commkeys, menuarray, "(...)", (APTR *) ids)))
1626 {
1627 if ((mv->movepathmenuitems = (struct MenuItem *) CreateMenus(mv->movenewmenuarray, NULL)))
1628 {
1629 if (LayoutMenuItems(mv->movepathmenuitems, mv->screen->visualinfo,
1630 GTMN_NewLookMenus, TRUE, TAG_DONE))
1631 {
1632 success = TRUE;
1633 }
1634 }
1635 }
1636 }
1637
1638 if (success)
1639 {
1640 struct MenuItem *it;
1641 success = FALSE;
1642
1643 if ((it = FindMenuItem(mv->window->menu, MITEM_COPYTOPATH)))
1644 {
1645 it->SubItem = mv->copypathmenuitems;
1646 success = TRUE;
1647 }
1648
1649 if (success)
1650 {
1651 success = FALSE;
1652 if ((it = FindMenuItem(mv->window->menu, MITEM_MOVETOPATH)))
1653 {
1654 it->SubItem = mv->movepathmenuitems;
1655 success = TRUE;
1656 }
1657 }
1658
1659 if (success)
1660 {
1661 success = LayoutMenus(mv->window->menu, mv->screen->visualinfo,
1662 GTMN_NewLookMenus, TRUE, TAG_DONE);
1663 }
1664
1665 if (!success)
1666 {
1667 FreePathMenus(mv);
1668 }
1669 }
1670
1671 SetMenuStrip(mv->window->window, mv->window->menu);
1672 }
1673 }
1674 }
1675 }
1676
1677
1678 /*--------------------------------------------------------------------
1679
1680 SetupPresetMenu(mv, settings);
1681 FreePresetMenu(mv);
1682
1683 create preset menu
1684
1685 --------------------------------------------------------------------*/
1686
1687 void FreePresetMenu(struct mview *mv)
1688 {
1689 if (mv)
1690 {
1691 struct MenuItem *it;
1692
1693 if ((it = FindMenuItem(mv->window->menu, MITEM_USEPRESET)))
1694 {
1695 it->SubItem = NULL;
1696 }
1697
1698 if (mv->presetmenuitems)
1699 {
1700 FreeMenus((struct Menu *) mv->presetmenuitems);
1701 }
1702
1703 mv->presetmenuitems = NULL;
1704
1705 DeleteNewMenuItems(mv->presetmenuarray);
1706 mv->presetmenuarray = NULL;
1707 }
1708 }
1709
1710 void SetupPresetMenu(struct mview *mv, struct pathsettings *settings)
1711 {
1712 BOOL success = FALSE;
1713
1714 if (mv && settings)
1715 {
1716 if (mv->window)
1717 {
1718 if (mv->window->menu)
1719 {
1720 int i;
1721 char *filenames[10];
1722 char *commkeys[10] = {"CTRL F1", "CTRL F2", "CTRL F3", "CTRL F4", "CTRL F5", "CTRL F6", "CTRL F7", "CTRL F8", "CTRL F9", "CTRL F10"};
1723 ULONG ids[10] =
1724 {MITEM_PRESET1, MITEM_PRESET1 + 1, MITEM_PRESET1 + 2, MITEM_PRESET1 + 3, MITEM_PRESET1 + 4,
1725 MITEM_PRESET1 + 5, MITEM_PRESET1 + 6, MITEM_PRESET1 + 7, MITEM_PRESET1 + 8, MITEM_PRESET1 + 9};
1726
1727 for (i = 0; i < 10; ++i)
1728 {
1729 filenames[i] = settings->preset[i] ? _StrDup(FilePart(settings->preset[i])) : NULL;
1730 }
1731
1732 ClearMenuStrip(mv->window->window);
1733
1734 FreePresetMenu(mv);
1735
1736 if ((mv->presetmenuarray = CreateNewMenuItems(10, commkeys, filenames, "(...)", (APTR *) ids)))
1737 {
1738 if ((mv->presetmenuitems = (struct MenuItem *) CreateMenus(mv->presetmenuarray, NULL)))
1739 {
1740 if (LayoutMenuItems(mv->presetmenuitems, mv->screen->visualinfo,
1741 GTMN_NewLookMenus, TRUE, TAG_DONE))
1742 {
1743 success = TRUE;
1744 }
1745 }
1746 }
1747
1748 for (i = 0; i < 10; ++i)
1749 {
1750 Free(filenames[i]);
1751 }
1752
1753 if (success)
1754 {
1755 struct MenuItem *it;
1756 success = FALSE;
1757
1758 if ((it = FindMenuItem(mv->window->menu, MITEM_USEPRESET)))
1759 {
1760 it->SubItem = mv->presetmenuitems;
1761 success = TRUE;
1762 }
1763
1764 if (success)
1765 {
1766 success = LayoutMenus(mv->window->menu, mv->screen->visualinfo,
1767 GTMN_NewLookMenus, TRUE, TAG_DONE);
1768 }
1769
1770 if (!success)
1771 {
1772 FreePresetMenu(mv);
1773 }
1774 }
1775
1776 SetMenuStrip(mv->window->window, mv->window->menu);
1777 }
1778 }
1779 }
1780 }
1781
1782
1783 /*--------------------------------------------------------------------
1784
1785 SetupPubscrenMenu(mv, settings);
1786 FreePubscreenMenu(mv);
1787
1788 create pubscreen menu
1789
1790 --------------------------------------------------------------------*/
1791
1792 void FreePubscreenMenu(struct mview *mv)
1793 {
1794 if (mv)
1795 {
1796 struct MenuItem *it;
1797
1798 if ((it = FindMenuItem(mv->window->menu, MITEM_SELECTPUBSCREEN)))
1799 {
1800 it->SubItem = NULL;
1801 }
1802
1803 if (mv->pubscreenmenuitems)
1804 {
1805 FreeMenus((struct Menu *) mv->pubscreenmenuitems);
1806 }
1807
1808 mv->pubscreenmenuitems = NULL;
1809
1810 DeleteNewMenuItems(mv->pubscreenmenuarray);
1811 mv->pubscreenmenuarray = NULL;
1812 }
1813 }
1814
1815 void SetupPubscreenMenu(struct mview *mv, struct mainsettings *settings)
1816 {
1817 BOOL success = FALSE;
1818
1819 if (mv && settings)
1820 {
1821 if (mv->window)
1822 {
1823 if (mv->window->menu)
1824 {
1825 int numscreens = 0;
1826 struct List *pubscreenlist;
1827
1828 if ((pubscreenlist = LockPubScreenList()))
1829 {
1830 struct Node *node;
1831 struct Node *nextnode;
1832
1833 node = pubscreenlist->lh_Head;
1834 while ((nextnode = node->ln_Succ))
1835 {
1836 numscreens++;
1837 node = nextnode;
1838 }
1839
1840 if (numscreens)
1841 {
1842 int count = 0;
1843
1844 char **p = mv->pubscreenlist;
1845 if (p)
1846 {
1847 while (*p)
1848 {
1849 if ((STRPTR) *p != NM_BARLABEL)
1850 {
1851 Free(*p);
1852 }
1853 p++;
1854 }
1855 Free(mv->pubscreenlist);
1856 }
1857
1858 if ((mv->pubscreenlist = CreateStringList(numscreens + 3)))
1859 {
1860 char *name;
1861
1862 node = pubscreenlist->lh_Head;
1863 while ((nextnode = node->ln_Succ))
1864 {
1865 BOOL getit = TRUE;
1866
1867 name = ((struct PubScreenNode *) node)->psn_Node.ln_Name;
1868
1869 if (getit)
1870 {
1871 if ((mv->pubscreenlist[count + 3] = _StrDup(name)))
1872 {
1873 count++;
1874 }
1875 }
1876 node = nextnode;
1877 }
1878 }
1879 numscreens = count;
1880 }
1881 }
1882 UnlockPubScreenList();
1883
1884 if (numscreens && mv->pubscreenlist)
1885 {
1886 ULONG *idlist;
1887
1888 if ((idlist = Malloc(sizeof(APTR) * (numscreens + 3))))
1889 {
1890 int i;
1891
1892 mv->pubscreenlist[0] = _StrDup("Select Mode...");
1893 mv->pubscreenlist[1] = NM_BARLABEL;
1894 mv->pubscreenlist[2] = _StrDup("Default Screen");
1895
1896 idlist[0] = MITEM_CUSTOMSCREEN;
1897 idlist[1] = MITEM_DUMMY;
1898 idlist[2] = MITEM_DEFAULTSCREEN;
1899 for (i = 0; i < numscreens; ++i)
1900 {
1901 idlist[i + 3] = MITEM_PUBSCREEN1 + i;
1902 }
1903
1904 ClearMenuStrip(mv->window->window);
1905
1906 FreePubscreenMenu(mv);
1907
1908 if ((mv->pubscreenmenuarray = CreateNewMenuItems(numscreens + 3, NULL, mv->pubscreenlist, "", (APTR *) idlist)))
1909 {
1910 if ((mv->pubscreenmenuitems = (struct MenuItem *) CreateMenus(mv->pubscreenmenuarray, NULL)))
1911 {
1912 if (LayoutMenuItems(mv->pubscreenmenuitems, mv->screen->visualinfo,
1913 GTMN_NewLookMenus, TRUE, TAG_DONE))
1914 {
1915 success = TRUE;
1916 }
1917 }
1918 }
1919
1920 if (success)
1921 {
1922 struct MenuItem *it;
1923 success = FALSE;
1924
1925 if ((it = FindMenuItem(mv->window->menu, MITEM_SELECTPUBSCREEN)))
1926 {
1927 it->SubItem = mv->pubscreenmenuitems;
1928 success = TRUE;
1929 }
1930
1931 if (success)
1932 {
1933 success = LayoutMenus(mv->window->menu, mv->screen->visualinfo,
1934 GTMN_NewLookMenus, TRUE, TAG_DONE);
1935 }
1936
1937 if (!success)
1938 {
1939 FreePubscreenMenu(mv);
1940 }
1941 }
1942
1943 SetMenuStrip(mv->window->window, mv->window->menu);
1944
1945 Free(idlist);
1946 }
1947 }
1948 }
1949 }
1950 }
1951 }
1952
1953
1954 /*--------------------------------------------------------------------
1955
1956 SetMenuSettings (mview, settings, viewdata)
1957 put the current settings into the menus.
1958
1959 --------------------------------------------------------------------*/
1960
1961 void SetMenuSettings(struct mview *mv, struct mainsettings *settings)
1962 {
1963 if (mv)
1964 {
1965 if (mv->window)
1966 {
1967 struct Menu *menu = mv->window->menu;
1968
1969 ClearMenuStrip(mv->window->window);
1970
1971 CLEARMENUITEM(menu, MITEM_DITHERON);
1972 CLEARMENUITEM(menu, MITEM_DITHERAUTO);
1973 switch (settings->dither)
1974 {
1975 case MVDITHERMODE_ON:
1976 SETMENUITEM(menu, MITEM_DITHERON);
1977 break;
1978 case MVDITHERMODE_AUTO:
1979 SETMENUITEM(menu, MITEM_DITHERAUTO);
1980 break;
1981 }
1982
1983 CLEARMENUITEM(menu, MITEM_KEEPASPECT1);
1984 CLEARMENUITEM(menu, MITEM_IGNOREASPECT);
1985 switch (settings->displaymode)
1986 {
1987 case MVDISPMODE_KEEPASPECT_MIN:
1988 SETMENUITEM(menu, MITEM_KEEPASPECT1);
1989 break;
1990 case MVDISPMODE_IGNOREASPECT:
1991 SETMENUITEM(menu, MITEM_IGNOREASPECT);
1992 break;
1993 }
1994
1995 CLEARMENUITEM(menu, MITEM_STATIC);
1996 if (settings->staticpalette) SETMENUITEM(menu, MITEM_STATIC);
1997
1998 CLEARMENUITEM(menu, MITEM_BACKDROP);
1999 if (settings->borderless) SETMENUITEM(menu, MITEM_BACKDROP);
2000
2001 CLEARMENUITEM(menu, MITEM_SMALLWINDOW);
2002 CLEARMENUITEM(menu, MITEM_HALFWINDOW);
2003 CLEARMENUITEM(menu, MITEM_LARGEWINDOW);
2004 CLEARMENUITEM(menu, MITEM_VISIBLEWINDOW);
2005 CLEARMENUITEM(menu, MITEM_FULLWINDOW);
2006 CLEARMENUITEM(menu, MITEM_FIXEDWINDOWSIZE);
2007 switch (settings->winsizemode)
2008 {
2009 case WSIZEMODE_33PERCENT:
2010 SETMENUITEM(menu, MITEM_SMALLWINDOW);
2011 break;
2012 case WSIZEMODE_HALF:
2013 SETMENUITEM(menu, MITEM_HALFWINDOW);
2014 break;
2015 case WSIZEMODE_66PERCENT:
2016 SETMENUITEM(menu, MITEM_LARGEWINDOW);
2017 break;
2018 case WSIZEMODE_VISIBLE:
2019 SETMENUITEM(menu, MITEM_VISIBLEWINDOW);
2020 break;
2021 case WSIZEMODE_FULL:
2022 SETMENUITEM(menu, MITEM_FULLWINDOW);
2023 break;
2024 case WSIZEMODE_NONE:
2025 SETMENUITEM(menu, MITEM_FIXEDWINDOWSIZE);
2026 break;
2027 }
2028
2029 CLEARMENUITEM(menu, MITEM_CENTERWINDOW);
2030 CLEARMENUITEM(menu, MITEM_MOUSEWINDOW);
2031 CLEARMENUITEM(menu, MITEM_FIXEDWINDOWPOS);
2032 switch (settings->winopenmode)
2033 {
2034 case WOPENMODE_CENTER:
2035 SETMENUITEM(menu, MITEM_CENTERWINDOW);
2036 break;
2037 case WOPENMODE_MOUSE:
2038 SETMENUITEM(menu, MITEM_MOUSEWINDOW);
2039 break;
2040 case WOPENMODE_NONE:
2041 SETMENUITEM(menu, MITEM_FIXEDWINDOWPOS);
2042 break;
2043 }
2044
2045 CLEARMENUITEM(menu, MITEM_REQUESTFILE);
2046 if (settings->requestfile) SETMENUITEM(menu, MITEM_REQUESTFILE);
2047
2048 CLEARMENUITEM(menu, MITEM_OPAQUE);
2049 CLEARMENUITEM(menu, MITEM_GRID);
2050 switch (settings->previewmode)
2051 {
2052 case MVPREVMODE_OPAQUE:
2053 SETMENUITEM(menu, MITEM_OPAQUE);
2054 break;
2055 case MVPREVMODE_GRID:
2056 SETMENUITEM(menu, MITEM_GRID);
2057 break;
2058 }
2059
2060 CLEARMENUITEM(menu, MITEM_SLIDE);
2061 if (settings->slideshow) SETMENUITEM(menu, MITEM_SLIDE);
2062
2063 CLEARMENUITEM(menu, MITEM_PICINFO);
2064 if (settings->picinfo) SETMENUITEM(menu, MITEM_PICINFO);
2065
2066 CLEARMENUITEM(menu, MITEM_CACHE_OFF);
2067 CLEARMENUITEM(menu, MITEM_CACHE_SMALL);
2068 CLEARMENUITEM(menu, MITEM_CACHE_MEDIUM);
2069 CLEARMENUITEM(menu, MITEM_CACHE_LARGE);
2070 CLEARMENUITEM(menu, MITEM_CACHE_HUGE);
2071 switch (settings->bufferpercent)
2072 {
2073 case 1:
2074 SETMENUITEM(menu, MITEM_CACHE_OFF);
2075 break;
2076 case 15:
2077 SETMENUITEM(menu, MITEM_CACHE_SMALL);
2078 break;
2079 case 25:
2080 SETMENUITEM(menu, MITEM_CACHE_MEDIUM);
2081 break;
2082 case 35:
2083 SETMENUITEM(menu, MITEM_CACHE_LARGE);
2084 break;
2085 case 50:
2086 SETMENUITEM(menu, MITEM_CACHE_HUGE);
2087 break;
2088 default:
2089 break;
2090 }
2091
2092 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_0);
2093 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_04);
2094 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_1);
2095 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_2);
2096 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_5);
2097 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_10);
2098 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_30);
2099 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_60);
2100 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_120);
2101 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_300);
2102 CLEARMENUITEM(menu, MITEM_SLIDEDELAY_600);
2103 switch (settings->slidedelay)
2104 {
2105 case 0:
2106 SETMENUITEM(menu, MITEM_SLIDEDELAY_0);
2107 break;
2108 case 4:
2109 SETMENUITEM(menu, MITEM_SLIDEDELAY_04);
2110 break;
2111 case 10:
2112 SETMENUITEM(menu, MITEM_SLIDEDELAY_1);
2113 break;
2114 case 20:
2115 SETMENUITEM(menu, MITEM_SLIDEDELAY_2);
2116 break;
2117 case 50:
2118 SETMENUITEM(menu, MITEM_SLIDEDELAY_5);
2119 break;
2120 case 100:
2121 SETMENUITEM(menu, MITEM_SLIDEDELAY_10);
2122 break;
2123 case 300:
2124 SETMENUITEM(menu, MITEM_SLIDEDELAY_30);
2125 break;
2126 case 600:
2127 SETMENUITEM(menu, MITEM_SLIDEDELAY_60);
2128 break;
2129 case 1200:
2130 SETMENUITEM(menu, MITEM_SLIDEDELAY_120);
2131 break;
2132 case 3000:
2133 SETMENUITEM(menu, MITEM_SLIDEDELAY_300);
2134 break;
2135 case 6000:
2136 SETMENUITEM(menu, MITEM_SLIDEDELAY_600);
2137 break;
2138 default:
2139 break;
2140 }
2141
2142 CLEARMENUITEM(menu, MITEM_AUTOQUIT);
2143 if (settings->autoquit) SETMENUITEM(menu, MITEM_AUTOQUIT);
2144
2145 CLEARMENUITEM(menu, MITEM_AUTOSTOP);
2146 if (settings->autostop) SETMENUITEM(menu, MITEM_AUTOSTOP);
2147
2148 CLEARMENUITEM(menu, MITEM_AUTOCLEAR);
2149 if (settings->autoclear) SETMENUITEM(menu, MITEM_AUTOCLEAR);
2150
2151 CLEARMENUITEM(menu, MITEM_AUTOHIDE);
2152 if (settings->autohide) SETMENUITEM(menu, MITEM_AUTOHIDE);
2153
2154 CLEARMENUITEM(menu, MITEM_LOOP);
2155 if (settings->loop) SETMENUITEM(menu, MITEM_LOOP);
2156
2157 CLEARMENUITEM(menu, MITEM_SORT_NONE);
2158 CLEARMENUITEM(menu, MITEM_SORT_ALPHA_FILE);
2159 CLEARMENUITEM(menu, MITEM_SORT_ALPHA_FULL);
2160 CLEARMENUITEM(menu, MITEM_SORT_RANDOM);
2161 CLEARMENUITEM(menu, MITEM_SORT_FILESIZE);
2162 CLEARMENUITEM(menu, MITEM_SORT_DATE);
2163 switch (settings->sortmode)
2164 {
2165 case SORTMODE_NONE:
2166 SETMENUITEM(menu, MITEM_SORT_NONE);
2167 break;
2168 case SORTMODE_ALPHA_FILE:
2169 SETMENUITEM(menu, MITEM_SORT_ALPHA_FILE);
2170 break;
2171 case SORTMODE_RANDOM:
2172 SETMENUITEM(menu, MITEM_SORT_RANDOM);
2173 break;
2174 case SORTMODE_FILESIZE:
2175 SETMENUITEM(menu, MITEM_SORT_FILESIZE);
2176 break;
2177 case SORTMODE_ALPHA_FULL:
2178 SETMENUITEM(menu, MITEM_SORT_ALPHA_FULL);
2179 break;
2180 case SORTMODE_DATE:
2181 SETMENUITEM(menu, MITEM_SORT_DATE);
2182 break;
2183 }
2184
2185 CLEARMENUITEM(menu, MITEM_SORT_REVERSE);
2186 if (settings->reverse) SETMENUITEM(menu, MITEM_SORT_REVERSE);
2187
2188 CLEARMENUITEM(menu, MITEM_MARKCENTER);
2189 if (settings->markcenter) SETMENUITEM(menu, MITEM_MARKCENTER);
2190
2191 CLEARMENUITEM(menu, MITEM_SHOWARROWS);
2192 if (settings->showarrows) SETMENUITEM(menu, MITEM_SHOWARROWS);
2193
2194 CLEARMENUITEM(menu, MITEM_SHOWPIP);
2195 if (settings->showpip) SETMENUITEM(menu, MITEM_SHOWPIP);
2196
2197 CLEARMENUITEM(menu, MITEM_SHOWBUTTONS);
2198 if (settings->showbuttons) SETMENUITEM(menu, MITEM_SHOWBUTTONS);
2199
2200 CLEARMENUITEM(menu, MITEM_RESETDISPLAYSETTINGS);
2201 if (settings->resetdisplaysettings) SETMENUITEM(menu, MITEM_RESETDISPLAYSETTINGS);
2202
2203 CLEARMENUITEM(menu, MITEM_CREATETHUMBNAILS);
2204 if (settings->createthumbnails) SETMENUITEM(menu, MITEM_CREATETHUMBNAILS);
2205
2206 CLEARMENUITEM(menu, MITEM_ASYNCSCANNING);
2207 if (settings->asyncscanning) SETMENUITEM(menu, MITEM_ASYNCSCANNING);
2208
2209 CLEARMENUITEM(menu, MITEM_FILTERPICTURES);
2210 if (settings->filterpictures) SETMENUITEM(menu, MITEM_FILTERPICTURES);
2211
2212 CLEARMENUITEM(menu, MITEM_APPENDICONS);
2213 if (settings->appendicons) SETMENUITEM(menu, MITEM_APPENDICONS);
2214
2215 CLEARMENUITEM(menu, MITEM_LMB_DRAG);
2216 if (settings->leftmouseaction == MOUSEACTION_DRAG) SETMENUITEM(menu, MITEM_LMB_DRAG);
2217
2218 CLEARMENUITEM(menu, MITEM_AUTODISPLAYMODE);
2219 if (settings->autodisplaymode) SETMENUITEM(menu, MITEM_AUTODISPLAYMODE);
2220
2221 CLEARMENUITEM(menu, MITEM_AUTOCROP);
2222 if (settings->autocrop) SETMENUITEM(menu, MITEM_AUTOCROP);
2223
2224 ResetMenuStrip(mv->window->window, mv->window->menu);
2225 }
2226 }
2227
2228 }
2229
2230
2231 void SetMenuPathSettings(struct mview *mv, struct pathsettings *settings)
2232 {
2233 if (mv)
2234 {
2235 if (mv->window)
2236 {
2237 struct Menu *menu = mv->window->menu;
2238
2239 ClearMenuStrip(mv->window->window);
2240
2241 CLEARMENUITEM(menu, MITEM_AUTOSAVESETTINGS);
2242 if (settings->autosavesettings) SETMENUITEM(menu, MITEM_AUTOSAVESETTINGS);
2243
2244 ResetMenuStrip(mv->window->window, mv->window->menu);
2245 }
2246 }
2247 }
2248
2249
2250 //////////////////////////////////////////////////////////////////////
2251 //////////////////////////////////////////////////////////////////////
2252 //////////////////////////////////////////////////////////////////////
2253
2254
2255
2256
2257 //////////////////////////////////////////////////////////////////////
2258 //////////////////////////////////////////////////////////////////////
2259 //////////////////////////////////////////////////////////////////////
2260
2261 /*********************************************************************
2262 ----------------------------------------------------------------------
2263
2264 waslastpic = GetNextPicture(mview, buttons, viewdata, settings, no-more-pic)
2265
2266 ----------------------------------------------------------------------
2267 *********************************************************************/
2268
2269 BOOL GetNextPicture(struct mview *mv, struct MVButtons *buttons, struct viewdata *viewdata,
2270 struct mainsettings *settings, PICTURE *defaultpic, ULONG *newpicsignal)
2271 {
2272 BOOL lastpic = FALSE;
2273
2274 if (viewdata->pichandler)
2275 {
2276 BOOL getit = TRUE;
2277
2278 if (GetNextPicNumber(viewdata->pichandler) == 0)
2279 {
2280 if (GetCurrentPicNumber(viewdata->pichandler) != -1)
2281 {
2282 if (GetTotalPicNumber(viewdata->pichandler) == 1)
2283 {
2284 getit = FALSE;
2285 lastpic = FALSE;
2286 }
2287 else
2288 {
2289 if (!settings->loop)
2290 {
2291 lastpic = TRUE;
2292 getit = FALSE;
2293
2294 DeleteViewPic(viewdata, defaultpic, settings);
2295 // Free(viewdata->picinfotext);
2296 // viewdata->picinfotext = NULL;
2297 SetViewText(viewdata, MVTEXT_SELECTNEXTPICTORESUME);
2298 ResetPicHandler(viewdata->pichandler);
2299 }
2300 }
2301 }
2302 }
2303
2304 if (getit)
2305 {
2306 NextPic(viewdata->pichandler); // request next picture
2307 // SetViewText(viewdata, SetPicInfoText(viewdata, defaultpic, settings));
2308 }
2309
2310 SetTrigger(viewdata->trigger, 0); // suspend trigger
2311 }
2312
2313 if (lastpic)
2314 {
2315 ResetDisplaySettings(viewdata, settings->resetdisplaysettings);
2316 if (settings->autostop) settings->slideshow = FALSE;
2317 SetMenuSettings(mv, settings);
2318 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
2319
2320 if (settings->autoclear)
2321 {
2322 //signals &= ~newpicsignal;
2323 *newpicsignal = NewPicHandler(viewdata, NULL, settings, mv->logopic);
2324 }
2325
2326 }
2327
2328 return lastpic;
2329 }
2330
2331
2332 /*********************************************************************
2333 ----------------------------------------------------------------------
2334
2335 GetCurrentPicture(mview, buttons, viewdata, settings, no-more-pic)
2336
2337 ----------------------------------------------------------------------
2338 *********************************************************************/
2339
2340 void GetCurrentPicture(struct mview *mv, struct MVButtons *buttons, struct viewdata *viewdata,
2341 struct mainsettings *settings, PICTURE *defaultpic)
2342 {
2343 if (viewdata->pichandler)
2344 {
2345 BOOL getit = TRUE;
2346
2347 if (GetTotalPicNumber(viewdata->pichandler) == 0)
2348 {
2349 DeleteViewPic(viewdata, defaultpic, settings);
2350 getit = FALSE;
2351 }
2352 else
2353 {
2354 if (GetNextPicNumber(viewdata->pichandler) == 0)
2355 {
2356 getit = TRUE;
2357 }
2358 }
2359
2360 if (getit)
2361 {
2362 CurrentPic(viewdata->pichandler); // request
2363 }
2364
2365 //!!!!!!!!! SetViewText(viewdata, SetPicInfoText(viewdata, defaultpic, settings));
2366
2367 SetTrigger(viewdata->trigger, 0); // suspend trigger
2368 }
2369 }
2370
2371
2372 /*********************************************************************
2373 ----------------------------------------------------------------------
2374
2375 status = HandleMView (mview, **settings, **pathsettings, oldsettings, viewdata, reopen, char **filepatternlist)
2376
2377 ----------------------------------------------------------------------
2378 *********************************************************************/
2379
2380 int HandleMView (struct mview *mv,
2381 struct mainsettings **initsettings,
2382 struct pathsettings **initpathsettings,
2383 struct mainsettings *oldsettings, struct viewdata *viewdata, BOOL reopen)
2384 {
2385 #define REQUEST_NONE 0
2386 #define REQUEST_OPENFILES 1
2387 #define REQUEST_APPENDFILES 2
2388
2389 int status = STATUS_WORKING;
2390 int requestfiles = REQUEST_NONE;
2391
2392 BOOL mousebutton = FALSE;
2393 BOOL checkinvisiblegadgets = FALSE;
2394
2395 BOOL slidesuspended = FALSE;
2396
2397 struct Window *win;
2398 struct Menu *menu;
2399 struct IntuiMessage *imsg;
2400 struct AppMessage *appmsg;
2401
2402 ULONG signals;
2403 ULONG loadsignal = 0;
2404 ULONG idcmpsignal;
2405 ULONG appsignal;
2406 ULONG triggersignal;
2407 ULONG newpicsignal = 0;
2408
2409 struct MVButtons *buttons;
2410
2411 ULONG cxsignal = 1 << (mv->brokermsgport->mp_SigBit);
2412 CxMsg *cxmsg;
2413
2414 struct mainsettings *settings = *initsettings;
2415 struct pathsettings *pathsettings = *initpathsettings;
2416
2417 BOOL setviewrelative = FALSE;
2418
2419 ULONG currentidcmp = mv->window->idcmpmask;
2420
2421
2422 /*
2423 ** init menus
2424 */
2425
2426 SetupPathMenus(mv, pathsettings);
2427 SetupPresetMenu(mv, pathsettings);
2428 SetupPubscreenMenu(mv, settings);
2429 SetMenuSettings(mv, settings);
2430 SetMenuPathSettings(mv, pathsettings);
2431
2432
2433
2434 /*
2435 ** misc initializations
2436 */
2437
2438 if (pathsettings->startpath && !viewdata->pathname)
2439 {
2440 viewdata->pathname = _StrDup(pathsettings->startpath);
2441 }
2442
2443 triggersignal = SetTrigger(viewdata->trigger, 0); // trigger suspended
2444
2445
2446
2447 /*
2448 ** buttons
2449 */
2450
2451 buttons = CreateButtons(mv->buttonpic, mv->animpic, mv->window);
2452 if (!buttons)
2453 {
2454 EasyRequest(mv->window->window, &nobuttonsreq, NULL, NULL);
2455 }
2456
2457 if (settings->showbuttons)
2458 {
2459 SetButtonSettings(viewdata, mv->window, buttons, settings, TRUE);
2460 }
2461
2462
2463 /*
2464 ** create viewer
2465 */
2466
2467 viewdata->view = MV_Create(mv->screen->screen, mv->window->window->RPort,
2468 MVIEW_BackColor, settings->bgcolor,
2469 MVIEW_TextColor, settings->textcolor,
2470 MVIEW_MarkColor, settings->markcolor,
2471 MVIEW_DisplayMode, settings->displaymode,
2472 MVIEW_DestWidth, mv->window->innerwidth,
2473 MVIEW_DestHeight, mv->window->innerheight - (settings->showbuttons && buttons ? buttons->gadgetheight + BUTTON_VSPACE * 2 : 0),
2474 MVIEW_DestX, mv->window->innerleft,
2475 MVIEW_DestY, mv->window->innertop + (settings->showbuttons && buttons ? buttons->gadgetheight + BUTTON_VSPACE * 2 : 0),
2476 MVIEW_Precision, settings->precision,
2477 MVIEW_PreviewMode, settings->previewmode,
2478 MVIEW_StaticPalette, settings->staticpalette,
2479 MVIEW_Dither, settings->dither,
2480 MVIEW_DitherMode, settings->dithermode,
2481 MVIEW_HSType, settings->hstype,
2482 MVIEW_ScreenAspectX, settings->screenaspectx,
2483 MVIEW_ScreenAspectY, settings->screenaspecty,
2484 MVIEW_ShowCursor, settings->markcenter,
2485 MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings),
2486 MVIEW_Picture, viewdata->showpic ? (IPTR)viewdata->showpic : (IPTR)mv->logopic,
2487 MVIEW_ReadySignal, viewdata->picturevisiblesignal,
2488 MVIEW_DrawArrows, settings->showarrows,
2489 MVIEW_ShowPip, settings->showpip,
2490 MVIEW_RPSemaphore, (IPTR)&viewdata->rastlock,
2491 TAG_DONE);
2492
2493 if (!viewdata->view)
2494 {
2495 EasyRequest(mv->window->window, &noviewreq, NULL, NULL);
2496 }
2497
2498 ApplyViewData(viewdata, settings, FALSE);
2499
2500 MV_DrawOn(viewdata->view);
2501
2502
2503
2504 /*
2505 ** create picture handler
2506 */
2507
2508 if (!viewdata->pichandler)
2509 {
2510 NewPicHandler(viewdata, viewdata->startfilepatternlist, settings, mv->logopic);
2511 }
2512 if (!viewdata->pichandler)
2513 {
2514 EasyRequest(mv->window->window, &nopichandlerreq, NULL, NULL);
2515 }
2516 else
2517 {
2518 newpicsignal = NewPicSignal(viewdata->pichandler);
2519 SetSortMode(viewdata->pichandler, settings->sortmode, settings->reverse);
2520 }
2521
2522
2523 /*
2524 ** open filerequester?
2525 */
2526
2527 if (!reopen && !viewdata->startfilepatternlist)
2528 {
2529 requestfiles = settings->requestfile ? REQUEST_OPENFILES : REQUEST_NONE;
2530 }
2531
2532
2533
2534
2535 /*
2536 ** continue slideshow / reload / display resume message
2537 */
2538
2539 if (GetTotalPicNumber(viewdata->pichandler) > 0)
2540 {
2541 if (GetCurrentPicNumber(viewdata->pichandler) == -1)
2542 {
2543 SetViewText(viewdata, MVTEXT_SELECTNEXTPICTORESUME);
2544 ResetPicHandler(viewdata->pichandler);
2545 }
2546 else
2547 {
2548 if (settings->slideshow)
2549 {
2550 if (GetTotalPicNumber(viewdata->pichandler) > 1)
2551 {
2552 SetTrigger(viewdata->trigger, settings->slidedelay ? settings->slidedelay * 5 : MINDELAY);
2553 }
2554 }
2555 }
2556 }
2557
2558
2559
2560
2561 /*
2562 ** main loop
2563 */
2564
2565 do
2566 {
2567 BOOL do_smoothing =
2568 (ABS(viewdata->destzoom - viewdata->zoom) > SMOOTHCUTOFF) |
2569 (ABS(viewdata->destxpos - viewdata->xpos) > SMOOTHCUTOFF) |
2570 (ABS(viewdata->destypos - viewdata->ypos) > SMOOTHCUTOFF);
2571
2572 if (mv->window)
2573 {
2574 win = mv->window->window;
2575 menu = mv->window->menu;
2576 idcmpsignal = mv->window->idcmpSignal;
2577 appsignal = mv->appSignal;
2578 }
2579 else
2580 {
2581 win = NULL;
2582 menu = NULL;
2583 idcmpsignal = 0;
2584 appsignal = 0;
2585 }
2586
2587
2588 if (settings->showbuttons && !do_smoothing)
2589 {
2590 int status;
2591 while ((status = GetPicHandlerStatus(viewdata->pichandler))
2592 & (PICHSTATUS_LOADING | PICHSTATUS_SCANNING))
2593 {
2594 AnimateButtons(viewdata, buttons, FALSE);
2595 if ((signals = SetSignal(0, 0)) & (idcmpsignal | appsignal | triggersignal |
2596 newpicsignal | (1 << viewdata->picturevisiblesignal) |
2597 loadsignal | cxsignal | SIGBREAKF_CTRL_C))
2598 {
2599 break;
2600 }
2601 Delay(1);
2602 }
2603
2604 if (status == PICHSTATUS_IDLE) AnimateButtons(viewdata, buttons, TRUE);
2605 }
2606
2607 if (requestfiles == REQUEST_NONE && !do_smoothing)
2608 {
2609 signals = Wait(idcmpsignal | appsignal | triggersignal |
2610 newpicsignal | (1 << viewdata->picturevisiblesignal) |
2611 loadsignal | cxsignal | SIGBREAKF_CTRL_C);
2612 }
2613 else
2614 {
2615 signals = SetSignal(0, idcmpsignal | appsignal | triggersignal |
2616 newpicsignal | (1 << viewdata->picturevisiblesignal) |
2617 loadsignal | cxsignal | SIGBREAKF_CTRL_C);
2618 }
2619
2620
2621
2622 if (win)
2623 {
2624 BOOL hardrefresh = FALSE;
2625
2626 if (signals & idcmpsignal)
2627 {
2628 struct IntuiMessage myImsg;
2629 // BOOL setviewrelative = FALSE;
2630 BOOL relayoutmenus = FALSE;
2631 BOOL softrefresh = FALSE;
2632 BOOL setmenusettings = FALSE;
2633
2634 while ((imsg = GT_GetIMsg(win->UserPort)))
2635 {
2636 memcpy(&myImsg, imsg, sizeof(struct IntuiMessage));
2637
2638 GT_ReplyIMsg(imsg);
2639
2640 myImsg.MouseX -= win->BorderLeft;
2641 myImsg.MouseY -= win->BorderTop;
2642
2643 if (buttons && settings->showbuttons && myImsg.Class == IDCMP_MOUSEBUTTONS)
2644 {
2645 ULONG id;
2646
2647 ObtainSemaphore(&viewdata->rastlock);
2648 id = HandleGadgetListEvent(buttons->gadgetlist, &myImsg, buttons->bitmap);
2649 ReleaseSemaphore(&viewdata->rastlock);
2650
2651 if (id !=INVALID_FAKEGADGET)
2652 {
2653 switch (id)
2654 {
2655 case GAD_OPEN:
2656 requestfiles = REQUEST_OPENFILES;
2657 break;
2658
2659 case GAD_RESTART:
2660 if (viewdata->pichandler)
2661 {
2662 ResetPicHandler(viewdata->pichandler);
2663 GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal);
2664
2665 SetTrigger(viewdata->trigger, 0);
2666 settings->slideshow = FALSE;
2667 // SetMenuSettings(mv, settings);
2668 setmenusettings = TRUE;
2669 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
2670 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings), TAG_DONE);
2671 }
2672 break;
2673
2674 case GAD_NEXT:
2675 if (GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal))
2676 {
2677 if (settings->autoquit) status = STATUS_QUIT;
2678 else if (settings->autohide) status = STATUS_SLEEP;
2679 else if (settings->requestfile) requestfiles = REQUEST_OPENFILES;
2680 }
2681 break;
2682
2683 case GAD_PREV:
2684 if (PrevPic(viewdata->pichandler))
2685 {
2686 SetTrigger(viewdata->trigger, 0);
2687 settings->slideshow = FALSE;
2688 // SetMenuSettings(mv, settings);
2689 setmenusettings = TRUE;
2690 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
2691 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings), TAG_DONE);
2692 }
2693 break;
2694
2695 case GAD_SLIDE:
2696 if ((settings->slideshow = buttons->gadgets[GAD_SLIDE]->togglestatus))
2697 {
2698 SetTrigger(viewdata->trigger, settings->slidedelay ? settings->slidedelay * 5 : MINDELAY);
2699 }
2700 else
2701 {
2702 SetTrigger(viewdata->trigger, 0);
2703 }
2704 // SetMenuSettings(mv, settings);
2705 setmenusettings = TRUE;
2706 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings), TAG_DONE);
2707 break;
2708
2709 case GAD_LOOP:
2710 if ((settings->loop = buttons->gadgets[GAD_LOOP]->togglestatus))
2711 {
2712 settings->autoquit = FALSE;
2713 settings->autohide = FALSE;
2714 // SetMenuSettings(mv, settings);
2715 // setmenusettings = TRUE;
2716 }
2717 //SetMenuSettings(mv, settings);
2718 setmenusettings = TRUE;
2719 break;
2720
2721 case GAD_DISPLAYMODE:
2722 {
2723 int newdisplaymode =
2724 buttons->gadgets[GAD_DISPLAYMODE]->togglestatus ?
2725 MVDISPMODE_KEEPASPECT_MIN : MVDISPMODE_IGNOREASPECT;
2726
2727 if (newdisplaymode != settings->displaymode)
2728 {
2729 settings->displaymode = newdisplaymode;
2730 // SetMenuSettings(mv, settings);
2731 setmenusettings = TRUE;
2732 Train(mv, settings, viewdata);
2733 MV_SetAttrs(viewdata->view, MVIEW_DisplayMode, settings->displaymode, TAG_DONE);
2734 }
2735 break;
2736 }
2737
2738 case GAD_RESET:
2739 {
2740 ResetDisplaySettings(viewdata, TRUE);
2741 break;
2742 }
2743
2744 default:
2745 break;
2746 }
2747 }
2748 }
2749
2750
2751 switch (myImsg.Class)
2752 {
2753 case IDCMP_ACTIVEWINDOW:
2754 SetupPubscreenMenu(mv, settings);
2755 mousebutton = FALSE;
2756 break;
2757
2758 case IDCMP_INACTIVEWINDOW:
2759 mousebutton = FALSE;
2760 break;
2761
2762 case IDCMP_MOUSEMOVE:
2763 if (mousebutton)
2764 {
2765 if (!setviewrelative)
2766 {
2767 setviewrelative = TRUE;
2768 }
2769 }
2770 break;
2771
2772 case IDCMP_MOUSEBUTTONS:
2773 {
2774 ULONG newidcmp = currentidcmp;
2775 int x, y, w, h;
2776
2777 MV_GetAttrs(viewdata->view,
2778 MVIEW_PictureX, (IPTR)&x, MVIEW_PictureY, (IPTR)&y,
2779 MVIEW_PictureWidth, (IPTR)&w, MVIEW_PictureHeight, (IPTR)&h, TAG_DONE);
2780
2781 switch (myImsg.Code)
2782 {
2783 case SELECTUP:
2784 {
2785 if (checkinvisiblegadgets)
2786 {
2787 if (myImsg.MouseY == 0)
2788 {
2789 if (myImsg.MouseX == 0)
2790 {
2791 status = settings->hideonclose ? STATUS_SLEEP : STATUS_QUIT;
2792 }
2793 else if (myImsg.MouseX == mv->screen->screen->Width - 1)
2794 {
2795 ScreenToBack(mv->screen->screen);
2796 }
2797 }
2798 }
2799
2800 checkinvisiblegadgets = FALSE;
2801 setviewrelative = FALSE;
2802 mousebutton = FALSE;
2803 newidcmp &= ~(IDCMP_MOUSEMOVE | IDCMP_INTUITICKS);
2804
2805 if (settings->leftmouseaction == MOUSEACTION_NEXT)
2806 {
2807 if (myImsg.MouseX >= x && myImsg.MouseX < x+w && myImsg.MouseY >= y && myImsg.MouseY < y+h)
2808 {
2809 if (GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal))
2810 {
2811 if (settings->autoquit) status = STATUS_QUIT;
2812 else if (settings->autohide) status = STATUS_SLEEP;
2813 else if (settings->requestfile) requestfiles = REQUEST_OPENFILES;
2814 }
2815 }
2816 }
2817
2818 break;
2819 }
2820
2821 case SELECTDOWN:
2822 {
2823
2824 mousebutton = TRUE;
2825
2826 if (myImsg.MouseY == 0 && win->TopEdge == 0)
2827 {
2828 if (myImsg.MouseX == 0 && win->LeftEdge == 0)
2829 {
2830 checkinvisiblegadgets = TRUE;
2831 }
2832 else if (myImsg.MouseX == win->Width - 1 && myImsg.MouseX == mv->screen->screen->Width - 1)
2833 {
2834 checkinvisiblegadgets = TRUE;
2835 }
2836 }
2837
2838 if (!checkinvisiblegadgets)
2839 {
2840 if (myImsg.MouseX >= x && myImsg.MouseX < x+w && myImsg.MouseY >= y && myImsg.MouseY < y+h)
2841 {
2842 newidcmp |= IDCMP_INTUITICKS;
2843 if (settings->leftmouseaction == MOUSEACTION_DRAG)
2844 {
2845 newidcmp |= IDCMP_MOUSEMOVE;
2846 MV_SetViewStart(viewdata->view, myImsg.MouseX, myImsg.MouseY);
2847 }
2848 }
2849 }
2850 break;
2851 }
2852 }
2853
2854 if (newidcmp != currentidcmp)
2855 {
2856 ModifyIDCMP(win, newidcmp);
2857 currentidcmp = newidcmp;
2858 }
2859
2860 break;
2861 }
2862
2863
2864 #if 0
2865
2866 switch (settings->leftmouseaction)
2867 {
2868 case MOUSEACTION_DRAG:
2869 switch (myImsg.Code)
2870 {
2871 case SELECTUP:
2872 if (checkinvisiblegadgets)
2873 {
2874 if (myImsg.MouseY == 0)
2875 {
2876 if (myImsg.MouseX == 0)
2877 {
2878 status = STATUS_QUIT;
2879 }
2880 else if (myImsg.MouseX == mv->screen->screen->Width - 1)
2881 {
2882 ScreenToBack(mv->screen->screen);
2883 }
2884 }
2885 }
2886 else
2887 {
2888 ModifyIDCMP(win, mv->window->idcmpmask);
2889 mousebutton = FALSE;
2890 }
2891 checkinvisiblegadgets = FALSE;
2892
2893 if (setviewrelative)
2894 {
2895 setviewrelative = FALSE;
2896 }
2897 break;
2898
2899 case SELECTDOWN:
2900 {
2901 int x, y, w, h;
2902 MV_GetAttrs(viewdata->view,
2903 MVIEW_PictureX, &x, MVIEW_PictureY, &y,
2904 MVIEW_PictureWidth, &w, MVIEW_PictureHeight, &h, TAG_DONE);
2905
2906 if (myImsg.MouseY == 0 && win->TopEdge == 0)
2907 {
2908 if (myImsg.MouseX == 0 && win->LeftEdge == 0)
2909 {
2910 checkinvisiblegadgets = TRUE;
2911 }
2912 else if (myImsg.MouseX == win->Width - 1 && myImsg.MouseX == mv->screen->screen->Width - 1)
2913 {
2914 checkinvisiblegadgets = TRUE;
2915 }
2916 }
2917
2918 if (myImsg.MouseX >= x && myImsg.MouseX < x+w && myImsg.MouseY >= y && myImsg.MouseY < y+h)
2919 {
2920 // ModifyIDCMP(win, mv->window->idcmpmask | IDCMP_MOUSEMOVE);
2921 MV_SetViewStart(viewdata->view, myImsg.MouseX, myImsg.MouseY);
2922 // mousebutton = TRUE;
2923 }
2924
2925
2926 ModifyIDCMP(win, mv->window->idcmpmask | IDCMP_MOUSEMOVE | IDCMP_INTUITICKS);
2927 mousebutton = TRUE;
2928
2929
2930 break;
2931 }
2932 }
2933 break;
2934
2935 case MOUSEACTION_NEXT:
2936 if (myImsg.Code == SELECTDOWN)
2937 {
2938 int x, y, w, h;
2939 MV_GetAttrs(viewdata->view,
2940 MVIEW_PictureX, &x, MVIEW_PictureY, &y,
2941 MVIEW_PictureWidth, &w, MVIEW_PictureHeight, &h, TAG_DONE);
2942
2943 if (myImsg.MouseX >= x && myImsg.MouseX < x+w && myImsg.MouseY >= y && myImsg.MouseY < y+h)
2944 {
2945 if (GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal))
2946 {
2947 if (settings->autoquit) status = STATUS_QUIT;
2948 else if (settings->autohide) status = STATUS_SLEEP;
2949 else if (settings->requestfile) requestfiles = REQUEST_OPENFILES;
2950 }
2951 }
2952 }
2953 break;
2954 }
2955 break;
2956 }
2957 #endif
2958 case IDCMP_CLOSEWINDOW:
2959 status = settings->hideonclose ? STATUS_SLEEP : STATUS_QUIT;
2960 break;
2961
2962 case IDCMP_NEWSIZE:
2963 softrefresh = TRUE;
2964 break;
2965
2966 case IDCMP_REFRESHWINDOW:
2967 BeginRefresh(win);
2968 EndRefresh(win, TRUE);
2969 softrefresh = TRUE;
2970 break;
2971
2972 case IDCMP_RAWKEY:
2973 {
2974 double inkrement = .01;
2975
2976 if (myImsg.Qualifier & IEQUALIFIER_CONTROL)
2977 inkrement=1.0;
2978
2979 if (myImsg.Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
2980 inkrement=.1;
2981
2982 if (myImsg.Code >= 80 && myImsg.Code <= 89)
2983 {
2984 int slot = myImsg.Code - 80;
2985 if (myImsg.Qualifier & IEQUALIFIER_CONTROL)
2986 {
2987 if (MVFunction_UsePreset(mv, &settings, pathsettings, viewdata, slot, TRUE))
2988 {
2989 status = STATUS_REOPENALL;
2990 }
2991 }
2992 else //if (myImsg.Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT) || myImsg.Qualifier == 0)
2993 {
2994 int action = (myImsg.Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)) ? FILEACTION_MOVE : FILEACTION_COPY;
2995 MVFunction_CopyMoveToPath(mv, settings, pathsettings, viewdata, slot, action, TRUE, buttons);
2996 SetupPathMenus(mv, pathsettings);
2997 }
2998 }
2999 else
3000 {
3001 switch (myImsg.Code)
3002 {
3003 case 76:
3004 viewdata->destypos -= inkrement;
3005 break;
3006 case 77:
3007 viewdata->destypos += inkrement;
3008 break;
3009 case 78:
3010 viewdata->destxpos += inkrement;
3011 break;
3012 case 79:
3013 viewdata->destxpos -= inkrement;
3014 break;
3015
3016 case 95: /* help */
3017 {
3018 ResetDisplaySettings(viewdata, TRUE);
3019 break;
3020 }
3021 }
3022 }
3023
3024 break;
3025 }
3026
3027 case IDCMP_VANILLAKEY:
3028 {
3029 double inkrement = .01;
3030
3031 if (myImsg.Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
3032 inkrement = 1;
3033
3034 if (myImsg.Qualifier & (IEQUALIFIER_LALT | IEQUALIFIER_RALT))
3035 inkrement = .1;
3036
3037 switch (myImsg.Code)
3038 {
3039 case 127:
3040 if (RemovePicture(viewdata->pichandler))
3041 {
3042 DeleteViewPic(viewdata, NULL, settings);
3043 GetCurrentPicture(mv, buttons, viewdata, settings, mv->logopic);
3044 }
3045 else
3046 {
3047 EasyRequest(mv->window->window, &nopicreq, NULL, NULL);
3048 }
3049 break;
3050
3051 case '8':
3052 viewdata->destypos -= inkrement;
3053 break;
3054 case '2':
3055 viewdata->destypos += inkrement;
3056 break;
3057 case '6':
3058 viewdata->destxpos += inkrement;
3059 break;
3060 case '4':
3061 viewdata->destxpos -= inkrement;
3062 break;
3063
3064 case 8:
3065 if (viewdata->pichandler)
3066 {
3067 ResetPicHandler(viewdata->pichandler);
3068 GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal);
3069
3070 SetTrigger(viewdata->trigger, 0);
3071 settings->slideshow = FALSE;
3072 // SetMenuSettings(mv, settings);
3073 setmenusettings = TRUE;
3074 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3075 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings), TAG_DONE);
3076 }
3077
3078 case '1':
3079 if (settings->displaymode != MVDISPMODE_KEEPASPECT_MIN)
3080 {
3081 settings->displaymode = MVDISPMODE_KEEPASPECT_MIN;
3082 // SetMenuSettings(mv, settings);
3083 setmenusettings = TRUE;
3084 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3085 Train(mv, settings, viewdata);
3086 MV_SetAttrs(viewdata->view, MVIEW_DisplayMode, settings->displaymode, TAG_DONE);
3087 }
3088 break;
3089
3090 case '3':
3091 if (settings->displaymode != MVDISPMODE_IGNOREASPECT)
3092 {
3093 settings->displaymode = MVDISPMODE_IGNOREASPECT;
3094 // SetMenuSettings(mv, settings);
3095 setmenusettings = TRUE;
3096 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3097 Train(mv, settings, viewdata);
3098 MV_SetAttrs(viewdata->view, MVIEW_DisplayMode, settings->displaymode, TAG_DONE);
3099 }
3100 break;
3101
3102 case 'i': case 'I': case '0':
3103 settings->picinfo = !settings->picinfo;
3104 SetViewText(viewdata, SetPicInfoText(viewdata, viewdata->showpic, settings));
3105 // SetMenuSettings(mv, settings);
3106 setmenusettings = TRUE;
3107 break;
3108
3109 case 'o': case 'O': case '7':
3110 requestfiles = REQUEST_OPENFILES;
3111 break;
3112
3113 case '+':
3114 viewdata->destzoom += settings->zoomstep;
3115 break;
3116
3117 case '-':
3118 viewdata->destzoom -= settings->zoomstep;
3119 break;
3120
3121 case '[': case '(': case '{':
3122 {
3123 viewdata->angle -= 65536 * settings->rotatestep / 360;
3124 break;
3125 }
3126
3127 case ']': case ')': case '}':
3128 viewdata->angle += 65536 * settings->rotatestep / 360;
3129 break;
3130
3131 case '/':
3132 viewdata->angle = 0;
3133 break;
3134
3135 case 'x': case 'X':
3136 {
3137 PICTURE *pic = viewdata->showpic ? viewdata->showpic : mv->logopic;
3138 if (DoPictureMethod(pic, PICMTHD_FLIPX, NULL))
3139 {
3140 hardrefresh = TRUE;
3141 }
3142 break;
3143 }
3144
3145 // case ',':
3146 // {
3147 // PICTURE *pic = viewdata->showpic ? viewdata->showpic : mv->logopic;
3148 // if (DoPictureMethod(pic, PICMTHD_CONVOLVE, NULL))
3149 // {
3150 // hardrefresh = TRUE;
3151 // }
3152 // break;
3153 // }
3154
3155 case 'y': case 'Y':
3156 {
3157 PICTURE *pic = viewdata->showpic ? viewdata->showpic : mv->logopic;
3158 if (DoPictureMethod(pic, PICMTHD_FLIPY, NULL))
3159 {
3160 hardrefresh = TRUE;
3161 }
3162 break;
3163 }
3164
3165 case '~':
3166 {
3167 PICTURE *pic = viewdata->showpic ? viewdata->showpic : mv->logopic;
3168 if (DoPictureMethod(pic, PICMTHD_NEGATIVE, NULL))
3169 {
3170 hardrefresh = TRUE;
3171 }
3172 break;
3173 }
3174
3175 case 'a': case 'A':
3176 settings->showarrows = !settings->showarrows;
3177 MV_SetAttrs(viewdata->view, MVIEW_DrawArrows, settings->showarrows, TAG_DONE);
3178 // SetMenuSettings(mv, settings);
3179 setmenusettings = TRUE;
3180 break;
3181
3182 case 'b': case 'B':
3183 settings->showbuttons = !settings->showbuttons;
3184 // SetMenuSettings(mv, settings);
3185 setmenusettings = TRUE;
3186 softrefresh = TRUE;
3187 break;
3188
3189 case 'p': case 'P':
3190 settings->showpip = !settings->showpip;
3191 MV_SetAttrs(viewdata->view, MVIEW_ShowPip, settings->showpip, TAG_DONE);
3192 // SetMenuSettings(mv, settings);
3193 setmenusettings = TRUE;
3194 break;
3195
3196 case 'c': case 'C':
3197 settings->markcenter = !settings->markcenter;
3198 MV_SetAttrs(viewdata->view, MVIEW_ShowCursor, settings->markcenter, TAG_DONE);
3199 // SetMenuSettings(mv, settings);
3200 setmenusettings = TRUE;
3201 break;
3202
3203 case 32:
3204 if (settings->slideshow)
3205 {
3206 settings->slideshow = FALSE;
3207 SetTrigger(viewdata->trigger, 0);
3208 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3209 // SetMenuSettings(mv, settings);
3210 setmenusettings = TRUE;
3211 }
3212 else
3213 {
3214 settings->slideshow = TRUE;
3215 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3216 // SetMenuSettings(mv, settings);
3217 setmenusettings = TRUE;
3218 SetTrigger(viewdata->trigger, settings->slidedelay ? settings->slidedelay * 5 : MINDELAY);
3219 if (GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal))
3220 {
3221 if (settings->autoquit) status = STATUS_QUIT;
3222 else if (settings->autohide) status = STATUS_SLEEP;
3223 else if (settings->requestfile) requestfiles = REQUEST_OPENFILES;
3224 }
3225 }
3226 break;
3227
3228 case 13:
3229
3230 /*
3231 ** dive into directory
3232 */
3233
3234 if (settings->browsemode)
3235 {
3236 if (viewdata->isdirectory)
3237 {
3238 char *newpath = FullName(viewdata->pathname, viewdata->filename);
3239 if (newpath)
3240 {
3241 char *newpath2 = _StrDupCat(newpath, "/#?");
3242 if (newpath2)
3243 {
3244 char *filepatternlist[2];
3245 filepatternlist[0] = newpath2;
3246 filepatternlist[1] = NULL;
3247 newpicsignal = NewPicHandler(viewdata, filepatternlist, settings, mv->logopic);
3248 Free(newpath2);
3249 }
3250 Free(newpath);
3251 }
3252 }
3253 }
3254
3255 case 'n': case 'N':
3256 if (GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal))
3257 {
3258 if (settings->autoquit) status = STATUS_QUIT;
3259 else if (settings->autohide) status = STATUS_SLEEP;
3260 else if (settings->requestfile) requestfiles = REQUEST_OPENFILES;
3261 }
3262 break;
3263
3264 case '.':
3265 if (PrevPic(viewdata->pichandler))
3266 {
3267 SetTrigger(viewdata->trigger, 0);
3268 settings->slideshow = FALSE;
3269 // SetMenuSettings(mv, settings);
3270 setmenusettings = TRUE;
3271 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3272 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings), TAG_DONE);
3273 }
3274 break;
3275 case 9:
3276 ZipWindow(win);
3277 break;
3278
3279 case 27:
3280 status = settings->hideonescape ? STATUS_SLEEP : STATUS_QUIT;
3281 break;
3282
3283 case '#':
3284 case '5':
3285 viewdata->destxpos = .5;
3286 viewdata->destypos = .5;
3287 break;
3288
3289 case '*':
3290 viewdata->destzoom = 1;
3291 break;
3292
3293 case 's': case 'S': case '9':
3294 if ((settings->slideshow = !settings->slideshow))
3295 {
3296 SetTrigger(viewdata->trigger, settings->slidedelay ? settings->slidedelay * 5 : MINDELAY);
3297 }
3298 else
3299 {
3300 SetTrigger(viewdata->trigger, 0);
3301 }
3302 // SetMenuSettings(mv, settings);
3303 setmenusettings = TRUE;
3304 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3305 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings), TAG_DONE);
3306 break;
3307
3308 default:
3309 break;
3310 }
3311 break;
3312 }
3313
3314
3315 case IDCMP_MENUPICK:
3316 {
3317 while((myImsg.Code != MENUNULL) && (status == STATUS_WORKING))
3318 {
3319 struct MenuItem *item = ItemAddress(menu, myImsg.Code);
3320 IPTR code = (IPTR)GTMENUITEM_USERDATA(item);
3321
3322 switch (code)
3323 {
3324 case MITEM_RESETALL:
3325 {
3326 ResetDisplaySettings(viewdata, TRUE);
3327 break;
3328 }
3329 case MITEM_CLEAR:
3330 signals &= ~newpicsignal;
3331 newpicsignal = NewPicHandler(viewdata, NULL, settings, mv->logopic);
3332 ResetDisplaySettings(viewdata, settings->resetdisplaysettings);
3333 break;
3334
3335 case MITEM_AUTOCROP:
3336 settings->autocrop = GetItemFlag(item, TRUE, FALSE);
3337 SetPicHandlerAutoCrop(viewdata->pichandler, settings->autocrop);
3338 break;
3339
3340 case MITEM_AUTODISPLAYMODE:
3341 if ((settings->autodisplaymode = GetItemFlag(item, TRUE, FALSE)))
3342 {
3343 if (!NeuralBase)
3344 {
3345 EasyRequest(win, &noneuralreq, NULL, NULL);
3346 settings->autodisplaymode = FALSE;
3347 // SetMenuSettings(mv, settings);
3348 setmenusettings = TRUE;
3349 }
3350 else
3351 {
3352 int newdispmode;
3353 if ((newdispmode = Recall(mv, settings, viewdata)) != settings->displaymode)
3354 {
3355 settings->displaymode = newdispmode;
3356 MV_SetAttrs(viewdata->view, MVIEW_DisplayMode, settings->displaymode, TAG_DONE);
3357 // SetMenuSettings(mv, settings);
3358 setmenusettings = TRUE;
3359 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3360 }
3361 }
3362 }
3363 break;
3364
3365 case MITEM_LMB_DRAG:
3366 settings->leftmouseaction =
3367 GetItemFlag(item, MOUSEACTION_DRAG, MOUSEACTION_NEXT);
3368 break;
3369
3370 case MITEM_ASYNCSCANNING:
3371 settings->asyncscanning = GetItemFlag(item, TRUE, FALSE);
3372 break;
3373
3374 case MITEM_FILTERPICTURES:
3375 settings->filterpictures = GetItemFlag(item, TRUE, FALSE);
3376 break;
3377
3378 case MITEM_APPENDICONS:
3379 settings->appendicons = GetItemFlag(item, TRUE, FALSE);
3380 break;
3381
3382 case MITEM_CREATETHUMBNAILS:
3383 settings->createthumbnails = GetItemFlag(item, TRUE, FALSE);
3384 if (settings->createthumbnails && !NewIconBase)
3385 {
3386 EasyRequest(win, &nonewiconreq, NULL, NULL);
3387 }
3388 break;
3389
3390 case MITEM_RESTART:
3391 if (viewdata->pichandler)
3392 {
3393 ResetPicHandler(viewdata->pichandler);
3394 GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal);
3395
3396 SetTrigger(viewdata->trigger, 0);
3397 settings->slideshow = FALSE;
3398 // SetMenuSettings(mv, settings);
3399 setmenusettings = TRUE;
3400 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3401 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings), TAG_DONE);
3402 }
3403 break;
3404
3405 case MITEM_SAVELIST:
3406 {
3407 if (viewdata->pichandler)
3408 {
3409 char **list;
3410
3411 if ((list = PicHandlerCreateFileList(viewdata->pichandler)))
3412 {
3413 char *pathname, *filename, *fullname;
3414 if (SaveRequest(mv->listfreq, win, MVTEXT_SAVELISTAS, pathsettings->listpath, NULL, &pathname, &filename))
3415 {
3416 if (pathname)
3417 {
3418 Free(pathsettings->listpath);
3419 pathsettings->listpath = _StrDup(pathname);
3420 }
3421
3422 if ((fullname = FullName(pathname, filename)))
3423 {
3424 WindowBusy(mv->window);
3425 if (!SaveListFile(mv, list, fullname, settings->defaulttool))
3426 {
3427 EasyRequest(mv->window->window, &errorsavinglistreq, NULL, NULL);
3428 }
3429 WindowFree(mv->window);
3430 Free(fullname);
3431 }
3432 Free(pathname);
3433 Free(filename);
3434 }
3435
3436 DeleteStringList(list);
3437 }
3438 }
3439 else
3440 {
3441 EasyRequest(mv->window->window, &nopicreq, NULL, NULL);
3442 }
3443
3444 break;
3445 }
3446
3447 case MITEM_OPENLIST:
3448 {
3449 char *pathname, *filename, *fullname;
3450 if (FileRequest(mv->listfreq, win, MVTEXT_OPENLISTFILE, pathsettings->listpath, NULL, &pathname, &filename))
3451 {
3452 if (pathname)
3453 {
3454 Free(pathsettings->listpath);
3455 pathsettings->listpath = _StrDup(pathname);
3456 }
3457
3458 if ((fullname = FullName(pathname, filename)))
3459 {
3460 char **piclist;
3461 if ((piclist = LoadStringList(fullname)))
3462 {
3463 newpicsignal = NewPicHandler(viewdata, piclist, settings, mv->logopic);
3464 DeleteFilePatternList(piclist);
3465 }
3466 Free(fullname);
3467 }
3468 Free(pathname);
3469 Free(filename);
3470 }
3471 break;
3472 }
3473
3474 case MITEM_APPENDLIST:
3475 {
3476 char *pathname, *filename, *fullname;
3477 if (FileRequest(mv->listfreq, win, MVTEXT_APPENDLISTFILE, pathsettings->listpath, NULL, &pathname, &filename))
3478 {
3479 if (pathname)
3480 {
3481 Free(pathsettings->listpath);
3482 pathsettings->listpath = _StrDup(pathname);
3483 }
3484
3485 if ((fullname = FullName(pathname, filename)))
3486 {
3487 char **piclist;
3488 if ((piclist = LoadStringList(fullname)))
3489 {
3490 AppendPicHandler(viewdata->pichandler, piclist);
3491 DeleteFilePatternList(piclist);
3492 }
3493 Free(fullname);
3494 }
3495 Free(pathname);
3496 Free(filename);
3497 }
3498 break;
3499 }
3500
3501 case MITEM_PICINFO:
3502 settings->picinfo = GetItemFlag(item, TRUE, FALSE);
3503 SetViewText(viewdata, SetPicInfoText(viewdata, viewdata->showpic, settings));
3504 break;
3505
3506 case MITEM_SHOWARROWS:
3507 settings->showarrows = GetItemFlag(item, TRUE, FALSE);
3508 MV_SetAttrs(viewdata->view, MVIEW_DrawArrows, settings->showarrows, TAG_DONE);
3509 break;
3510
3511 case MITEM_SHOWPIP:
3512 settings->showpip = GetItemFlag(item, TRUE, FALSE);
3513 MV_SetAttrs(viewdata->view, MVIEW_ShowPip, settings->showpip, TAG_DONE);
3514 break;
3515
3516 case MITEM_SHOWBUTTONS:
3517 {
3518 int newshowbuttons;
3519 newshowbuttons = GetItemFlag(item, TRUE, FALSE);
3520 if (newshowbuttons != settings->showbuttons)
3521 {
3522 settings->showbuttons = newshowbuttons;
3523 softrefresh = TRUE;
3524 }
3525 break;
3526 }
3527
3528 case MITEM_MARKCENTER:
3529 settings->markcenter = GetItemFlag(item, TRUE, FALSE);
3530 MV_SetAttrs(viewdata->view, MVIEW_ShowCursor, settings->markcenter, TAG_DONE);
3531 break;
3532
3533 case MITEM_OPEN:
3534 requestfiles = REQUEST_OPENFILES;
3535 break;
3536
3537 case MITEM_APPEND:
3538 requestfiles = REQUEST_APPENDFILES;
3539 break;
3540
3541 case MITEM_NEXT:
3542 if (GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal))
3543 {
3544 if (settings->autoquit) status = STATUS_QUIT;
3545 else if (settings->autohide) status = STATUS_SLEEP;
3546 else if (settings->requestfile) requestfiles = REQUEST_OPENFILES;
3547 }
3548 break;
3549
3550 case MITEM_PREV:
3551 if (PrevPic(viewdata->pichandler))
3552 {
3553 SetTrigger(viewdata->trigger, 0);
3554 settings->slideshow = FALSE;
3555 // SetMenuSettings(mv, settings);
3556 setmenusettings = TRUE;
3557 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3558 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings), TAG_DONE);
3559 }
3560 break;
3561
3562 case MITEM_ABOUT:
3563 MVFunction_About(mv);
3564 break;
3565
3566 case MITEM_SLIDE:
3567 if ((settings->slideshow = GetItemFlag(item, TRUE, FALSE)))
3568 {
3569 SetTrigger(viewdata->trigger, settings->slidedelay ? settings->slidedelay * 5 : MINDELAY);
3570 }
3571 else
3572 {
3573 SetTrigger(viewdata->trigger, 0);
3574 }
3575 MV_SetAttrs(viewdata->view, MVIEW_Text, (IPTR)SetPicInfoText(viewdata, viewdata->showpic, settings), TAG_DONE);
3576 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3577 break;
3578
3579 case MITEM_QUIT:
3580 status = STATUS_QUIT;
3581 break;
3582
3583 case MITEM_HIDE:
3584 status = STATUS_SLEEP;
3585 break;
3586
3587 case MITEM_ZIPWINDOW:
3588 ZipWindow(win);
3589 break;
3590
3591 case MITEM_ZOOMIN:
3592 viewdata->destzoom += settings->zoomstep;
3593 break;
3594
3595 case MITEM_ZOOMOUT:
3596 viewdata->destzoom -= settings->zoomstep;
3597 break;
3598
3599 case MITEM_RESETZOOM:
3600 viewdata->destzoom = 1;
3601 break;
3602
3603 case MITEM_ROTATELEFT:
3604 viewdata->angle -= 65536 * settings->rotatestep / 360;
3605 break;
3606
3607 case MITEM_ROTATERIGHT:
3608 viewdata->angle += 65536 * settings->rotatestep / 360;
3609 break;
3610
3611 case MITEM_RESETROT:
3612 viewdata->angle = 0;
3613 break;
3614
3615 case MITEM_RESETPOS:
3616 viewdata->destxpos = .5;
3617 viewdata->destypos = .5;
3618 break;
3619
3620 case MITEM_DITHERON:
3621 case MITEM_DITHERAUTO:
3622 settings->dither = GetMenuFlag(menu, MITEM_DITHERON, MVDITHERMODE_ON, MVDITHERMODE_OFF);
3623 settings->dither = GetMenuFlag(menu, MITEM_DITHERAUTO, MVDITHERMODE_AUTO, settings->dither);
3624 MV_SetAttrs(viewdata->view, MVIEW_Dither, settings->dither, TAG_DONE);
3625 break;
3626
3627 case MITEM_AUTOQUIT:
3628 if ((settings->autoquit = GetItemFlag(item, TRUE, FALSE)))
3629 {
3630 settings->autohide = FALSE;
3631 settings->loop = FALSE;
3632 // SetMenuSettings(mv, settings);
3633 setmenusettings = TRUE;
3634 }
3635 break;
3636
3637 case MITEM_AUTOHIDE:
3638 if ((settings->autohide = GetItemFlag(item, TRUE, FALSE)))
3639 {
3640 settings->autoquit = FALSE;
3641 settings->loop = FALSE;
3642 // SetMenuSettings(mv, settings);
3643 setmenusettings = TRUE;
3644 }
3645 break;
3646
3647 case MITEM_AUTOSTOP:
3648 settings->autostop = GetItemFlag(item, TRUE, FALSE);
3649 break;
3650
3651 case MITEM_AUTOCLEAR:
3652 settings->autoclear = GetItemFlag(item, TRUE, FALSE);
3653 break;
3654
3655 case MITEM_LOOP:
3656 if ((settings->loop = GetItemFlag(item, TRUE, FALSE)))
3657 {
3658 settings->autoquit = FALSE;
3659 settings->autohide = FALSE;
3660 // SetMenuSettings(mv, settings);
3661 setmenusettings = TRUE;
3662 }
3663 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3664 break;
3665
3666 case MITEM_RESETDISPLAYSETTINGS:
3667 settings->resetdisplaysettings = GetItemFlag(item, TRUE, FALSE);
3668 ResetDisplaySettings(viewdata, settings->resetdisplaysettings);
3669 break;
3670
3671 case MITEM_OPAQUE:
3672 case MITEM_GRID:
3673 settings->previewmode =
3674 GetMenuFlag(menu, MITEM_OPAQUE, MVPREVMODE_OPAQUE, 0) +
3675 GetMenuFlag(menu, MITEM_GRID, MVPREVMODE_GRID, 0);
3676 MV_SetAttrs(viewdata->view, MVIEW_PreviewMode, settings->previewmode, TAG_DONE);
3677 break;
3678
3679 case MITEM_KEEPASPECT1:
3680 case MITEM_IGNOREASPECT:
3681 {
3682 int newdisplaymode =
3683 GetMenuFlag(menu, MITEM_KEEPASPECT1, MVDISPMODE_KEEPASPECT_MIN, 0) +
3684 GetMenuFlag(menu, MITEM_IGNOREASPECT, MVDISPMODE_IGNOREASPECT, 0);
3685
3686 if (newdisplaymode != settings->displaymode)
3687 {
3688 settings->displaymode = newdisplaymode;
3689 MV_SetAttrs(viewdata->view, MVIEW_DisplayMode, settings->displaymode, TAG_DONE);
3690 Train(mv, settings, viewdata);
3691 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
3692 }
3693 break;
3694 }
3695
3696 case MITEM_STATIC:
3697 settings->staticpalette = GetItemFlag(item, TRUE, FALSE);
3698 MV_SetAttrs(viewdata->view, MVIEW_StaticPalette, settings->staticpalette, TAG_DONE);
3699 break;
3700
3701 case MITEM_BACKDROP:
3702 settings->borderless = GetItemFlag(item, TRUE, FALSE);
3703 status = STATUS_REOPENWINDOW;
3704 break;
3705
3706 case MITEM_AUTOSAVESETTINGS:
3707 pathsettings->autosavesettings = GetItemFlag(item, TRUE, FALSE);
3708 break;
3709
3710 case MITEM_REQUESTFILE:
3711 settings->requestfile = GetItemFlag(item, TRUE, FALSE) ?
3712 REQUEST_OPENFILES : REQUEST_NONE;
3713 break;
3714
3715 case MITEM_CUSTOMSCREEN:
3716 if (ModeRequest(mv->modereq, win, settings, MVTEXT_SELECTSCREENMODE))
3717 {
3718 settings->scropenmode = SCROPENMODE_CUSTOM;
3719 status = STATUS_REOPENALL;
3720 }
3721 break;
3722
3723 case MITEM_PUBLICSCREEN:
3724 case MITEM_DEFAULTSCREEN:
3725 settings->scropenmode =
3726 GetMenuFlag(menu, MITEM_CUSTOMSCREEN, SCROPENMODE_CUSTOM, 0) +
3727 GetMenuFlag(menu, MITEM_PUBLICSCREEN, SCROPENMODE_PUBLIC, 0) +
3728 GetMenuFlag(menu, MITEM_DEFAULTSCREEN, SCROPENMODE_NONE, 0);
3729 status = STATUS_REOPENALL;
3730 break;
3731
3732 case MITEM_SMALLWINDOW:
3733 case MITEM_LARGEWINDOW:
3734 case MITEM_HALFWINDOW:
3735 case MITEM_FULLWINDOW:
3736 case MITEM_VISIBLEWINDOW:
3737 case MITEM_FIXEDWINDOWSIZE:
3738 settings->winsizemode =
3739 GetMenuFlag(menu, MITEM_SMALLWINDOW, WSIZEMODE_33PERCENT, 0) +
3740 GetMenuFlag(menu, MITEM_HALFWINDOW, WSIZEMODE_HALF, 0) +
3741 GetMenuFlag(menu, MITEM_LARGEWINDOW, WSIZEMODE_66PERCENT, 0) +
3742 GetMenuFlag(menu, MITEM_VISIBLEWINDOW, WSIZEMODE_VISIBLE, 0) +
3743 GetMenuFlag(menu, MITEM_FULLWINDOW, WSIZEMODE_FULL, 0) +
3744 GetMenuFlag(menu, MITEM_FIXEDWINDOWSIZE, WSIZEMODE_NONE, 0);
3745
3746 if (settings->winsizemode == WSIZEMODE_NONE)
3747 {
3748 UpdateWindowParameters(mv->window);
3749 settings->winwidth = mv->window->winwidth;
3750 settings->winheight = mv->window->winheight;
3751 }
3752 else
3753 {
3754 status = STATUS_REOPENWINDOW;
3755 }
3756 break;
3757
3758 case MITEM_SORT_NONE:
3759 case MITEM_SORT_ALPHA_FILE:
3760 case MITEM_SORT_ALPHA_FULL:
3761 case MITEM_SORT_DATE:
3762 case MITEM_SORT_RANDOM:
3763 case MITEM_SORT_FILESIZE:
3764 case MITEM_SORT_REVERSE:
3765 settings->sortmode =
3766 GetMenuFlag(menu, MITEM_SORT_NONE, SORTMODE_NONE, 0) +
3767 GetMenuFlag(menu, MITEM_SORT_ALPHA_FILE, SORTMODE_ALPHA_FILE, 0) +
3768 GetMenuFlag(menu, MITEM_SORT_RANDOM, SORTMODE_RANDOM, 0) +
3769 GetMenuFlag(menu, MITEM_SORT_FILESIZE, SORTMODE_FILESIZE, 0) +
3770 GetMenuFlag(menu, MITEM_SORT_DATE, SORTMODE_DATE, 0) +
3771 GetMenuFlag(menu, MITEM_SORT_ALPHA_FULL, SORTMODE_ALPHA_FULL, 0);
3772 settings->reverse = GetMenuFlag(menu, MITEM_SORT_REVERSE, TRUE, FALSE);
3773 if (viewdata->pichandler)
3774 {
3775 WindowBusy(mv->window);
3776 SetSortMode(viewdata->pichandler, settings->sortmode, settings->reverse);
3777 WindowFree(mv->window);
3778 }
3779 SetViewText(viewdata, SetPicInfoText(viewdata, mv->logopic, settings));
3780 break;
3781
3782 case MITEM_CENTERWINDOW:
3783 case MITEM_MOUSEWINDOW:
3784 case MITEM_FIXEDWINDOWPOS:
3785 settings->winopenmode =
3786 GetMenuFlag(menu, MITEM_CENTERWINDOW, WOPENMODE_CENTER, 0) +
3787 GetMenuFlag(menu, MITEM_MOUSEWINDOW, WOPENMODE_MOUSE, 0) +
3788 GetMenuFlag(menu, MITEM_FIXEDWINDOWPOS, WOPENMODE_NONE, 0);
3789 if (settings->winopenmode == WOPENMODE_NONE)
3790 {
3791 UpdateWindowParameters(mv->window);
3792 settings->winleft = mv->window->winleft;
3793 settings->wintop = mv->window->wintop;
3794 }
3795 else
3796 {
3797 status = STATUS_REOPENWINDOW;
3798 }
3799 break;
3800
3801 case MITEM_SNAPWINDOW:
3802 UpdateWindowParameters(mv->window);
3803 settings->winwidth = mv->window->winwidth;
3804 settings->winheight = mv->window->winheight;
3805 settings->winleft = mv->window->winleft;
3806 settings->wintop = mv->window->wintop;
3807 settings->winsizemode = WSIZEMODE_NONE;
3808 settings->winopenmode = WOPENMODE_NONE;
3809 // SetMenuSettings(mv, settings);
3810 setmenusettings = TRUE;
3811 break;
3812
3813 case MITEM_SAVESETTINGS:
3814 WindowBusy(mv->window);
3815 SaveDefaultSettings(settings, mv->progfilename);
3816 WindowFree(mv->window);
3817 break;
3818
3819 case MITEM_RESETSETTINGS:
3820 {
3821 struct mainsettings *new;
3822 if ((new = CreateMainSettings(NULL, NULL, TAG_END)))
3823 {
3824 DeleteMainSettings(settings);
3825 settings = new;
3826 status = STATUS_REOPENALL;
3827 }
3828 break;
3829 }
3830
3831 case MITEM_RESTORESETTINGS:
3832 {
3833 struct mainsettings *new;
3834 if ((new = CreateMainSettings(NULL, oldsettings, TAG_END)))
3835 {
3836 DeleteMainSettings(settings);
3837 settings = new;
3838 status = STATUS_REOPENALL;
3839 }
3840 break;
3841 }
3842
3843 case MITEM_LASTSETTINGS:
3844 {
3845 struct mainsettings *new;
3846 WindowBusy(mv->window);
3847 if ((new = LoadDefaultSettings(mv->progfilename)))
3848 {
3849 DeleteMainSettings(settings);
3850 settings = new;
3851 status = STATUS_REOPENALL;
3852 }
3853 WindowFree(mv->window);
3854 break;
3855 }
3856
3857 case MITEM_FLIPX:
3858 {
3859 PICTURE *pic = viewdata->showpic ? viewdata->showpic : mv->logopic;
3860 WindowBusy(mv->window);
3861 if (DoPictureMethod(pic, PICMTHD_FLIPX, NULL))
3862 {
3863 hardrefresh = TRUE;
3864 }
3865 WindowFree(mv->window);
3866 break;
3867 }
3868
3869 case MITEM_FLIPY:
3870 {
3871 PICTURE *pic = viewdata->showpic ? viewdata->showpic : mv->logopic;
3872 WindowBusy(mv->window);
3873 if (DoPictureMethod(pic, PICMTHD_FLIPY, NULL))
3874 {
3875 hardrefresh = TRUE;
3876 }
3877 WindowFree(mv->window);
3878 break;
3879 }
3880
3881 case MITEM_NEGATIVE:
3882 {
3883 PICTURE *pic = viewdata->showpic ? viewdata->showpic : mv->logopic;
3884 WindowBusy(mv->window);
3885 if (DoPictureMethod(pic, PICMTHD_NEGATIVE, NULL))
3886 {
3887 hardrefresh = TRUE;
3888 }
3889 WindowFree(mv->window);
3890 break;
3891 }
3892
3893 case MITEM_PRESET1:
3894 case MITEM_PRESET1+1:
3895 case MITEM_PRESET1+2:
3896 case MITEM_PRESET1+3:
3897 case MITEM_PRESET1+4:
3898 case MITEM_PRESET1+5:
3899 case MITEM_PRESET1+6:
3900 case MITEM_PRESET1+7:
3901 case MITEM_PRESET1+8:
3902 case MITEM_PRESET1+9:
3903 {
3904 int slot = code - MITEM_PRESET1;
3905 if (MVFunction_UsePreset(mv, &settings, pathsettings, viewdata, slot, FALSE))
3906 {
3907 status = STATUS_REOPENALL;
3908 }
3909 break;
3910 }
3911
3912 case MITEM_COPYTO:
3913 {
3914 MVFunction_CopyMoveTo(mv, settings, pathsettings, viewdata, FILEACTION_COPY, FALSE, buttons);
3915 relayoutmenus = TRUE;
3916 break;
3917 }
3918 case MITEM_MOVETO:
3919 {
3920 MVFunction_CopyMoveTo(mv, settings, pathsettings, viewdata, FILEACTION_MOVE, FALSE, buttons);
3921 relayoutmenus = TRUE;
3922 break;
3923 }
3924
3925 case MITEM_COPY1:
3926 case MITEM_COPY1+1:
3927 case MITEM_COPY1+2:
3928 case MITEM_COPY1+3:
3929 case MITEM_COPY1+4:
3930 case MITEM_COPY1+5:
3931 case MITEM_COPY1+6:
3932 case MITEM_COPY1+7:
3933 case MITEM_COPY1+8:
3934 case MITEM_COPY1+9:
3935 case MITEM_MOVE1:
3936 case MITEM_MOVE1+1:
3937 case MITEM_MOVE1+2:
3938 case MITEM_MOVE1+3:
3939 case MITEM_MOVE1+4:
3940 case MITEM_MOVE1+5:
3941 case MITEM_MOVE1+6:
3942 case MITEM_MOVE1+7:
3943 case MITEM_MOVE1+8:
3944 case MITEM_MOVE1+9:
3945 {
3946 BOOL action = (code >= MITEM_MOVE1 && code <= MITEM_MOVE1+9) ? FILEACTION_MOVE : FILEACTION_COPY;
3947 int slot = code - (action == FILEACTION_MOVE ? MITEM_MOVE1 : MITEM_COPY1);
3948 if (slot >= 0 && slot < 10)
3949 {
3950 MVFunction_CopyMoveToPath(mv, settings, pathsettings, viewdata, slot, action, FALSE, buttons);
3951 relayoutmenus = TRUE;
3952 }
3953 break;
3954 }
3955
3956 case MITEM_DELETE:
3957 {
3958 char *fullsourcename;
3959
3960 if ((fullsourcename = GetPicFile(viewdata->pichandler)))
3961 {
3962 if (PerformFileAction(mv, fullsourcename, fullsourcename, FILEACTION_DELETE, settings->confirmlevel))
3963 {
3964 if (RemovePicture(viewdata->pichandler))
3965 {
3966 DeleteViewPic(viewdata, NULL, settings);
3967 GetCurrentPicture(mv, buttons, viewdata, settings, mv->logopic);
3968 }
3969 // else
3970 // {
3971 // printf("ALERT: Delete Picture - something went wrong\n");
3972 // }
3973 }
3974 Free(fullsourcename);
3975 }
3976 else
3977 {
3978 EasyRequest(mv->window->window, &nopicreq, NULL, NULL);
3979 }
3980 break;
3981 }
3982
3983 case MITEM_REMOVE:
3984 {
3985 if (RemovePicture(viewdata->pichandler))
3986 {
3987 DeleteViewPic(viewdata, NULL, settings);
3988 GetCurrentPicture(mv, buttons, viewdata, settings, mv->logopic);
3989 }
3990 else
3991 {
3992 EasyRequest(mv->window->window, &nopicreq, NULL, NULL);
3993 }
3994 break;
3995 }
3996
3997 case MITEM_CACHE_OFF:
3998 settings->bufferpercent = 1;
3999 SetPicHandlerBuffer(viewdata->pichandler, settings->bufferpercent);
4000 break;
4001 case MITEM_CACHE_SMALL:
4002 settings->bufferpercent = 15;
4003 SetPicHandlerBuffer(viewdata->pichandler, settings->bufferpercent);
4004 break;
4005 case MITEM_CACHE_MEDIUM:
4006 settings->bufferpercent = 25;
4007 SetPicHandlerBuffer(viewdata->pichandler, settings->bufferpercent);
4008 break;
4009 case MITEM_CACHE_LARGE:
4010 settings->bufferpercent = 35;
4011 SetPicHandlerBuffer(viewdata->pichandler, settings->bufferpercent);
4012 break;
4013 case MITEM_CACHE_HUGE:
4014 settings->bufferpercent = 50;
4015 SetPicHandlerBuffer(viewdata->pichandler, settings->bufferpercent);
4016 break;
4017
4018 case MITEM_SLIDEDELAY_0:
4019 settings->slidedelay = 0;
4020 break;
4021 case MITEM_SLIDEDELAY_04:
4022 settings->slidedelay = 4;
4023 break;
4024 case MITEM_SLIDEDELAY_1:
4025 settings->slidedelay = 10;
4026 break;
4027 case MITEM_SLIDEDELAY_2:
4028 settings->slidedelay = 20;
4029 break;
4030 case MITEM_SLIDEDELAY_5:
4031 settings->slidedelay = 50;
4032 break;
4033 case MITEM_SLIDEDELAY_10:
4034 settings->slidedelay = 100;
4035 break;
4036 case MITEM_SLIDEDELAY_30:
4037 settings->slidedelay = 300;
4038 break;
4039 case MITEM_SLIDEDELAY_60:
4040 settings->slidedelay = 600;
4041 break;
4042 case MITEM_SLIDEDELAY_120:
4043 settings->slidedelay = 1200;
4044 break;
4045 case MITEM_SLIDEDELAY_300:
4046 settings->slidedelay = 3000;
4047 break;
4048 case MITEM_SLIDEDELAY_600:
4049 settings->slidedelay = 6000;
4050 break;
4051
4052 case MITEM_SAVEPRESET:
4053 {
4054 char *pathname, *filename, *fullname;
4055 if (SaveRequest(mv->presetfreq, win, MVTEXT_SAVEPRESETAS, pathsettings->presetpath, NULL, &pathname, &filename))
4056 {
4057 if (pathname)
4058 {
4059 Free(pathsettings->presetpath);
4060 pathsettings->presetpath = _StrDup(pathname);
4061 }
4062
4063 if ((fullname = FullName(pathname, filename)))
4064 {
4065 WindowBusy(mv->window);
4066 SavePreset(mv, settings, fullname);
4067 WindowFree(mv->window);
4068 Free(fullname);
4069 }
4070 Free(pathname);
4071 Free(filename);
4072 }
4073 break;
4074 }
4075
4076 case MITEM_LOADPRESET:
4077 {
4078 char *pathname, *filename, *fullname;
4079 if (FileRequest(mv->presetfreq, win, MVTEXT_LOADPRESET, pathsettings->presetpath, NULL, &pathname, &filename))
4080 {
4081 if (pathname)
4082 {
4083 Free(pathsettings->presetpath);
4084 pathsettings->presetpath = _StrDup(pathname);
4085 }
4086
4087 if ((fullname = FullName(pathname, filename)))
4088 {
4089 struct mainsettings *new;
4090 WindowBusy(mv->window);
4091 if ((new = LoadPreset(fullname, settings)))
4092 {
4093 DeleteMainSettings(settings);
4094 settings = new;
4095 status = STATUS_REOPENALL;
4096 }
4097 WindowFree(mv->window);
4098 Free(fullname);
4099 }
4100 Free(pathname);
4101 Free(filename);
4102 }
4103 break;
4104 }
4105
4106 default:
4107 break;
4108 }
4109
4110 if (code >= MITEM_PUBSCREEN1)
4111 {
4112 int slot = code - MITEM_PUBSCREEN1;
4113 Free(settings->pubscreen);
4114 settings->pubscreen = _StrDup(mv->pubscreenlist[slot + 3]);
4115 settings->scropenmode = SCROPENMODE_PUBLIC;
4116 status = STATUS_REOPENALL;
4117 break;
4118 }
4119
4120 myImsg.Code = item->NextSelect;
4121 }
4122
4123 break;
4124 }
4125
4126 default:
4127 break;
4128 }
4129 }
4130
4131
4132 if (relayoutmenus)
4133 {
4134 SetupPathMenus(mv, pathsettings);
4135 SetupPresetMenu(mv, pathsettings);
4136 SetupPubscreenMenu(mv, settings);
4137 }
4138
4139 if (softrefresh)
4140 {
4141 int newdispmode;
4142
4143 if ((newdispmode = Recall(mv, settings, viewdata)) != settings->displaymode)
4144 {
4145 settings->displaymode = newdispmode;
4146 // SetMenuSettings(mv, settings);
4147 setmenusettings = TRUE;
4148 }
4149
4150 SetButtonSettings(viewdata, mv->window, buttons, settings, TRUE);
4151
4152 UpdateWindowParameters(mv->window);
4153
4154 MV_SetAttrs(viewdata->view,
4155 MVIEW_DestWidth, mv->window->innerwidth,
4156 MVIEW_DestHeight, mv->window->innerheight - (settings->showbuttons && buttons ? buttons->gadgetheight + BUTTON_VSPACE * 2 : 0),
4157 MVIEW_DestX, mv->window->innerleft,
4158 MVIEW_DestY, mv->window->innertop + (settings->showbuttons && buttons ? buttons->gadgetheight + BUTTON_VSPACE * 2 : 0),
4159 MVIEW_DisplayMode, settings->displaymode,
4160 TAG_DONE);
4161 }
4162
4163
4164 // MV_SetPIPRelative(viewdata->view, myImsg.MouseX, myImsg.MouseY, mousebutton);
4165
4166 if (setviewrelative)
4167 {
4168 IPTR newxpos, newypos;
4169 MV_SetViewRelative(viewdata->view, myImsg.MouseX, myImsg.MouseY);
4170 MV_GetAttrs(viewdata->view, MVIEW_XPos, (IPTR)&newxpos, MVIEW_YPos, (IPTR)&newypos, TAG_DONE);
4171 viewdata->xpos = viewdata->destxpos = (double) newxpos / 65536;
4172 viewdata->ypos = viewdata->destypos = (double) newypos / 65536;
4173 }
4174
4175
4176 if (setmenusettings)
4177 {
4178 SetMenuSettings(mv, settings);
4179 }
4180 }
4181
4182
4183 ApplyViewData(viewdata, settings, TRUE);
4184
4185
4186 if (hardrefresh)
4187 {
4188 MV_Refresh(viewdata->view);
4189 }
4190
4191
4192 /*
4193 ** request files
4194 */
4195
4196 if (requestfiles != REQUEST_NONE)
4197 {
4198 char **filepatternlist;
4199 char *newpath, *newfile;
4200
4201 if ((filepatternlist = MultiFileRequest(mv->freq, win,
4202 requestfiles == REQUEST_OPENFILES ? MVTEXT_SELECTPICTURES : MVTEXT_ADDPICTURES,
4203 viewdata->pathname, NULL /*viewdata->filename*/, &newpath, &newfile, settings->filterpictures, settings->rejectpattern)))
4204 {
4205 if (requestfiles == REQUEST_APPENDFILES && viewdata->pichandler)
4206 {
4207 AppendPicHandler(viewdata->pichandler, filepatternlist);
4208 }
4209 else
4210 {
4211 newpicsignal = NewPicHandler(viewdata, filepatternlist, settings, mv->logopic);
4212 }
4213
4214 if (newpath)
4215 {
4216 Free(pathsettings->startpath);
4217 pathsettings->startpath = _StrDup(newpath);
4218 }
4219
4220 Free(newpath);
4221 Free(newfile);
4222 DeleteFilePatternList(filepatternlist);
4223 }
4224 requestfiles = REQUEST_NONE;
4225 }
4226
4227
4228 /*
4229 ** appmessage loop
4230 */
4231
4232 if (signals & appsignal)
4233 {
4234 char **newfilepatternlist = NULL;
4235 char **filepatternlist = NULL;
4236
4237 ScreenToFront(mv->screen->screen);
4238 WindowToFront(mv->window->window);
4239
4240 while ((appmsg = (struct AppMessage *) GetMsg(mv->appmsgport)))
4241 {
4242 DeleteFilePatternList(newfilepatternlist);
4243 if ((newfilepatternlist = CreateFilePatternList(appmsg->am_ArgList, appmsg->am_NumArgs)))
4244 {
4245 DeleteFilePatternList(filepatternlist);
4246 filepatternlist = newfilepatternlist;
4247 newfilepatternlist = NULL;
4248 }
4249 ReplyMsg((struct Message *) appmsg);
4250 }
4251
4252 if (filepatternlist)
4253 {
4254 if (FilterFilePatternList(&filepatternlist, &settings) & 2)
4255 {
4256 status = STATUS_REOPENALL;
4257 }
4258 }
4259
4260 if (filepatternlist)
4261 {
4262 if (settings->appendicons && viewdata->pichandler)
4263 {
4264 AppendPicHandler(viewdata->pichandler, filepatternlist);
4265 }
4266 else
4267 {
4268 newpicsignal = NewPicHandler(viewdata, filepatternlist, settings, mv->logopic);
4269 }
4270 }
4271
4272 DeleteFilePatternList(filepatternlist);
4273 }
4274 }
4275
4276
4277 /*
4278 ** commodity broker
4279 */
4280
4281 if (signals & cxsignal)
4282 {
4283 ULONG msgid, msgtype;
4284 while ((cxmsg = (CxMsg *) GetMsg(mv->brokermsgport)))
4285 {
4286 msgid = CxMsgID(cxmsg);
4287 msgtype = CxMsgType(cxmsg);
4288 ReplyMsg((struct Message *) cxmsg);
4289
4290 if (msgtype == CXM_COMMAND)
4291 {
4292 switch (msgid)
4293 {
4294 case CXCMD_ENABLE:
4295 case CXCMD_DISABLE:
4296 break;
4297
4298 case CXCMD_DISAPPEAR:
4299 status = STATUS_SLEEP;
4300 break;
4301
4302 case CXCMD_KILL:
4303 status = STATUS_QUIT;
4304 break;
4305
4306 default:
4307 break;
4308 }
4309 }
4310 }
4311 }
4312
4313
4314 /*
4315 ** trigger signal arrived
4316 */
4317
4318 if (signals & triggersignal)
4319 {
4320 if (GetNextPicture(mv, buttons, viewdata, settings, mv->logopic, &newpicsignal))
4321 {
4322 if (settings->autoquit) status = STATUS_QUIT;
4323 else if (settings->autohide) status = STATUS_SLEEP;
4324 else if (settings->requestfile) requestfiles = TRUE;
4325 }
4326 }
4327
4328
4329 /*
4330 ** new picture arrived
4331 */
4332
4333 if (signals & newpicsignal)
4334 {
4335 if (viewdata->pichandler)
4336 {
4337 LONG error;
4338
4339 if (NewPicAvailable(viewdata->pichandler, &error))
4340 {
4341 PICTURE *newpic;
4342 char *fullname;
4343
4344 Free(viewdata->filename); viewdata->filename = NULL;
4345 Free(viewdata->pathname); viewdata->pathname = NULL;
4346 Free(viewdata->formatname); viewdata->formatname = NULL;
4347
4348 if ((fullname = GetPicFile(viewdata->pichandler)))
4349 {
4350 viewdata->formatname = GetPicFormat(viewdata->pichandler);
4351 viewdata->isdirectory = GetPicFileType(viewdata->pichandler);
4352 viewdata->filename = _StrDup(FilePart(fullname));
4353 *PathPart(fullname) = (char) 0;
4354 viewdata->pathname = _StrDup(fullname);
4355 Free(fullname);
4356 }
4357
4358 ResetDisplaySettings(viewdata, settings->resetdisplaysettings);
4359
4360 if ((newpic = GetPic(viewdata->pichandler)))
4361 {
4362 int newdispmode;
4363
4364 viewdata->showpic = newpic;
4365
4366 if ((newdispmode = Recall(mv, settings, viewdata)) != settings->displaymode)
4367 {
4368 settings->displaymode = newdispmode;
4369 SetMenuSettings(mv, settings);
4370 SetButtonSettings(viewdata, mv->window, buttons, settings, FALSE);
4371 }
4372
4373 MV_SetAttrs(viewdata->view,
4374 MVIEW_Picture, viewdata->showpic ? (IPTR)viewdata->showpic : (IPTR)mv->logopic,
4375 MVIEW_DisplayMode, settings->displaymode,
4376 MVIEW_Text, (IPTR)SetPicInfoText(viewdata, newpic, settings), TAG_DONE);
4377
4378 MVFunction_CreateAutoThumbnail(mv->window, settings, viewdata);
4379
4380 if (settings->slideshow)
4381 {
4382 slidesuspended = TRUE; // wait for picture to be fully visible!
4383 }
4384 }
4385 }
4386 else
4387 {
4388
4389 if (error == ERROR_OBJECT_WRONG_TYPE && settings->simplescanning)
4390 {
4391 /*
4392 ** unrecognized file and simplescanning mode on:
4393 ** silently remove the non-picture from the list
4394 */
4395
4396 if (PicHandler_Remove(viewdata->pichandler->newPicHandler,
4397 viewdata->pichandler->requestedID))
4398 {
4399 viewdata->pichandler->error = 0;
4400 Free(viewdata->pichandler->errortext);
4401 viewdata->pichandler->errortext = NULL;
4402 DeleteViewPic(viewdata, NULL, settings);
4403 GetCurrentPicture(mv, buttons, viewdata, settings, mv->logopic);
4404 }
4405 }
4406 else
4407 {
4408 char *text;
4409 text = SetPicInfoText(viewdata, viewdata->showpic, settings);
4410
4411 if (error)
4412 {
4413 viewdata->destzoom = 1;
4414 viewdata->destxpos = 0.5;
4415 viewdata->destypos = 0.5;
4416
4417 DeleteViewPic(viewdata, mv->logopic, settings);
4418 SetViewText(viewdata, text);
4419 ApplyViewData(viewdata, settings, TRUE);
4420 }
4421 else
4422 {
4423 SetViewText(viewdata, text);
4424 }
4425 }
4426 }
4427 }
4428 }
4429
4430
4431 if (slidesuspended) //wait for picture to be fully visible
4432 {
4433 if (settings->slideshow)
4434 {
4435 if (signals & (1 << viewdata->picturevisiblesignal))
4436 {
4437 slidesuspended = FALSE; // fully visible picture breaks suspended state
4438 SetTrigger(viewdata->trigger, settings->slidedelay ? settings->slidedelay * 5 : MINDELAY);
4439 }
4440 else
4441 {
4442 SetTrigger(viewdata->trigger, 0);
4443 }
4444 }
4445 else
4446 {
4447 slidesuspended = FALSE;
4448 }
4449 }
4450
4451
4452 /*
4453 ** break
4454 */
4455
4456 if (signals & SIGBREAKF_CTRL_C)
4457 {
4458 status = STATUS_QUIT;
4459 }
4460
4461
4462 } while (status == STATUS_WORKING);
4463
4464
4465
4466
4467 WindowBusy(mv->window);
4468
4469 DeleteButtons(buttons);
4470
4471 MV_Delete(viewdata->view);
4472 viewdata->view = NULL;
4473
4474 FreePubscreenMenu(mv);
4475 FreePathMenus(mv);
4476 FreePresetMenu(mv);
4477
4478 *initsettings = settings;
4479 *initpathsettings = pathsettings;
4480
4481 WindowFree(mv->window);
4482
4483 return status;
4484 }
4485
4486
4487 /*********************************************************************
4488 ----------------------------------------------------------------------
4489
4490 main
4491
4492 ----------------------------------------------------------------------
4493 *********************************************************************/
4494
4495 int mymain(int argc, char **argv);
4496
4497 #ifdef __MORPHOS__
4498 extern struct WBStartup *_WBenchMsg;
4499 #endif
4500
4501 #ifdef __STORM__
4502
4503 struct WBStartup *_WBenchMsg;
4504 void wbmain(struct WBStartup *argmsg)
4505 {
4506 struct WBArg *wbarg;
4507
4508 _WBenchMsg = argmsg;
4509
4510 wbarg = argmsg->sm_ArgList;
4511 if (wbarg->wa_Lock)
4512 {
4513 BPTR olddir;
4514 olddir = CurrentDir(wbarg->wa_Lock);
4515 mymain(0, (char **) argmsg);
4516 CurrentDir(olddir);
4517 }
4518 else
4519 {
4520 mymain(0, (char **) argmsg);
4521 }
4522 }
4523
4524 #endif
4525
4526
4527 int main(int argc, char **argv)
4528 {
4529 return mymain(argc, argv);
4530 }
4531
4532
4533 int mymain(int argc, char **argv)
4534 {
4535 char **startfilepatternlist;
4536 char **wbargarray = NULL;
4537 char *progfilename = NULL;
4538 char **ttypes;
4539
4540 char **piclist = NULL;
4541
4542
4543 struct mview *viewer;
4544 struct mainsettings *initsettings = NULL;
4545 struct pathsettings *initpathsettings;
4546
4547 int result;
4548
4549 struct RDArgs *rdargs = NULL;
4550 long opts[RDNUMARGS];
4551
4552 memset((void *) opts, 0, (size_t) (sizeof(long) * RDNUMARGS));
4553
4554 if (InitGlobal())
4555 {
4556 struct keyfile *key = InstallKey();
4557
4558 ttypes = (char **) ArgArrayInit((LONG) argc, (UBYTE **) argv);
4559
4560 MVNeuro_CreateNet();
4561
4562 initpathsettings = LoadPathSettings("ENV:MysticView", NULL);
4563
4564 #ifdef __AROS__
4565 // FIXME: Fix AROS WBenchMsg/_WBenchMsg/not_in_any_header stuff
4566 #define _WBenchMsg WBenchMsg
4567 extern struct WBStartup *WBenchMsg;
4568 #endif
4569 if(_WBenchMsg)
4570 {
4571 char fullname[MAXFULLNAMELEN];
4572 struct mainsettings *newsettings;
4573
4574 if (NameFromLock(GetProgramDir(), fullname, MAXPATHNAMELEN))
4575 {
4576 if (AddPart(fullname, _WBenchMsg->sm_ArgList[0].wa_Name, MAXFULLNAMELEN))
4577 {
4578 progfilename = _StrDup(fullname);
4579 }
4580 }
4581
4582 initsettings = LoadDefaultSettings(progfilename);
4583
4584 if ((newsettings = CreateMainSettings(ttypes, initsettings, TAG_END)))
4585 {
4586 DeleteMainSettings(initsettings);
4587 initsettings = newsettings;
4588 }
4589
4590 wbargarray = CreateFilePatternList(&_WBenchMsg->sm_ArgList[1], _WBenchMsg->sm_NumArgs - 1);
4591
4592 /*
4593 ** check for preset and listfiles
4594 */
4595
4596 if (wbargarray)
4597 {
4598 FilterFilePatternList(&wbargarray, &initsettings);
4599 }
4600
4601 startfilepatternlist = wbargarray;
4602
4603 }
4604 else
4605 {
4606 char fullname[MAXFULLNAMELEN];
4607 struct mainsettings *newsettings;
4608
4609 rdargs = ReadArgs(RDARGTEMPLATE, opts, NULL);
4610 startfilepatternlist = (char **) opts[0];
4611
4612
4613 if (NameFromLock(GetProgramDir(), fullname, MAXPATHNAMELEN))
4614 {
4615 if (AddPart(fullname, argv[0], MAXFULLNAMELEN))
4616 {
4617 progfilename = _StrDup(fullname);
4618 }
4619 }
4620
4621
4622 if (!opts[ARG_DEFAULT]) // do not read config when DEFAULT is specified
4623 {
4624 struct DiskObject *dob;
4625
4626 if ((dob = GetDiskObject(progfilename)))
4627 {
4628 initsettings = CreateMainSettings((char **)dob->do_ToolTypes, NULL, TAG_END);
4629 FreeDiskObject(dob);
4630 }
4631 }
4632
4633
4634 // use list file?
4635
4636 if (opts[ARG_LISTFILE])
4637 {
4638 if ((piclist = LoadStringList((char *) opts[ARG_LISTFILE])))
4639 {
4640 startfilepatternlist = piclist;
4641 }
4642 else
4643 {
4644 char *fullname = FullName(initpathsettings->listpath, FilePart((char *)opts[ARG_LISTFILE]));
4645 if ((piclist = LoadStringList(fullname)))
4646 {
4647 startfilepatternlist = piclist;
4648 }
4649 Free(fullname);
4650 }
4651 }
4652
4653 // use preset?
4654
4655 if (opts[ARG_PRESETFILE])
4656 {
4657 struct mainsettings *new;
4658
4659
4660 if ((new = LoadPreset((char *) opts[ARG_PRESETFILE], initsettings)))
4661 {
4662 DeleteMainSettings(initsettings);
4663 initsettings = new;
4664 }
4665 else
4666 {
4667 char *fullname = FullName(initpathsettings->presetpath, FilePart((char *) opts[ARG_PRESETFILE]));
4668 if ((new = LoadPreset(fullname, initsettings)))
4669 {
4670 DeleteMainSettings(initsettings);
4671 initsettings = new;
4672 }
4673 Free(fullname);
4674 }
4675 }
4676 if ((newsettings = CreateMainSettings(ttypes, initsettings, TAG_END)))
4677 {
4678 DeleteMainSettings(initsettings);
4679 initsettings = newsettings;
4680 }
4681
4682 if (opts[ARG_APPEND] && startfilepatternlist)
4683 {
4684 if (PicHandler_AppendScanList(startfilepatternlist,
4685 PICH_Reject, initsettings ? (IPTR) initsettings->rejectpattern : (IPTR) TRUE,
4686 PICH_Recursive, initsettings ? (IPTR) initsettings->recursive : (IPTR) TRUE,
4687 TAG_DONE))
4688 {
4689 goto appended_raus;
4690 }
4691 }
4692
4693 }
4694
4695
4696 globalpriority = SetTaskPri(FindTask(NULL), MAXPRIORITY);
4697 SetTaskPri(FindTask(NULL), globalpriority);
4698
4699
4700 if (!(SetSignal(0,0) & SIGBREAKF_CTRL_C))
4701 {
4702 struct mainsettings *settings = NULL;
4703 struct mainsettings *oldsettings;
4704 struct pathsettings *pathsettings = NULL;
4705
4706 if ((settings = CreateMainSettings(NULL, initsettings, TAG_END)))
4707 {
4708 // if (pathsettings = LoadPathSettings("ENV:MysticView", initpathsettings))
4709 if ((pathsettings = CreatePathSettings(NULL, initpathsettings, TAG_END)))
4710 {
4711 if ((oldsettings = CreateMainSettings(NULL, settings, TAG_END)))
4712 {
4713 struct viewdata *viewdata;
4714
4715 if ((viewdata = CreateViewData(startfilepatternlist)))
4716 {
4717 BOOL reopen = FALSE;
4718 int status = settings->cx_popup ? STATUS_WORKING : STATUS_SLEEP;
4719
4720 if ((viewer = CreateMView(settings, progfilename)))
4721 {
4722
4723 do
4724 {
4725
4726 switch (status)
4727 {
4728 case STATUS_WORKING:
4729 if (!viewer->screen) viewer->screen = CreateMVScreen(settings);
4730 if (!viewer->window) viewer->window = CreateMVWindow(viewer, viewer->screen, settings);
4731
4732 if (viewer->screen && viewer->window)
4733 {
4734 status = HandleMView(viewer, &settings, &pathsettings, oldsettings, viewdata, reopen);
4735 }
4736 else
4737 {
4738 printf("*** could not open window - screen: %s - window %s.\n", viewer->screen?"okay":"failed", viewer->window?"okay":"failed");
4739 status = STATUS_QUIT;
4740 }
4741
4742 break;
4743
4744 case STATUS_REOPENALL:
4745 DeleteMVWindow(viewer, viewer->window);
4746 viewer->window = NULL;
4747 DeleteMVScreen(viewer->screen);
4748 viewer->screen = NULL;
4749 status = STATUS_WORKING;
4750 reopen = TRUE;
4751 break;
4752
4753 case STATUS_REOPENWINDOW:
4754 DeleteMVWindow(viewer, viewer->window);
4755 viewer->window = NULL;
4756 status = STATUS_WORKING;
4757 reopen = TRUE;
4758 break;
4759
4760 case STATUS_SLEEP:
4761 {
4762 ULONG cxsignal = 1 << (viewer->brokermsgport->mp_SigBit);
4763 struct AppMessage *appmsg;
4764 CxMsg *cxmsg;
4765 ULONG signals;
4766
4767 DeleteMVWindow(viewer, viewer->window);
4768 viewer->window = NULL;
4769
4770 DeleteMVScreen(viewer->screen);
4771 viewer->screen = NULL;
4772
4773 do
4774 {
4775 signals = Wait(cxsignal | viewer->appSignal | SIGBREAKF_CTRL_C);
4776
4777 if (signals & viewer->appSignal)
4778 {
4779 char **newfilepatternlist = NULL;
4780 char **filepatternlist = NULL;
4781
4782 while ((appmsg = (struct AppMessage *) GetMsg(viewer->appmsgport)))
4783 {
4784 DeleteFilePatternList(newfilepatternlist);
4785 if ((newfilepatternlist = CreateFilePatternList(appmsg->am_ArgList, appmsg->am_NumArgs)))
4786 {
4787 DeleteFilePatternList(filepatternlist);
4788 filepatternlist = newfilepatternlist;
4789 newfilepatternlist = NULL;
4790 }
4791 ReplyMsg((struct Message *) appmsg);
4792 }
4793
4794 if (filepatternlist)
4795 {
4796 FilterFilePatternList(&filepatternlist, &settings);
4797 }
4798 if (filepatternlist)
4799 {
4800 NewPicHandler(viewdata, filepatternlist, settings, NULL);
4801 DeleteFilePatternList(filepatternlist);
4802 }
4803 status = STATUS_WORKING;
4804 }
4805
4806 if (signals & cxsignal)
4807 {
4808 ULONG msgid, msgtype;
4809 while ((cxmsg = (CxMsg *) GetMsg(viewer->brokermsgport)))
4810 {
4811 msgid = CxMsgID(cxmsg);
4812 msgtype = CxMsgType(cxmsg);
4813 ReplyMsg((struct Message *) cxmsg);
4814
4815 switch (msgtype)
4816 {
4817 case CXM_COMMAND:
4818 switch (msgid)
4819 {
4820 case CXCMD_APPEAR:
4821 status = STATUS_WORKING;
4822 break;
4823
4824 case CXCMD_KILL:
4825 status = STATUS_QUIT;
4826 break;
4827
4828 default:
4829 break;
4830 }
4831
4832 case CXM_IEVENT:
4833 if (msgid == EVT_HOTKEY)
4834 {
4835 status = STATUS_WORKING;
4836 break;
4837 }
4838 }
4839 }
4840 }
4841 if (signals & SIGBREAKF_CTRL_C)
4842 {
4843 status = STATUS_QUIT;
4844 }
4845 } while (status == STATUS_SLEEP);
4846
4847 break;
4848 }
4849
4850 default:
4851 case STATUS_QUIT:
4852 DeleteMView(viewer);
4853 viewer = NULL;
4854 break;
4855 }
4856
4857 } while (status != STATUS_QUIT);
4858
4859 DeleteMView(viewer);
4860
4861 }
4862 DeleteViewData(viewdata);
4863 }
4864
4865 if (pathsettings->autosavesettings)
4866 {
4867 SaveDefaultSettings(settings, progfilename);
4868 }
4869
4870 SavePathSettings(pathsettings, "ENVARC:MysticView");
4871 SavePathSettings(pathsettings, "ENV:MysticView");
4872
4873 DeleteMainSettings(oldsettings);
4874 }
4875
4876 DeletePathSettings(pathsettings);
4877 }
4878 DeleteMainSettings(settings);
4879 }
4880 }
4881
4882 appended_raus:
4883
4884
4885 DeleteFilePatternList(wbargarray);
4886 FreeArgs(rdargs);
4887
4888
4889 DeleteStringList(piclist);
4890
4891 Free(progfilename);
4892
4893 DeleteMainSettings(initsettings);
4894
4895 DeletePathSettings(initpathsettings);
4896
4897 ArgArrayDone();
4898
4899 MVNeuro_DeleteNet();
4900
4901 RemoveKey(key);
4902
4903 CloseGlobal();
4904 result = RETURN_OK;
4905 }
4906 else
4907 {
4908 printf("*** abnormal program termination.\n");
4909 result = RETURN_FAIL;
4910 }
4911
4912 return result;
4913 }
4914
4915
Mirror of AROS' Contrib svn.