?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated backport
[AROS.git] / workbench / utilities / MultiView / main.c
blob1e604d75842097ec09a31d919f1773c52b675f06
1 /*
2 Copyright © 1995-2012, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 /*********************************************************************************************/
7
8 #include "global.h"
9
10 #include "compilerspecific.h"
11 #include "debug.h"
12 #include "arossupport.h"
13
14 #include <setjmp.h>
15 #include <stdio.h>
16 #include <string.h>
17
18 extern struct NewMenu nm[];
19 extern struct NewMenu nmpict[];
20 extern struct NewMenu nmtext[];
21
22 /*********************************************************************************************/
23
24 /* Many datatype classes seem to rely on OM_NOTIFY calls coming back to the datatype object
25 as OM_UPDATE :-\ */
26
27 #define BACK_CONNECTION 1
28
29 /*********************************************************************************************/
30
31 #define ARG_TEMPLATE "FILE,CLIPBOARD/S,CLIPUNIT/K/N,SCREEN/S,PUBSCREEN/K,REQUESTER/S," \
32 "BOOKMARK/S,FONTNAME/K,FONTSIZE/K/N,BACKDROP/S,WINDOW/S," \
33 "PORTNAME/K,IMMEDIATE/S,REPEAT/S,PRTUNIT/K/N"
34
35 #define ARG_FILE 0
36 #define ARG_CLIPBOARD 1
37 #define ARG_CLIPUNIT 2
38 #define ARG_SCREEN 3
39 #define ARG_PUBSCREEN 4
40 #define ARG_REQUESTER 5
41 #define ARG_BOOKMARK 6
42 #define ARG_FONTNAME 7
43 #define ARG_FONTSIZE 8
44 #define ARG_BACKDROP 9
45 #define ARG_WINDOW 10
46 #define ARG_PORTNAME 11
47 #define ARG_IMMEDIATE 12
48 #define ARG_REPEAT 13
49 #define ARG_PRTUNIT 14
50
51 #define NUM_ARGS 15
52
53 /*********************************************************************************************/
54
55 static struct libinfo
56 {
57 APTR var;
58 STRPTR name;
59 WORD version;
60 } libtable[] =
61 {
62 {&IntuitionBase , "intuition.library" , 39 },
63 {&GfxBase , "graphics.library" , 39 },
64 {&GadToolsBase , "gadtools.library" , 39 },
65 {&LayersBase , "layers.library" , 39 },
66 {&UtilityBase , "utility.library" , 39 },
67 {&KeymapBase , "keymap.library" , 39 },
68 {&DataTypesBase , "datatypes.library" , 39 },
69 {&DiskfontBase , "diskfont.library" , 39 },
70 {NULL }
71 };
72
73 static struct TextAttr textattr;
74 static struct TextFont *font;
75 static struct RDArgs *myargs;
76 static IPTR args[NUM_ARGS];
77 static UBYTE fontname[256];
78 static WORD winwidth, winheight;
79 static WORD sizeimagewidth, sizeimageheight;
80 static BOOL model_has_members;
81 static jmp_buf exit_buf;
82
83 /*********************************************************************************************/
84
85 static void CloseLibs(void);
86 static void KillFont(void);
87 static void FreeArguments(void);
88 static void KillICObjects(void);
89 static void FreeVisual(void);
90 static void KillGadgets(void);
91 static void CloseDTO(void);
92 static void KillWindow(void);
93 static void ScrollTo(UWORD dir, UWORD quali);
94 static void FitToWindow(void);
95
96 /*********************************************************************************************/
97
98 void OutputMessage(CONST_STRPTR msg)
99 {
100 struct EasyStruct es;
101
102 if (msg)
103 {
104 if ( IntuitionBase && !((struct Process *)FindTask(NULL))->pr_CLI )
105 {
106 es.es_StructSize = sizeof(es);
107 es.es_Flags = 0;
108 es.es_Title = "MultiView";
109 es.es_TextFormat = msg;
110 es.es_GadgetFormat = MSG(MSG_OK);
111
112 EasyRequestArgs(win, &es, NULL, NULL);
113 }
114 else
115 {
116 Printf("MultiView: %s\n", msg);
117 }
118 }
119 }
120
121 /*********************************************************************************************/
122
123 void WinCleanup(void)
124 {
125
126 if (win)
127 {
128 wincoords.MinX = win->LeftEdge;
129 wincoords.MinY = win->TopEdge;
130 wincoords.MaxX = win->Width;
131 wincoords.MaxY = win->Height;
132 }
133 D(bug("[Multiview] WinCleanup() MinX = %d MinY = %d MaxX = %d MaxY = %d\n",
134 wincoords.MinX, wincoords.MinY, wincoords.MaxX, wincoords.MaxY));
135
136 if (msgport)
137 {
138 DeleteMsgPort(msgport);
139 msgport = NULL;
140 D(bug("[Multiview] removed msgport\n"));
141 }
142 if (appwindow)
143 {
144 RemoveAppWindow(appwindow);
145 appwindow = NULL;
146 D(bug("[Multiview] removed appwindow\n"));
147 }
148
149 KillWindow();
150 KillMenus();
151 KillGadgets();
152 FreeVisual();
153 CloseDTO();
154 KillICObjects();
155 KillFont();
156 }
157
158 /*********************************************************************************************/
159
160 void Cleanup(CONST_STRPTR msg)
161 {
162 struct ScreenNotifyMessage *snmsg;
163
164 OutputMessage(msg);
165
166 while (!EndScreenNotify (isnstarted))
167 Delay (10);
168
169 if (isnport)
170 {
171 while ((snmsg = (struct ScreenNotifyMessage *) GetMsg (isnport)))
172 {
173 ReplyMsg((struct Message *)snmsg);
174 }
175 DeleteMsgPort(isnport);
176 }
177
178 WinCleanup();
179
180 FreeArguments();
181
182 if (cd != BNULL)
183 CurrentDir(cd); /* restore current directory */
184
185 CloseLibs();
186 CleanupLocale();
187
188 longjmp(exit_buf, 0);
189 }
190
191
192 /*********************************************************************************************/
193
194 static void OpenLibs(void)
195 {
196 struct libinfo *li;
197
198 for(li = libtable; li->var; li++)
199 {
200 if (!((*(struct Library **)li->var) = OpenLibrary(li->name, li->version)))
201 {
202 __sprintf(s, MSG(MSG_CANT_OPEN_LIB), li->name, li->version);
203 Cleanup(s);
204 }
205 }
206
207 }
208
209 /*********************************************************************************************/
210
211 static void CloseLibs(void)
212 {
213 struct libinfo *li;
214
215 for(li = libtable; li->var; li++)
216 {
217 if (*(struct Library **)li->var) CloseLibrary((*(struct Library **)li->var));
218 }
219 }
220
221 /*********************************************************************************************/
222
223 static void LoadFont(void)
224 {
225 font = OpenDiskFont(&textattr);
226 if (!font)
227 {
228 textattr.ta_Name = "topaz.font";
229 textattr.ta_YSize = 8;
230 textattr.ta_Style = 0;
231 textattr.ta_Flags = 0;
232
233 font = OpenFont(&textattr);
234 }
235 }
236
237 /*********************************************************************************************/
238
239 static void KillFont(void)
240 {
241 if (font) CloseFont(font);
242 }
243
244 /*********************************************************************************************/
245
246 static void InitDefaults(void)
247 {
248 struct TextFont *defaultfont = GfxBase->DefaultFont;
249
250 /* This might be a bit problematic depending on how default system font
251 switching through Font prefs program works and if then the previous
252 default system font is closed or not. So this is very likely only safe
253 when in such a case the previous font is not closed (means -> the font
254 will remain in memory in any case)
255
256 ClipView example program on Amiga Dev CD also does it like this. So ... */
257
258 textattr.ta_Name = defaultfont->tf_Message.mn_Node.ln_Name;
259 textattr.ta_YSize = defaultfont->tf_YSize;
260 textattr.ta_Style = defaultfont->tf_Style;
261 textattr.ta_Flags = defaultfont->tf_Flags;
262 }
263
264 /*********************************************************************************************/
265
266 static void GetArguments(void)
267 {
268
269 if (!(myargs = ReadArgs(ARG_TEMPLATE, args, NULL)))
270 {
271 Fault(IoErr(), 0, s, 256);
272 Cleanup(s);
273 }
274
275 filename = (STRPTR)args[ARG_FILE];
276 if (!filename && !args[ARG_CLIPBOARD])
277 {
278 filename = GetFileName(MSG_ASL_OPEN_TITLE);
279 if (!filename) Cleanup(NULL);
280 }
281
282 if (args[ARG_FONTNAME])
283 {
284 strncpy(fontname, (char *)args[ARG_FONTNAME], 255 - 5);
285 if (!strstr(fontname, ".font")) strcat(fontname, ".font");
286
287 textattr.ta_Name = fontname;
288 }
289
290 if (args[ARG_FONTSIZE])
291 {
292 textattr.ta_YSize = *(LONG *)args[ARG_FONTSIZE];
293 }
294
295 }
296
297 /*********************************************************************************************/
298
299 static void FreeArguments(void)
300 {
301 if (myargs) FreeArgs(myargs);
302 }
303
304 /*********************************************************************************************/
305
306 static void MakeICObjects(void)
307 {
308 static const struct TagItem dto_to_vert_map[] =
309 {
310 {DTA_TopVert , PGA_Top },
311 {DTA_VisibleVert , PGA_Visible },
312 {DTA_TotalVert , PGA_Total },
313 {TAG_DONE }
314 };
315 static const struct TagItem dto_to_horiz_map[] =
316 {
317 {DTA_TopHoriz , PGA_Top },
318 {DTA_VisibleHoriz , PGA_Visible },
319 {DTA_TotalHoriz , PGA_Total },
320 {TAG_DONE }
321 };
322 static const struct TagItem vert_to_dto_map[] =
323 {
324 {PGA_Top , DTA_TopVert },
325 {TAG_DONE }
326 };
327 static const struct TagItem horiz_to_dto_map[] =
328 {
329 {PGA_Top , DTA_TopHoriz },
330 {TAG_DONE }
331 };
332
333 model_obj = NewObject(NULL, MODELCLASS, ICA_TARGET, ICTARGET_IDCMP,
334 TAG_DONE);
335 dto_to_vert_ic_obj = NewObject(NULL, ICCLASS, ICA_MAP, (IPTR)dto_to_vert_map,
336 TAG_DONE);
337 dto_to_horiz_ic_obj = NewObject(NULL, ICCLASS, ICA_MAP, (IPTR)dto_to_horiz_map,
338 TAG_DONE);
339 vert_to_dto_ic_obj = NewObject(NULL, ICCLASS, ICA_MAP, (IPTR)vert_to_dto_map,
340 TAG_DONE);
341 horiz_to_dto_ic_obj = NewObject(NULL, ICCLASS, ICA_MAP, (IPTR)horiz_to_dto_map,
342 TAG_DONE);
343 #if BACK_CONNECTION
344 model_to_dto_ic_obj = NewObject(NULL, ICCLASS, TAG_DONE);
345 #endif
346
347 if (!model_obj ||
348 !dto_to_vert_ic_obj ||
349 !dto_to_horiz_ic_obj ||
350 !vert_to_dto_ic_obj ||
351 !horiz_to_dto_ic_obj
352 #if BACK_CONNECTION
353 || !model_to_dto_ic_obj
354 #endif
355 )
356 {
357 Cleanup(MSG(MSG_CANT_CREATE_IC));
358 }
359
360 DoMethod(model_obj, OM_ADDMEMBER, (IPTR) dto_to_vert_ic_obj);
361 DoMethod(model_obj, OM_ADDMEMBER, (IPTR) dto_to_horiz_ic_obj);
362 #if BACK_CONNECTION
363 DoMethod(model_obj, OM_ADDMEMBER, (IPTR) model_to_dto_ic_obj);
364 #endif
365
366 model_has_members = TRUE;
367
368 }
369
370 /*********************************************************************************************/
371
372 static void KillICObjects(void)
373 {
374 if (!model_has_members)
375 {
376 if (dto_to_vert_ic_obj) DisposeObject(dto_to_vert_ic_obj);
377 if (dto_to_horiz_ic_obj) DisposeObject(dto_to_horiz_ic_obj);
378 #if BACK_CONNECTION
379 if (model_to_dto_ic_obj) DisposeObject(model_to_dto_ic_obj);
380 #endif
381 }
382
383 if (model_obj) DisposeObject(model_obj);
384 if (vert_to_dto_ic_obj) DisposeObject(vert_to_dto_ic_obj);
385 if (horiz_to_dto_ic_obj) DisposeObject(horiz_to_dto_ic_obj);
386 }
387
388 /*********************************************************************************************/
389
390 static void GetVisual(void)
391 {
392 scr = LockPubScreen((CONST_STRPTR)args[ARG_PUBSCREEN]);
393 if (!scr) Cleanup(MSG(MSG_CANT_LOCK_SCR));
394
395 dri = GetScreenDrawInfo(scr);
396 if (!dri) Cleanup(MSG(MSG_CANT_GET_DRI));
397
398 vi = GetVisualInfoA(scr, NULL);
399 if (!vi) Cleanup(MSG(MSG_CANT_GET_VI));
400 }
401
402 /*********************************************************************************************/
403
404 static void FreeVisual(void)
405 {
406 if (vi) FreeVisualInfo(vi);
407 if (dri) FreeScreenDrawInfo(scr, dri);
408 if (scr) UnlockPubScreen(NULL, scr);
409 }
410
411 /*********************************************************************************************/
412
413 static void MakeGadgets(void)
414 {
415 static WORD img2which[] =
416 {
417 UPIMAGE,
418 DOWNIMAGE,
419 LEFTIMAGE,
420 RIGHTIMAGE,
421 SIZEIMAGE
422 };
423
424 IPTR imagew[NUM_IMAGES], imageh[NUM_IMAGES];
425 WORD v_offset, h_offset, btop, i;
426
427 for(i = 0; i < NUM_IMAGES; i++)
428 {
429 img[i] = NewObject(NULL, SYSICLASS, SYSIA_DrawInfo , (IPTR)( dri ),
430 SYSIA_Which , (IPTR)( img2which[i] ),
431 TAG_DONE);
432
433 if (!img[i]) Cleanup(MSG(MSG_CANT_CREATE_SYSIMAGE));
434
435 GetAttr(IA_Width,(Object *)img[i],&imagew[i]);
436 GetAttr(IA_Height,(Object *)img[i],&imageh[i]);
437 }
438
439 sizeimagewidth = imagew[IMG_SIZE];
440 sizeimageheight = imageh[IMG_SIZE];
441
442 btop = scr->WBorTop + dri->dri_Font->tf_YSize + 1;
443
444 v_offset = imagew[IMG_DOWNARROW] / 4;
445 h_offset = imageh[IMG_LEFTARROW] / 4;
446
447 gad[GAD_UPARROW] = NewObject(NULL, BUTTONGCLASS,
448 GA_Image , (IPTR)( img[IMG_UPARROW] ),
449 GA_RelRight , (IPTR)( -imagew[IMG_UPARROW] + 1 ),
450 GA_RelBottom , (IPTR)( -imageh[IMG_DOWNARROW] - imageh[IMG_UPARROW] - imageh[IMG_SIZE] + 1 ),
451 GA_ID , (IPTR)( GAD_UPARROW ),
452 GA_RightBorder , (IPTR)TRUE,
453 GA_Immediate , (IPTR)TRUE,
454 GA_RelVerify , (IPTR)TRUE,
455 TAG_DONE);
456
457 gad[GAD_DOWNARROW] = NewObject(NULL, BUTTONGCLASS,
458 GA_Image , (IPTR)( img[IMG_DOWNARROW] ),
459 GA_RelRight , (IPTR)( -imagew[IMG_UPARROW] + 1 ),
460 GA_RelBottom , (IPTR)( -imageh[IMG_UPARROW] - imageh[IMG_SIZE] + 1 ),
461 GA_ID , (IPTR)( GAD_DOWNARROW ),
462 GA_RightBorder , (IPTR)TRUE,
463 GA_Previous , (IPTR)( gad[GAD_UPARROW] ),
464 GA_Immediate , (IPTR)TRUE,
465 GA_RelVerify , (IPTR)TRUE,
466 TAG_DONE);
467
468 gad[GAD_VERTSCROLL] = NewObject(NULL, PROPGCLASS,
469 GA_Top , (IPTR)( btop + 1 ),
470 GA_RelRight , (IPTR)( -imagew[IMG_DOWNARROW] + v_offset + 1 ),
471 GA_Width , (IPTR)( imagew[IMG_DOWNARROW] - v_offset * 2 ),
472 GA_RelHeight , (IPTR)( -imageh[IMG_DOWNARROW] - imageh[IMG_UPARROW] - imageh[IMG_SIZE] - btop -2 ),
473 GA_ID , (IPTR)( GAD_VERTSCROLL ),
474 GA_Previous , (IPTR)( gad[GAD_DOWNARROW] ),
475 GA_RightBorder , (IPTR)TRUE,
476 GA_RelVerify , (IPTR)TRUE,
477 GA_Immediate , (IPTR)TRUE,
478 PGA_NewLook , (IPTR)TRUE,
479 PGA_Borderless , (IPTR)TRUE,
480 PGA_Total , (IPTR)100,
481 PGA_Visible , (IPTR)100,
482 PGA_Freedom , (IPTR)FREEVERT,
483 PGA_NotifyBehaviour , (IPTR)PG_BEHAVIOUR_NICE,
484 TAG_DONE);
485
486 gad[GAD_RIGHTARROW] = NewObject(NULL, BUTTONGCLASS,
487 GA_Image , (IPTR)( img[IMG_RIGHTARROW] ),
488 GA_RelRight , (IPTR)( -imagew[IMG_SIZE] - imagew[IMG_RIGHTARROW] + 1 ),
489 GA_RelBottom , (IPTR)( -imageh[IMG_RIGHTARROW] + 1 ),
490 GA_ID , (IPTR)( GAD_RIGHTARROW ),
491 GA_BottomBorder , (IPTR)TRUE,
492 GA_Previous , (IPTR)( gad[GAD_VERTSCROLL] ),
493 GA_Immediate , (IPTR)TRUE,
494 GA_RelVerify , (IPTR)TRUE,
495 TAG_DONE);
496
497 gad[GAD_LEFTARROW] = NewObject(NULL, BUTTONGCLASS,
498 GA_Image , (IPTR)( img[IMG_LEFTARROW] ),
499 GA_RelRight , (IPTR)( -imagew[IMG_SIZE] - imagew[IMG_RIGHTARROW] - imagew[IMG_LEFTARROW] + 1 ),
500 GA_RelBottom , (IPTR)( -imageh[IMG_RIGHTARROW] + 1 ),
501 GA_ID , (IPTR)( GAD_LEFTARROW ),
502 GA_BottomBorder , (IPTR)TRUE,
503 GA_Previous , (IPTR)( gad[GAD_RIGHTARROW] ),
504 GA_Immediate , (IPTR)TRUE,
505 GA_RelVerify , (IPTR)TRUE,
506 TAG_DONE);
507
508 gad[GAD_HORIZSCROLL] = NewObject(NULL, PROPGCLASS,
509 GA_Left , (IPTR)( scr->WBorLeft ),
510 GA_RelBottom , (IPTR)( -imageh[IMG_LEFTARROW] + h_offset + 1 ),
511 GA_RelWidth , (IPTR)( -imagew[IMG_LEFTARROW] - imagew[IMG_RIGHTARROW] - imagew[IMG_SIZE] - scr->WBorRight - 2 ),
512 GA_Height , (IPTR)( imageh[IMG_LEFTARROW] - (h_offset * 2) ),
513 GA_ID , (IPTR)( GAD_HORIZSCROLL ),
514 GA_Previous , (IPTR)( gad[GAD_LEFTARROW] ),
515 GA_BottomBorder , (IPTR)TRUE,
516 GA_RelVerify , (IPTR)TRUE,
517 GA_Immediate , (IPTR)TRUE,
518 PGA_NewLook , (IPTR)TRUE,
519 PGA_Borderless , (IPTR)TRUE,
520 PGA_Total , (IPTR)100,
521 PGA_Visible , (IPTR)100,
522 PGA_Freedom , (IPTR)FREEHORIZ,
523 PGA_NotifyBehaviour , (IPTR)PG_BEHAVIOUR_NICE,
524 TAG_DONE);
525
526 for(i = 0;i < NUM_GADGETS;i++)
527 {
528 if (!gad[i]) Cleanup(MSG(MSG_CANT_CREATE_GADGET));
529 }
530
531 SetAttrs(gad[GAD_VERTSCROLL] , ICA_TARGET, (IPTR)vert_to_dto_ic_obj, TAG_DONE);
532 SetAttrs(gad[GAD_HORIZSCROLL], ICA_TARGET, (IPTR)horiz_to_dto_ic_obj, TAG_DONE);
533 SetAttrs(dto_to_vert_ic_obj , ICA_TARGET, (IPTR)gad[GAD_VERTSCROLL], TAG_DONE);
534 SetAttrs(dto_to_horiz_ic_obj , ICA_TARGET, (IPTR)gad[GAD_HORIZSCROLL], TAG_DONE);
535 }
536
537 /*********************************************************************************************/
538
539 static void KillGadgets(void)
540 {
541 WORD i;
542
543 for(i = 0; i < NUM_GADGETS;i++)
544 {
545 if (win) RemoveGadget(win, (struct Gadget *)gad[i]);
546 if (gad[i]) DisposeObject(gad[i]);
547 gad[i] = 0;
548 }
549
550 for(i = 0; i < NUM_IMAGES;i++)
551 {
552 if (img[i]) DisposeObject(img[i]);
553 img[i] = NULL;
554 }
555 }
556
557 /*********************************************************************************************/
558
559 void AddDTOToWin(void)
560 {
561 EraseRect(win->RPort, win->BorderLeft,
562 win->BorderTop,
563 win->Width - 1 - win->BorderRight,
564 win->Height - 1 - win->BorderBottom);
565
566 SetDTAttrs (dto, NULL, NULL, GA_Left , win->BorderLeft + 2 ,
567 GA_Top , win->BorderTop + 2 ,
568 GA_RelWidth , - win->BorderLeft - win->BorderRight - 4 ,
569 GA_RelHeight , - win->BorderTop - win->BorderBottom - 4 ,
570 TAG_DONE);
571
572 AddDTObject(win, NULL, dto, -1);
573 RefreshDTObjects(dto, win, NULL, 0); // seems to be needed by text datatype to render more than first line at start...
574 }
575
576 /*********************************************************************************************/
577
578 static void OpenDTO(void)
579 {
580 struct DTMethod *triggermethods;
581 ULONG *methods;
582 STRPTR objname = NULL;
583 IPTR val;
584 struct DataType *dt;
585
586 old_dto = dto;
587
588 do
589 {
590 if (!old_dto && args[ARG_CLIPBOARD])
591 {
592 APTR clipunit = 0;
593
594 if (args[ARG_CLIPUNIT]) clipunit = *(APTR *)args[ARG_CLIPUNIT];
595
596 D(bug("MultiView: calling NewDTObject\n"));
597
598 dto = NewDTObject(clipunit, ICA_TARGET , (IPTR)model_obj,
599 GA_ID , 1000 ,
600 DTA_SourceType, DTST_CLIPBOARD ,
601 DTA_TextAttr , (IPTR)&textattr,
602 TAG_DONE);
603
604 D(bug("MultiView: NewDTObject returned %x\n", dto));
605 }
606 else
607 {
608 dto = NewDTObject(filename, ICA_TARGET , (IPTR)model_obj,
609 GA_ID , 1000 ,
610 DTA_TextAttr , (IPTR)&textattr,
611 TAG_DONE);
612 }
613
614 if (!dto)
615 {
616 ULONG errnum = IoErr();
617
618 if (errnum == DTERROR_UNKNOWN_DATATYPE)
619 {
620 BPTR lock = Lock(filename,ACCESS_READ);
621 if (lock)
622 {
623 struct DataType *dtn;
624 if ((dtn = ObtainDataTypeA(DTST_FILE, (APTR)lock, NULL)))
625 {
626 if (!Stricmp(dtn->dtn_Header->dth_Name, "directory"))
627 {
628 /* file is a directory and no directory.datatype is installed */
629 strncpy(filenamebuffer, (filename ? filename : (STRPTR)""), 298);
630 filenamebuffer[298]=0;
631
632 if (strlen(filenamebuffer) &&
633 filenamebuffer[strlen(filenamebuffer)-1] != ':' &&
634 filenamebuffer[strlen(filenamebuffer)-1] != '/')
635 {
636 strcat(filenamebuffer,"/");
637 }
638
639 filename = GetFileName(MSG_ASL_OPEN_TITLE);
640 if (filename) continue;
641 }
642 ReleaseDataType(dtn);
643 }
644 UnLock(lock);
645 }
646 }
647
648 if (errnum >= DTERROR_UNKNOWN_DATATYPE)
649 __sprintf(s, GetDTString(errnum), filename);
650 else
651 Fault(errnum, 0, s, 256);
652
653 if (!old_dto)
654 {
655 /* Check if file is 0-length, fail silently (AOS confirmed) */
656 STRPTR msg = s;
657 BPTR lock = Lock(filename, ACCESS_READ);
658 if (lock)
659 {
660 struct FileInfoBlock * fib = AllocDosObject(DOS_FIB, NULL);
661 if (Examine(lock, fib))
662 {
663 if (fib->fib_Size == 0)
664 {
665 /* prog_exitcode = 20; */ /* ABIV1 Multiview no longer exits in Cleanup */
666 msg = NULL;
667 }
668 }
669 FreeDosObject(DOS_FIB, fib);
670 UnLock(lock);
671 }
672
673 Cleanup(msg);
674 }
675 dto = old_dto;
676 return;
677 }
678 } while (!dto);
679
680 strncpy(filenamebuffer, (filename ? filename : (STRPTR)""), 299);
681
682 SetAttrs(vert_to_dto_ic_obj, ICA_TARGET, (IPTR)dto, TAG_DONE);
683 SetAttrs(horiz_to_dto_ic_obj, ICA_TARGET, (IPTR)dto, TAG_DONE);
684 #if BACK_CONNECTION
685 SetAttrs(model_to_dto_ic_obj, ICA_TARGET, (IPTR)dto, TAG_DONE);
686 #endif
687
688 val = 0;
689 GetDTAttrs(dto, DTA_NominalHoriz, (IPTR)&val, TAG_DONE);
690 pdt_origwidth = winwidth = (WORD)val;
691 GetDTAttrs(dto, DTA_NominalVert , (IPTR)&val, TAG_DONE);
692 pdt_origheight = winheight = (WORD)val;
693 pdt_zoom = 1;
694
695 /*
696 * Add 4 Pixels for border around DataType-Object
697 * See AddDTOToWin() for details
698 */
699 if(winwidth)
700 {
701 winwidth += 4;
702 }
703
704 if(winheight)
705 {
706 winheight += 4;
707 }
708
709 GetDTAttrs(dto, DTA_ObjName, (IPTR)&objname, TAG_DONE);
710 strncpy(objnamebuffer, objname ? objname : filenamebuffer, 299);
711
712 dt = NULL;
713 dto_subclass_gid = 0;
714 if (GetDTAttrs(dto, DTA_DataType, (IPTR)&dt, TAG_DONE))
715 {
716 if (dt)
717 {
718 dto_subclass_gid = dt->dtn_Header->dth_GroupID;
719 }
720 }
721
722 dto_supports_write = FALSE;
723 dto_supports_write_iff = FALSE;
724 dto_supports_print = FALSE;
725 dto_supports_copy = FALSE;
726 dto_supports_selectall = FALSE;
727 dto_supports_clearselected = FALSE;
728
729 if (DoWriteMethod(NULL, DTWM_RAW)) dto_supports_write = TRUE; /* probe raw saving */
730 if ((methods = GetDTMethods(dto)))
731 {
732 if (FindMethod(methods, DTM_WRITE)) dto_supports_write_iff = TRUE;
733 if (FindMethod(methods, DTM_PRINT)) dto_supports_print = TRUE;
734 if (FindMethod(methods, DTM_COPY)) dto_supports_copy = TRUE;
735 if (FindMethod(methods, DTM_SELECT)) dto_supports_selectall = TRUE;
736 if (FindMethod(methods, DTM_CLEARSELECTED)) dto_supports_clearselected = TRUE;
737 }
738
739 dto_supports_activate_field = FALSE;
740 dto_supports_next_field = FALSE;
741 dto_supports_prev_field = FALSE;
742 dto_supports_retrace = FALSE;
743 dto_supports_browse_next = FALSE;
744 dto_supports_browse_prev = FALSE;
745 dto_supports_search = FALSE;
746 dto_supports_search_next = FALSE;
747 dto_supports_search_prev = FALSE;
748
749 if ((triggermethods = (struct DTMethod *)GetDTTriggerMethods(dto)))
750 {
751 if (FindTriggerMethod(triggermethods, NULL, STM_ACTIVATE_FIELD)) dto_supports_activate_field = TRUE;
752 if (FindTriggerMethod(triggermethods, NULL, STM_NEXT_FIELD)) dto_supports_next_field = TRUE;
753 if (FindTriggerMethod(triggermethods, NULL, STM_PREV_FIELD)) dto_supports_prev_field = TRUE;
754 if (FindTriggerMethod(triggermethods, NULL, STM_RETRACE)) dto_supports_retrace = TRUE;
755 if (FindTriggerMethod(triggermethods, NULL, STM_BROWSE_NEXT)) dto_supports_browse_next = TRUE;
756 if (FindTriggerMethod(triggermethods, NULL, STM_BROWSE_PREV)) dto_supports_browse_prev = TRUE;
757 if (FindTriggerMethod(triggermethods, NULL, STM_SEARCH)) dto_supports_search = TRUE;
758 if (FindTriggerMethod(triggermethods, NULL, STM_SEARCH_NEXT)) dto_supports_search_next = TRUE;
759 if (FindTriggerMethod(triggermethods, NULL, STM_SEARCH_PREV)) dto_supports_search_prev = TRUE;
760 }
761
762 D(bug("\nMultiview: Found Methods:%s%s%s%s%s%s\n",
763 dto_supports_write ? " DTM_WRITE->RAW" : "",
764 dto_supports_write_iff ? " DTM_WRITE->IFF" : "",
765 dto_supports_print ? " DTM_PRINT" : "",
766 dto_supports_copy ? " DTM_COPY" : "",
767 dto_supports_selectall ? " DTM_SELECT" : "",
768 dto_supports_clearselected ? " DTM_CLEARSELECTED" : ""));
769
770 D(bug("Multiview: Found Triggers:%s%s%s%s%s%s%s\n\n",
771 dto_supports_activate_field ? " STM_ACTIVATE_FIELD" : "",
772 dto_supports_next_field ? " STM_NEXT_FIELD" : "",
773 dto_supports_prev_field ? " STM_PREV_FIELD" : "",
774 dto_supports_retrace ? " STM_RETRACE" : "",
775 dto_supports_browse_next ? " STM_BROWSE_NEXT" : "",
776 dto_supports_browse_prev ? " STM_BROWSE_PREV" : "",
777 dto_supports_search ? " STM_SEARCH" : "",
778 dto_supports_search_next ? " STM_SEARCH_NEXT" : "",
779 dto_supports_search_prev ? " STM_SEARCH_PREV" : ""));
780
781 if (old_dto)
782 {
783 if (win) RemoveDTObject(win, old_dto);
784 DisposeDTObject(old_dto);
785
786 if (win)
787 {
788 AddDTOToWin();
789 SetWindowTitles(win, objnamebuffer, (UBYTE *)~0);
790 SetMenuFlags();
791
792 // adopt object to current settings
793 if (dto_subclass_gid == GID_TEXT)
794 {
795 SetDTAttrs (dto, NULL, NULL,
796 TDTA_WordWrap, tdt_text_wordwrap,
797 TAG_DONE);
798 DoLayout(TRUE);
799 }
800 else if (dto_subclass_gid == GID_PICTURE)
801 {
802 // zoom has been set to 1 above
803 FitToWindow();
804 SetDTAttrs (dto, NULL, NULL,
805 PDTA_DestMode, (pdt_force_map) ? PMODE_V42 : PMODE_V43,
806 TAG_DONE);
807 SetDTAttrs (dto, NULL, NULL,
808 PDTA_DitherQuality, pdt_pict_dither ? 4 : 0,
809 TAG_DONE);
810 DoLayout(TRUE);
811 }
812 }
813 }
814 }
815
816 /*********************************************************************************************/
817
818 static void CloseDTO(void)
819 {
820 if (dto)
821 {
822 if (win) RemoveDTObject(win, dto);
823 DisposeDTObject(dto);
824 dto = NULL;
825 }
826 }
827
828 /*********************************************************************************************/
829
830 static void MakeWindow(void)
831 {
832 WORD minwidth, minheight;
833 if (pdt_fit_win)
834 winwidth = winheight = 0;
835
836 if (wincoords.MinX == 0)
837 wincoords.MinX = (- scr->LeftEdge);
838 if (wincoords.MinY == 0)
839 wincoords.MinY = ( (- scr->TopEdge) < (scr->BarHeight + 1) ) ? (scr->BarHeight + 1) : (- scr->TopEdge);
840 if (wincoords.MaxX == 0)
841 wincoords.MaxX = scr->ViewPort.DWidth;
842 if (wincoords.MaxY == 0)
843 wincoords.MaxY = scr->ViewPort.DHeight - scr->BarHeight - 2;
844
845 minwidth = ( (winwidth) && (winwidth < 50) ) ? winwidth : 50;
846 minheight = ( (winheight) && (winheight < 50) ) ? winheight : 50;
847
848 win = OpenWindowTags(0, WA_PubScreen , (IPTR)scr ,
849 WA_Title , (IPTR)objnamebuffer ,
850 WA_CloseGadget , TRUE ,
851 WA_DepthGadget , TRUE ,
852 WA_DragBar , TRUE ,
853 WA_SizeGadget , TRUE ,
854 WA_Activate , TRUE ,
855 WA_SimpleRefresh , TRUE ,
856 WA_NoCareRefresh , TRUE ,
857 WA_NewLookMenus , TRUE ,
858 WA_Left , wincoords.MinX ,
859 WA_Top , wincoords.MinY ,
860 ( winwidth ? WA_InnerWidth
861 : WA_Width ) ,
862 ( winwidth ? winwidth
863 : wincoords.MaxX ) ,
864 ( winheight ? WA_InnerHeight
865 : WA_Height ) ,
866 ( winheight ? winheight
867 : wincoords.MaxY ) ,
868 WA_AutoAdjust , TRUE ,
869 WA_MinWidth , minwidth ,
870 WA_MinHeight , minheight ,
871 WA_MaxWidth , 16383 ,
872 WA_MaxHeight , 16383 ,
873 WA_Gadgets , (IPTR)gad[GAD_UPARROW],
874 WA_IDCMP , IDCMP_CLOSEWINDOW |
875 IDCMP_GADGETUP |
876 IDCMP_GADGETDOWN |
877 IDCMP_MOUSEMOVE |
878 IDCMP_VANILLAKEY |
879 IDCMP_RAWKEY |
880 IDCMP_IDCMPUPDATE |
881 IDCMP_MENUPICK |
882 IDCMP_NEWSIZE |
883 IDCMP_INTUITICKS ,
884 TAG_DONE);
885
886 if (!win) Cleanup(MSG(MSG_CANT_CREATE_WIN));
887
888 AddDTOToWin();
889
890 SetMenuStrip(win, menus);
891
892 winmask = 1L << win->UserPort->mp_SigBit;
893 if (!(msgport = CreateMsgPort()))
894 {
895 Cleanup(MSG(MSG_CANT_CREATE_MSGPORT));
896 }
897 if (!(appwindow = AddAppWindow(0, 0, win, msgport, NULL)))
898 {
899 Cleanup(MSG(MSG_CANT_ADD_APPWINDOW));
900 }
901 msgmask = 1L << msgport->mp_SigBit;
902 }
903
904 /*********************************************************************************************/
905
906 static void KillWindow(void)
907 {
908 if (win)
909 {
910 if (dto) RemoveDTObject(win, dto);
911 if (menus) ClearMenuStrip(win);
912 CloseWindow(win);
913 win = NULL;
914
915 winwidth = winheight = 0;
916 }
917 }
918
919 /*********************************************************************************************/
920
921 static void InitIScreenNotify(void)
922 {
923 if (!(isnport = CreateMsgPort()))
924 {
925 Cleanup(MSG(MSG_CANT_CREATE_MSGPORT));
926 }
927 if ( (isnstarted = StartScreenNotifyTags(SNA_Notify, SNOTIFY_WAIT_REPLY |
928 SNOTIFY_BEFORE_CLOSEWB |
929 SNOTIFY_AFTER_OPENWB,
930 SNA_MsgPort, isnport,
931 SNA_Priority, 0,
932 TAG_END )) )
933 {
934 isnmask = 1L << isnport->mp_SigBit;
935 }
936 }
937
938 /************************************************************************************/
939 /* Handle Intuition's ScreenNotify signals */
940
941 static void HandleIScreenNotify(void)
942 {
943 struct ScreenNotifyMessage *isnmsg;
944 while ((isnmsg = (struct ScreenNotifyMessage *) GetMsg (isnport)))
945 {
946 IPTR isnmclass = isnmsg->snm_Class;
947
948 switch (isnmclass)
949 {
950 case SNOTIFY_BEFORE_CLOSEWB:
951 D(bug("[Multiview] received isn before close WB msg\n"));
952 if (win)
953 {
954 WinCleanup();
955 }
956 ReplyMsg ((struct Message *) isnmsg);
957 break;
958 case SNOTIFY_AFTER_OPENWB:
959 ReplyMsg ((struct Message *) isnmsg);
960 D(bug("[Multiview] received isn after open WB msg\n"));
961 if (!win)
962 {
963 InitWin();
964 }
965 break;
966 default:
967 ReplyMsg ((struct Message *) isnmsg);
968 D(bug("[Multiview] received unexpected msg!\n"));
969 break;
970 }
971 }
972 }
973
974 /*********************************************************************************************/
975
976 static void ScrollTo(UWORD dir, UWORD quali)
977 {
978 IPTR val;
979 LONG oldtop, top, total, visible, delta = 1;
980 BOOL horiz;
981 BOOL inc;
982
983 #ifdef __AROS__
984 switch(dir)
985 {
986 case RAWKEY_NM_WHEEL_UP:
987 dir = CURSORUP;
988 delta = 3;
989 break;
990
991 case RAWKEY_NM_WHEEL_DOWN:
992 dir = CURSORDOWN;
993 delta = 3;
994 break;
995
996 case RAWKEY_NM_WHEEL_LEFT:
997 dir = CURSORLEFT;
998 delta = 3;
999 break;
1000
1001 case RAWKEY_NM_WHEEL_RIGHT:
1002 dir = CURSORRIGHT;
1003 delta = 3;
1004 break;
1005 }
1006 #endif
1007
1008 if ((dir == CURSORUP) || (dir == CURSORDOWN))
1009 {
1010 horiz = FALSE;
1011 if (dir == CURSORUP) inc = FALSE; else inc = TRUE;
1012
1013 GetDTAttrs(dto, DTA_TopVert, (IPTR)&val, TAG_DONE);
1014 top = (LONG)val;
1015 GetDTAttrs(dto, DTA_TotalVert, (IPTR)&val, TAG_DONE);
1016 total = (LONG)val;
1017 GetDTAttrs(dto, DTA_VisibleVert, (IPTR)&val, TAG_DONE);
1018 visible = (LONG)val;
1019 }
1020 else
1021 {
1022 horiz = TRUE;
1023 if (dir == CURSORLEFT) inc = FALSE; else inc = TRUE;
1024
1025 GetDTAttrs(dto, DTA_TopHoriz, (IPTR)&val, TAG_DONE);
1026 top = (LONG)val;
1027 GetDTAttrs(dto, DTA_TotalHoriz, (IPTR)&val, TAG_DONE);
1028 total = (LONG)val;
1029 GetDTAttrs(dto, DTA_VisibleHoriz, (IPTR)&val, TAG_DONE);
1030 visible = (LONG)val;
1031
1032 }
1033
1034 oldtop = top;
1035 if (quali & (IEQUALIFIER_LALT | IEQUALIFIER_RALT | IEQUALIFIER_CONTROL))
1036 {
1037 if (inc) top = total; else top = 0;
1038 }
1039 else
1040 if (quali & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
1041 {
1042 if (inc) top += visible - 1; else top -= visible - 1;
1043 }
1044 else
1045 {
1046 if (inc) top += delta; else top -= delta;
1047 }
1048
1049 if (top + visible > total) top = total - visible;
1050 if (top < 0) top = 0;
1051
1052 if (top != oldtop)
1053 {
1054 struct Gadget *g;
1055
1056 if (horiz)
1057 {
1058 g = (struct Gadget *)gad[GAD_HORIZSCROLL];
1059 }
1060 else
1061 {
1062 g = (struct Gadget *)gad[GAD_VERTSCROLL];
1063 }
1064
1065 SetGadgetAttrs(g, win, NULL, PGA_Top, top,
1066 TAG_DONE);
1067
1068 #ifdef __MORPHOS__
1069 /* Looks like setting PGA_Top on Amiga does not cause OM_NOTIFIEs
1070 to be sent (to dto). Or something like that. */
1071
1072 SetDTAttrs(dto, win, NULL, (horiz ? DTA_TopHoriz : DTA_TopVert), top, TAG_DONE);
1073 #endif
1074
1075 } /* if (top != oldtop) */
1076
1077 }
1078
1079 /*********************************************************************************************/
1080
1081 static void FitToWindow(void)
1082 {
1083 if( pdt_fit_win )
1084 {
1085 int x, y;
1086
1087 x = win->Width - (win->BorderLeft + win->BorderRight + 4);
1088 y = win->Height - (win->BorderTop + win->BorderBottom + 4);
1089 D(bug("=> width %ld height %ld\n", x, y));
1090 DoScaleMethod(x, y, pdt_keep_aspect);
1091 // DoLayout(TRUE); seems to be done by intuition ?
1092 }
1093 }
1094
1095 /*********************************************************************************************/
1096
1097 static void HandleAll(void)
1098 {
1099 struct IntuiMessage *msg;
1100 struct TagItem *tstate, *tags;
1101 struct TagItem *tag;
1102 struct MenuItem *item;
1103 struct Gadget *activearrowgad = NULL;
1104 WORD arrowticker = 0, activearrowkind = 0;
1105 IPTR tidata;
1106 UWORD men;
1107 BOOL quitme = FALSE;
1108 const STRPTR not_supported = "Sorry, not supported yet\n";
1109 ULONG sigs;
1110
1111 while (!quitme)
1112 {
1113 // if ( (sigs & winmask) || (sigs & msgmask) )
1114 TEXT editorvarbuffer[300];
1115 struct AppMessage *appmsg;
1116
1117 sigs = Wait(msgmask | winmask | isnmask);
1118
1119 if (sigs & isnmask)
1120 {
1121 HandleIScreenNotify();
1122 }
1123
1124 while ( (msgport) && (appmsg = (struct AppMessage *) GetMsg(msgport)) )
1125 {
1126 if (appmsg->am_Type == AMTYPE_APPWINDOW)
1127 {
1128 if (appmsg->am_NumArgs >= 1)
1129 {
1130 NameFromLock(appmsg->am_ArgList->wa_Lock, filenamebuffer, 299);
1131 AddPart(filenamebuffer, appmsg->am_ArgList->wa_Name, 299);
1132 filename = filenamebuffer;
1133 D(bug("[Multiview] appwindow received message: filename = %s\n", filename));
1134 }
1135 }
1136
1137 ReplyMsg ((struct Message *) appmsg);
1138 ActivateWindow(win);
1139
1140 if (filename)
1141 {
1142 OpenDTO();
1143 FitToWindow();
1144 }
1145
1146 } /* while ((appmsg = (struct AppMessage *) GetMsg(msgport))) */
1147
1148 while( (win) && (msg = (struct IntuiMessage *)GetMsg(win->UserPort)) )
1149 {
1150 // D(if (msg->Class!=IDCMP_INTUITICKS) bug(" Msg Class %08lx\n", (long)msg->Class));
1151 switch (msg->Class)
1152 {
1153 case IDCMP_CLOSEWINDOW:
1154 quitme = TRUE;
1155 break;
1156
1157 case IDCMP_VANILLAKEY:
1158 D(bug("[Multiview] Vanillakey %d\n", (int)msg->Code));
1159 switch(msg->Code)
1160 {
1161 case 27: /* ESC */
1162 quitme = TRUE;
1163 break;
1164
1165 case 13: /* RETURN */
1166 if (dto_supports_activate_field) DoTrigger(STM_ACTIVATE_FIELD);
1167 else if (dto_supports_search) DoTrigger(STM_SEARCH);
1168 RefreshDTObjects (dto, win, NULL, (IPTR) NULL);
1169 break;
1170
1171 case 9: /* TAB */
1172 if (dto_supports_next_field) DoTrigger(STM_NEXT_FIELD);
1173 else if (dto_supports_search_next) DoTrigger(STM_SEARCH_NEXT);
1174 break;
1175
1176 case 8: /* Backspace */
1177 if (dto_supports_retrace) DoTrigger(STM_RETRACE);
1178 break;
1179
1180 case '>':
1181 if (dto_supports_browse_next) DoTrigger(STM_BROWSE_NEXT);
1182 break;
1183
1184 case '<':
1185 if (dto_supports_browse_prev) DoTrigger(STM_BROWSE_PREV);
1186 break;
1187
1188 } /* switch(msg->Code) */
1189 if (strchr(MSG(MSG_SHORTCUT_EDITOR), ToUpper(msg->Code)))
1190 {
1191 if ( (GetVar("editor", (STRPTR) editorvarbuffer, 299, GVF_GLOBAL_ONLY)) != -1L )
1192 {
1193 __sprintf(s, "Run QUIET \"%s\" \"%s\"", editorvarbuffer, filename );
1194 D(bug("[Multiview] editor command: '%s'\n", s));
1195 if (SystemTags(s, TAG_END))
1196 DisplayBeep(NULL);
1197 }
1198 }
1199 break;
1200
1201 case IDCMP_RAWKEY:
1202 switch(msg->Code)
1203 {
1204 #ifdef __AROS__
1205 case RAWKEY_NM_WHEEL_UP:
1206 case RAWKEY_NM_WHEEL_DOWN:
1207 case RAWKEY_NM_WHEEL_LEFT:
1208 case RAWKEY_NM_WHEEL_RIGHT:
1209 #endif
1210 case CURSORUP:
1211 case CURSORDOWN:
1212 case CURSORRIGHT:
1213 case CURSORLEFT:
1214 ScrollTo(msg->Code, msg->Qualifier);
1215 break;
1216
1217 #ifdef __AROS__
1218 case RAWKEY_HOME: /* HOME */
1219 ScrollTo(CURSORUP, IEQUALIFIER_LALT);
1220 break;
1221
1222 case RAWKEY_END: /* END */
1223 ScrollTo(CURSORDOWN, IEQUALIFIER_LALT);
1224 break;
1225
1226 case RAWKEY_PAGEUP: /* PAGE UP */
1227 ScrollTo(CURSORUP, IEQUALIFIER_LSHIFT);
1228 break;
1229
1230 case RAWKEY_PAGEDOWN: /* PAGE DOWN */
1231 ScrollTo(CURSORDOWN, IEQUALIFIER_LSHIFT);
1232 break;
1233 #endif
1234
1235 case 0x42: /* SHIFT TAB? */
1236 if (msg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
1237 {
1238 if (dto_supports_prev_field) DoTrigger(STM_PREV_FIELD);
1239 else if (dto_supports_search_prev) DoTrigger(STM_SEARCH_PREV);
1240 }
1241 break;
1242
1243 } /* switch(msg->Code) */
1244 break;
1245
1246 case IDCMP_GADGETDOWN:
1247 arrowticker = 3;
1248 activearrowgad = (struct Gadget *)msg->IAddress;
1249 switch(activearrowgad->GadgetID)
1250 {
1251 case GAD_UPARROW:
1252 activearrowkind = CURSORUP;
1253 ScrollTo(CURSORUP, 0);
1254 break;
1255
1256 case GAD_DOWNARROW:
1257 activearrowkind = CURSORDOWN;
1258 ScrollTo(CURSORDOWN, 0);
1259 break;
1260
1261 case GAD_LEFTARROW:
1262 activearrowkind = CURSORLEFT;
1263 ScrollTo(CURSORLEFT, 0);
1264 break;
1265
1266 case GAD_RIGHTARROW:
1267 activearrowkind = CURSORRIGHT;
1268 ScrollTo(CURSORRIGHT, 0);
1269 break;
1270
1271 default:
1272 activearrowkind = 0;
1273 break;
1274
1275 }
1276 break;
1277
1278 case IDCMP_INTUITICKS:
1279 if (activearrowkind)
1280 {
1281 if (arrowticker)
1282 {
1283 arrowticker--;
1284 }
1285 else if (activearrowgad->Flags & GFLG_SELECTED)
1286 {
1287 ScrollTo(activearrowkind, 0);
1288 }
1289 }
1290 break;
1291
1292 case IDCMP_GADGETUP:
1293 switch(((struct Gadget *)msg->IAddress)->GadgetID)
1294 {
1295 case GAD_UPARROW:
1296 case GAD_DOWNARROW:
1297 case GAD_LEFTARROW:
1298 case GAD_RIGHTARROW:
1299 activearrowkind = 0;
1300 break;
1301 }
1302 break;
1303
1304 case IDCMP_MENUPICK:
1305 men = msg->Code;
1306 // D(bug(" * MV: men %08lx\n", (long)men));
1307 while(men != MENUNULL)
1308 {
1309 if ((item = ItemAddress(menus, men)))
1310 {
1311 // D(bug(" * MV: item %08lx menus %08lx\n", (long)item, (long)menus));
1312 switch((IPTR)GTMENUITEM_USERDATA(item))
1313 {
1314 case MSG_MEN_PROJECT_OPEN:
1315 filename = GetFileName(MSG_ASL_OPEN_TITLE);
1316 if (filename) OpenDTO();
1317 break;
1318
1319 case MSG_MEN_PROJECT_SAVEAS:
1320 filename = GetFileName(MSG_ASL_SAVE_TITLE);
1321 if (filename) DoWriteMethod(filename, DTWM_RAW);
1322 break;
1323
1324 case MSG_MEN_PROJECT_SAVEAS_IFF:
1325 filename = GetFileName(MSG_ASL_SAVE_TITLE);
1326 if (filename) DoWriteMethod(filename, DTWM_IFF);
1327 break;
1328
1329 case MSG_MEN_PROJECT_PRINT:
1330 DoPrintMethod();
1331 break;
1332
1333 case MSG_MEN_PROJECT_ABOUT:
1334 About();
1335 break;
1336
1337 case MSG_MEN_PROJECT_QUIT:
1338 quitme = TRUE;
1339 break;
1340
1341 case MSG_MEN_EDIT_MARK:
1342 #if defined(__AROS__) && !defined(__MORPHOS__)
1343 if (StartDragSelect(dto))
1344 #else
1345 {
1346 struct DTSpecialInfo *si;
1347
1348 /*
1349 ** ClipView example on AmigaDev CD does just the following.
1350 ** None of the checks AROS datatypes.library/StartDragSelect()
1351 ** does.
1352 */
1353
1354 si = (struct DTSpecialInfo *)(((struct Gadget *)dto)->SpecialInfo);
1355 si->si_Flags |= DTSIF_DRAGSELECT;
1356 }
1357 #endif
1358 {
1359 //TODO: change mouse pointer to crosshair
1360 }
1361 break;
1362
1363 case MSG_MEN_EDIT_COPY:
1364 {
1365 struct dtGeneral dtg;
1366
1367 dtg.MethodID = DTM_COPY;
1368 dtg.dtg_GInfo = NULL;
1369
1370 DoDTMethodA(dto, win, NULL, (Msg)&dtg);
1371 }
1372 break;
1373
1374 case MSG_MEN_EDIT_SELECTALL:
1375 OutputMessage(not_supported);
1376 break;
1377
1378 case MSG_MEN_EDIT_CLEARSELECTED:
1379 {
1380 struct dtGeneral dtg;
1381
1382 dtg.MethodID = DTM_CLEARSELECTED;
1383 dtg.dtg_GInfo = NULL;
1384
1385 DoDTMethodA(dto, win, NULL, (Msg)&dtg);
1386 }
1387 break;
1388
1389 case MSG_MEN_WINDOW_SEPSCREEN:
1390 OutputMessage(not_supported);
1391 break;
1392
1393 case MSG_MEN_WINDOW_MINIMIZE:
1394 OutputMessage(not_supported);
1395 break;
1396
1397 case MSG_MEN_WINDOW_NORMAL:
1398 OutputMessage(not_supported);
1399 break;
1400
1401 case MSG_MEN_WINDOW_MAXIMIZE:
1402 OutputMessage(not_supported);
1403 break;
1404
1405 case MSG_MEN_SETTINGS_SAVEDEF:
1406 OutputMessage(not_supported);
1407 break;
1408
1409 case MSG_MEN_PICT_ZOOM_IN:
1410 pdt_zoom++;
1411 if (pdt_zoom == -1 ) pdt_zoom = 1;
1412 DoZoom(pdt_zoom);
1413 break;
1414
1415 case MSG_MEN_PICT_ZOOM_OUT:
1416 pdt_zoom--;
1417 if (pdt_zoom == 0 ) pdt_zoom = -2;
1418 DoZoom(pdt_zoom);
1419 break;
1420
1421 case MSG_MEN_PICT_RESET:
1422 pdt_zoom = 1;
1423 DoZoom(pdt_zoom);
1424 break;
1425
1426 case MSG_MEN_PICT_FIT_WIN:
1427 pdt_fit_win = (item->Flags & CHECKED) ? TRUE : FALSE;
1428 FitToWindow();
1429 DoLayout(TRUE);
1430 break;
1431
1432 case MSG_MEN_PICT_KEEP_ASPECT:
1433 pdt_keep_aspect = (item->Flags & CHECKED) ? TRUE : FALSE;
1434 FitToWindow();
1435 DoLayout(TRUE);
1436 break;
1437
1438 case MSG_MEN_PICT_FORCE_MAP:
1439 pdt_force_map = (item->Flags & CHECKED) ? TRUE : FALSE;
1440 SetDTAttrs (dto, NULL, NULL,
1441 PDTA_DestMode, (pdt_force_map) ? PMODE_V42 : PMODE_V43,
1442 TAG_DONE);
1443 DoLayout(TRUE);
1444 break;
1445
1446 case MSG_MEN_PICT_DITHER:
1447 pdt_pict_dither = (item->Flags & CHECKED) ? TRUE : FALSE;
1448 SetDTAttrs (dto, NULL, NULL,
1449 PDTA_DitherQuality, pdt_pict_dither ? 4 : 0,
1450 TAG_DONE);
1451 DoLayout(TRUE);
1452 break;
1453
1454 case MSG_MEN_TEXT_WORDWRAP:
1455 tdt_text_wordwrap = (item->Flags & CHECKED) ? TRUE : FALSE;
1456 if (tdt_text_wordwrap)
1457 D(bug("wordwrap enabled\n"))
1458 else
1459 D(bug("wordwrap disabled\n"));
1460 SetDTAttrs (dto, NULL, NULL,
1461 TDTA_WordWrap, tdt_text_wordwrap,
1462 TAG_DONE);
1463 DoLayout(TRUE);
1464 break;
1465
1466 case MSG_MEN_TEXT_SEARCH:
1467 if (dto_supports_search) DoTrigger(STM_SEARCH);
1468 break;
1469
1470 case MSG_MEN_TEXT_SEARCH_PREV:
1471 if (dto_supports_search_prev) DoTrigger(STM_SEARCH_PREV);
1472 break;
1473
1474 case MSG_MEN_TEXT_SEARCH_NEXT:
1475 if (dto_supports_search_next) DoTrigger(STM_SEARCH_NEXT);
1476 break;
1477
1478 } /* switch(GTMENUITEM_USERDATA(item)) */
1479
1480 men = item->NextSelect;
1481 }
1482 else
1483 {
1484 men = MENUNULL;
1485 }
1486
1487 } /* while(men != MENUNULL) */
1488 break;
1489
1490 case IDCMP_NEWSIZE:
1491 D(bug("IDCMP NEWSIZE\n"));
1492 FitToWindow();
1493 break;
1494
1495 case IDCMP_IDCMPUPDATE:
1496 tstate = tags = (struct TagItem *) msg->IAddress;
1497 while ((tag = NextTagItem(&tstate)) != NULL)
1498 {
1499 tidata = tag->ti_Data;
1500 // D(bug("IDCMP UPDATE %08lx %08lx\n", (long)tag->ti_Tag, (long)tag->ti_Data));
1501 switch (tag->ti_Tag)
1502 {
1503 /* Change in busy state */
1504 case DTA_Busy:
1505 if (tidata)
1506 SetWindowPointer (win, WA_BusyPointer, TRUE, TAG_DONE);
1507 else
1508 SetWindowPointer (win, WA_Pointer, (IPTR) NULL, TAG_DONE);
1509 break;
1510
1511 case DTA_Title:
1512 SetWindowTitles(win, (UBYTE *)tidata, (UBYTE *)~0);
1513 break;
1514
1515 /* Error message */
1516 case DTA_ErrorLevel:
1517 /* if (tidata)
1518 {
1519 errnum = GetTagData (DTA_ErrorNumber, NULL, tags);
1520 PrintErrorMsg (errnum, (STRPTR) options[OPT_NAME]);
1521 }*/
1522 break;
1523
1524 /* Time to refresh */
1525 case DTA_Sync:
1526 /* Refresh the DataType object */
1527 D(bug("Multiview: DTA_SYNC\n"));
1528 RefreshDTObjects (dto, win, NULL, (IPTR) NULL);
1529 break;
1530
1531 } /* switch (tag->ti_Tag) */
1532
1533 } /* while ((tag = NextTagItem ((const struct TagItem **)&tstate))) */
1534 break;
1535
1536 } /* switch (msg->Class) */
1537
1538 ReplyMsg((struct Message *)msg);
1539
1540 } /* while((msg = (struct IntuiMessage *)GetMsg(win->UserPort))) */
1541
1542 } /* while (!quitme) */
1543 }
1544
1545 /*********************************************************************************************/
1546
1547 void InitWin(void)
1548 {
1549 InitDefaults();
1550 LoadFont();
1551 MakeICObjects();
1552 OpenDTO();
1553 GetVisual();
1554 MakeGadgets();
1555 menus = MakeMenus(nm);
1556 pictmenus = MakeMenus(nmpict);
1557 textmenus = MakeMenus(nmtext);
1558 SetMenuFlags();
1559 MakeWindow();
1560 SetDTAttrs (dto, NULL, NULL,
1561 PDTA_DestMode, (pdt_force_map) ? PMODE_V42 : PMODE_V43,
1562 PDTA_DitherQuality, (pdt_pict_dither) ? 4 : 0,
1563 TDTA_WordWrap, tdt_text_wordwrap,
1564 TAG_DONE);
1565 FitToWindow();
1566 }
1567
1568 /*********************************************************************************************/
1569
1570 int main(int argc, char **argv)
1571 {
1572 int rc;
1573
1574 /* This is for when Cleanup() is called */
1575 rc = setjmp(exit_buf);
1576 if (rc)
1577 return rc;
1578
1579 wincoords.MinX = 0;
1580 wincoords.MinY = 0;
1581 wincoords.MaxX = 0;
1582 wincoords.MaxY = 0;
1583
1584 pdt_fit_win = FALSE;
1585 pdt_keep_aspect = FALSE;
1586 pdt_force_map = FALSE;
1587 pdt_pict_dither = TRUE;
1588 tdt_text_wordwrap = TRUE;
1589 separate_screen = FALSE;
1590
1591 InitLocale("System/Utilities/MultiView.catalog", 1);
1592 InitMenus(nm);
1593 InitMenus(nmpict);
1594 InitMenus(nmtext);
1595 OpenLibs();
1596
1597 if (argc == 0)
1598 {
1599 struct WBStartup *startup = (struct WBStartup *) argv;
1600
1601 if (startup->sm_NumArgs >= 2)
1602 {
1603 /* FIXME: all arguments but the first are ignored */
1604 cd = CurrentDir(startup->sm_ArgList[1].wa_Lock);
1605 filename = startup->sm_ArgList[1].wa_Name;
1606 }
1607 else
1608 {
1609 filename = GetFileName(MSG_ASL_OPEN_TITLE);
1610 if (!filename) Cleanup(NULL);
1611 }
1612 }
1613 else
1614 {
1615 GetArguments();
1616 }
1617
1618 InitIScreenNotify();
1619 InitWin();
1620
1621 HandleAll();
1622 Cleanup(NULL);
1623
1624 return 0;
1625 }
1626
1627 /*********************************************************************************************/
Mirror of AROS' svn.