ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/Frodo4/Src/Display_SDL.h
Revision: 1.1
Committed: 2003-07-01T17:32:13Z (20 years, 9 months ago) by cebix
Content type: text/plain
Branch: MAIN
Log Message:
imported files

File Contents

# User Rev Content
1 cebix 1.1 /*
2     * Display_SDL.h - C64 graphics display, emulator window handling,
3     * SDL specific stuff
4     *
5     * Frodo (C) 1994-1997,2002 Christian Bauer
6     *
7     * This program is free software; you can redistribute it and/or modify
8     * it under the terms of the GNU General Public License as published by
9     * the Free Software Foundation; either version 2 of the License, or
10     * (at your option) any later version.
11     *
12     * This program is distributed in the hope that it will be useful,
13     * but WITHOUT ANY WARRANTY; without even the implied warranty of
14     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15     * GNU General Public License for more details.
16     *
17     * You should have received a copy of the GNU General Public License
18     * along with this program; if not, write to the Free Software
19     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20     */
21    
22     #include "C64.h"
23     #include "SAM.h"
24     #include "Version.h"
25    
26     #include <SDL.h>
27    
28    
29     // Display surface
30     static SDL_Surface *screen = NULL;
31    
32     // Keyboard
33     static bool num_locked = false;
34    
35     // For LED error blinking
36     static C64Display *c64_disp;
37     static struct sigaction pulse_sa;
38     static itimerval pulse_tv;
39    
40     // Colors for speedometer/drive LEDs
41     enum {
42     black = 0,
43     white = 1,
44     fill_gray = 16,
45     shine_gray = 17,
46     shadow_gray = 18,
47     red = 19,
48     green = 20,
49     PALETTE_SIZE = 21
50     };
51    
52     /*
53     C64 keyboard matrix:
54    
55     Bit 7 6 5 4 3 2 1 0
56     0 CUD F5 F3 F1 F7 CLR RET DEL
57     1 SHL E S Z 4 A W 3
58     2 X T F C 6 D R 5
59     3 V U H B 8 G Y 7
60     4 N O K M 0 J I 9
61     5 , @ : . - L P +
62     6 / ^ = SHR HOM ; * £
63     7 R/S Q C= SPC 2 CTL <- 1
64     */
65    
66     #define MATRIX(a,b) (((a) << 3) | (b))
67    
68    
69     /*
70     * Open window
71     */
72    
73     int init_graphics(void)
74     {
75     // Init SDL
76     if (SDL_Init(SDL_INIT_VIDEO) < 0) {
77     fprintf(stderr, "Couldn't initialize SDL (%s)\n", SDL_GetError());
78     return 0;
79     }
80    
81     // Open window
82     SDL_WM_SetCaption(VERSION_STRING, "Frodo");
83     screen = SDL_SetVideoMode(DISPLAY_X, DISPLAY_Y + 17, 8, SDL_DOUBLEBUF);
84    
85     return 1;
86     }
87    
88    
89     /*
90     * Display constructor
91     */
92    
93     C64Display::C64Display(C64 *the_c64) : TheC64(the_c64)
94     {
95     quit_requested = false;
96     speedometer_string[0] = 0;
97    
98     // LEDs off
99     for (int i=0; i<4; i++)
100     led_state[i] = old_led_state[i] = LED_OFF;
101    
102     // Start timer for LED error blinking
103     c64_disp = this;
104     pulse_sa.sa_handler = (void (*)(int))pulse_handler;
105     pulse_sa.sa_flags = 0;
106     sigemptyset(&pulse_sa.sa_mask);
107     sigaction(SIGALRM, &pulse_sa, NULL);
108     pulse_tv.it_interval.tv_sec = 0;
109     pulse_tv.it_interval.tv_usec = 400000;
110     pulse_tv.it_value.tv_sec = 0;
111     pulse_tv.it_value.tv_usec = 400000;
112     setitimer(ITIMER_REAL, &pulse_tv, NULL);
113     }
114    
115    
116     /*
117     * Display destructor
118     */
119    
120     C64Display::~C64Display()
121     {
122     SDL_Quit();
123     }
124    
125    
126     /*
127     * Prefs may have changed
128     */
129    
130     void C64Display::NewPrefs(Prefs *prefs)
131     {
132     }
133    
134    
135     /*
136     * Redraw bitmap
137     */
138    
139     void C64Display::Update(void)
140     {
141     // Draw speedometer/LEDs
142     SDL_Rect r = {0, DISPLAY_Y, DISPLAY_X, 15};
143     SDL_FillRect(screen, &r, fill_gray);
144     r.w = DISPLAY_X; r.h = 1;
145     SDL_FillRect(screen, &r, shine_gray);
146     r.y = DISPLAY_Y + 14;
147     SDL_FillRect(screen, &r, shadow_gray);
148     r.w = 16;
149     for (int i=2; i<6; i++) {
150     r.x = DISPLAY_X * i/5 - 24; r.y = DISPLAY_Y + 4;
151     SDL_FillRect(screen, &r, shadow_gray);
152     r.y = DISPLAY_Y + 10;
153     SDL_FillRect(screen, &r, shine_gray);
154     }
155     r.y = DISPLAY_Y; r.w = 1; r.h = 15;
156     for (int i=0; i<5; i++) {
157     r.x = DISPLAY_X * i / 5;
158     SDL_FillRect(screen, &r, shine_gray);
159     r.x = DISPLAY_X * (i+1) / 5 - 1;
160     SDL_FillRect(screen, &r, shadow_gray);
161     }
162     r.y = DISPLAY_Y + 4; r.h = 7;
163     for (int i=2; i<6; i++) {
164     r.x = DISPLAY_X * i/5 - 24;
165     SDL_FillRect(screen, &r, shadow_gray);
166     r.x = DISPLAY_X * i/5 - 9;
167     SDL_FillRect(screen, &r, shine_gray);
168     }
169     r.y = DISPLAY_Y + 5; r.w = 14; r.h = 5;
170     for (int i=0; i<4; i++) {
171     r.x = DISPLAY_X * (i+2) / 5 - 23;
172     int c;
173     switch (led_state[i]) {
174     case LED_ON:
175     c = green;
176     break;
177     case LED_ERROR_ON:
178     c = red;
179     break;
180     default:
181     c = black;
182     break;
183     }
184     SDL_FillRect(screen, &r, c);
185     }
186    
187     draw_string(screen, DISPLAY_X * 1/5 + 8, DISPLAY_Y + 4, "D\x12 8", black, fill_gray);
188     draw_string(screen, DISPLAY_X * 2/5 + 8, DISPLAY_Y + 4, "D\x12 9", black, fill_gray);
189     draw_string(screen, DISPLAY_X * 3/5 + 8, DISPLAY_Y + 4, "D\x12 10", black, fill_gray);
190     draw_string(screen, DISPLAY_X * 4/5 + 8, DISPLAY_Y + 4, "D\x12 11", black, fill_gray);
191     draw_string(screen, 24, DISPLAY_Y + 4, speedometer_string, black, fill_gray);
192    
193     // Update display
194     SDL_Flip(screen);
195     }
196    
197    
198     /*
199     * Draw string into surface using the C64 ROM font
200     */
201    
202     void C64Display::draw_string(SDL_Surface *s, int x, int y, const char *str, uint8 front_color, uint8 back_color)
203     {
204     uint8 *pb = (uint8 *)s->pixels + s->pitch*y + x;
205     char c;
206     while ((c = *str++) != 0) {
207     uint8 *q = TheC64->Char + c*8 + 0x800;
208     uint8 *p = pb;
209     for (int y=0; y<8; y++) {
210     uint8 v = *q++;
211     p[0] = (v & 0x80) ? front_color : back_color;
212     p[1] = (v & 0x40) ? front_color : back_color;
213     p[2] = (v & 0x20) ? front_color : back_color;
214     p[3] = (v & 0x10) ? front_color : back_color;
215     p[4] = (v & 0x08) ? front_color : back_color;
216     p[5] = (v & 0x04) ? front_color : back_color;
217     p[6] = (v & 0x02) ? front_color : back_color;
218     p[7] = (v & 0x01) ? front_color : back_color;
219     p += s->pitch;
220     }
221     pb += 8;
222     }
223     }
224    
225    
226     /*
227     * LED error blink
228     */
229    
230     void C64Display::pulse_handler(...)
231     {
232     for (int i=0; i<4; i++)
233     switch (c64_disp->led_state[i]) {
234     case LED_ERROR_ON:
235     c64_disp->led_state[i] = LED_ERROR_OFF;
236     break;
237     case LED_ERROR_OFF:
238     c64_disp->led_state[i] = LED_ERROR_ON;
239     break;
240     }
241     }
242    
243    
244     /*
245     * Draw speedometer
246     */
247    
248     void C64Display::Speedometer(int speed)
249     {
250     static int delay = 0;
251    
252     if (delay >= 20) {
253     delay = 0;
254     sprintf(speedometer_string, "%d%%", speed);
255     } else
256     delay++;
257     }
258    
259    
260     /*
261     * Return pointer to bitmap data
262     */
263    
264     uint8 *C64Display::BitmapBase(void)
265     {
266     return (uint8 *)screen->pixels;
267     }
268    
269    
270     /*
271     * Return number of bytes per row
272     */
273    
274     int C64Display::BitmapXMod(void)
275     {
276     return screen->pitch;
277     }
278    
279    
280     /*
281     * Poll the keyboard
282     */
283    
284     static void translate_key(SDLKey key, bool key_up, uint8 *key_matrix, uint8 *rev_matrix, uint8 *joystick)
285     {
286     int c64_key = -1;
287     switch (key) {
288     case SDLK_a: c64_key = MATRIX(1,2); break;
289     case SDLK_b: c64_key = MATRIX(3,4); break;
290     case SDLK_c: c64_key = MATRIX(2,4); break;
291     case SDLK_d: c64_key = MATRIX(2,2); break;
292     case SDLK_e: c64_key = MATRIX(1,6); break;
293     case SDLK_f: c64_key = MATRIX(2,5); break;
294     case SDLK_g: c64_key = MATRIX(3,2); break;
295     case SDLK_h: c64_key = MATRIX(3,5); break;
296     case SDLK_i: c64_key = MATRIX(4,1); break;
297     case SDLK_j: c64_key = MATRIX(4,2); break;
298     case SDLK_k: c64_key = MATRIX(4,5); break;
299     case SDLK_l: c64_key = MATRIX(5,2); break;
300     case SDLK_m: c64_key = MATRIX(4,4); break;
301     case SDLK_n: c64_key = MATRIX(4,7); break;
302     case SDLK_o: c64_key = MATRIX(4,6); break;
303     case SDLK_p: c64_key = MATRIX(5,1); break;
304     case SDLK_q: c64_key = MATRIX(7,6); break;
305     case SDLK_r: c64_key = MATRIX(2,1); break;
306     case SDLK_s: c64_key = MATRIX(1,5); break;
307     case SDLK_t: c64_key = MATRIX(2,6); break;
308     case SDLK_u: c64_key = MATRIX(3,6); break;
309     case SDLK_v: c64_key = MATRIX(3,7); break;
310     case SDLK_w: c64_key = MATRIX(1,1); break;
311     case SDLK_x: c64_key = MATRIX(2,7); break;
312     case SDLK_y: c64_key = MATRIX(3,1); break;
313     case SDLK_z: c64_key = MATRIX(1,4); break;
314    
315     case SDLK_0: c64_key = MATRIX(4,3); break;
316     case SDLK_1: c64_key = MATRIX(7,0); break;
317     case SDLK_2: c64_key = MATRIX(7,3); break;
318     case SDLK_3: c64_key = MATRIX(1,0); break;
319     case SDLK_4: c64_key = MATRIX(1,3); break;
320     case SDLK_5: c64_key = MATRIX(2,0); break;
321     case SDLK_6: c64_key = MATRIX(2,3); break;
322     case SDLK_7: c64_key = MATRIX(3,0); break;
323     case SDLK_8: c64_key = MATRIX(3,3); break;
324     case SDLK_9: c64_key = MATRIX(4,0); break;
325    
326     case SDLK_SPACE: c64_key = MATRIX(7,4); break;
327     case SDLK_BACKQUOTE: c64_key = MATRIX(7,1); break;
328     case SDLK_BACKSLASH: c64_key = MATRIX(6,6); break;
329     case SDLK_COMMA: c64_key = MATRIX(5,7); break;
330     case SDLK_PERIOD: c64_key = MATRIX(5,4); break;
331     case SDLK_MINUS: c64_key = MATRIX(5,0); break;
332     case SDLK_EQUALS: c64_key = MATRIX(5,3); break;
333     case SDLK_LEFTBRACKET: c64_key = MATRIX(5,6); break;
334     case SDLK_RIGHTBRACKET: c64_key = MATRIX(6,1); break;
335     case SDLK_SEMICOLON: c64_key = MATRIX(5,5); break;
336     case SDLK_QUOTE: c64_key = MATRIX(6,2); break;
337     case SDLK_SLASH: c64_key = MATRIX(6,7); break;
338    
339     case SDLK_ESCAPE: c64_key = MATRIX(7,7); break;
340     case SDLK_RETURN: c64_key = MATRIX(0,1); break;
341     case SDLK_BACKSPACE: case SDLK_DELETE: c64_key = MATRIX(0,0); break;
342     case SDLK_INSERT: c64_key = MATRIX(6,3); break;
343     case SDLK_HOME: c64_key = MATRIX(6,3); break;
344     case SDLK_END: c64_key = MATRIX(6,0); break;
345     case SDLK_PAGEUP: c64_key = MATRIX(6,0); break;
346     case SDLK_PAGEDOWN: c64_key = MATRIX(6,5); break;
347    
348     case SDLK_LCTRL: case SDLK_TAB: c64_key = MATRIX(7,2); break;
349     case SDLK_RCTRL: c64_key = MATRIX(7,5); break;
350     case SDLK_LSHIFT: c64_key = MATRIX(1,7); break;
351     case SDLK_RSHIFT: c64_key = MATRIX(6,4); break;
352     case SDLK_LALT: case SDLK_LMETA: c64_key = MATRIX(7,5); break;
353     case SDLK_RALT: case SDLK_RMETA: c64_key = MATRIX(7,5); break;
354    
355     case SDLK_UP: c64_key = MATRIX(0,7)| 0x80; break;
356     case SDLK_DOWN: c64_key = MATRIX(0,7); break;
357     case SDLK_LEFT: c64_key = MATRIX(0,2) | 0x80; break;
358     case SDLK_RIGHT: c64_key = MATRIX(0,2); break;
359    
360     case SDLK_F1: c64_key = MATRIX(0,4); break;
361     case SDLK_F2: c64_key = MATRIX(0,4) | 0x80; break;
362     case SDLK_F3: c64_key = MATRIX(0,5); break;
363     case SDLK_F4: c64_key = MATRIX(0,5) | 0x80; break;
364     case SDLK_F5: c64_key = MATRIX(0,6); break;
365     case SDLK_F6: c64_key = MATRIX(0,6) | 0x80; break;
366     case SDLK_F7: c64_key = MATRIX(0,3); break;
367     case SDLK_F8: c64_key = MATRIX(0,3) | 0x80; break;
368    
369     case SDLK_KP0: case SDLK_KP5: c64_key = 0x10 | 0x40; break;
370     case SDLK_KP1: c64_key = 0x06 | 0x40; break;
371     case SDLK_KP2: c64_key = 0x02 | 0x40; break;
372     case SDLK_KP3: c64_key = 0x0a | 0x40; break;
373     case SDLK_KP4: c64_key = 0x04 | 0x40; break;
374     case SDLK_KP6: c64_key = 0x08 | 0x40; break;
375     case SDLK_KP7: c64_key = 0x05 | 0x40; break;
376     case SDLK_KP8: c64_key = 0x01 | 0x40; break;
377     case SDLK_KP9: c64_key = 0x09 | 0x40; break;
378    
379     case SDLK_KP_DIVIDE: c64_key = MATRIX(6,7); break;
380     case SDLK_KP_ENTER: c64_key = MATRIX(0,1); break;
381     default: break;
382     }
383    
384     if (c64_key < 0)
385     return;
386    
387     // Handle joystick emulation
388     if (c64_key & 0x40) {
389     c64_key &= 0x1f;
390     if (key_up)
391     *joystick |= c64_key;
392     else
393     *joystick &= ~c64_key;
394     return;
395     }
396    
397     // Handle other keys
398     bool shifted = c64_key & 0x80;
399     int c64_byte = (c64_key >> 3) & 7;
400     int c64_bit = c64_key & 7;
401     if (key_up) {
402     if (shifted) {
403     key_matrix[6] |= 0x10;
404     rev_matrix[4] |= 0x40;
405     }
406     key_matrix[c64_byte] |= (1 << c64_bit);
407     rev_matrix[c64_bit] |= (1 << c64_byte);
408     } else {
409     if (shifted) {
410     key_matrix[6] &= 0xef;
411     rev_matrix[4] &= 0xbf;
412     }
413     key_matrix[c64_byte] &= ~(1 << c64_bit);
414     rev_matrix[c64_bit] &= ~(1 << c64_byte);
415     }
416     }
417    
418     void C64Display::PollKeyboard(uint8 *key_matrix, uint8 *rev_matrix, uint8 *joystick)
419     {
420     SDL_Event event;
421     while (SDL_PollEvent(&event)) {
422     switch (event.type) {
423    
424     // Key pressed
425     case SDL_KEYDOWN:
426     switch (event.key.keysym.sym) {
427    
428     case SDLK_F9: // F9: Invoke SAM
429     SAM(TheC64);
430     break;
431    
432     case SDLK_F10: // F10: Quit
433     quit_requested = true;
434     break;
435    
436     case SDLK_F11: // F11: NMI (Restore)
437     TheC64->NMI();
438     break;
439    
440     case SDLK_F12: // F12: Reset
441     TheC64->Reset();
442     break;
443    
444     case SDLK_NUMLOCK:
445     num_locked = true;
446     break;
447    
448     case SDLK_KP_PLUS: // '+' on keypad: Increase SkipFrames
449     ThePrefs.SkipFrames++;
450     break;
451    
452     case SDLK_KP_MINUS: // '-' on keypad: Decrease SkipFrames
453     if (ThePrefs.SkipFrames > 1)
454     ThePrefs.SkipFrames--;
455     break;
456    
457     case SDLK_KP_MULTIPLY: // '*' on keypad: Toggle speed limiter
458     ThePrefs.LimitSpeed = !ThePrefs.LimitSpeed;
459     break;
460    
461     default:
462     translate_key(event.key.keysym.sym, false, key_matrix, rev_matrix, joystick);
463     break;
464     }
465     break;
466    
467     // Key released
468     case SDL_KEYUP:
469     if (event.key.keysym.sym == SDLK_NUMLOCK)
470     num_locked = false;
471     else
472     translate_key(event.key.keysym.sym, true, key_matrix, rev_matrix, joystick);
473     break;
474    
475     // Quit Frodo
476     case SDL_QUIT:
477     quit_requested = true;
478     break;
479     }
480     }
481     }
482    
483    
484     /*
485     * Check if NumLock is down (for switching the joystick keyboard emulation)
486     */
487    
488     bool C64Display::NumLock(void)
489     {
490     return num_locked;
491     }
492    
493    
494     /*
495     * Allocate C64 colors
496     */
497    
498     void C64Display::InitColors(uint8 *colors)
499     {
500     SDL_Color palette[PALETTE_SIZE];
501     for (int i=0; i<16; i++) {
502     palette[i].r = palette_red[i];
503     palette[i].g = palette_green[i];
504     palette[i].b = palette_blue[i];
505     }
506     palette[fill_gray].r = palette[fill_gray].g = palette[fill_gray].b = 0xd0;
507     palette[shine_gray].r = palette[shine_gray].g = palette[shine_gray].b = 0xf0;
508     palette[shadow_gray].r = palette[shadow_gray].g = palette[shadow_gray].b = 0x80;
509     palette[red].r = 0xf0;
510     palette[red].g = palette[red].b = 0;
511     palette[green].g = 0xf0;
512     palette[green].r = palette[green].b = 0;
513     SDL_SetColors(screen, palette, 0, PALETTE_SIZE);
514    
515     for (int i=0; i<256; i++)
516     colors[i] = i & 0x0f;
517     }
518    
519    
520     /*
521     * Show a requester (error message)
522     */
523    
524     long int ShowRequester(char *a,char *b,char *)
525     {
526     printf("%s: %s\n", a, b);
527     return 1;
528     }