![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ami-win.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src / od-amiga|
Return to ami-win.c CVS log | Up to [UNIX Amiga Emulator] / uae / src / od-amiga |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * Amiga interface
5: *
6: * Copyright 1996,1997 Samuel Devulder.
7: */
8:
9: /*
10: * NOTE:
11: * - Im quite unhappy with the color allocation scheme in case of
12: * EXTRA_HALFBRITE...
13: */
14:
15: /*
16: * History: (Day/Month/Year)
17: * 16/10/96 - Rewrote cybergfx support. (there is still a bug if the memory
18: * is not linear).
19: * 15/11/96 - Inhibit the drive in readdevice().
20: * 23/11/96 - Added call to rexx_init() and gui_handle_event().
21: * 14/12/96 - Added support for graffiti screens.
22: * 14/02/97 - Now uses SetRGB32() for cybergfx screens.
23: * 15/02/97 - Dump iff file when ENV:UAEIFF is defined.
24: * 25/02/97 - Get rid of cybergfx screen direct access.. Now uses
25: * BltBitMapRastPort(). Thanks to Mats Eirik Hansen for
26: * his patch from which I'm widely inspired.
27: * 10/05/97 - Use OpenWindowTag() for public screen. Uses Zoom,
28: * SimpleRefresh.
29: * 20/08/97 - Removed halfv stuff (use correct_aspect instead).
30: * 21/08/97 - Added HAM support (yeah!).
31: * 05/10/97 - Added drag&drop support.
32: * 13/10/97 - Fixed CyberGFX crash (a missing "return" in flush_line()).
33: * 31/10/97 - Added support for gray output (-T). Added missing "Cyb"
34: * prefix to BitMap=NULL in graphics_leave().
35: * 07/12/97 - New calc_err(). UAE screen (-H2) is now a public screen.
36: */
37:
38: #define USE_CYBERGFX /* undefine this if you don't have CYBERGFX includes */
39:
40: /****************************************************************************/
41:
42: #include <exec/execbase.h>
43: #include <exec/memory.h>
44:
45: #include <dos/dos.h>
46:
47: #include <graphics/gfxbase.h>
48: #include <graphics/displayinfo.h>
49:
50: #include <libraries/asl.h>
51: #include <intuition/pointerclass.h>
52:
53: #include <proto/intuition.h>
54: #include <proto/graphics.h>
55: #include <proto/exec.h>
56: #include <proto/asl.h>
57:
58: #ifdef USE_CYBERGFX
59: #ifdef __SASC
60: #include <cybergraphics/cybergraphics.h>
61: #include <proto/cybergraphics.h>
62: #else
63: #include <inline/cybergraphics.h>
64: #endif
65: #ifndef BMF_SPECIALFMT
66: #define BMF_SPECIALFMT 0x80 /* should be cybergraphics.h but isn't for */
67: /* some strange reason */
68: #endif
69: #endif
70:
71: /****************************************************************************/
72:
73: #include "sysconfig.h"
74: #include "sysdeps.h"
75:
76: #include <ctype.h>
77: #include <signal.h>
78: #ifdef __GNUC__
79: #include <ix.h>
80: #endif
81: #ifdef __SASC
82: extern struct ExecBase *SysBase;
83: #endif
84:
85: /****************************************************************************/
86:
87: #include "config.h"
88: #include "options.h"
89: #include "threaddep/penguin.h"
90: #include "uae.h"
91: #include "memory.h"
92: #include "custom.h"
93: #include "readcpu.h"
94: #include "osdep/memory.h" /* for implicit decl. of get_long() in newcpu.h */
95: #include "newcpu.h"
96: #include "xwin.h"
97: #include "keyboard.h"
98: #include "keybuf.h"
99: #include "gui.h"
100: #include "debug.h"
101: #include "disk.h"
102:
103: #define BitMap Picasso96BitMap /* Argh! */
104: #include "picasso96.h"
105: #undef BitMap
106:
107: /****************************************************************************/
108:
109: #define use_dither (!currprefs.no_xhair)
110: #define use_gray (currprefs.use_mitshm)
111:
112: #define UAEIFF "UAEIFF" /* env: var to trigger iff dump */
113:
114: static int need_dither; /* well.. guess :-) */
115: static int use_low_bandwidth; /* this will redraw only needed places */
116: static int use_cyb; /* this is for cybergfx */
117: static int use_graffiti;
118: static int use_approx_color;
119: int dump_iff;
120:
121: extern xcolnr xcolors[4096];
122:
123: /* Keyboard and mouse */
124:
125: static int keystate[256];
126:
127: extern int buttonstate[3];
128: extern int lastmx, lastmy;
129: extern int newmousecounters;
130:
131: static int inwindow;
132:
133: static char *oldpixbuf;
134:
135: /****************************************************************************/
136: /*
137: * prototypes & global vars
138: */
139: struct IntuitionBase *IntuitionBase;
140: struct GfxBase *GfxBase;
141: struct Library *AslBase;
142: struct Library *CyberGfxBase;
143:
144: static UBYTE *Line;
145: static struct RastPort *RP;
146: static struct Screen *S;
147: static struct Window *W;
148: static struct RastPort *TempRPort;
149: static struct BitMap *BitMap;
150: #ifdef USE_CYBERGFX
151: static struct BitMap *CybBitMap;
152: #endif
153: static struct ColorMap *CM;
154: static Object *Pointer; /* for os 39 */
155: static UWORD *Sprite;
156: static int XOffset,YOffset;
157:
158: static int os39; /* kick 39 present */
159: static int usepub; /* use public screen */
160: static int usecyb; /* use cybergraphics.library */
161: static int is_halfbrite;
162: static int is_ham;
163:
164: static int get_color_failed;
165: static int maxpen;
166: static UBYTE pen[256];
167:
168: static struct BitMap *myAllocBitMap(ULONG,ULONG,ULONG,ULONG,struct BitMap *);
169: static void set_title(void);
170: static void myFreeBitMap(struct BitMap *);
171: static LONG ObtainColor(ULONG, ULONG, ULONG);
172: static void ReleaseColors(void);
173: static int DoSizeWindow(struct Window *,int,int);
174: static void disk_hotkeys(void);
175: static void graffiti_SetRGB(int,int,int,int);
176: static void graffiti_WritePixelLine8(int,int,short,char*);
177: static int SaveIFF(char *filename, struct Screen *scr);
178: static int init_ham(void);
179: static void ham_conv(UWORD *src, UBYTE *buf, UWORD len);
180: static int RPDepth(struct RastPort *RP);
181:
182: /****************************************************************************/
183:
184: void main_window_led(int led, int on);
185:
186: extern int rexx_init(void);
187: extern void rexx_exit(void);
188: extern void initpseudodevices(void);
189: extern void closepseudodevices(void);
190: extern char *to_unix_path(char *s);
191: extern char *from_unix_path(char *s);
192: extern void split_dir_file(char *src, char **dir, char **file);
193: extern void appw_init(struct Window *W);
194: extern void appw_exit(void);
195: extern void appw_events(void);
196:
197: extern int ievent_alive;
198:
199: /****************************************************************************/
200:
201: static RETSIGTYPE sigbrkhandler(int foo)
202: {
203: activate_debugger();
204: }
205:
206: void setup_brkhandler(void)
207: {
208: #ifdef HAVE_SIGACTION
209: struct sigaction sa;
210: sa.sa_handler = (void*)sigbrkhandler;
211: sa.sa_flags = 0;
212: sa.sa_flags = SA_RESTART;
213: sigemptyset(&sa.sa_mask);
214: sigaction(SIGINT, &sa, NULL);
215: #else
216: signal(SIGINT,sigbrkhandler);
217: #endif
218: }
219:
220: /****************************************************************************/
221:
222: extern UBYTE cidx[4][8*4096];
223:
224: __inline__ void flush_line(int y)
225: {
226: int xs = 0, len;
227: int yoffset = y*gfxvidinfo.rowbytes;
228: char *linebuf = gfxvidinfo.bufmem + yoffset;
229: char *src, *dst;
230:
231: if(y<0 || y>=gfxvidinfo.height) {
232: /* printf("flush_line out of window: %d\n", y); */
233: return;
234: }
235:
236: len = gfxvidinfo.width;
237:
238: if(is_ham) {
239: ham_conv((void*)linebuf,Line,len);
240: WritePixelLine8(RP, 0, y, len, Line, TempRPort);
241: return;
242: }
243:
244: #ifdef USE_CYBERGFX
245: /*
246: * cybergfx bitmap && no dither
247: */
248: if(use_cyb && !need_dither) {
249: BltBitMapRastPort(CybBitMap, 0, y,
250: RP, XOffset, YOffset+y,
251: len, 1, 0xc0);
252: /* sam: I'm worried because BltBitMapRastPort() is known to */
253: /* produce spilled registers with gcc */
254: return;
255: }
256: #endif
257:
258: #if 0
259: if(use_graffiti && !need_dither) {
260: graffiti_WritePixelLine8(0, y, gfxvidinfo.rowbytes, linebuf);
261: }
262: #endif
263:
264: /*
265: * cybergfx && dither \_ LOW_BANDWIDTH and 1 byte per pixel in the output
266: * or standard screen /
267: */
268:
269: switch(gfxvidinfo.pixbytes) {
270: case 4:
271: { /* sam: we should not arrive here on the amiga */
272: fprintf(stderr, "Bug in flush_line() !\n");
273: fprintf(stderr, "use_cyb=%d\n",use_cyb);
274: fprintf(stderr, "need_dither=%d\n",need_dither);
275: fprintf(stderr, "depth=%d\n",RPDepth(RP));
276: fprintf(stderr, "Please return those values to maintainer.\n");
277: abort();
278: return;
279: } break;
280: case 2:
281: { short *newp = (short *)linebuf;
282: short *oldp = (short *)(oldpixbuf + yoffset);
283: while (*newp++ == *oldp++) if(!--len) return;
284: src = (char *)--newp;
285: dst = (char *)--oldp;
286: newp += len;
287: oldp += len;
288: while (*--newp == *--oldp);
289: len = 1 + (oldp - (short *)dst);
290: xs = (src - linebuf)/2;
291: CopyMem (src, dst, len * 2);
292: } break;
293: case 1:
294: { char *newp = (char *)linebuf;
295: char *oldp = (char *)(oldpixbuf + yoffset);
296: while (*newp++ == *oldp++) if(!--len) return;
297: src = (char *)--newp;
298: dst = (char *)--oldp;
299: newp += len;
300: oldp += len;
301: while (*--newp == *--oldp);
302: len = 1 + (oldp - (char *)dst);
303: xs = (src - linebuf);
304: CopyMem (src, dst, len);
305: } break;
306: default:
307: abort();
308: break;
309: }
310:
311: if (need_dither) {
312: DitherLine(Line, (UWORD *)dst, xs, y, (len+3)&~3, 8);
313: } else CopyMem(dst, Line, len);
314:
315: if (use_cyb) { /* pixbyte == 1 */
316: #ifdef USE_CYBERGFX
317: BltBitMapRastPort(CybBitMap, xs, y,
318: RP, XOffset+xs, YOffset+y,
319: len, 1, 0xc0);
320: #endif
321: } else if(use_graffiti) {
322: graffiti_WritePixelLine8(xs, y, len, Line);
323: } else WritePixelLine8(RP, xs + XOffset, y + YOffset, len, Line, TempRPort);
324: }
325:
326: /****************************************************************************/
327:
328: void flush_block (int ystart, int ystop)
329: {
330: int y;
331: #ifdef USE_CYBERGFX
332: if(use_cyb && !need_dither) {
333: int len = gfxvidinfo.width;
334: BltBitMapRastPort(CybBitMap,
335: 0, ystart,
336: RP, XOffset, YOffset+ystart,
337: len, ystop-ystart+1, 0xc0);
338: return;
339: }
340: #endif
341: for(y=ystart; y<=ystop; ++y) flush_line(y);
342: }
343:
344: /****************************************************************************/
345:
346: void flush_screen (int ystart, int ystop)
347: {
348: /* WaitBOVP() ? */
349: char *file;
350: static int cpt = 0;
351: char name[80];
352:
353: if(!dump_iff) return;
354: if(!(file = getenv(UAEIFF))) return;
355: if(strchr(file,'%')) sprintf(name,file,cpt++);
356: else sprintf(name,"%s.%05d",file,cpt++);
357: if(W->WScreen) SaveIFF(name,W->WScreen);
358: }
359:
360: /****************************************************************************/
361:
362: static int RPDepth(struct RastPort *RP)
363: {
364: #ifdef USE_CYBERGFX
365: if(use_cyb) return GetCyberMapAttr(RP->BitMap,(LONG)CYBRMATTR_DEPTH);
366: #endif
367: if(use_graffiti) return 8;
368: return RP->BitMap->Depth;
369: }
370:
371: /****************************************************************************/
372:
373: static int get_color(int r, int g, int b, xcolnr *cnp)
374: {
375: int col;
376:
377: if(use_gray) r = g = b = (77*r + 151*g + 29*b) / 256;
378:
379: r *= 0x11111111;
380: g *= 0x11111111;
381: b *= 0x11111111;
382: col = ObtainColor(r, g, b);
383:
384: if(col == -1) {
385: get_color_failed = 1;
386: return 0;
387: }
388:
389: *cnp = col;
390: return 1;
391: }
392:
393: /****************************************************************************/
394: /*
395: * FIXME: find a better way to determine closeness of colors (closer to
396: * human perception).
397: */
398: static __inline__ void rgb2xyz(int r, int g, int b,
399: int *x, int *y, int *z)
400: {
401: *x = r*1024 - (g+b)*512;
402: *y = 886*(g-b);
403: *z = (r+g+b)*341;
404: }
405: static __inline__ int calc_err(int r1, int g1, int b1,
406: int r2, int g2, int b2)
407: {
408: int x1,y1,z1,x2,y2,z2;
409:
410: rgb2xyz(r1,g1,b1,&x1,&y1,&z1);
411: rgb2xyz(r2,g2,b2,&x2,&y2,&z2);
412: x1 -= x2; y1 -= y2; z1 -= z2;
413: return x1*x1 + y1*y1 + z1*z1;
414: }
415:
416: /****************************************************************************/
417:
418: static int get_nearest_color(int r, int g, int b)
419: {
420: int i, best, err, besterr;
421: int colors;
422: int br=0,bg=0,bb=0;
423:
424: if(use_gray) r = g = b = (77*r + 151*g + 29*b) / 256;
425:
426: best = 0;
427: besterr = calc_err(0,0,0, 15,15,15);
428: colors = is_halfbrite?32:(1<<RPDepth(RP));
429:
430: for(i=0; i<colors; i++ ) {
431: long rgb = GetRGB4(CM, i);
432: int cr, cg, cb;
433:
434: cr = (rgb >> 8) & 15;
435: cg = (rgb >> 4) & 15;
436: cb = (rgb >> 0) & 15;
437:
438: err = calc_err(r,g,b, cr,cg,cb);
439:
440: if(err < besterr) {
441: best = i;
442: besterr = err;
443: br=cr; bg=cg; bb=cb;
444: }
445:
446: if(is_halfbrite) {
447: cr /= 2; cg /= 2; cb /= 2;
448: err = calc_err(r,g,b, cr,cg,cb);
449: if(err < besterr) {
450: best = i + 32;
451: besterr = err;
452: br=cr; bg=cg; bb=cb;
453: }
454: }
455: }
456: return best;
457: }
458:
459: /****************************************************************************/
460:
461: static int init_colors(void)
462: {
463: gfxvidinfo.can_double = 0;
464: if (need_dither) {
465: /* first try color allocation */
466: int bitdepth = usepub ? 8 : RPDepth(RP);
467: int maxcol;
468:
469: if(!use_gray && bitdepth>=3)
470: do {
471: get_color_failed = 0;
472: setup_dither(bitdepth, get_color);
473: if(get_color_failed) ReleaseColors();
474: } while(get_color_failed && --bitdepth>=3);
475:
476: if(!use_gray && bitdepth>=3) {
477: printf("Color dithering with %d bits\n",bitdepth);
478: return 1;
479: }
480:
481: /* if that fail then try grey allocation */
482: maxcol = 1<<(usepub ? 8 : RPDepth(RP));
483:
484: do {
485: get_color_failed = 0;
486: setup_greydither_maxcol(maxcol, get_color);
487: if(get_color_failed) ReleaseColors();
488: } while(get_color_failed && --maxcol>=2);
489:
490: /* extra pass with approximated colors */
491: if(get_color_failed) do {
492: maxcol=2;
493: use_approx_color = 1;
494: get_color_failed = 0;
495: setup_greydither_maxcol(maxcol, get_color);
496: if(get_color_failed) ReleaseColors();
497: } while(get_color_failed && --maxcol>=2);
498:
499: if (maxcol >= 2) {
500: printf("Gray dither with %d shades.\n",maxcol);
501: return 1;
502: }
503:
504: return 0; /* everything failed :-( */
505: }
506:
507: /* No dither */
508: switch(RPDepth(RP)) {
509: case 6: if (is_halfbrite) {
510: static int tab[]={
511: 0x000, 0x00f, 0x0f0, 0x0ff, 0x08f, 0x0f8, 0xf00, 0xf0f,
512: 0x80f, 0xff0, 0xfff, 0x88f, 0x8f0, 0x8f8, 0x8ff, 0xf08,
513: 0xf80, 0xf88, 0xf8f, 0xff8, /* end of regular pattern */
514: 0xa00, 0x0a0, 0xaa0, 0x00a, 0xa0a, 0x0aa, 0xaaa,
515: 0xfaa, 0xf6a, 0xa80, 0x06a, 0x6af };
516: int i;
517: for(i=0;i<32;++i) get_color(tab[i]>>8, (tab[i]>>4)&15, tab[i]&15, xcolors);
518: for(i=0;i<4096;++i) xcolors[i] = get_nearest_color(i>>8, (i>>4)&15, i&15);
519: printf("Using %d colors + halfbrite\n",32);
520: break;
521: } else if(is_ham) {
522: int i;
523: for(i=0;i<16;++i) get_color(i,i,i, xcolors);
524: printf("Using %d bits pseudo-truecolor (HAM).\n",12);
525: alloc_colors64k(4,4,4,10,5,0);
526: return init_ham();
527: }
528:
529: case 1: case 2: case 3: case 4: case 5: case 7: case 8: {
530: int maxcol = 1<<RPDepth(RP);
531:
532: if(maxcol>=8 && !use_gray) do {
533: get_color_failed = 0;
534: setup_maxcol(maxcol);
535: alloc_colors256(get_color);
536: if(get_color_failed) ReleaseColors();
537: } while(get_color_failed && --maxcol>=8);
538: else {
539: int i;
540: for(i=0;i<maxcol;++i) {
541: get_color((i*15)/(maxcol-1), (i*15)/(maxcol-1),
542: (i*15)/(maxcol-1), xcolors);
543: }
544: }
545: printf("Using %d colors.\n",maxcol);
546: for(maxcol=0; maxcol<4096; ++maxcol)
547: xcolors[maxcol] = get_nearest_color(maxcol>>8, (maxcol>>4)&15,
548: maxcol&15);
549: } break;
550:
551: case 15:
552: printf("Using %d bits truecolor.\n",15);
553: alloc_colors64k(5,5,5,10,5,0);
554: break;
555:
556: case 16:
557: printf("Using %d bits truecolor.\n",16);
558: alloc_colors64k(5,6,5,11,5,0);
559: break;
560:
561: case 24:
562: printf("Using %d bits truecolor.\n",24);
563: alloc_colors64k(8,8,8,16,8,0);
564: break;
565:
566: case 32:
567: printf("Using %d bits truecolor.\n",32);
568: alloc_colors64k(8,8,8,16,8,0);
569: break;
570: }
571: return 1;
572: }
573:
574: /****************************************************************************/
575:
576: static void setup_sprite(struct Window *W)
577: {
578: Sprite = AllocVec(4+2, MEMF_CHIP|MEMF_CLEAR);
579: if(!Sprite) {
580: fprintf(stderr, "Warning: Can't alloc sprite buffer !\n");
581: return;
582: }
583: Sprite[2] = 0x8000; Sprite[3] = 0x8000;
584: SetPointer(W, Sprite, 1, 16, -1, 0);
585: }
586:
587: /****************************************************************************/
588:
589: static int setup_customscreen(void)
590: {
591: /* hum some of old programming style here :) */
592: static struct NewScreen NewScreenStructure = {
593: 0,0, 800,600, 3, 0,1,
594: LACE+HIRES, CUSTOMSCREEN|SCREENQUIET|SCREENBEHIND,
595: NULL, (void*)"UAE", NULL, NULL};
596: static struct NewWindow NewWindowStructure = {
597: 0,0, 800,600, 0,1,
598: IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY|IDCMP_DISKINSERTED|IDCMP_DISKREMOVED|
599: IDCMP_ACTIVEWINDOW|IDCMP_INACTIVEWINDOW|IDCMP_MOUSEMOVE,
600: WFLG_SMART_REFRESH|WFLG_BACKDROP|WFLG_RMBTRAP|WFLG_NOCAREREFRESH|
601: WFLG_BORDERLESS|WFLG_WINDOWACTIVE|WFLG_REPORTMOUSE,
602: NULL, NULL, (void*)"UAE", NULL, NULL, 5,5, 800,600,
603: CUSTOMSCREEN};
604:
605: NewScreenStructure.Width = currprefs.gfx_width;
606: NewScreenStructure.Height = currprefs.gfx_height;
607: NewScreenStructure.Depth = os39?8:(currprefs.gfx_lores?5:4);
608: NewScreenStructure.ViewModes = SPRITES | (currprefs.gfx_lores?NULL:HIRES) |
609: (currprefs.gfx_height>256?LACE:NULL);
610:
611: do S = (void*)OpenScreen(&NewScreenStructure);
612: while(!S && --NewScreenStructure.Depth);
613: if(!S) {
614: fprintf(stderr, "Can't open custom screen !\n");
615: return 0;
616: }
617:
618: CM = S->ViewPort.ColorMap;
619: RP = &S->RastPort;
620:
621: NewWindowStructure.Width = S->Width;
622: NewWindowStructure.Height = S->Height;
623: NewWindowStructure.Screen = S;
624: W = (void*)OpenWindow(&NewWindowStructure);
625: if(!W) {
626: fprintf(stderr, "Can't open window on custom screen !\n");
627: return 0;
628: }
629: setup_sprite(W);
630: return 1;
631: }
632:
633: /****************************************************************************/
634:
635: static int setup_publicscreen(void)
636: {
637: UWORD ZoomArray[4] = {0,0,0,0};
638:
639: S = LockPubScreen(NULL);
640: if(!S) {
641: fprintf(stderr,"No public screen !\n");
642: return 0;
643: }
644:
645: ZoomArray[2] = 128;
646: ZoomArray[3] = S->BarHeight+1;
647:
648: CM = S->ViewPort.ColorMap;
649:
650: if((S->ViewPort.Modes & (HIRES|LACE))==HIRES) {
651: if(currprefs.gfx_height + S->BarHeight + 1 >= S->Height) {
652: currprefs.gfx_height >>= 1;
653: currprefs.gfx_correct_aspect = 1;
654: }
655: }
656:
657: #ifdef USE_CYBERGFX
658: if(CyberGfxBase && IsCyberModeID(GetVPModeID(&S->ViewPort))) use_cyb = 1;
659: #endif
660: W = OpenWindowTags(NULL,
661: WA_Title, (ULONG)"UAE",
662: WA_AutoAdjust, TRUE,
663: WA_InnerWidth, currprefs.gfx_width,
664: WA_InnerHeight, currprefs.gfx_height,
665: WA_PubScreen, (ULONG)S,
666: WA_Zoom, (ULONG)ZoomArray,
667: WA_IDCMP, IDCMP_MOUSEBUTTONS|
668: IDCMP_RAWKEY|
669: IDCMP_ACTIVEWINDOW|
670: IDCMP_INACTIVEWINDOW|
671: IDCMP_MOUSEMOVE|
672: IDCMP_CLOSEWINDOW|
673: IDCMP_REFRESHWINDOW|
674: IDCMP_NEWSIZE|
675: 0,
676: WA_Flags, WFLG_DRAGBAR|
677: WFLG_DEPTHGADGET|
678: WFLG_REPORTMOUSE|
679: WFLG_RMBTRAP|
680: WFLG_ACTIVATE|
681: WFLG_CLOSEGADGET|
682: WFLG_SMART_REFRESH|
683: 0,
684: TAG_DONE);
685:
686: UnlockPubScreen(NULL, S);
687:
688: if(!W) {
689: fprintf(stderr,"Can't open window on public screen !\n");
690: CM = NULL;
691: return 0;
692: }
693:
694: gfxvidinfo.width = (W->Width - W->BorderRight - W->BorderLeft);
695: gfxvidinfo.height = (W->Height - W->BorderTop - W->BorderBottom);
696: XOffset = W->BorderLeft;
697: YOffset = W->BorderTop;
698:
699: RP = W->RPort;
700: setup_sprite(W);
701:
702: appw_init(W);
703:
704: return 1;
705: }
706:
707: /****************************************************************************/
708:
709: static int setup_userscreen(void)
710: {
711: struct ScreenModeRequester *ScreenRequest;
712: ULONG DisplayID;
713: static struct BitMap PointerBitMap;
714: UWORD *PointerLine;
715: LONG ScreenWidth=0,ScreenHeight=0,Depth=0;
716: UWORD OverscanType=0;
717: BOOL AutoScroll=0;
718:
719: if(!AslBase) AslBase = OpenLibrary("asl.library",38);
720: if(!AslBase) {
721: fprintf(stderr,"Can't open asl.library v38 !");
722: return 0;
723: }
724:
725: ScreenRequest = AllocAslRequest(ASL_ScreenModeRequest,NULL);
726: if(!ScreenRequest) {
727: fprintf(stderr,"Unable to allocate screen mode requester.\n");
728: return 0;
729: }
730:
731: if(AslRequestTags(ScreenRequest,
732: ASLSM_TitleText, (ULONG)"Select screen display mode",
733: ASLSM_InitialDisplayID, NULL,
734: ASLSM_InitialDisplayDepth, 8,
735: ASLSM_InitialDisplayWidth, currprefs.gfx_width,
736: ASLSM_InitialDisplayHeight,currprefs.gfx_height,
737: ASLSM_MinWidth, currprefs.gfx_width,
738: ASLSM_MinHeight, currprefs.gfx_height,
739: ASLSM_DoWidth, TRUE,
740: ASLSM_DoHeight, TRUE,
741: ASLSM_DoDepth, TRUE,
742: ASLSM_DoOverscanType, TRUE,
743: ASLSM_PropertyFlags, 0,
744: ASLSM_PropertyMask, DIPF_IS_DUALPF |
745: DIPF_IS_PF2PRI |
746: /* DIPF_IS_HAM | */
747: 0,
748: TAG_DONE)) {
749: ScreenWidth = ScreenRequest->sm_DisplayWidth;
750: ScreenHeight = ScreenRequest->sm_DisplayHeight;
751: Depth = ScreenRequest->sm_DisplayDepth;
752: DisplayID = ScreenRequest->sm_DisplayID;
753: OverscanType = ScreenRequest->sm_OverscanType;
754: AutoScroll = ScreenRequest->sm_AutoScroll;
755: if(ScreenWidth < currprefs.gfx_width) ScreenWidth = currprefs.gfx_width;
756: if(ScreenHeight < currprefs.gfx_height) ScreenHeight = currprefs.gfx_height;
757: }
758: else DisplayID = INVALID_ID;
759: FreeAslRequest(ScreenRequest);
760:
761: if(DisplayID == (ULONG)INVALID_ID) return 0;
762:
763: #ifdef USE_CYBERGFX
764: if(CyberGfxBase && IsCyberModeID(DisplayID)) use_cyb = 1;
765: #endif
766: if(DisplayID & DIPF_IS_HAM) Depth = 6; /* only ham6 for the moment */
767:
768: S = OpenScreenTags(NULL,
769: SA_DisplayID, DisplayID,
770: SA_Width, ScreenWidth,
771: SA_Height, ScreenHeight,
772: SA_Depth, Depth,
773: SA_Overscan, OverscanType,
774: SA_AutoScroll, AutoScroll,
775: SA_ShowTitle, FALSE,
776: SA_Quiet, TRUE,
777: SA_Behind, TRUE,
778: SA_PubName, (ULONG)"UAE",
779: /* v39 stuff here: */
780: (os39?SA_BackFill:TAG_DONE), (ULONG)LAYERS_NOBACKFILL,
781: SA_SharePens, TRUE,
782: SA_Exclusive, (use_cyb?TRUE:FALSE),
783: SA_Draggable, (use_cyb?FALSE:TRUE),
784: SA_Interleaved, TRUE,
785: TAG_DONE);
786: if(!S) {
787: fprintf(stderr,"Unable to open the screen.\n");
788: return 0;
789: }
790:
791: CM = S->ViewPort.ColorMap;
792: is_halfbrite = (S->ViewPort.Modes & EXTRA_HALFBRITE);
793: is_ham = (S->ViewPort.Modes & HAM);
794:
795: PointerLine = malloc(4);/* autodocs says it needs not be in chip memory */
796: if(PointerLine) PointerLine[0]=PointerLine[1]=0;
797: InitBitMap(&PointerBitMap,2,16,1);
798: PointerBitMap.Planes[0] = (PLANEPTR)&PointerLine[0];
799: PointerBitMap.Planes[1] = (PLANEPTR)&PointerLine[1];
800:
801: Pointer = NewObject(NULL,POINTERCLASS,
802: POINTERA_BitMap, (ULONG)&PointerBitMap,
803: POINTERA_WordWidth, 1,
804: TAG_DONE);
805: if(!Pointer)
806: fprintf(stderr,"Warning: Unable to allocate blank mouse pointer.\n");
807:
808: W = OpenWindowTags(NULL,
809: WA_Width, S->Width,
810: WA_Height, S->Height,
811: WA_CustomScreen, (ULONG)S,
812: WA_Backdrop, TRUE,
813: WA_Borderless, TRUE,
814: WA_RMBTrap, TRUE,
815: WA_ReportMouse, TRUE,
816: WA_IDCMP, IDCMP_MOUSEBUTTONS|
817: IDCMP_RAWKEY|
818: IDCMP_DISKINSERTED|
819: IDCMP_DISKREMOVED|
820: IDCMP_ACTIVEWINDOW|
821: IDCMP_INACTIVEWINDOW|
822: IDCMP_MOUSEMOVE,
823: (os39?WA_BackFill:TAG_IGNORE), (ULONG)LAYERS_NOBACKFILL,
824: (Pointer?WA_Pointer:TAG_IGNORE), (ULONG)Pointer,
825: TAG_DONE);
826:
827: if(!W) {
828: fprintf(stderr,"Unable to open the window.\n");
829: CloseScreen(S);S=NULL;RP=NULL;CM=NULL;
830: return 0;
831: }
832: if(!Pointer) setup_sprite(W);
833:
834: RP = W->RPort; /* &S->Rastport if screen is not public */
835: PubScreenStatus(S, 0);
836:
837: return 1;
838: }
839:
840: /****************************************************************************/
841:
842: static int setup_graffiti(void)
843: {
844: static struct NewScreen NewScreenStructure = {
845: 0,0, 800,600, 4, 0,1,
846: HIRES, CUSTOMSCREEN|SCREENQUIET/*|SCREENBEHIND*/,
847: NULL, (void*)"UAE", NULL, NULL};
848: static struct NewWindow NewWindowStructure = {
849: 0,0, 800,600, 0,1,
850: IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY|IDCMP_DISKINSERTED|IDCMP_DISKREMOVED|
851: IDCMP_ACTIVEWINDOW|IDCMP_INACTIVEWINDOW|IDCMP_MOUSEMOVE,
852: WFLG_SMART_REFRESH|WFLG_BACKDROP|WFLG_RMBTRAP|WFLG_NOCAREREFRESH|
853: WFLG_BORDERLESS|WFLG_WINDOWACTIVE|WFLG_REPORTMOUSE,
854: NULL, NULL, (void*)"UAE", NULL, NULL, 5,5, 800,600,
855: CUSTOMSCREEN};
856: static short colarr[] = {
857: 0x000,0x001,0x008,0x009,0x080,0x081,0x088,0x089,
858: 0x800,0x801,0x808,0x809,0x880,0x881,0x888,0x889};
859: int i;
860:
861: NewScreenStructure.Width = 2*currprefs.gfx_width;
862: /* I leave 8 extra lines for palette & mode: */
863: NewScreenStructure.Height = currprefs.gfx_height+8;
864: NewScreenStructure.Depth = 4;
865: NewScreenStructure.ViewModes = HIRES|GENLOCK_AUDIO/*|GENLOCK_VIDEO*/;
866: /* ^^ ^^ which one ? */
867:
868: S = (void*)OpenScreen(&NewScreenStructure);
869: if(!S) {
870: fprintf(stderr, "Can't open graffiti screen !\n");
871: return 0;
872: }
873:
874: for(i=0;i<15;++i) {
875: unsigned int rgb = colarr[i];
876: SetRGB4(&S->ViewPort,i,(rgb>>8)&15,(rgb>>4)&15,rgb&15);
877: }
878:
879: CM = S->ViewPort.ColorMap;
880: RP = &S->RastPort;
881:
882: NewWindowStructure.Width = S->Width;
883: NewWindowStructure.Height = S->Height;
884: NewWindowStructure.Screen = S;
885: W = (void*)OpenWindow(&NewWindowStructure);
886: if(!W) {
887: fprintf(stderr, "Can't open window on graffiti screen !\n");
888: return 0;
889: }
890: setup_sprite(W);
891: {
892: /* make sure cmd part is cleared */
893: int d;
894: for(d = 0; d < 4; ++d) {
895: short *p;
896: int i;
897: p = (void*)RP->BitMap->Planes[d];
898: for(i=0;i<40*7;++i) p[i] = 0;
899: }
900: /* set graffiti mode to lores */
901: *((short*)RP->BitMap->Planes[3]+8*40-1) = 0x0800;
902: for(d=0;d<256;++d) graffiti_SetRGB(d,0,0,0);
903: }
904:
905: return 1;
906: }
907:
908: /****************************************************************************/
909:
910: int graphics_setup(void)
911: {
912: #ifdef __GNUC__
913: if(ix_os != OS_IS_AMIGAOS) {
914: ix_req(NULL, "Abort", NULL, "That version of %s is only for AmigaOS!", __progname);
915: exit(20);
916: }
917: #endif
918: if(SysBase->LibNode.lib_Version < 36) {
919: fprintf(stderr, "UAE needs OS 2.0+ !\n");
920: return 0;
921: }
922: os39 = (SysBase->LibNode.lib_Version>=39);
923:
924: atexit(graphics_leave);
925:
926: IntuitionBase = (void*)OpenLibrary("intuition.library",0L);
927: if(!IntuitionBase) {
928: fprintf(stderr,"No intuition.library ?\n");
929: return 0;
930: }
931: GfxBase = (void*)OpenLibrary("graphics.library",0L);
932: if(!GfxBase) {
933: fprintf(stderr,"No graphics.library ?\n");
934: return 0;
935: }
936: #ifdef USE_CYBERGFX
937: if(!CyberGfxBase) CyberGfxBase = OpenLibrary("cybergraphics.library",40);
938: #endif
939: initpseudodevices();
940:
941: return 1;
942: }
943:
944: /****************************************************************************/
945:
946: int graphics_init(void)
947: {
948: int i,bitdepth;
949:
950: use_low_bandwidth = 0;
951: need_dither = 0;
952: use_cyb = 0;
953:
954: if (currprefs.gfx_width < 320)
955: currprefs.gfx_width = 320;
956: if (!currprefs.gfx_correct_aspect && (currprefs.gfx_height < 64/*200*/))
957: currprefs.gfx_height = 200;
958: currprefs.gfx_width += 7;
959: currprefs.gfx_width &= ~7;
960:
961: if (currprefs.color_mode > 5)
962: fprintf(stderr, "Bad color mode selected. Using default.\n"), currprefs.color_mode = 0;
963:
964: if(currprefs.color_mode == 3) { /* graffiti */
965: currprefs.gfx_width = 320;
966: if(currprefs.gfx_height > 256)
967: currprefs.gfx_height = 256;
968: currprefs.gfx_lores = 1;
969: } /* graffiti */
970:
971: gfxvidinfo.width = currprefs.gfx_width;
972: gfxvidinfo.height = currprefs.gfx_height;
973:
974: switch(currprefs.color_mode) {
975: case 3:
976: if(setup_graffiti()) {use_graffiti = 1;break;}
977: fprintf(stderr,"Asking user for screen...\n");
978: /* fall trough */
979: case 2:
980: if(setup_userscreen()) break;
981: fprintf(stderr,"Trying on public screen...\n");
982: /* fall trough */
983: case 1:
984: is_halfbrite = 0;
985: if(setup_publicscreen()) {usepub = 1;break;}
986: fprintf(stderr,"Trying on custom screen...\n");
987: /* fall trough */
988: case 0:
989: default:
990: if(!setup_customscreen()) return 0;
991: break;
992: }
993:
994: Line = AllocVec((currprefs.gfx_width + 15) & ~15,MEMF_ANY|MEMF_PUBLIC);
995: if(!Line) {
996: fprintf(stderr,"Unable to allocate raster buffer.\n");
997: return 0;
998: }
999: BitMap = myAllocBitMap(currprefs.gfx_width,1,8,BMF_CLEAR|BMF_MINPLANES,RP->BitMap);
1000: if(!BitMap) {
1001: fprintf(stderr,"Unable to allocate BitMap.\n");
1002: return 0;
1003: }
1004: TempRPort = AllocVec(sizeof(struct RastPort),MEMF_ANY|MEMF_PUBLIC);
1005: if(!TempRPort) {
1006: fprintf(stderr,"Unable to allocate RastPort.\n");
1007: return 0;
1008: }
1009: CopyMem(RP,TempRPort,sizeof(struct RastPort));
1010: TempRPort->Layer = NULL;
1011: TempRPort->BitMap = BitMap;
1012:
1013: if(usepub) set_title();
1014:
1015: bitdepth = RPDepth(RP);
1016: if(is_ham) {
1017: /* ham 6 */
1018: use_low_bandwidth = 0; /* needless as the line must be fully */
1019: need_dither = 0; /* recomputed */
1020: gfxvidinfo.pixbytes = 2;
1021: } else if(bitdepth <= 8) {
1022: /* chunk2planar is slow so we define use_low_bandwidth for all modes
1023: except cybergraphics modes */
1024: use_low_bandwidth = 1;
1025: need_dither = use_dither || (bitdepth<=1);
1026: gfxvidinfo.pixbytes = need_dither?2:1;
1027: } else {
1028: /* Cybergfx mode */
1029: gfxvidinfo.pixbytes = (bitdepth == 24 || bitdepth == 32) ? 4 :
1030: (bitdepth == 12 || bitdepth == 16) ? 2 : 1;
1031: }
1032:
1033: if (!use_cyb) {
1034: gfxvidinfo.rowbytes = gfxvidinfo.pixbytes * currprefs.gfx_width;
1035: gfxvidinfo.bufmem = (char *)calloc(gfxvidinfo.rowbytes, currprefs.gfx_height+1);
1036: /* ^^ */
1037: /* This is because DitherLine may read one extra row */
1038: } else {
1039: #ifdef USE_CYBERGFX
1040: ULONG fmt = 0;
1041: switch(bitdepth) {
1042: case 8: fmt = PIXFMT_LUT8; break;
1043: case 15: fmt = PIXFMT_RGB15; break;
1044: case 16: fmt = PIXFMT_RGB16; break;
1045: case 24: fmt = PIXFMT_RGB24; break;
1046: case 32: fmt = PIXFMT_ARGB32; break;
1047: default: fprintf(stderr,"Unsupported bitdepth %d.\n",bitdepth); return 0;
1048: }
1049: CybBitMap = myAllocBitMap(currprefs.gfx_width, currprefs.gfx_height+1,
1050: bitdepth,
1051: (fmt<<24)|BMF_SPECIALFMT|BMF_MINPLANES,
1052: NULL);
1053: if(CybBitMap) {
1054: gfxvidinfo.rowbytes = GetCyberMapAttr(CybBitMap,CYBRMATTR_XMOD);
1055: gfxvidinfo.pixbytes = GetCyberMapAttr(CybBitMap,CYBRMATTR_BPPIX);
1056: gfxvidinfo.bufmem = (char *)GetCyberMapAttr(CybBitMap,CYBRMATTR_DISPADR);
1057: } else gfxvidinfo.bufmem = NULL;
1058: #endif
1059: }
1060: if(!gfxvidinfo.bufmem) {
1061: fprintf(stderr,"Not enough memory for video bufmem.\n");
1062: return 0;
1063: }
1064:
1065: if (use_low_bandwidth) {
1066: gfxvidinfo.maxblocklines = currprefs.gfx_height-1; /* it seems to increase the speed */
1067: oldpixbuf = (char *)calloc(gfxvidinfo.rowbytes, currprefs.gfx_height);
1068: if(!oldpixbuf) {
1069: fprintf(stderr,"Not enough memory for oldpixbuf.\n");
1070: return 0;
1071: }
1072: } else {
1073: gfxvidinfo.maxblocklines = 0; /* whatever... */
1074: }
1075:
1076: if (!init_colors()) {
1077: fprintf(stderr,"Failed to init colors.\n");
1078: return 0;
1079: }
1080: switch (gfxvidinfo.pixbytes) {
1081: case 2:
1082: for (i = 0; i < 4096; i++) xcolors[i] *= 0x00010001;
1083: gfxvidinfo.can_double = 1;
1084: break;
1085: case 1:
1086: for (i = 0; i < 4096; i++) xcolors[i] *= 0x01010101;
1087: gfxvidinfo.can_double = 1;
1088: break;
1089: default:
1090: gfxvidinfo.can_double = 0;
1091: break;
1092: }
1093:
1094: if(!usepub) ScreenToFront(S);
1095:
1096: buttonstate[0] = buttonstate[1] = buttonstate[2] = 0;
1097: for(i=0; i<256; i++)
1098: keystate[i] = 0;
1099:
1100: lastmx = lastmy = 0;
1101: newmousecounters = 0;
1102: inwindow = 0;
1103:
1104: rexx_init();
1105:
1106: if(getenv(UAEIFF) && !use_cyb) {
1107: dump_iff = 1;
1108: fprintf(stderr,"Saving to \"%s\"\n",getenv(UAEIFF));
1109: }
1110:
1111: return 1;
1112: }
1113:
1114: /****************************************************************************/
1115:
1116: void graphics_leave(void)
1117: {
1118: rexx_exit();
1119: closepseudodevices();
1120: appw_exit();
1121: #ifdef USE_CYBERGFX
1122: if(CybBitMap) {
1123: WaitBlit();
1124: myFreeBitMap(CybBitMap);
1125: CybBitMap = NULL;
1126: }
1127: #endif
1128: if(BitMap) {
1129: WaitBlit();
1130: myFreeBitMap(BitMap);
1131: BitMap = NULL;
1132: }
1133: if(TempRPort) {
1134: FreeVec(TempRPort);
1135: TempRPort = NULL;
1136: }
1137: if(Line) {
1138: FreeVec(Line);
1139: Line = NULL;
1140: }
1141: if(CM) {
1142: ReleaseColors();
1143: CM = NULL;
1144: }
1145: if(W) {
1146: CloseWindow(W);
1147: W = NULL;
1148: }
1149: if(Sprite) {
1150: FreeVec(Sprite);
1151: Sprite = NULL;
1152: }
1153: if(Pointer) {
1154: DisposeObject(Pointer);
1155: Pointer = NULL;
1156: }
1157: if(!usepub && S) {
1158: int warn = 0;
1159: if(!CloseScreen(S)) {
1160: fprintf(stderr,"Please close all opened windows on UAE's "
1161: "screen.\n");
1162: do Delay(50); while(!CloseScreen(S));
1163: }
1164: S = NULL;
1165: }
1166: if(AslBase) {
1167: CloseLibrary((void*)AslBase);
1168: AslBase = NULL;
1169: }
1170: if(GfxBase) {
1171: CloseLibrary((void*)GfxBase);
1172: GfxBase = NULL;
1173: }
1174: if(IntuitionBase) {
1175: CloseLibrary((void*)IntuitionBase);
1176: IntuitionBase = NULL;
1177: }
1178: if(CyberGfxBase) {
1179: CloseLibrary((void*)CyberGfxBase);
1180: CyberGfxBase = NULL;
1181: }
1182: }
1183:
1184:
1185: /***************************************************************************/
1186:
1187: void handle_events(void)
1188: {
1189: struct IntuiMessage *msg;
1190: int mx,my,class,code;
1191:
1192: newmousecounters = 0;
1193:
1194: /*
1195: * This is a hack to simulate ^C as is seems that break_handler
1196: * is lost when system() is called.
1197: */
1198: if(SetSignal(0L, SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D) &
1199: (SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D)) {
1200: activate_debugger();
1201: }
1202:
1203: while((msg=(struct IntuiMessage*)GetMsg(W->UserPort))) {
1204: class = msg->Class;
1205: code = msg->Code;
1206: mx = msg->MouseX;
1207: my = msg->MouseY;
1208: ReplyMsg((struct Message*)msg);
1209:
1210: mx -= XOffset;
1211: my -= YOffset;
1212:
1213: if(use_graffiti) {
1214: my -= 8;
1215: }
1216:
1217: switch(class) {
1218: case IDCMP_NEWSIZE:
1219: inhibit_frame = (W->Flags & WFLG_ZOOMED)?1:0;
1220: set_title();
1221: break;
1222:
1223: case IDCMP_REFRESHWINDOW:
1224: if(use_low_bandwidth) {
1225: /* hack: this forces refresh */
1226: char *ptr = oldpixbuf;
1227: int i, len = gfxvidinfo.width;
1228: len *= gfxvidinfo.pixbytes;
1229: for(i=0;i<currprefs.gfx_height;++i) {
1230: ptr[00000] ^= 255;
1231: ptr[len-1] ^= 255;
1232: ptr += gfxvidinfo.rowbytes;
1233: }
1234: BeginRefresh(W);
1235: flush_block(0,currprefs.gfx_height-1);
1236: EndRefresh(W, TRUE);
1237: } else {
1238: BeginRefresh(W);
1239: EndRefresh(W, TRUE);
1240: } break;
1241:
1242: case IDCMP_CLOSEWINDOW:
1243: activate_debugger();
1244: break;
1245:
1246: case IDCMP_RAWKEY: {
1247: int kc = code&127;
1248: int released = code&128?1:0;
1249:
1250: if(released) {
1251: keystate[kc] = 0;
1252: record_key ((kc << 1) | 1);
1253: } else if (!keystate[kc]) {
1254: keystate[kc] = 1;
1255: record_key (kc << 1);
1256: }
1257: } break;
1258:
1259: case IDCMP_MOUSEMOVE:
1260: if(inwindow) {
1261: lastmx = mx >> (use_graffiti?1:0);
1262: lastmy = my;
1263: if(!ievent_alive) {
1264: if(currprefs.gfx_lores) lastmx <<= 1;
1265: if(currprefs.gfx_height < 512) {
1266: lastmy *= 512;
1267: lastmy /= currprefs.gfx_height;
1268: }
1269: }
1270: } break;
1271:
1272: case IDCMP_MOUSEBUTTONS:
1273: if(code==SELECTDOWN) buttonstate[0]=1;
1274: if(code==SELECTUP) buttonstate[0]=0;
1275: if(code==MENUDOWN) buttonstate[2]=1;
1276: if(code==MENUUP) buttonstate[2]=0;
1277: break;
1278:
1279: /* Those 2 could be of some use later. */
1280: case IDCMP_DISKINSERTED:
1281: /*printf("diskinserted(%d)\n",code);*/
1282: break;
1283:
1284: case IDCMP_DISKREMOVED:
1285: /*printf("diskremoved(%d)\n",code);*/
1286: break;
1287:
1288: case IDCMP_ACTIVEWINDOW:
1289: inwindow = 1;
1290: newmousecounters = 1;
1291: break;
1292:
1293: case IDCMP_INACTIVEWINDOW:
1294: inwindow = 0;
1295: break;
1296:
1297: default:
1298: fprintf(stderr, "Unknown class: %d\n",class);
1299: break;
1300: }
1301: }
1302: /* "Affengriff" */
1303: if(keystate[AK_CTRL] && keystate[AK_LAMI] && keystate[AK_RAMI])
1304: m68k_reset();
1305:
1306: /* PC-like :-) CTRL-ALT-DEL => reboot */
1307: if(keystate[AK_CTRL] && (keystate[AK_LALT] || keystate[AK_RALT]) &&
1308: keystate[AK_DEL])
1309: m68k_reset();
1310:
1311: /* CTRL+LSHIFT+LALT+F10 on amiga => F12 on X11 */
1312: /* F9 => ScrollLock on X11 (inhibit_frame) */
1313: if(keystate[AK_CTRL] && keystate[AK_LSH] && keystate[AK_LALT]) {
1314: if(keystate[AK_F10]) togglemouse();
1315: if(keystate[AK_F9]) {
1316: inhibit_frame = inhibit_frame != 2 ? inhibit_frame ^ 1 :
1317: inhibit_frame;
1318: set_title();
1319: if(inhibit_frame) printf("display disabled\n");
1320: else printf("display enabled\n");
1321: }
1322: }
1323:
1324: disk_hotkeys();
1325: gui_handle_events();
1326: appw_events();
1327: }
1328:
1329: /***************************************************************************/
1330:
1331: int debuggable(void)
1332: {
1333: return 1;
1334: }
1335:
1336: /***************************************************************************/
1337:
1338: int needmousehack(void)
1339: {
1340: return 1;
1341: }
1342:
1343: /***************************************************************************/
1344:
1345: void LED(int on)
1346: {
1347: }
1348:
1349: /***************************************************************************/
1350:
1351: /* sam: need to put all this in a separate module */
1352:
1353: #ifdef PICASSO96
1354:
1355: void DX_Invalidate (int first, int last)
1356: {
1357: }
1358:
1359: int DX_BitsPerCannon (void)
1360: {
1361: return 8;
1362: }
1363:
1364: void DX_SetPalette(int start, int count)
1365: {
1366: }
1367:
1368: int DX_FillResolutions (uae_u16 *ppixel_format)
1369: {
1370: return 0;
1371: }
1372:
1373: void gfx_set_picasso_modeinfo (int w, int h, int depth)
1374: {
1375: }
1376:
1377: void gfx_set_picasso_baseaddr (uaecptr a)
1378: {
1379: }
1380:
1381: void gfx_set_picasso_state (int on)
1382: {
1383: }
1384:
1385: void begindrawing (void)
1386: {
1387: }
1388:
1389: void enddrawing (void)
1390: {
1391: }
1392:
1393: uae_u8 *lockscr (void)
1394: {
1395: return NULL;
1396: }
1397:
1398: void unlockscr (void)
1399: {
1400: }
1401: #endif
1402:
1403: /***************************************************************************/
1404:
1405: static int led_state[5];
1406:
1407: static void set_title(void)
1408: {
1409: static char title[80];
1410: static char ScreenTitle[100];
1411:
1412: if(!usepub) return;
1413:
1414: sprintf(title,"%sPower: [%c] Drives: [%c] [%c] [%c] [%c]",
1415: inhibit_frame?"UAE (PAUSED) - ":"UAE � ",
1416: led_state[0]?'X':' ',
1417: led_state[1]?'0':' ',
1418: led_state[2]?'1':' ',
1419: led_state[3]?'2':' ',
1420: led_state[4]?'3':' ');
1421:
1422: if(!*ScreenTitle) {
1423: sprintf(ScreenTitle,
1424: "UAE-%d.%d.%d � by Bernd Schmidt & contributors, "
1425: "Amiga Port by Samuel Devulder.",
1426: (version / 100) % 10, (version / 10) % 10, version % 10);
1427: SetWindowTitles(W, title, ScreenTitle);
1428: } else SetWindowTitles(W, title, (char*)-1);
1429: }
1430:
1431: /****************************************************************************/
1432:
1433: void main_window_led(int led, int on) /* is used in amigui.c */
1434: {
1435: if(led>=0 && led<=4) led_state[led] = on;
1436: set_title();
1437: }
1438:
1439: /****************************************************************************/
1440:
1441: static void unrecord(int kc)
1442: {
1443: keystate[kc] = 0;
1444: record_key ((kc << 1) | 1);
1445: }
1446:
1447: /****************************************************************************/
1448:
1449: static void disk_hotkeys(void)
1450: {
1451: struct FileRequester *FileRequest;
1452: char buff[80];
1453: int drive;
1454: char *last_file,*last_dir,*s;
1455:
1456: if(!(keystate[AK_CTRL] && keystate[AK_LALT])) return;
1457:
1458: /* CTRL-LSHIFT-LALT F1-F4 => eject_disk */
1459: if(keystate[AK_LSH]) {
1460: int ok = 0;
1461:
1462: if(keystate[AK_F1]) {ok=1;disk_eject(0);
1463: printf("drive DF0: ejected\n");}
1464: if(keystate[AK_F2]) {ok=1;disk_eject(1);
1465: printf("drive DF1: ejected\n");}
1466: if(keystate[AK_F3]) {ok=1;disk_eject(2);
1467: printf("drive DF2: ejected\n");}
1468: if(keystate[AK_F4]) {ok=1;disk_eject(3);
1469: printf("drive DF3: ejected\n");}
1470:
1471: if(ok) {
1472: unrecord(AK_CTRL);unrecord(AK_LALT);unrecord(AK_LSH);
1473: unrecord(AK_F1);unrecord(AK_F2);
1474: unrecord(AK_F3);unrecord(AK_F4);
1475: }
1476: return;
1477: }
1478:
1479: /* CTRL-LALT F1-F4 => insert_disk */
1480: if(keystate[AK_F1]) {drive = 0;unrecord(AK_F1);}
1481: else if(keystate[AK_F2]) {drive = 1;unrecord(AK_F2);}
1482: else if(keystate[AK_F3]) {drive = 2;unrecord(AK_F3);}
1483: else if(keystate[AK_F4]) {drive = 3;unrecord(AK_F4);}
1484: else return;
1485: unrecord(AK_CTRL);unrecord(AK_LALT);
1486:
1487: switch(drive) {
1488: case 0: case 1: case 2: case 3: last_file = currprefs.df[drive]; break;
1489: default: return;
1490: }
1491:
1492: split_dir_file(from_unix_path(last_file), &last_dir, &last_file);
1493: if(!last_file) return;
1494: if(!last_dir) return;
1495:
1496: if(!AslBase) AslBase = OpenLibrary("asl.library",36);
1497: if(!AslBase) {
1498: fprintf(stderr,"Can't open asl.library v36 !");
1499: return;
1500: }
1501:
1502: FileRequest = AllocAslRequest(ASL_FileRequest,NULL);
1503: if(!FileRequest) {
1504: fprintf(stderr,"Unable to allocate file requester.\n");
1505: return;
1506: }
1507:
1508: sprintf(buff,"Select file to use for drive DF%d:",drive);
1509: if(AslRequestTags(FileRequest,
1510: use_graffiti?TAG_IGNORE:
1511: ASLFR_Window, (ULONG)W,
1512: ASLFR_TitleText, (ULONG)buff,
1513: ASLFR_InitialDrawer, (ULONG)last_dir,
1514: ASLFR_InitialFile, (ULONG)last_file,
1515: ASLFR_InitialPattern, (ULONG)"(#?.ad(f|z)#?|df?|?)",
1516: ASLFR_DoPatterns, TRUE,
1517: ASLFR_RejectIcons, TRUE,
1518: TAG_DONE)) {
1519: free(last_file);
1520: last_file = malloc(3 + strlen(FileRequest->fr_Drawer) +
1521: strlen(FileRequest->fr_File));
1522: if((last_file)) {
1523: s = last_file;
1524: strcpy(s,FileRequest->fr_Drawer);
1525: if(*s && !(s[strlen(s)-1]==':' || s[strlen(s)-1]=='/'))
1526: strcat(s,"/");
1527: strcat(s,FileRequest->fr_File);
1528: last_file = to_unix_path(s);free(s);
1529: }
1530: } else {
1531: free(last_file);
1532: last_file = NULL;
1533: }
1534: FreeAslRequest(FileRequest);
1535: free(last_dir);
1536:
1537: if(last_file) {
1538: disk_insert(drive,last_file);
1539: free(last_file);
1540: }
1541: }
1542:
1543: /****************************************************************************/
1544: /*
1545: * Routines for OS2.0 (code taken out of mpeg_play by Michael Balzer)
1546: */
1547: static struct BitMap *myAllocBitMap(ULONG sizex, ULONG sizey, ULONG depth,
1548: ULONG flags, struct BitMap *friend_bitmap)
1549: {
1550: struct BitMap *bm;
1551: unsigned long extra;
1552:
1553: if(os39) return AllocBitMap(sizex, sizey, depth, flags, friend_bitmap);
1554:
1555: extra = (depth > 8) ? depth - 8 : 0;
1556: bm = AllocVec( sizeof *bm + (extra * 4), MEMF_CLEAR );
1557:
1558: if( bm )
1559: {
1560: ULONG i;
1561: InitBitMap(bm, depth, sizex, sizey);
1562: for( i=0; i<depth; i++ )
1563: {
1564: if( !(bm->Planes[i] = AllocRaster(sizex, sizey)) )
1565: {
1566: while(i--) FreeRaster(bm->Planes[i], sizex, sizey);
1567: FreeVec(bm);
1568: bm = 0;
1569: break;
1570: }
1571: }
1572: }
1573: return bm;
1574: }
1575:
1576: /****************************************************************************/
1577:
1578: static void myFreeBitMap(struct BitMap *bm)
1579: {
1580: if(os39) {FreeBitMap(bm);return;}
1581: while(bm->Depth--)
1582: FreeRaster(bm->Planes[bm->Depth], bm->BytesPerRow*8, bm->Rows);
1583: FreeVec(bm);
1584: }
1585:
1586: /****************************************************************************/
1587: /*
1588: * find the best appropriate color. return -1 if none is available
1589: */
1590: static LONG ObtainColor(ULONG r,ULONG g,ULONG b)
1591: {
1592: int i, crgb;
1593: int colors;
1594:
1595: if(use_graffiti) {
1596: if(maxpen >= 256) {
1597: fprintf(stderr,"Asking more than 256 colors for graffiti ?\n");
1598: abort();
1599: }
1600: graffiti_SetRGB(maxpen, r>>24, g>>24, b>>24);
1601: return maxpen++;
1602: }
1603:
1604: if(os39 && usepub && CM) {
1605: i = ObtainBestPen(CM,r,g,b,
1606: OBP_Precision, (use_approx_color?PRECISION_GUI:
1607: PRECISION_EXACT),
1608: OBP_FailIfBad, TRUE,
1609: TAG_DONE);
1610: if(i != -1) {
1611: if(maxpen<256) pen[maxpen++] = i;
1612: else i = -1;
1613: }
1614: return i;
1615: }
1616:
1617: if(os39 && use_cyb) {
1618: if(maxpen >= 256) return -1;
1619: SetRGB32(&S->ViewPort, maxpen, r, g, b);
1620: return maxpen++;
1621: }
1622:
1623: r >>= 28; g >>= 28; b >>= 28;
1624:
1625: colors = is_halfbrite?32:(1<<RPDepth(RP));
1626:
1627: /* private screen => standard allocation */
1628: if(!usepub) {
1629: if(maxpen >= colors) return -1; /* no more colors available */
1630: SetRGB4(&S->ViewPort, maxpen, r, g, b);
1631: return maxpen++;
1632: }
1633:
1634: /* public => find exact match */
1635: if(use_approx_color) return get_nearest_color(r,g,b);
1636: crgb = (r<<8)|(g<<4)|b;
1637: for(i=0; i<colors; i++ ) {
1638: int rgb = GetRGB4(CM, i);
1639: if(rgb == crgb) return i;
1640: }
1641: return -1;
1642: }
1643:
1644: /****************************************************************************/
1645: /*
1646: * free a color entry
1647: */
1648: static void ReleaseColors(void)
1649: {
1650: if(os39 && usepub && CM)
1651: while(maxpen>0) ReleasePen(CM, pen[--maxpen]);
1652: else maxpen = 0;
1653: }
1654:
1655: /****************************************************************************/
1656:
1657: static int DoSizeWindow(struct Window *W,int wi,int he)
1658: {
1659: register int x,y;
1660: int ret = 1;
1661:
1662: wi += W->BorderRight + W->BorderLeft;
1663: he += W->BorderBottom + W->BorderTop;
1664: x = W->LeftEdge;
1665: y = W->TopEdge;
1666:
1667: if(x + wi >= W->WScreen->Width) x = W->WScreen->Width - wi;
1668: if(y + he >= W->WScreen->Height) y = W->WScreen->Height - he;
1669:
1670: if(x<0 || y<0) {
1671: fprintf(stderr, "Working screen too small to open window (%dx%d)!\n",
1672: wi, he);
1673: if(x<0) {x = 0; wi = W->WScreen->Width;}
1674: if(y<0) {y = 0; he = W->WScreen->Height;}
1675: ret = 0;
1676: }
1677:
1678: x -= W->LeftEdge;
1679: y -= W->TopEdge;
1680: wi -= W->Width;
1681: he -= W->Height;
1682:
1683: if(x|y) MoveWindow(W,x,y);
1684: if(wi|he) SizeWindow(W,wi,he);
1685: return ret;
1686: }
1687:
1688: /****************************************************************************/
1689: /*
1690: * support code for graffiti card
1691: */
1692: static void graffiti_SetRGB(int i, int r, int g, int b)
1693: {
1694: UWORD **ptr = (void*)RP->BitMap->Planes;
1695:
1696: *(*ptr++ + i) = 0x0406;
1697: *(*ptr++ + i) = (i<<8)|((g>>2)&0x3f);
1698: *(*ptr++ + i) = 0x0606;
1699: *(*ptr + i) = ((r<<6)&0x3f00)|((b>>2)&0x3f);
1700: }
1701:
1702: /****************************************************************************/
1703:
1704: static void graffiti_WritePixelLine8(int x, int y, short len, char *line)
1705: {
1706: #if 0
1707: /* standard code */
1708: char **ptr = (void*)RP->BitMap->Planes;
1709:
1710: y += 8;
1711: x += (y*80)<<2;
1712: while(len--) {
1713: *(ptr[x&3] + (x>>2)) = *line++;
1714: ++x;
1715: }
1716: #else
1717: /* this one must be quite fast for 680x0 processor */
1718: char **ptr;
1719: char *ptr0,*ptr1,*ptr2,*ptr3;
1720: ptr = (void*)RP->BitMap->Planes;
1721: switch(x&3) {
1722: case 0: ptr0=*ptr++; ptr1=*ptr++; ptr2=*ptr++; ptr3=*ptr; break;
1723: case 1: ptr3=*ptr++ + 1; ptr0=*ptr++; ptr1=*ptr++; ptr2=*ptr; break;
1724: case 2: ptr2=*ptr++ + 1; ptr3=*ptr++ + 1; ptr0=*ptr++; ptr1=*ptr; break;
1725: default:
1726: case 3: ptr1=*ptr++ + 1; ptr2=*ptr++ + 1; ptr3=*ptr++ + 1; ptr0=*ptr; break;
1727: }
1728: x >>= 2; x += (80*(y+8));
1729: ptr0 += x; ptr1 += x; ptr2 += x; ptr3 += x;
1730: ++len;
1731: /* full speed here */
1732: while(1) {
1733: if(--len) *ptr0++ = *line++; else break;
1734: if(--len) *ptr1++ = *line++; else break;
1735: if(--len) *ptr2++ = *line++; else break;
1736: if(--len) *ptr3++ = *line++; else break;
1737: }
1738: #endif
1739: }
1740:
1741: /****************************************************************************/
1742:
1743: #define MAKEID(a,b,c,d) ((a<<24)|(b<<16)|(c<<8)|d)
1744:
1745: static int SaveIFF(char *filename, struct Screen *scr)
1746: {
1747: struct DisplayInfo DI;
1748: FILE *file;
1749: ULONG BODYsize;
1750: ULONG modeid;
1751: ULONG count;
1752: ULONG i;
1753:
1754: struct {ULONG iff_type, iff_length;} chunk;
1755: struct {ULONG fc_type, fc_length, fc_subtype;} FORM;
1756: struct {
1757: UWORD w,h,x,y;
1758: UBYTE depth,masking,compression,pad1;
1759: UWORD transparentColor;
1760: UBYTE xAspect,yAspect;
1761: WORD pagewidth,pageheight;
1762: } BMHD;
1763:
1764: BODYsize = scr->BitMap.Depth * scr->BitMap.Rows * 2 * ((scr->Width+15)/16);
1765: modeid = GetVPModeID(&S->ViewPort);
1766: count = scr->ViewPort.ColorMap->Count;
1767:
1768: FORM.fc_type = MAKEID('F','O','R','M');
1769: FORM.fc_length = 4 + /* ILBM */
1770: 8 + sizeof(BMHD) + /* BMHD */
1771: 8 + 4 + /* CAMG */
1772: 8 + 3*count + /* CMAP */
1773: 8 + BODYsize; /* BODY */
1774: FORM.fc_subtype = MAKEID('I','L','B','M');
1775:
1776: if(!(file = fopen(filename,"w"))) return 0;
1777: if(fwrite(&FORM,sizeof(FORM),1,file)!=1) goto err;
1778:
1779: BMHD.w =
1780: BMHD.pagewidth = scr->Width;
1781: BMHD.h =
1782: BMHD.pageheight = scr->Height;
1783: BMHD.x = 0;
1784: BMHD.y = 0;
1785: BMHD.depth = scr->BitMap.Depth;
1786: BMHD.masking = 0;
1787: BMHD.compression = 0;
1788: BMHD.pad1 = 0;
1789: BMHD.transparentColor = 0;
1790: BMHD.xAspect = 22;
1791: BMHD.yAspect = 11;
1792:
1793: if(GetDisplayInfoData(NULL, (UBYTE *)&DI, sizeof(struct DisplayInfo),
1794: DTAG_DISP, modeid)) {
1795: BMHD.xAspect = DI.Resolution.x;
1796: BMHD.yAspect = DI.Resolution.y;
1797: }
1798:
1799: chunk.iff_type = MAKEID('B','M','H','D');
1800: chunk.iff_length = sizeof(BMHD);
1801: if(fwrite(&chunk,sizeof(chunk),1,file)!=1
1802: || fwrite(&BMHD, sizeof(BMHD), 1,file)!=1) goto err;
1803:
1804: chunk.iff_type = MAKEID('C','A','M','G');
1805: chunk.iff_length = sizeof(modeid);
1806: if(fwrite(&chunk, sizeof(chunk), 1,file)!=1
1807: || fwrite(&modeid,chunk.iff_length,1,file)!=1) goto err;
1808:
1809: chunk.iff_type = MAKEID('C','M','A','P');
1810: chunk.iff_length = 3 * count;
1811: if(fwrite(&chunk,sizeof(chunk),1,file)!=1) goto err;
1812: for(i=0; i<count; ++i) {
1813: ULONG c = GetRGB4(scr->ViewPort.ColorMap, i);
1814: UBYTE d;
1815: d = (c>>8)&15;d |= d<<4;if(fwrite(&d,1,1,file)!=1) goto err;
1816: d = (c>>4)&15;d |= d<<4;if(fwrite(&d,1,1,file)!=1) goto err;
1817: d = (c>>0)&15;d |= d<<4;if(fwrite(&d,1,1,file)!=1) goto err;
1818: }
1819:
1820: chunk.iff_type = MAKEID('B','O','D','Y');
1821: chunk.iff_length = BODYsize;
1822: if(fwrite(&chunk,sizeof(chunk),1,file)!=1) goto err;
1823: {
1824: int r,p;
1825: struct BitMap *bm = S->RastPort.BitMap;
1826: for(r=0; r<bm->Rows; ++r) for(p=0; p<bm->Depth; ++p)
1827: if(fwrite(bm->Planes[p] + r*bm->BytesPerRow, 2*((S->Width+15)/16), 1, file)!=1) goto err;
1828: }
1829:
1830: fclose(file);
1831: return 1;
1832: err:
1833: fprintf(stderr,"Error writing to \"%s\"\n",filename);
1834: fclose(file);
1835: return 0;
1836: }
1837:
1838: void write_log (const char *buf)
1839: {
1840: fprintf (stderr, buf);
1841: }
1842:
1843: /****************************************************************************/
1844: /* Here lies an algorithm to convert a 12bits truecolor buffer into a HAM
1845: * buffer. That algorithm is quite fast and if you study it closely, you'll
1846: * understand why there is no need for MMX cpu to subtract three numbers in
1847: * the same time. I can think of a quicker algorithm but it'll need 4096*4096
1848: * = 1<<24 = 16Mb of memory. That's why I'm quite proud of this one which
1849: * only need roughly 64Kb (could be reduced down to 40Kb, but it's not
1850: * worth as I use cidx as a buffer which is 128Kb long)..
1851: ****************************************************************************/
1852:
1853: static int dist4(LONG rgb1, LONG rgb2) /* computes distance very quickly */
1854: {
1855: int d = 0, t;
1856: t = (rgb1&0xF00)-(rgb2&0xF00); t>>=8; if (t<0) d -= t; else d += t;
1857: t = (rgb1&0x0F0)-(rgb2&0x0F0); t>>=4; if (t<0) d -= t; else d += t;
1858: t = (rgb1&0x00F)-(rgb2&0x00F); t>>=0; if (t<0) d -= t; else d += t;
1859: #if 0
1860: t = rgb1^rgb2;
1861: if(t&15) ++d; t>>=4;
1862: if(t&15) ++d; t>>=4;
1863: if(t&15) ++d;
1864: #endif
1865: return d;
1866: }
1867:
1868: #define d_dst (00000+(UBYTE*)cidx) /* let's use cidx as a buffer */
1869: #define d_cmd (16384+(UBYTE*)cidx)
1870: #define h_buf (32768+(UBYTE*)cidx)
1871:
1872: static int init_ham(void)
1873: {
1874: int i,t,RGB;
1875:
1876: /* try direct color first */
1877: for(RGB=0;RGB<4096;++RGB) {
1878: int c,d;
1879: c = d = 50;
1880: for(i=0;i<16;++i) {
1881: t = dist4(i*0x111, RGB);
1882: if(t<d) {
1883: d = t;
1884: c = i;
1885: }
1886: }
1887: i = (RGB&0x00F) | ((RGB&0x0F0)<<1) | ((RGB&0xF00)<<2);
1888: d_dst[i] = (d<<2)|3; /* the "|3" is a trick to speedup comparison */
1889: d_cmd[i] = c; /* in the conversion process */
1890: }
1891: /* then hold & modify */
1892: for(i=0;i<32768;++i) {
1893: int dr, dg, db, d, c;
1894: dr = (i>>10) & 0x1F; dr -= 0x10;if(dr<0) dr = -dr;
1895: dg = (i>>5) & 0x1F; dg -= 0x10;if(dg<0) dg = -dg;
1896: db = (i>>0) & 0x1F; db -= 0x10;if(db<0) db = -db;
1897: c = 0; d = 50;
1898: t = dist4(0, 0*256 + dg*16 + db); if(t < d) {d = t;c = 0;}
1899: t = dist4(0, dr*256 + 0*16 + db); if(t < d) {d = t;c = 1;}
1900: t = dist4(0, dr*256 + dg*16 + 0); if(t < d) {d = t;c = 2;}
1901: h_buf[i] = (d<<2) | c;
1902: }
1903: return 1;
1904: }
1905:
1906: /* great algorithm: convert trucolor into ham using precalc buffers */
1907: static void ham_conv(UWORD *src, UBYTE *buf, UWORD len)
1908: {
1909: /* A good compiler (ie. gcc :) will use bfext/bfins instructions */
1910: #ifdef __SASC
1911: union { struct { unsigned int _:17, r:5, g:5, b:5; } _;
1912: int all;} rgb, RGB;
1913: #else
1914: union { struct { UWORD _:1,r:5,g:5,b:5;} _; UWORD all;} rgb, RGB;
1915: #endif
1916: rgb.all = 0;
1917: while(len--) {
1918: UBYTE c,t;
1919: RGB.all = *src++;
1920: c = d_cmd[RGB.all];
1921: /* cowabonga! */
1922: t = h_buf[16912 + RGB.all - rgb.all];
1923: if(t<=d_dst[RGB.all]) {
1924: if(!(t&=3)) {c = 32; c |= (rgb._.r = RGB._.r);}
1925: else if(!--t) {c = 48; c |= (rgb._.g = RGB._.g);}
1926: else {c = 16; c |= (rgb._.b = RGB._.b);}
1927: } else rgb._.r = rgb._.g = rgb._.b = c;
1928: *buf++ = c;
1929: }
1930: }
1931:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.