![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ggi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to ggi.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * GGI - Interface
5: *
6: * Always remember: "GGI - The right thing to do[tm]"
7: *
8: * Copyright 1997 Christian Schmitt <[email protected]>,
9: * Stefan Reinauer <[email protected]>
10: */
11:
12: #include "sysconfig.h"
13: #include "sysdeps.h"
14:
15: #include <stdio.h>
16: #include <stdlib.h>
17: #include <time.h>
18: #include <unistd.h>
19: #include <ggi/libggi.h>
20: #include <ggi/libggi_db.h>
21: #include <ggi/events.h>
22: #include <string.h>
23:
24: #include "config.h"
25: #include "options.h"
26: #include "threaddep/penguin.h"
27: #include "uae.h"
28: #include "memory.h"
29: #include "custom.h"
30: #include "readcpu.h"
31: #include "newcpu.h"
32: #include "keyboard.h"
33: #include "xwin.h"
34: #include "keybuf.h"
35: #include "gui.h"
36: #include "picasso96.h"
37:
38: static ggi_visual_t vis;
39: static ggi_graphtype amiga_modetype;
40: static unsigned char pack[256];
41: static uae_u8 dither_buf[1000];
42: int buttonstate[3] = {0, 0, 0};
43: int lastmx,lastmy,newmousecounters=0;
44: static int keystate[256];
45:
46: int need_dither,bpp;
47: void *linear=NULL;
48:
49: static int screen_is_picasso;
50: static char picasso_invalid_lines[1200];
51: static ggi_graphtype picasso_modetype;
52:
53: struct bstring *video_mode_menu = NULL;
54:
55: /* We don't need a brkhandler with GGI */
56: void setup_brkhandler(void)
57: {
58: }
59:
60: #define MAX_SCREEN_MODES 6
61: #define MAX_GGI_COLOR_MODES 4
62:
63: int x_size_table[MAX_SCREEN_MODES]={320,640,640,800,1024,1152};
64: int y_size_table[MAX_SCREEN_MODES]={200,400,480,600,768,864};
65: ggi_graphtype color_table[MAX_GGI_COLOR_MODES]=
66: {GT_4BIT,GT_8BIT,GT_16BIT,GT_32BIT};
67:
68: static struct ggi_graphmodes{
69: int x;
70: int y;
71: int col;
72: struct ggi_graphmodes *next;
73: } got_modes;
74:
75:
76: int graphics_setup(void)
77: {
78: struct ggi_graphmodes *dummy;
79: int count=0;
80: char buf[80];
81: int i,j,c=0;
82:
83: ggiInit();
84:
85: if((vis=ggiOpen(NULL))==NULL) {
86: fprintf(stderr,"Can't open Visual\n");
87: return 0;
88: }
89:
90: for(i=0;i<MAX_SCREEN_MODES;i++) {
91: for(j=0;j<MAX_GGI_COLOR_MODES;j++) {
92: if (ggiCheckGraphMode(vis, x_size_table[i], y_size_table[i],
93: x_size_table[i], y_size_table[i],
94: color_table[j]) != 0)
95: continue;
96:
97: dummy=(struct ggi_graphmodes *)malloc(sizeof(struct ggi_graphmodes));
98: dummy->x=x_size_table[i];
99: dummy->y=y_size_table[i];
100: switch(color_table[j]) {
101: case GT_4BIT : c=4;break;
102: case GT_8BIT : c=8;break;
103: case GT_16BIT : c=16;break;
104: case GT_32BIT : c=32;break;
105: default : break; /* Ups */
106: }
107: dummy->col=c;
108: dummy->next=got_modes.next;
109: got_modes.next=dummy;
110: count++;
111: }
112: }
113: count++;
114: video_mode_menu = (struct bstring *)malloc(sizeof (struct bstring)*count);
115: memset(video_mode_menu, 0, sizeof (struct bstring)*count);
116: dummy=got_modes.next;
117: for (i = 0; i < count - 1; i++) {
118: sprintf(buf, "%3dx%d, %2d Bit", dummy->x, dummy->y,dummy->col);
119: video_mode_menu[i].val = -1;
120: video_mode_menu[i].data = strdup(buf);
121: dummy = dummy->next;
122: }
123: video_mode_menu[count-1].val = -3;
124: video_mode_menu[count-1].data = NULL;
125: return 1;
126: }
127:
128: void vidmode_menu_selected(int m)
129: {
130: int i;
131: struct ggi_graphmodes *dummy=got_modes.next;
132: for(i=1;i<=m;i++) dummy=dummy->next;
133: currprefs.gfx_width = dummy->x;
134: currprefs.gfx_height = dummy->y;
135: currprefs.color_mode = dummy->col == 32 ? 5 : dummy->col == 16 ? 2 : 0;
136: }
137:
138: static int colors_allocated;
139: static ggi_color map[256];
140: static ggi_color vga_map[256];
141:
142: static void restore_vga_colors (void)
143: {
144: int i;
145: if (gfxvidinfo.pixbytes != 1)
146: return;
147: memcpy (map, vga_map, sizeof map);
148: ggiSetPaletteVec(vis, 0, colors_allocated, map);
149: }
150:
151: static int get_color(int r, int g, int b, xcolnr *cnp)
152: {
153: if(colors_allocated == 255)
154: return -1;
155: *cnp = colors_allocated;
156: map[colors_allocated].r = doMask (r,16,0);
157: map[colors_allocated].g = doMask (g,16,0);
158: map[colors_allocated].b = doMask (b,16,0);
159:
160: colors_allocated++;
161: return 1;
162: }
163:
164: static void init_colors(void)
165: {
166: if (need_dither) {
167: setup_dither (8, get_color);
168: } else {
169: int i;
170: colors_allocated = 0;
171: gfxvidinfo.can_double = 0;
172: switch (bpp){
173: case 8:
174: alloc_colors256 (get_color);
175: ggiSetPaletteVec (vis, 0, colors_allocated, map);
176: memcpy (vga_map, map, sizeof vga_map);
177: for (i = 0; i < 4096;i++)
178: xcolors[i] *= 0x01010101;
179: gfxvidinfo.can_double=1;
180: break;
181: case 16:
182: alloc_colors64k (5, 6, 5, 11, 5, 0);
183: for(i = 0; i < 4096; i++)
184: xcolors[i] *= 0x00010001;
185: gfxvidinfo.can_double=1;
186: break;
187: case 32:
188: alloc_colors64k(8, 8, 8, 16, 8, 0);
189: break;
190: default:
191: break;
192: }
193: }
194: }
195:
196: static int set_amiga_mode (void)
197: {
198: int sx = gfxvidinfo.width;
199: int sy = gfxvidinfo.height;
200: ggi_directbuffer_t gbuf=NULL;
201: ggi_pixellinearbuffer *plb;
202:
203: ggiSetFocus(vis);
204:
205: if (ggiSetGraphMode (vis, sx, sy, sx, sy, amiga_modetype) != 0) {
206: fprintf(stderr,"Can't set graphics mode\n");
207: return 0;
208: }
209: ggiDBGetBuffer(vis,&gbuf);
210: plb=ggiDBGetPLB(gbuf);
211: linear = plb->write;
212: return 1;
213: }
214:
215: int graphics_init (void) /* See how simple it is? :-> */
216: {
217: int err,i;
218:
219: switch(currprefs.color_mode) {
220: case 0:
221: amiga_modetype = GT_8BIT;
222: need_dither = 0;
223: break;
224: case 1:
225: case 2:
226: amiga_modetype = GT_16BIT;
227: need_dither = 0;
228: break;
229: case 3:
230: amiga_modetype = GT_8BIT;
231: need_dither = 1;
232: break;
233: case 4:
234: amiga_modetype = GT_4BIT;
235: need_dither = 1;
236: break;
237: default:
238: fprintf(stderr, "Bad color mode selected. Using default.\n");
239: currprefs.color_mode = 0;
240: amiga_modetype = GT_8BIT;
241: break;
242: }
243:
244: gfxvidinfo.width = currprefs.gfx_width;
245: gfxvidinfo.height = currprefs.gfx_height;
246:
247: if (! set_amiga_mode ())
248: return 0;
249:
250: bpp = ggiGetBPP (vis);
251:
252: gfxvidinfo.pixbytes = bpp >> 3;
253: gfxvidinfo.rowbytes = gfxvidinfo.pixbytes * currprefs.gfx_width;
254: if (linear != NULL)
255: gfxvidinfo.bufmem = linear;
256: else
257: gfxvidinfo.bufmem = (char *)malloc (gfxvidinfo.rowbytes * currprefs.gfx_height);
258: gfxvidinfo.maxblocklines = 0;
259: memset (gfxvidinfo.bufmem, 0, gfxvidinfo.rowbytes * currprefs.gfx_height);
260:
261: screen_is_picasso = 0;
262:
263: for (i = 0; i < 256; i++) {
264: map[i].r=i;
265: map[i].g=i;
266: map[i].b=i;
267: }
268: ggiPackColors(vis, pack, map, 256);
269: init_colors ();
270:
271: buttonstate[0] = buttonstate[1] = buttonstate[2] = 0;
272: for (i = 0; i < 256; i++)
273: keystate[i] = 0;
274: lastmx = lastmy = 0;
275: return 1;
276: }
277:
278: void graphics_leave(void)
279: {
280: ggiClose (vis);
281: ggiExit ();
282: }
283:
284: void flush_line(int y)
285: {
286: int target_y = y;
287: int bit_unit=8;
288: int i=0;
289: char *addr;
290:
291: if (linear != NULL && !need_dither)
292: return;
293:
294: addr = gfxvidinfo.bufmem + y*gfxvidinfo.rowbytes;
295: if (target_y < 400 && target_y >= 0) {
296: if (need_dither) {
297: if (linear == NULL){
298: DitherLine (dither_buf, (uae_u16 *)addr, 0, y,
299: gfxvidinfo.width, bit_unit);
300: addr = dither_buf;
301: ggiPutHLine (vis, 0, target_y, gfxvidinfo.width, addr);
302: } else {
303: DitherLine (linear + gfxvidinfo.rowbytes*y, (uae_u16 *)addr, 0, y,
304: gfxvidinfo.width, bit_unit);
305: }
306: return;
307: }
308: if(linear==NULL)
309: ggiPutHLine(vis, 0, target_y, gfxvidinfo.width, addr);
310: }
311: }
312:
313: void flush_block(int a, int b){};
314: void flush_screen(int a, int b){};
315:
316: #define KEY_NOTHING 0x00
317: #define AK_QUIT 0xf00
318:
319: /* We should not need to have different versions for different keyboard */
320: static short decodekey[128]={
321: KEY_NOTHING, /* 0 */
322: AK_ESC,
323: AK_1, AK_2, AK_3, AK_4, AK_5, AK_6, AK_7, AK_8, AK_9, AK_0,
324: AK_MINUS, /* 12 */
325: AK_EQUAL,
326: AK_BS,
327: AK_TAB, /* 0x0f */
328: AK_Q, AK_W, AK_E, AK_R, AK_T,
329: AK_Y, /* 0x15 Attention: language specific !!!! */
330: AK_U, AK_I, AK_O, AK_P, AK_LBRACKET,
331: AK_RBRACKET, /* 0x1b */
332: AK_RET,
333: AK_CTRL,
334: AK_A, AK_S, AK_D, AK_F, AK_G, AK_H, AK_J, AK_K, AK_L,
335: AK_SEMICOLON, /* 0x27 */
336: AK_QUOTE, /* ä 0x28 */
337: KEY_NOTHING,
338: AK_LSH, /* 0x2a */
339: AK_LTGT, /* < 0x2b Attention: language specific !!!! */
340: AK_Z, /* 0x2c Attention: language specific !!!! */
341: AK_X, AK_C, AK_V, AK_B, AK_N, AK_M, AK_COMMA, AK_PERIOD,
342: AK_SLASH, /* 0x35 */
343: AK_RSH, /* 0x36 */
344: AK_NPMUL,
345: AK_LALT,
346: AK_SPC,
347: AK_CAPSLOCK, /* 0x3a */
348: AK_F1, AK_F2, AK_F3, AK_F4, AK_F5, AK_F6, AK_F7, AK_F8, AK_F9,
349: AK_F10, /* 0x44 */
350: KEY_NOTHING, /* NumLock */
351: KEY_NOTHING, /* "Rollen" */
352: AK_NP7, /* 0x47 */
353: AK_NP8,
354: AK_NP9,
355: AK_NPSUB, /* 0x4a */
356: AK_NP4,
357: AK_NP5,
358: AK_NP6,
359: AK_NPADD, /* 0x4e */
360: AK_NP1,
361: AK_NP2,
362: AK_NP3,
363: AK_NP0, /* 0x52 */
364: AK_NPDEL,
365: KEY_NOTHING, /* ??? */
366: KEY_NOTHING, /* ??? */
367: KEY_NOTHING, /* ??? */
368: AK_BS, /* 0x57 --> F11 */
369: AK_QUIT, /* 0x58 --> F12 */
370: KEY_NOTHING, /* ??? */
371: KEY_NOTHING, /* ??? */
372: KEY_NOTHING, /* ??? */
373: KEY_NOTHING, /* ??? */
374: KEY_NOTHING, /* ??? */
375: KEY_NOTHING, /* ??? */
376: KEY_NOTHING, /* ??? */
377: AK_ENT, /* 0x60 */
378: AK_RCTRL, /* 0x61 */
379: AK_NPDIV,
380: KEY_NOTHING,
381: AK_RALT, /* 0x64 */
382: KEY_NOTHING, /* ??? */
383: AK_NP7, /* Pos1 */
384: AK_UP, /* 0x67 */
385: AK_LAMI, /* 0x68 --> PgUp, */
386: AK_LF, /* 0x69 */
387: AK_RT, /* 0x6a */
388: AK_NP1, /* End */
389: AK_DN, /* 0x6c */
390: AK_RAMI, /* --> PgDown */
391: AK_HELP, /* 0x6e --> insert */
392: AK_DEL,
393: KEY_NOTHING,
394: KEY_NOTHING,
395: KEY_NOTHING,
396: KEY_NOTHING,
397: KEY_NOTHING,
398: KEY_NOTHING,
399: KEY_NOTHING,
400: KEY_NOTHING, /* 0x77 --> Pause */
401: KEY_NOTHING,
402: KEY_NOTHING,
403: KEY_NOTHING,
404: KEY_NOTHING,
405: KEY_NOTHING,
406: AK_LAMI, /* 0x7d --> WindOoze left */
407: AK_RAMI, /* --> WindOoze right */
408: AK_CTRL /* 0x7f --> WindOoze Menu */
409: };
410:
411: void handle_events (void)
412: {
413: struct timeval t={0,1};
414: ggi_event ev;
415: ggi_event_mask mask;
416: int akey;
417: uint32 state=0,button=0;
418: while(ggiEventPoll(vis,emPtrButton|emPtrRelative|emKey,&t)) {
419: ggiEventRead(vis,&ev,emPtrButton|emPtrRelative|emKey);
420: switch(ev.any.type){
421: case evPtrButtonPress:
422: case evPtrButtonRelease:
423: state=ev.pbutton.state;
424: button=ev.pbutton.button;
425: switch(button) {
426: case 1 : buttonstate[2]=state&button;break;
427: case 2 : buttonstate[0]=(state&button)>>1;break;
428: case 4 : buttonstate[1]=(state&button)>>2;break;
429: default: break;
430: }
431: break;
432: case evPtrRelative:
433: lastmx+=ev.pmove.x;
434: lastmy+=ev.pmove.y;
435: break;
436: case evKeyPress:
437: case evKeyRelease:
438: if(ev.key.sym==0) continue;
439: if(ev.key.code>128) return;
440: akey=decodekey[ev.key.code];
441: if(akey==0xf00) uae_quit();
442: if(keystate[AK_CTRL] && keystate[AK_LAMI] && keystate[AK_RAMI])
443: m68k_reset();
444: switch(ev.key.type) {
445: case 6 : keystate[akey]=0;
446: record_key((akey << 1) | 1);
447: break;
448: case 5 : if(akey==KEY_NOTHING) break;
449: if(!keystate[akey]) {
450: keystate[akey]=1;
451: record_key(akey << 1);
452: }
453: break;
454: default : break;
455: }
456: default:
457: printf("Ugh\n");
458: }
459: }
460:
461:
462:
463: #ifdef PICASSO96
464: if (screen_is_picasso && !picasso_vidinfo.extra_mem) {
465: int i;
466: char *addr = gfxmemory + (picasso96_state.Address - gfxmem_start);
467: for (i = 0; i < picasso_vidinfo.height; i++, addr += picasso96_state.BytesPerRow) {
468: if (!picasso_invalid_lines[i])
469: continue;
470: picasso_invalid_lines[i] = 0;
471: ggiPutHLine (vis, 0, i, gfxvidinfo.width, addr);
472: }
473: }
474: #endif
475:
476: return;
477: }
478:
479: void write_log(const char *buf)
480: {
481: fprintf(stderr,buf);
482: }
483:
484: int debuggable(void)
485: {
486: return 0;
487: }
488:
489: int needmousehack(void)
490: {
491: return 0;
492: }
493:
494: /* This is not implemented yet as GGI is not that far */
495: void LED(int on)
496: {
497: }
498:
499: #ifdef PICASSO96
500:
501: void DX_Invalidate (int first, int last)
502: {
503: do {
504: picasso_invalid_lines[first] = 1;
505: first++;
506: } while (first <= last);
507: }
508:
509: int DX_BitsPerCannon (void)
510: {
511: return 8;
512: }
513:
514: void DX_SetPalette(int start, int count)
515: {
516: int i;
517:
518: if (!screen_is_picasso || picasso_vidinfo.pixbytes != 1)
519: return;
520:
521: fprintf (stderr, "DX_SetPalette\n");
522:
523: for (i = 0; i < count; i++) {
524: map[start + i].r = picasso96_state.CLUT[start + i].Red * 0x0101;
525: map[start + i].g = picasso96_state.CLUT[start + i].Green * 0x0101;
526: map[start + i].b = picasso96_state.CLUT[start + i].Blue * 0x0101;
527: }
528: ggiSetPaletteVec (vis, start, count, map + start);
529: }
530:
531: int DX_FillResolutions (uae_u16 *ppixel_format)
532: {
533: int i, count = 0;
534: uae_u16 format = 0;
535:
536: for (i = 0; i < MAX_SCREEN_MODES; i++) {
537: if (ggiCheckGraphMode (vis, x_size_table[i], y_size_table[i],
538: x_size_table[i], y_size_table[i],
539: GT_8BIT) == 0) {
540: DisplayModes[count].res.width = x_size_table[i];
541: DisplayModes[count].res.height = y_size_table[i];
542: DisplayModes[count].depth = 1;
543: DisplayModes[count].refresh = 75;
544: count++;
545: format |= RGBFF_CHUNKY;
546: }
547: if (ggiCheckGraphMode (vis, x_size_table[i], y_size_table[i],
548: x_size_table[i], y_size_table[i],
549: GT_16BIT) == 0) {
550: DisplayModes[count].res.width = x_size_table[i];
551: DisplayModes[count].res.height = y_size_table[i];
552: DisplayModes[count].depth = 2;
553: DisplayModes[count].refresh = 75;
554: count++;
555: format |= RGBFF_R5G6B5PC;
556: }
557: if (ggiCheckGraphMode (vis, x_size_table[i], y_size_table[i],
558: x_size_table[i], y_size_table[i],
559: GT_32BIT) == 0) {
560: DisplayModes[count].res.width = x_size_table[i];
561: DisplayModes[count].res.height = y_size_table[i];
562: DisplayModes[count].depth = 4;
563: DisplayModes[count].refresh = 75;
564: count++;
565: format |= RGBFF_B8G8R8A8;
566: }
567: }
568:
569: *ppixel_format = format;
570: return count;
571: }
572:
573: static void set_window_for_picasso (void)
574: {
575: int sx, sy;
576: ggi_directbuffer_t gbuf=NULL;
577: ggi_pixellinearbuffer *plb;
578:
579: sx = picasso_vidinfo.width;
580: sy = picasso_vidinfo.height;
581: fprintf (stderr, "picasso mode %d %d %d!\n", sx, sy, picasso_modetype);
582: if (ggiSetGraphMode (vis, sx, sy, sx, sy, picasso_modetype) != 0) {
583: fprintf (stderr,"Can't set graphics mode\n");
584: abort ();
585: }
586: fprintf (stderr, "picasso mode ok!\n");
587:
588: ggiDBGetBuffer(vis,&gbuf);
589: plb=ggiDBGetPLB(gbuf);
590: linear = plb->write;
591:
592: if (linear != NULL)
593: picasso_vidinfo.extra_mem = 1;
594: else
595: picasso_vidinfo.extra_mem = 0;
596: fprintf (stderr, "em: %d\n", picasso_vidinfo.extra_mem);
597: DX_SetPalette (0, 256);
598: }
599:
600: static void set_window_for_amiga (void)
601: {
602: set_amiga_mode ();
603: if (linear != NULL && !need_dither)
604: gfxvidinfo.bufmem = linear;
605:
606: restore_vga_colors ();
607: }
608:
609: void gfx_set_picasso_modeinfo (int w, int h, int depth)
610: {
611: fprintf (stderr, "set_picasso_modeinfo\n");
612: picasso_vidinfo.width = w;
613: picasso_vidinfo.height = h;
614: picasso_vidinfo.depth = depth;
615: picasso_vidinfo.pixbytes = depth >> 3;
616: picasso_vidinfo.rowbytes = w /* @@@ */;
617: picasso_modetype = (depth == 8 ? GT_8BIT
618: : depth == 16 ? GT_16BIT
619: : GT_32BIT);
620: if (screen_is_picasso)
621: set_window_for_picasso ();
622: }
623:
624: void gfx_set_picasso_baseaddr (uaecptr a)
625: {
626: }
627:
628: void gfx_set_picasso_state (int on)
629: {
630: if (on == screen_is_picasso)
631: return;
632: fprintf (stderr, "set_picasso_state\n");
633: screen_is_picasso = on;
634: if (on)
635: set_window_for_picasso ();
636: else
637: set_window_for_amiga ();
638: }
639:
640: uae_u8 *lockscr (void)
641: {
642: return linear;
643: }
644: void unlockscr (void)
645: {
646: }
647: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.