![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sdlgfx.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 sdlgfx.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * SDL interface
5: *
6: * Copyright 2001 Bernd Lachner (EMail: [email protected])
7: *
8: * Partialy based on the UAE X interface (xwin.c)
9: *
10: * Copyright 1995, 1996 Bernd Schmidt
11: * Copyright 1996 Ed Hanway, Andre Beck, Samuel Devulder, Bruno Coste
12: * Copyright 1998 Marcus Sundberg
13: * DGA support by Kai Kollmorgen
14: * X11/DGA merge, hotkeys and grabmouse by Marcus Sundberg
15: */
16:
17: #include "sysconfig.h"
18: #include "sysdeps.h"
19:
20: #include <unistd.h>
21: #include <signal.h>
22:
23: #include <SDL/SDL.h>
24: #include <SDL/SDL_endian.h>
25:
26: #include "config.h"
27: #include "options.h"
28: #include "uae.h"
29: #include "memory.h"
30: #include "xwin.h"
31: #include "custom.h"
32: #include "drawing.h"
33: #include "newcpu.h"
34: #include "keyboard.h"
35: #include "keybuf.h"
36: #include "gui.h"
37: #include "debug.h"
38: #include "picasso96.h"
39:
40: #define DEBUG
41: /* Uncomment for debugging output */
42: /* #define DEBUG */
43:
44: #ifdef __cplusplus
45: static RETSIGTYPE sigbrkhandler(...)
46: #else
47: static RETSIGTYPE sigbrkhandler (int foo)
48: #endif
49: {
50: activate_debugger();
51: #if !defined(__unix) || defined(__NeXT__)
52: signal (SIGINT, sigbrkhandler);
53: #endif
54: }
55:
56: void setup_brkhandler (void)
57: {
58: #if defined(__unix) && !defined(__NeXT__)
59: struct sigaction sa;
60: sa.sa_handler = sigbrkhandler;
61: sa.sa_flags = 0;
62: #ifdef SA_RESTART
63: sa.sa_flags = SA_RESTART;
64: #endif
65: sigemptyset (&sa.sa_mask);
66: sigaction (SIGINT, &sa, NULL);
67: #else
68: signal (SIGINT, sigbrkhandler);
69: #endif
70: }
71:
72: /* SDL variable for output surface */
73: static SDL_Surface *prSDLScreen = NULL;
74: /* Possible screen modes (x and y resolutions) */
75: #define MAX_SCREEN_MODES 11
76: static int x_size_table[MAX_SCREEN_MODES] = { 320, 320, 320, 320, 640, 640, 640, 800, 1024, 1152, 1280 };
77: static int y_size_table[MAX_SCREEN_MODES] = { 200, 240, 256, 400, 350, 480, 512, 600, 768, 864, 1024 };
78: /* Possible screen depth (0 terminated) */
79: static int aScreenDepth[] = {16, 15, 12, 0};
80:
81: static int red_bits, green_bits, blue_bits;
82: static int red_shift, green_shift, blue_shift;
83:
84: static int screen_is_picasso;
85: static char picasso_invalid_lines[1201];
86: static int picasso_has_invalid_lines;
87: static int picasso_invalid_start, picasso_invalid_stop;
88: static int picasso_maxw = 0, picasso_maxh = 0;
89:
90: static int bitdepth, bit_unit;
91:
92: static int current_width, current_height;
93: static SDL_Color arSDLColors[256];
94: static int ncolors = 0;
95:
96: /* Keyboard and mouse */
97: static int keystate[256];
98:
99: static void handle_mousegrab(void);
100: static void handle_inhibit(void);
101: static void framerate_up(void);
102: static void framerate_down(void);
103: static void togglefullscreen(void)
104: {
105: SDL_WM_ToggleFullScreen(prSDLScreen);
106: };
107:
108: static void handle_interpol (void);
109:
110: struct SDLHotKey
111: {
112: SDLKey aHotKeys[2];
113: void (*pfHandler)(void);
114: long aPressedKeys[2];
115: };
116:
117:
118: static struct SDLHotKey arHotKeys[] =
119: {
120: {{ SDLK_F12, SDLK_s}, togglefullscreen, {0, 0} },
121: {{ SDLK_F12, SDLK_q}, uae_quit, {0, 0} },
122: {{ SDLK_F12, SDLK_m}, togglemouse, {0, 0} },
123: {{ SDLK_F12, SDLK_g}, handle_mousegrab, {0, 0} },
124: {{ SDLK_F12, SDLK_i}, handle_inhibit, {0, 0} },
125: {{ SDLK_F12, SDLK_p}, handle_interpol, {0, 0} },
126: {{ SDLK_F12, SDLK_KP_PLUS}, framerate_up, {0, 0} },
127: {{ SDLK_F12, SDLK_KP_MINUS}, framerate_down, {0, 0} },
128: {{ 0, 0 }, NULL, {0, 0} } /* List must be terminated */
129: };
130:
131: void flush_line (int y)
132: {
133: /* Not implemented for SDL output */
134: #ifdef DEBUG
135: fprintf(stderr, "Function: flush_line\n");
136: #endif
137: }
138:
139: void flush_block (int ystart, int ystop)
140: {
141: #ifdef DEBUG
142: fprintf(stderr, "Function: flush_block %d %d\n", ystart, ystop);
143: #endif
144: SDL_UnlockSurface (prSDLScreen);
145: SDL_UpdateRect(prSDLScreen, 0, ystart, current_width, ystop-ystart+1);
146: SDL_LockSurface (prSDLScreen);
147: }
148:
149: void flush_screen (int ystart, int ystop)
150: {
151: #ifdef DEBUG
152: fprintf(stderr, "Function: flush_screen\n");
153: #endif
154:
155: #if 0
156: SDL_UpdateRect(prSDLScreen, 0, 0, current_width, current_height);
157: #endif
158: }
159:
160: STATIC_INLINE int bitsInMask (unsigned long mask)
161: {
162: /* count bits in mask */
163: int n = 0;
164: while (mask)
165: {
166: n += mask & 1;
167: mask >>= 1;
168: }
169: return n;
170: }
171:
172: STATIC_INLINE int maskShift (unsigned long mask)
173: {
174: /* determine how far mask is shifted */
175: int n = 0;
176: while (!(mask & 1))
177: {
178: n++;
179: mask >>= 1;
180: }
181: return n;
182: }
183:
184: static int get_color (int r, int g, int b, xcolnr *cnp)
185: {
186: #ifdef DEBUG
187: fprintf(stderr, "Function: get_color\n");
188: #endif
189:
190: *cnp = SDL_MapRGB(prSDLScreen->format, r, g, b);
191: arSDLColors[ncolors].r = r;
192: arSDLColors[ncolors].g = g;
193: arSDLColors[ncolors].b = b;
194:
195: ncolors++;
196: return 1;
197: }
198:
199: static int init_colors (void)
200: {
201: int i;
202:
203: #ifdef DEBUG
204: fprintf(stderr, "Function: init_colors\n");
205: #endif
206:
207: if (bitdepth > 8)
208: {
209: /* Truecolor: */
210: red_bits = bitsInMask(prSDLScreen->format->Rmask);
211: green_bits = bitsInMask(prSDLScreen->format->Gmask);
212: blue_bits = bitsInMask(prSDLScreen->format->Bmask);
213: red_shift = maskShift(prSDLScreen->format->Rmask);
214: green_shift = maskShift(prSDLScreen->format->Gmask);
215: blue_shift = maskShift(prSDLScreen->format->Bmask);
216: alloc_colors64k (red_bits, green_bits, blue_bits, red_shift, green_shift, blue_shift);
217: }
218: else
219: {
220: alloc_colors256 (get_color);
221: SDL_SetColors(prSDLScreen, arSDLColors, 0, 256);
222: }
223:
224: switch (gfxvidinfo.pixbytes)
225: {
226: case 2:
227: for (i = 0; i < 4096; i++)
228: xcolors[i] = xcolors[i] * 0x00010001;
229: gfxvidinfo.can_double = 1;
230: break;
231: case 1:
232: for (i = 0; i < 4096; i++)
233: xcolors[i] = xcolors[i] * 0x01010101;
234: gfxvidinfo.can_double = 1;
235: break;
236: default:
237: gfxvidinfo.can_double = 0;
238: break;
239: }
240: if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
241: {
242: switch (gfxvidinfo.pixbytes)
243: {
244: case 4:
245: for(i = 0; i < 4096; i++)
246: SDL_Swap32(xcolors[i]);
247: break;
248: case 2:
249: for (i = 0; i < 4096; i++)
250: SDL_Swap16(xcolors[i]);
251: break;
252: }
253: }
254: return 1;
255: }
256:
257: int graphics_setup (void)
258: {
259: #ifdef DEBUG
260: fprintf(stderr, "Function: graphics_setup\n");
261: #endif
262:
263: /* Initialize the SDL library */
264: if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
265: {
266: fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
267: return 0;
268: }
269:
270: return 1;
271: }
272:
273:
274: static void graphics_subinit (void)
275: {
276: int i, j;
277: Uint32 uiSDLVidModFlags;
278:
279: #ifdef DEBUG
280: fprintf(stderr, "Function: graphics_subinit\n");
281: #endif
282:
283: /* Open SDL Window in current mode */
284: uiSDLVidModFlags = SDL_SWSURFACE;
285: if (bitdepth == 8)
286: {
287: uiSDLVidModFlags |= SDL_HWPALETTE;
288: }
289: if (currprefs.gfx_afullscreen || currprefs.gfx_pfullscreen)
290: {
291: uiSDLVidModFlags |= SDL_FULLSCREEN;
292: }
293: fprintf(stderr, "Resolution: %d x %d x %d\n", current_width, current_height, bitdepth);
294:
295: prSDLScreen = SDL_SetVideoMode(current_width, current_height, bitdepth, uiSDLVidModFlags);
296: if (prSDLScreen == NULL)
297: {
298: fprintf(stderr, "Unable to set video mode: %s\n", SDL_GetError());
299: return;
300: }
301: else
302: {
303: #ifdef DEBUG
304: fprintf(stderr, "Bytes per Pixel: %d\n", prSDLScreen->format->BytesPerPixel);
305: fprintf(stderr, "Bytes per Line: %d\n", prSDLScreen->pitch);
306: #endif
307: SDL_LockSurface(prSDLScreen);
308: memset(prSDLScreen->pixels, 0xff, current_width * current_height * prSDLScreen->format->BytesPerPixel);
309: SDL_UnlockSurface(prSDLScreen);
310: SDL_UpdateRect(prSDLScreen, 0, 0, current_width, current_height);
311: /* Set UAE window title and icon name */
312: SDL_WM_SetCaption("UAE","UAE");
313: /* Hide mouse cursor */
314: SDL_ShowCursor(SDL_DISABLE);
315: /* Initialize structure for Amiga video modes */
316: gfxvidinfo.bufmem = prSDLScreen->pixels;
317: gfxvidinfo.linemem = 0;
318: gfxvidinfo.emergmem = 0;
319: gfxvidinfo.pixbytes = prSDLScreen->format->BytesPerPixel;
320: bit_unit = prSDLScreen->format->BytesPerPixel * 8;
321: gfxvidinfo.rowbytes = prSDLScreen->pitch;
322: gfxvidinfo.maxblocklines = 100;
323: gfxvidinfo.can_double = 0;
324: /* Initialize structure for Picasso96 video modes */
325: picasso_vidinfo.rowbytes = current_width * gfxvidinfo.pixbytes;
326: picasso_vidinfo.extra_mem = 1;
327: picasso_vidinfo.depth = bitdepth;
328: picasso_has_invalid_lines = 0;
329: picasso_invalid_start = picasso_vidinfo.height + 1;
330: picasso_invalid_stop = -1;
331: memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines);
332: }
333: lastmx = lastmy = 0;
334: newmousecounters = 0;
335: }
336:
337:
338: int graphics_init (void)
339: {
340: int i,j;
341:
342: #ifdef DEBUG
343: fprintf(stderr, "Function: graphics_init\n");
344: #endif
345:
346: if (currprefs.color_mode > 5)
347: fprintf (stderr, "Bad color mode selected. Using default.\n"), currprefs.color_mode = 0;
348:
349: screen_is_picasso = 0;
350:
351: fixup_prefs_dimensions (&currprefs);
352:
353:
354: gfxvidinfo.width = currprefs.gfx_width;
355: gfxvidinfo.height = currprefs.gfx_height;
356: current_width = currprefs.gfx_width;
357: current_height = currprefs.gfx_height;
358:
359: /* Find a SDL video mode with exact width and height */
360: for (i = 0; aScreenDepth[i] != 0; i++)
361: {
362: bitdepth = SDL_VideoModeOK(current_width, current_height, aScreenDepth[i], SDL_SWSURFACE);
363: if (bitdepth)
364: {
365: #ifdef DEBUG
366: fprintf(stderr, "Bit depth: %d\n", bitdepth);
367: #endif
368: break;
369: }
370: else
371: {
372: fprintf(stderr, "Video mode %dx%d@%d not available\n", current_width, current_height, aScreenDepth[i]);
373: }
374: }
375: if (bitdepth == 0)
376: {
377: /* Find a SDL video mode from standard resolutions */
378: for (j = 0; j < MAX_SCREEN_MODES && !bitdepth; j++)
379: {
380: if (x_size_table[j] < current_width || y_size_table[j] < current_height)
381: continue;
382: for (i = 0; aScreenDepth[i] != 0 && !bitdepth; i++)
383: {
384: bitdepth = SDL_VideoModeOK(x_size_table[j], y_size_table[j], aScreenDepth[i], SDL_SWSURFACE);
385: if (bitdepth)
386: {
387: #ifdef DEBUG
388: fprintf(stderr, "Bit depth: %d\n", bitdepth);
389: #endif
390: gfxvidinfo.width = current_width = x_size_table[j];
391: gfxvidinfo.height = current_height = y_size_table[j];
392: break;
393: }
394: else
395: {
396: fprintf(stderr, "Video mode %dx%d@%d not available\n", current_width, current_height, aScreenDepth[i]);
397: }
398: }
399: }
400: if (bitdepth == 0)
401: {
402: fprintf(stderr, "No video mode found!\n");
403: return 0;
404: }
405: }
406:
407: graphics_subinit ();
408:
409:
410: if (!init_colors ())
411: return 0;
412:
413: buttonstate[0] = buttonstate[1] = buttonstate[2] = 0;
414: for (i = 0; i < 256; i++)
415: keystate[i] = 0;
416:
417: return 1;
418: }
419:
420: static void graphics_subshutdown (void)
421: {
422: #ifdef DEBUG
423: fprintf(stderr, "Function: graphics_subshutdown\n");
424: #endif
425:
426: SDL_FreeSurface(prSDLScreen);
427: }
428:
429: void graphics_leave (void)
430: {
431: #ifdef DEBUG
432: fprintf(stderr, "Function: graphics_leave\n");
433: #endif
434:
435: graphics_subshutdown ();
436:
437: SDL_Quit();
438:
439: dumpcustom ();
440: }
441:
442: /* Decode KeySyms. This function knows about all keys that are common
443: * between different keyboard languages. */
444: static int kc_decode (SDL_keysym *prKeySym)
445: {
446: switch (prKeySym->sym)
447: {
448: case SDLK_b: return AK_B;
449: case SDLK_c: return AK_C;
450: case SDLK_d: return AK_D;
451: case SDLK_e: return AK_E;
452: case SDLK_f: return AK_F;
453: case SDLK_g: return AK_G;
454: case SDLK_h: return AK_H;
455: case SDLK_i: return AK_I;
456: case SDLK_j: return AK_J;
457: case SDLK_k: return AK_K;
458: case SDLK_l: return AK_L;
459: case SDLK_n: return AK_N;
460: case SDLK_o: return AK_O;
461: case SDLK_p: return AK_P;
462: case SDLK_r: return AK_R;
463: case SDLK_s: return AK_S;
464: case SDLK_t: return AK_T;
465: case SDLK_u: return AK_U;
466: case SDLK_v: return AK_V;
467: case SDLK_x: return AK_X;
468:
469: case SDLK_0: return AK_0;
470: case SDLK_1: return AK_1;
471: case SDLK_2: return AK_2;
472: case SDLK_3: return AK_3;
473: case SDLK_4: return AK_4;
474: case SDLK_5: return AK_5;
475: case SDLK_6: return AK_6;
476: case SDLK_7: return AK_7;
477: case SDLK_8: return AK_8;
478: case SDLK_9: return AK_9;
479:
480: case SDLK_KP0: return AK_NP0;
481: case SDLK_KP1: return AK_NP1;
482: case SDLK_KP2: return AK_NP2;
483: case SDLK_KP3: return AK_NP3;
484: case SDLK_KP4: return AK_NP4;
485: case SDLK_KP5: return AK_NP5;
486: case SDLK_KP6: return AK_NP6;
487: case SDLK_KP7: return AK_NP7;
488: case SDLK_KP8: return AK_NP8;
489: case SDLK_KP9: return AK_NP9;
490: case SDLK_KP_DIVIDE: return AK_NPDIV;
491: case SDLK_KP_MULTIPLY: return AK_NPMUL;
492: case SDLK_KP_MINUS: return AK_NPSUB;
493: case SDLK_KP_PLUS: return AK_NPADD;
494: case SDLK_KP_PERIOD: return AK_NPDEL;
495: case SDLK_KP_ENTER: return AK_ENT;
496:
497: case SDLK_F1: return AK_F1;
498: case SDLK_F2: return AK_F2;
499: case SDLK_F3: return AK_F3;
500: case SDLK_F4: return AK_F4;
501: case SDLK_F5: return AK_F5;
502: case SDLK_F6: return AK_F6;
503: case SDLK_F7: return AK_F7;
504: case SDLK_F8: return AK_F8;
505: case SDLK_F9: return AK_F9;
506: case SDLK_F10: return AK_F10;
507:
508: case SDLK_BACKSPACE: return AK_BS;
509: case SDLK_DELETE: return AK_DEL;
510: case SDLK_LCTRL: return AK_CTRL;
511: case SDLK_RCTRL: return AK_RCTRL;
512: case SDLK_TAB: return AK_TAB;
513: case SDLK_LALT: return AK_LALT;
514: case SDLK_RALT: return AK_RALT;
515: case SDLK_RMETA: return AK_RAMI;
516: case SDLK_LMETA: return AK_LAMI;
517: case SDLK_RETURN: return AK_RET;
518: case SDLK_SPACE: return AK_SPC;
519: case SDLK_LSHIFT: return AK_LSH;
520: case SDLK_RSHIFT: return AK_RSH;
521: case SDLK_ESCAPE: return AK_ESC;
522:
523: case SDLK_INSERT: return AK_HELP;
524: case SDLK_HOME: return AK_NPLPAREN;
525: case SDLK_END: return AK_NPRPAREN;
526: case SDLK_CAPSLOCK: return AK_CAPSLOCK;
527:
528: case SDLK_UP: return AK_UP;
529: case SDLK_DOWN: return AK_DN;
530: case SDLK_LEFT: return AK_LF;
531: case SDLK_RIGHT: return AK_RT;
532:
533: case SDLK_PAGEUP: return AK_RAMI; /* PgUp mapped to right amiga */
534: case SDLK_PAGEDOWN: return AK_LAMI; /* PgDn mapped to left amiga */
535:
536: default: return -1;
537: }
538: }
539:
540: static int decode_fr (SDL_keysym *prKeySym)
541: {
542: switch(prKeySym->sym)
543: {
544: /* FR specific */
545: case SDLK_a: return AK_Q;
546: case SDLK_m: return AK_SEMICOLON;
547: case SDLK_q: return AK_A;
548: case SDLK_y: return AK_Y;
549: case SDLK_w: return AK_Z;
550: case SDLK_z: return AK_W;
551: case SDLK_LEFTBRACKET: return AK_LBRACKET;
552: case SDLK_RIGHTBRACKET: return AK_RBRACKET;
553: case SDLK_COMMA: return AK_M;
554: case SDLK_LESS: case SDLK_GREATER: return AK_LTGT;
555: case SDLK_PERIOD: case SDLK_SEMICOLON: return AK_COMMA;
556: case SDLK_RIGHTPAREN: return AK_MINUS;
557: case SDLK_EQUALS: return AK_SLASH;
558: case SDLK_HASH: return AK_NUMBERSIGN;
559: case SDLK_SLASH: return AK_PERIOD;
560: case SDLK_MINUS: return AK_EQUAL;
561: case SDLK_BACKSLASH: return AK_BACKSLASH;
562: default: return -1;
563: }
564: }
565:
566: static int decode_us (SDL_keysym *prKeySym)
567: {
568: switch(prKeySym->sym)
569: {
570: /* US specific */
571: case SDLK_a: return AK_A;
572: case SDLK_m: return AK_M;
573: case SDLK_q: return AK_Q;
574: case SDLK_y: return AK_Y;
575: case SDLK_w: return AK_W;
576: case SDLK_z: return AK_Z;
577: case SDLK_LEFTBRACKET: return AK_LBRACKET;
578: case SDLK_RIGHTBRACKET: return AK_RBRACKET;
579: case SDLK_COMMA: return AK_COMMA;
580: case SDLK_PERIOD: return AK_PERIOD;
581: case SDLK_SLASH: return AK_SLASH;
582: case SDLK_SEMICOLON: return AK_SEMICOLON;
583: case SDLK_MINUS: return AK_MINUS;
584: case SDLK_EQUALS: return AK_EQUAL;
585: /* this doesn't work: */
586: case SDLK_BACKQUOTE: return AK_QUOTE;
587: case SDLK_QUOTE: return AK_BACKQUOTE;
588: case SDLK_BACKSLASH: return AK_BACKSLASH;
589: default: return -1;
590: }
591: }
592:
593: static int decode_de (SDL_keysym *prKeySym)
594: {
595: switch(prKeySym->sym)
596: {
597: /* DE specific */
598: case SDLK_a: return AK_A;
599: case SDLK_m: return AK_M;
600: case SDLK_q: return AK_Q;
601: case SDLK_w: return AK_W;
602: case SDLK_y: return AK_Z;
603: case SDLK_z: return AK_Y;
604: /* German umlaut oe */
605: case SDLK_WORLD_86: return AK_SEMICOLON;
606: /* German umlaut ae */
607: case SDLK_WORLD_68: return AK_QUOTE;
608: /* German umlaut ue */
609: case SDLK_WORLD_92: return AK_LBRACKET;
610: case SDLK_PLUS: case SDLK_ASTERISK: return AK_RBRACKET;
611: case SDLK_COMMA: return AK_COMMA;
612: case SDLK_PERIOD: return AK_PERIOD;
613: case SDLK_LESS: case SDLK_GREATER: return AK_LTGT;
614: case SDLK_HASH: return AK_NUMBERSIGN;
615: /* German sharp s */
616: case SDLK_WORLD_63: return AK_MINUS;
617: case SDLK_QUOTE: return AK_EQUAL;
618: case SDLK_CARET: return AK_BACKQUOTE;
619: case SDLK_MINUS: return AK_SLASH;
620: default: return -1;
621: }
622: }
623:
624: static int decode_se (SDL_keysym *prKeySym)
625: {
626: switch(prKeySym->sym)
627: {
628: /* SE specific */
629: case SDLK_a: return AK_A;
630: case SDLK_m: return AK_M;
631: case SDLK_q: return AK_Q;
632: case SDLK_w: return AK_W;
633: case SDLK_y: return AK_Y;
634: case SDLK_z: return AK_Z;
635: case SDLK_WORLD_86: return AK_SEMICOLON;
636: case SDLK_WORLD_68: return AK_QUOTE;
637: case SDLK_WORLD_69: return AK_LBRACKET;
638: case SDLK_COMMA: return AK_COMMA;
639: case SDLK_PERIOD: return AK_PERIOD;
640: case SDLK_MINUS: return AK_SLASH;
641: case SDLK_LESS: case SDLK_GREATER: return AK_LTGT;
642: case SDLK_PLUS: case SDLK_QUESTION: return AK_EQUAL;
643: case SDLK_AT: case SDLK_WORLD_29: return AK_BACKQUOTE;
644: case SDLK_CARET: return AK_RBRACKET;
645: case SDLK_BACKSLASH: return AK_MINUS;
646: case SDLK_HASH: return AK_NUMBERSIGN;
647: default: return -1;
648: }
649: }
650:
651: static int decode_it (SDL_keysym *prKeySym)
652: {
653: switch(prKeySym->sym)
654: {
655: /* IT specific */
656: case SDLK_a: return AK_A;
657: case SDLK_m: return AK_M;
658: case SDLK_q: return AK_Q;
659: case SDLK_w: return AK_W;
660: case SDLK_y: return AK_Y;
661: case SDLK_z: return AK_Z;
662: case SDLK_WORLD_82: return AK_SEMICOLON;
663: case SDLK_WORLD_64: return AK_QUOTE;
664: case SDLK_WORLD_72: return AK_LBRACKET;
665: case SDLK_PLUS: case SDLK_ASTERISK: return AK_RBRACKET;
666: case SDLK_COMMA: return AK_COMMA;
667: case SDLK_PERIOD: return AK_PERIOD;
668: case SDLK_LESS: case SDLK_GREATER: return AK_LTGT;
669: case SDLK_BACKSLASH: return AK_BACKQUOTE;
670: case SDLK_QUOTE: return AK_MINUS;
671: case SDLK_WORLD_76: return AK_EQUAL;
672: case SDLK_MINUS: return AK_SLASH;
673: case SDLK_HASH: return AK_NUMBERSIGN;
674: default: return -1;
675: }
676: }
677:
678: static int decode_es (SDL_keysym *prKeySym)
679: {
680: switch(prKeySym->sym)
681: {
682: /* ES specific */
683: case SDLK_a: return AK_A;
684: case SDLK_m: return AK_M;
685: case SDLK_q: return AK_Q;
686: case SDLK_w: return AK_W;
687: case SDLK_y: return AK_Y;
688: case SDLK_z: return AK_Z;
689: case SDLK_WORLD_81: return AK_SEMICOLON;
690: case SDLK_PLUS: case SDLK_ASTERISK: return AK_RBRACKET;
691: case SDLK_COMMA: return AK_COMMA;
692: case SDLK_PERIOD: return AK_PERIOD;
693: case SDLK_LESS: case SDLK_GREATER: return AK_LTGT;
694: case SDLK_BACKSLASH: return AK_BACKQUOTE;
695: case SDLK_QUOTE: return AK_MINUS;
696: case SDLK_WORLD_76: return AK_EQUAL;
697: case SDLK_MINUS: return AK_SLASH;
698: case SDLK_HASH: return AK_NUMBERSIGN;
699: default: return -1;
700: }
701: }
702:
703: static int keycode2amiga(SDL_keysym *prKeySym)
704: {
705: int iAmigaKeycode = kc_decode(prKeySym);
706: if (iAmigaKeycode == -1)
707: {
708: switch (currprefs.keyboard_lang)
709: {
710: case KBD_LANG_FR:
711: return decode_fr(prKeySym);
712: case KBD_LANG_US:
713: return decode_us(prKeySym);
714: case KBD_LANG_DE:
715: return decode_de(prKeySym);
716: case KBD_LANG_SE:
717: return decode_se (prKeySym);
718: case KBD_LANG_IT:
719: return decode_it (prKeySym);
720: case KBD_LANG_ES:
721: return decode_es (prKeySym);
722: default:
723: return -1;
724: }
725: }
726: return iAmigaKeycode;
727: }
728:
729: static int refresh_necessary = 0;
730:
731: void handle_events (void)
732: {
733: SDL_Event rEvent;
734: int iAmigaKeyCode;
735: int i, j;
736: int iIsHotKey = 0;
737: #ifdef DEBUG
738: fprintf(stderr, "Function: handle_events\n");
739: #endif
740:
741: /* Handle GUI events */
742: gui_handle_events ();
743:
744: while (SDL_PollEvent(&rEvent))
745: {
746: switch (rEvent.type)
747: {
748: case SDL_QUIT:
749: #ifdef DEBUG
750: fprintf(stderr, "Event: quit\n");
751: #endif
752: uae_quit();
753: break;
754: case SDL_KEYDOWN:
755: #ifdef DEBUG
756: fprintf(stderr, "Event: key down\n");
757: #endif
758: /* Check for hotkey sequence */
759: i = 0;
760: while (arHotKeys[i].pfHandler != NULL)
761: {
762: if (rEvent.key.keysym.sym == arHotKeys[i].aHotKeys[0])
763: {
764: arHotKeys[i].aPressedKeys[0] = 1;
765: iIsHotKey = 1;
766: }
767: if (arHotKeys[i].aPressedKeys[0] == 1 &&
768: rEvent.key.keysym.sym == arHotKeys[i].aHotKeys[1])
769: {
770: arHotKeys[i].aPressedKeys[1] = 1;
771: arHotKeys[i].pfHandler();
772: iIsHotKey = 1;
773: }
774: i++;
775: }
776: if (iIsHotKey == 0)
777: {
778: /* No hotkey sequence */
779: iAmigaKeyCode = keycode2amiga(&(rEvent.key.keysym));
780: if (iAmigaKeyCode >= 0)
781: {
782: if (!keystate[iAmigaKeyCode])
783: {
784: keystate[iAmigaKeyCode] = 1;
785: record_key(iAmigaKeyCode << 1);
786: }
787: }
788: }
789: break;
790: case SDL_KEYUP:
791: #ifdef DEBUG
792: fprintf(stderr, "Event: key up\n");
793: #endif
794: /* Check for hotkey sequence */
795: i = 0;
796: while (arHotKeys[i].pfHandler != NULL)
797: {
798: for (j = 0; j < 2; j++)
799: {
800: if (rEvent.key.keysym.sym == arHotKeys[i].aHotKeys[j] &&
801: arHotKeys[i].aPressedKeys[j] == 1)
802: {
803: arHotKeys[i].aPressedKeys[j] = 0;
804: iIsHotKey = 1;
805: }
806: }
807: i++;
808: }
809: if (iIsHotKey == 0)
810: {
811: iAmigaKeyCode = keycode2amiga(&(rEvent.key.keysym));
812: if (iAmigaKeyCode >= 0)
813: {
814: keystate[iAmigaKeyCode] = 0;
815: record_key((iAmigaKeyCode << 1) | 1);
816: }
817: }
818: break;
819: case SDL_MOUSEBUTTONDOWN:
820: #ifdef DEBUG
821: fprintf(stderr, "Event: mouse button down\n");
822: #endif
823: buttonstate[rEvent.button.button-1] = 1;
824: break;
825: case SDL_MOUSEBUTTONUP:
826: #ifdef DEBUG
827: fprintf(stderr, "Event: mouse button up\n");
828: #endif
829: buttonstate[rEvent.button.button-1] = 0;
830: break;
831: case SDL_MOUSEMOTION:
832: #ifdef DEBUG
833: fprintf(stderr, "Event: mouse motion\n");
834: #endif
835: newmousecounters = 1;
836: lastmx += rEvent.motion.xrel;
837: lastmy += rEvent.motion.yrel;
838: break;
839: }
840: }
841: #if defined PICASSO96
842: if (screen_is_picasso && refresh_necessary)
843: {
844: SDL_UpdateRect(prSDLScreen, 0, 0, picasso_vidinfo.width, picasso_vidinfo.height);
845: refresh_necessary = 0;
846: memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines);
847: }
848: else if (screen_is_picasso && picasso_has_invalid_lines)
849: {
850: int i;
851: int strt = -1;
852: picasso_invalid_lines[picasso_vidinfo.height] = 0;
853: for (i = picasso_invalid_start; i < picasso_invalid_stop + 2; i++)
854: {
855: if (picasso_invalid_lines[i])
856: {
857: picasso_invalid_lines[i] = 0;
858: if (strt != -1)
859: continue;
860: strt = i;
861: }
862: else
863: {
864: if (strt == -1)
865: continue;
866: SDL_UpdateRect(prSDLScreen, 0, strt, picasso_vidinfo.width, i-strt);
867: strt = -1;
868: }
869: }
870: if (strt != -1)
871: abort ();
872: }
873: picasso_has_invalid_lines = 0;
874: picasso_invalid_start = picasso_vidinfo.height + 1;
875: picasso_invalid_stop = -1;
876: #endif
877:
878: /* Handle UAE reset */
879: if ((keystate[AK_CTRL] || keystate[AK_RCTRL]) && keystate[AK_LAMI] && keystate[AK_RAMI])
880: uae_reset ();
881: }
882:
883: int check_prefs_changed_gfx (void)
884: {
885:
886: if (changed_prefs.gfx_width != currprefs.gfx_width
887: || changed_prefs.gfx_height != currprefs.gfx_height)
888: {
889: fixup_prefs_dimensions (&changed_prefs);
890: }
891:
892: if (changed_prefs.gfx_width == currprefs.gfx_width
893: && changed_prefs.gfx_height == currprefs.gfx_height
894: && changed_prefs.gfx_lores == currprefs.gfx_lores
895: && changed_prefs.gfx_linedbl == currprefs.gfx_linedbl
896: && changed_prefs.gfx_correct_aspect == currprefs.gfx_correct_aspect
897: && changed_prefs.gfx_xcenter == currprefs.gfx_xcenter
898: && changed_prefs.gfx_ycenter == currprefs.gfx_ycenter
899: && changed_prefs.gfx_afullscreen == currprefs.gfx_afullscreen
900: && changed_prefs.gfx_pfullscreen == currprefs.gfx_pfullscreen)
901: {
902: return 0;
903: }
904: #ifdef DEBUG
905: fprintf(stderr, "Function: check_prefs_changed_gfx\n");
906: #endif
907: graphics_subshutdown ();
908: currprefs.gfx_width = changed_prefs.gfx_width;
909: currprefs.gfx_height = changed_prefs.gfx_height;
910: currprefs.gfx_lores = changed_prefs.gfx_lores;
911: currprefs.gfx_linedbl = changed_prefs.gfx_linedbl;
912: currprefs.gfx_correct_aspect = changed_prefs.gfx_correct_aspect;
913: currprefs.gfx_xcenter = changed_prefs.gfx_xcenter;
914: currprefs.gfx_ycenter = changed_prefs.gfx_ycenter;
915: currprefs.gfx_afullscreen = changed_prefs.gfx_afullscreen;
916: currprefs.gfx_pfullscreen = changed_prefs.gfx_pfullscreen;
917:
918: gui_update_gfx ();
919:
920: graphics_subinit ();
921:
922: /* if (! inwindow)
923: XWarpPointer (display, None, mywin, 0, 0, 0, 0,
924: current_width / 2, current_height / 2);
925: */
926: notice_screen_contents_lost ();
927: init_row_map ();
928: if (screen_is_picasso)
929: picasso_enablescreen (1);
930: return 0;
931: }
932:
933: int debuggable (void)
934: {
935: return 1;
936: }
937:
938: int needmousehack (void)
939: {
940: return 1;
941: }
942:
943: void LED (int on)
944: {
945: #if 0 /* Maybe that is responsible for the joystick emulation problems on SunOS? */
946: static int last_on = -1;
947: XKeyboardControl control;
948:
949: if (last_on == on)
950: return;
951: last_on = on;
952: control.led = 1; /* implementation defined */
953: control.led_mode = on ? LedModeOn : LedModeOff;
954: XChangeKeyboardControl(display, KBLed | KBLedMode, &control);
955: #endif
956: }
957:
958: #ifdef PICASSO96
959:
960: void DX_Invalidate (int first, int last)
961: {
962: #ifdef DEBUG
963: fprintf(stderr, "Function: DX_Invalidate %i - %i\n", first, last);
964: #endif
965:
966: if (first > last)
967: return;
968:
969: picasso_has_invalid_lines = 1;
970: if (first < picasso_invalid_start)
971: picasso_invalid_start = first;
972: if (last > picasso_invalid_stop)
973: picasso_invalid_stop = last;
974:
975: while (first <= last)
976: {
977: picasso_invalid_lines[first] = 1;
978: first++;
979: }
980: }
981:
982: int DX_BitsPerCannon (void)
983: {
984: return 8;
985: }
986:
987: static int palette_update_start=256;
988: static int palette_update_end=0;
989:
990: void DX_SetPalette (int start, int count)
991: {
992: #ifdef DEBUG
993: fprintf(stderr, "Function: DX_SetPalette_real\n");
994: #endif
995:
996: if (! screen_is_picasso || picasso96_state.RGBFormat != RGBFB_CHUNKY)
997: return;
998:
999: if (picasso_vidinfo.pixbytes != 1)
1000: {
1001: /* This is the case when we're emulating a 256 color display. */
1002: while (count-- > 0)
1003: {
1004: int r = picasso96_state.CLUT[start].Red;
1005: int g = picasso96_state.CLUT[start].Green;
1006: int b = picasso96_state.CLUT[start].Blue;
1007: picasso_vidinfo.clut[start++] = (doMask256 (r, red_bits, red_shift)
1008: | doMask256 (g, green_bits, green_shift)
1009: | doMask256 (b, blue_bits, blue_shift));
1010: }
1011: return;
1012: }
1013:
1014: while (count-- > 0)
1015: {
1016: #if 0
1017: XColor col = parsed_xcolors[start];
1018: col.red = picasso96_state.CLUT[start].Red * 0x0101;
1019: col.green = picasso96_state.CLUT[start].Green * 0x0101;
1020: col.blue = picasso96_state.CLUT[start].Blue * 0x0101;
1021: XStoreColor (display, cmap, &col);
1022: #endif
1023: start++;
1024: }
1025: }
1026:
1027: int DX_FillResolutions (uae_u16 *ppixel_format)
1028: {
1029: int i, count = 0;
1030: int w = 0;
1031: int h = 0;
1032: int emulate_chunky = 0;
1033:
1034: #ifdef DEBUG
1035: fprintf(stderr, "Function: DX_FillResolutions\n");
1036: #endif
1037:
1038: /* Find out, which is the highest resolution the SDL can offer */
1039: for (i = MAX_SCREEN_MODES-1; i>=0; i--)
1040: {
1041: if (bitdepth == SDL_VideoModeOK(x_size_table[i], y_size_table[i], bitdepth, SDL_SWSURFACE))
1042: {
1043: w = x_size_table[i];
1044: h = y_size_table[i];
1045: break;
1046: }
1047: }
1048:
1049: #ifdef DEBUG
1050: fprintf(stderr, "Max. Picasso screen size: %d x %d\n", w, h);
1051: #endif
1052:
1053: picasso_vidinfo.rgbformat = (bit_unit == 8 ? RGBFB_CHUNKY
1054: : bitdepth == 15 && bit_unit == 16 ? RGBFB_R5G5B5PC
1055: : bitdepth == 16 && bit_unit == 16 ? RGBFB_R5G6B5PC
1056: : bit_unit == 24 ? RGBFB_B8G8R8
1057: : bit_unit == 32 ? RGBFB_B8G8R8A8
1058: : RGBFB_NONE);
1059:
1060: *ppixel_format = 1 << picasso_vidinfo.rgbformat;
1061: if (bit_unit == 16 || bit_unit == 32)
1062: {
1063: *ppixel_format |= RGBFF_CHUNKY;
1064: emulate_chunky = 1;
1065: }
1066:
1067: for (i = 0; i < MAX_SCREEN_MODES && count < MAX_PICASSO_MODES; i++)
1068: {
1069: int j;
1070: for (j = 0; j <= emulate_chunky && count < MAX_PICASSO_MODES; j++)
1071: {
1072: if (x_size_table[i] <= w && y_size_table[i] <= h)
1073: {
1074: if (x_size_table[i] > picasso_maxw)
1075: picasso_maxw = x_size_table[i];
1076: if (y_size_table[i] > picasso_maxh)
1077: picasso_maxh = y_size_table[i];
1078: DisplayModes[count].res.width = x_size_table[i];
1079: DisplayModes[count].res.height = y_size_table[i];
1080: DisplayModes[count].depth = j == 1 ? 1 : bit_unit >> 3;
1081: DisplayModes[count].refresh = 75;
1082: #ifdef DEBUG
1083: fprintf(stderr, "Picasso resolution %d x %d @ %d allowed\n", DisplayModes[count].res.width, DisplayModes[count].res.height, DisplayModes[count].depth);
1084: #endif
1085:
1086: count++;
1087: }
1088: }
1089: }
1090: #ifdef DEBUG
1091: fprintf(stderr, "Max. Picasso screen size: %d x %d\n", picasso_maxw, picasso_maxh);
1092: #endif
1093: return count;
1094: }
1095:
1096: static void set_window_for_picasso (void)
1097: {
1098: #ifdef DEBUG
1099: fprintf(stderr, "Function: set_window_for_picasso\n");
1100: #endif
1101:
1102: if (current_width == picasso_vidinfo.width && current_height == picasso_vidinfo.height)
1103: return;
1104:
1105: current_width = picasso_vidinfo.width;
1106: current_height = picasso_vidinfo.height;
1107: // XResizeWindow (display, mywin, current_width, current_height);
1108: }
1109:
1110: void gfx_set_picasso_modeinfo (int w, int h, int depth, int rgbfmt)
1111: {
1112: #ifdef DEBUG
1113: fprintf(stderr, "Function: gfx_set_picasso_modeinfo w: %i h: %i depth: %i rgbfmt: %i\n",w, h, depth, rgbfmt);
1114: #endif
1115:
1116: picasso_vidinfo.width = w;
1117: picasso_vidinfo.height = h;
1118: picasso_vidinfo.depth = depth;
1119: picasso_vidinfo.pixbytes = bit_unit >> 3;
1120: if (screen_is_picasso)
1121: set_window_for_picasso();
1122: }
1123:
1124: void gfx_set_picasso_baseaddr (uaecptr a)
1125: {
1126: }
1127:
1128: void gfx_set_picasso_state (int on)
1129: {
1130: #ifdef DEBUG
1131: fprintf(stderr, "Function: gfx_set_picasso_state\n");
1132: #endif
1133:
1134: if (on == screen_is_picasso)
1135: return;
1136: graphics_subshutdown ();
1137: screen_is_picasso = on;
1138: if (on)
1139: {
1140: // Set height, width for Picasso gfx
1141: current_width = picasso_vidinfo.width;
1142: current_height = picasso_vidinfo.height;
1143: }
1144: else
1145: {
1146: // Set height, width for Amiga gfx
1147: current_width = gfxvidinfo.width;
1148: current_height = gfxvidinfo.height;
1149: }
1150: graphics_subinit ();
1151: if (on)
1152: DX_SetPalette (0, 256);
1153: }
1154:
1155: uae_u8 *gfx_lock_picasso (void)
1156: {
1157: #ifdef DEBUG
1158: fprintf(stderr, "Function: gfx_lock_picasso\n");
1159: #endif
1160: SDL_LockSurface(prSDLScreen);
1161: return prSDLScreen->pixels;
1162: }
1163:
1164: void gfx_unlock_picasso (void)
1165: {
1166: #ifdef DEBUG
1167: fprintf(stderr, "Function: gfx_unlock_picasso\n");
1168: #endif
1169: SDL_UnlockSurface(prSDLScreen);
1170: }
1171: #endif
1172:
1173: int lockscr (void)
1174: {
1175: #ifdef DEBUG
1176: fprintf(stderr, "Function: lockscr\n");
1177: #endif
1178: SDL_LockSurface(prSDLScreen);
1179: return 1;
1180: }
1181:
1182: void unlockscr (void)
1183: {
1184: #ifdef DEBUG
1185: fprintf(stderr, "Function: unlockscr\n");
1186: #endif
1187: SDL_UnlockSurface(prSDLScreen);
1188: }
1189:
1190: static void handle_mousegrab (void)
1191: {
1192: if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
1193: {
1194: SDL_WM_GrabInput(SDL_GRAB_ON);
1195: SDL_WarpMouse(0, 0);
1196: }
1197: else
1198: {
1199: SDL_WM_GrabInput(SDL_GRAB_OFF);
1200: }
1201: }
1202:
1203: static void handle_inhibit (void)
1204: {
1205: toggle_inhibit_frame (IHF_SCROLLLOCK);
1206: }
1207:
1208:
1209: static void handle_interpol (void)
1210: {
1211: if (currprefs.sound_interpol == 0)
1212: {
1213: currprefs.sound_interpol = 1;
1214: printf ("Interpol on: rh\n");
1215: }
1216: else if (currprefs.sound_interpol == 1)
1217: {
1218: currprefs.sound_interpol = 2;
1219: printf ("Interpol on: crux\n");
1220: }
1221: else
1222: {
1223: currprefs.sound_interpol = 0;
1224: printf ("Interpol off\n");
1225: }
1226: }
1227:
1228: static void framerate_up (void)
1229: {
1230: if (currprefs.gfx_framerate < 20)
1231: changed_prefs.gfx_framerate = currprefs.gfx_framerate + 1;
1232: }
1233:
1234: static void framerate_down (void)
1235: {
1236: if (currprefs.gfx_framerate > 1)
1237: changed_prefs.gfx_framerate = currprefs.gfx_framerate - 1;
1238: }
1239:
1240: void target_save_options (FILE *f, struct uae_prefs *p)
1241: {
1242: }
1243:
1244: int target_parse_option (struct uae_prefs *p, char *option, char *value)
1245: {
1246: return 0;
1247: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.