/[cebix]/Frodo4/Src/Display_WIN32.h
ViewVC logotype

Annotation of /Frodo4/Src/Display_WIN32.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.4 - (hide annotations)
Mon Jun 27 19:55:48 2005 UTC (9 years, 3 months ago) by cebix
Branch: MAIN
CVS Tags: VERSION_4_2
Changes since 1.3: +1 -1 lines
File MIME type: text/plain
updated copyright dates

1 cebix 1.1 /*
2     * Display_WIN32.h - C64 graphics display, emulator window handling,
3     * WIN32 specific stuff
4     *
5 cebix 1.4 * Frodo (C) 1994-1997,2002-2005 Christian Bauer
6 cebix 1.1 *
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 <shellapi.h>
23     #include <commctrl.h>
24    
25     #include "C64.h"
26     #include "SAM.h"
27     #include "Version.h"
28     #include "VIC.h"
29     #include "resource.h"
30    
31     #define NAME "Frodo"
32     #define TITLE (IsFrodoSC ? "FrodoSC" : "Frodo")
33    
34     #ifdef DEBUG
35    
36     class TimeScope
37     {
38    
39     public:
40     TimeScope(const char *s)
41     {
42     tag = s;
43     QueryPerformanceCounter(&liStart);
44     }
45     ~TimeScope()
46     {
47     QueryPerformanceCounter(&liFinish);
48     OutputTime();
49     }
50    
51     private:
52     void
53     OutputTime()
54     {
55     LARGE_INTEGER liFreq;
56    
57     QueryPerformanceFrequency(&liFreq);
58     Debug("%s: %.0f usec\n", tag,
59     double(liFinish.LowPart - liStart.LowPart)
60     /liFreq.LowPart*1000000);
61     }
62     const char *tag;
63     LARGE_INTEGER liStart, liFinish;
64     };
65    
66     #define TIMESCOPE(var, tag) TimeScope var(tag)
67    
68     #else
69    
70     #define TIMESCOPE(var, tag)
71    
72     #endif
73    
74     /*
75     C64 keyboard matrix:
76    
77     Bit 7 6 5 4 3 2 1 0
78     0 CUD F5 F3 F1 F7 CLR RET DEL
79     1 SHL E S Z 4 A W 3
80     2 X T F C 6 D R 5
81     3 V U H B 8 G Y 7
82     4 N O K M 0 J I 9
83     5 , @ : . - L P +
84     6 / ^ = SHR HOM ; *
85     7 R/S Q C= SPC 2 CTL <- 1
86     */
87    
88     #define MATRIX(a,b) (((a) << 3) | (b))
89    
90     #define KEY_F9 256
91     #define KEY_F10 257
92     #define KEY_F11 258
93     #define KEY_F12 259
94    
95     #define KEY_FIRE 260
96     #define KEY_JUP 261
97     #define KEY_JDN 262
98     #define KEY_JLF 263
99     #define KEY_JRT 264
100     #define KEY_JUPLF 265
101     #define KEY_JUPRT 266
102     #define KEY_JDNLF 267
103     #define KEY_JDNRT 268
104     #define KEY_CENTER 269
105    
106     #define KEY_NUMLOCK 270
107    
108     #define KEY_KPPLUS 271
109     #define KEY_KPMINUS 272
110     #define KEY_KPMULT 273
111     #define KEY_KPDIV 274
112     #define KEY_KPENTER 275
113     #define KEY_KPPERIOD 276
114    
115     #define KEY_PAUSE 277
116     #define KEY_ALTENTER 278
117     #define KEY_CTRLENTER 279
118    
119     #define VK_bracketleft 0xdb
120     #define VK_bracketright 0xdd
121     #define VK_comma 0xbc
122     #define VK_period 0xbe
123     #define VK_slash 0xbf
124     #define VK_semicolon 0xba
125     #define VK_grave 0xc0
126     #define VK_minus 0xbd
127     #define VK_equal 0xbb
128     #define VK_quote 0xde
129     #define VK_backslash 0xdc
130    
131     static C64Display *TheDisplay;
132     static int keystate[256];
133     static UBYTE rev_matrix[8], key_matrix[8];
134     static int quit = 0;
135     static int numlock = 0;
136     static int joystate = 0xff;
137    
138     static RECT rcScreen;
139     static RECT rcLast;
140     static RECT rcWindow;
141     static RECT rcWork;
142     static BOOL need_new_color_table = FALSE;
143     static int view_x, view_y;
144    
145     static int led_rows = 16;
146    
147     static HCURSOR invisible_cursor;
148     static HCURSOR arrow_cursor;
149    
150     static HFONT led_font;
151    
152     static HPEN led_highlight;
153     static HPEN led_shadow;
154    
155     static HBRUSH led_brush;
156     static HBRUSH off_brush;
157     static HBRUSH error_off_brush;
158     static HBRUSH on_brush;
159     static HBRUSH error_on_brush;
160    
161     // Not fully working yet.
162     #ifdef WORKBUFFER_BITMAP
163     static BOOL workbuffer_bitmap = FALSE;
164     static BOOL workbuffer_locked = FALSE;
165     static DDSURFACEDESC bitmap_ddsd;
166     #endif
167    
168     C64Display::DisplayMode default_modes[] = {
169     { 320, 200, 8 },
170     { 320, 240, 8 },
171     { 512, 384, 8 },
172     { 640, 400, 8 },
173     { 640, 480, 8 },
174     { 320, 200, 16 },
175     { 320, 240, 16 },
176     { 512, 384, 16 },
177     { 640, 400, 16 },
178     { 640, 480, 16 },
179     };
180     static int num_default_modes =
181     sizeof(default_modes)/sizeof(C64Display::DisplayMode);
182    
183     static C64Display::DisplayMode *display_modes = NULL;
184     static int num_display_modes = 0;
185     static int max_display_modes = 16;
186    
187     int C64Display::GetNumDisplayModes() const
188     {
189     if (num_display_modes == 0)
190     return num_default_modes;
191     return num_display_modes;
192     }
193    
194     const C64Display::DisplayMode *C64Display::GetDisplayModes() const
195     {
196     if (num_display_modes == 0)
197     return default_modes;
198     return display_modes;
199     }
200    
201     long ShowRequester(char *str, char *button1, char *button2)
202     {
203     if (!TheDisplay) {
204     MessageBox(hwnd, str, "Frodo", MB_OK | MB_ICONSTOP);
205     return FALSE;
206     }
207     return TheDisplay->ShowRequester(str, button1, button2);
208     }
209    
210     /*
211     * Display constructor: Create window/screen
212     */
213    
214     C64Display::C64Display(C64 *the_c64) : TheC64(the_c64)
215     {
216     in_constructor = TRUE;
217     in_destructor = FALSE;
218    
219     TheDisplay = this;
220     speed_index = 0;
221    
222     pDD = NULL;
223     pPrimary = NULL;
224     pBack = NULL;
225     pWork = NULL;
226     pClipper = NULL;
227     pPalette = NULL;
228     active = FALSE;
229     paused = FALSE;
230     waiting = FALSE;
231     show_leds = ThePrefs.ShowLEDs;
232     full_screen = ThePrefs.DisplayType == DISPTYPE_SCREEN;
233    
234     // Turn LEDs off.
235     for (int i = 0; i < 4; i++)
236     led_state[i] = old_led_state[i] = LED_OFF;
237    
238     // Allocate chunky buffer to draw into.
239     chunky_buf = new UBYTE[DISPLAY_X * DISPLAY_Y];
240    
241     CalcViewPort();
242    
243     ResetKeyboardState();
244    
245     if (!MakeWindow()) {
246     ShowRequester("Failed to create window.", "Quit");
247     Quit();
248     }
249     else {
250     WindowTitle();
251    
252     if (!StartDirectDraw()) {
253     ShowRequester(failure_message, "Quit");
254     Quit();
255     }
256     else
257     draw_led_bar();
258     }
259    
260     in_constructor = FALSE;
261     }
262    
263     /*
264     * Display destructor
265     */
266    
267     C64Display::~C64Display()
268     {
269     in_destructor = TRUE;
270    
271     Debug("~C64Display\n");
272    
273     StopDirectDraw();
274    
275     // Offer to save now that we are not in full screen mode.
276     OfferSave();
277    
278     // Free the display modes table.
279     delete[] display_modes;
280    
281     // Free chunky buffer
282     delete chunky_buf;
283    
284     // Destroy the main window.
285     DestroyWindow(hwnd);
286    
287     // Drain the window message queue.
288     for (;;)
289     {
290     MSG msg;
291     if (!GetMessage(&msg, NULL, 0, 0))
292     break;
293     if (ThePrefs.SystemKeys)
294     TranslateMessage(&msg);
295     DispatchMessage(&msg);
296     }
297    
298     DeleteObjects();
299    
300     in_destructor = FALSE;
301     }
302    
303     /*
304     * Prefs may have changed
305     */
306    
307     void C64Display::NewPrefs(Prefs *prefs)
308     {
309     }
310    
311     void C64Display::DeleteObjects()
312     {
313     // Delete objects we created.
314     DeleteObject(led_highlight);
315     DeleteObject(led_shadow);
316     DeleteObject(led_font);
317     DeleteObject(led_brush);
318     DeleteObject(off_brush);
319     DeleteObject(error_off_brush);
320     DeleteObject(on_brush);
321     DeleteObject(error_on_brush);
322     }
323    
324     BOOL C64Display::CalcViewPort()
325     {
326     int old_view_x = view_x, old_view_y = view_y;
327     const char *view_port = ThePrefs.ViewPort;
328     if (view_port[0] == '\0' ||
329     stricmp(view_port, "Default") == 0)
330     view_port = NULL;
331     if (!view_port || sscanf(view_port, "%dx%d", &view_x, &view_y) != 2) {
332     view_x = DISPLAY_X;
333     view_y = DISPLAY_Y;
334     }
335     SetRect(&rcWork, 0, 0, view_x, view_y);
336     if (view_x != old_view_x || view_y != old_view_y)
337     return TRUE;
338     return FALSE;
339     }
340    
341    
342     BOOL C64Display::ResizeWindow(int side, RECT *pRect)
343     {
344     // Compute size of non-client borders.
345     DWORD style = GetWindowLong(hwnd, GWL_STYLE);
346     RECT rc;
347     SetRect(&rc, 0, 0, view_x, view_y);
348     BOOL has_menu = GetMenu(hwnd) != NULL;
349     AdjustWindowRect(&rc, style, has_menu);
350     if (ThePrefs.ShowLEDs)
351     rc.bottom += led_rows;
352     int nc_x = rc.right - rc.left - view_x;
353     int nc_y = rc.bottom - rc.top - view_y;
354    
355     // Compute client area corresponding to resizing.
356     int old_x = pRect->right - pRect->left - nc_x;
357     int old_y = pRect->bottom - pRect->top - nc_y;
358    
359     // Compute nearest integral scaling numerators.
360     int d = ThePrefs.ScalingDenominator;
361     int x = (old_x + view_x/d/2)/(view_x/d);
362     if (x == 0)
363     x = 1;
364     int y = (old_y + view_y/4)/(view_y/d);
365     if (y == 0)
366     y = 1;
367    
368     // When resizing corners make the scale factors agree.
369     switch (side) {
370     case WMSZ_BOTTOMRIGHT:
371     case WMSZ_BOTTOMLEFT:
372     case WMSZ_TOPRIGHT:
373     case WMSZ_TOPLEFT:
374     if (x < y)
375     y = x;
376     else
377     x = y;
378     }
379    
380     // Compute the quantized size of the window area.
381     int new_x = x*(view_x/d) + nc_x;
382     int new_y = y*(view_y/d) + nc_y;
383    
384     // Adjust the resizing rectangle.
385     switch (side) {
386    
387     case WMSZ_BOTTOMRIGHT:
388     case WMSZ_BOTTOMLEFT:
389     case WMSZ_BOTTOM:
390     pRect->bottom = pRect->top + new_y;
391     break;
392    
393     case WMSZ_TOPRIGHT:
394     case WMSZ_TOPLEFT:
395     case WMSZ_TOP:
396     pRect->top = pRect->bottom - new_y;
397     break;
398     }
399     switch (side) {
400    
401     case WMSZ_TOPRIGHT:
402     case WMSZ_BOTTOMRIGHT:
403     case WMSZ_RIGHT:
404     pRect->right = pRect->left + new_x;
405     break;
406    
407     case WMSZ_TOPLEFT:
408     case WMSZ_BOTTOMLEFT:
409     case WMSZ_LEFT:
410     pRect->left = pRect->right - new_x;
411     break;
412     }
413    
414     return TRUE;
415     }
416    
417     /*
418     * Update speedometer
419     */
420    
421     void C64Display::Speedometer(int speed)
422     {
423     Debug("speed = %d %%\n", speed);
424     speed_index = speed;
425    
426     if (full_screen)
427     return;
428    
429     if (!ThePrefs.ShowLEDs) {
430     WindowTitle();
431     return;
432     }
433    
434     if (speed_index == 0)
435     return;
436    
437     HDC hdc = GetDC(hwnd);
438     RECT rc;
439     GetClientRect(hwnd, &rc);
440     rc.top = rc.bottom - led_rows;
441     rc.right = rc.left + (rc.right - rc.left)/5;
442     FillRect(hdc, &rc, led_brush);
443     SelectObject(hdc, led_font);
444     SetTextAlign(hdc, TA_TOP | TA_LEFT);
445     SetBkMode(hdc, TRANSPARENT);
446     SetTextColor(hdc, (COLORREF) GetSysColor(COLOR_MENUTEXT));
447     char str[128];
448     if (IsFrodoSC)
449     sprintf(str, "%d%%", speed_index);
450     else
451     sprintf(str, "%d%%", speed_index);
452     int x = rc.left + 4;
453     int y = rc.top + 2;
454     TextOut(hdc, x, y, str, strlen(str));
455     ReleaseDC(hwnd, hdc);
456     }
457    
458    
459     /*
460     * Return pointer to bitmap data
461     */
462    
463     UBYTE *C64Display::BitmapBase()
464     {
465     #ifdef WORKBUFFER_BITMAP
466     if (colors_depth == 8 && pWork) {
467     if (workbuffer_locked) {
468     pWork->Unlock(NULL);
469     workbuffer_locked = FALSE;
470     }
471     HRESULT ddrval;
472     for (;;) {
473     bitmap_ddsd.dwSize = sizeof(bitmap_ddsd);
474     ddrval = pWork->Lock(NULL, &bitmap_ddsd, 0, NULL);
475     if (ddrval != DDERR_WASSTILLDRAWING)
476     break;
477     }
478     if (ddrval == DD_OK) {
479     workbuffer_locked = TRUE;
480     workbuffer_bitmap = TRUE;
481     return (UBYTE *) bitmap_ddsd.lpSurface;
482     }
483     }
484     workbuffer_bitmap = FALSE;
485     #endif
486     return chunky_buf;
487     }
488    
489    
490     /*
491     * Return number of bytes per row
492     */
493    
494     int C64Display::BitmapXMod()
495     {
496     #ifdef WORKBUFFER_BITMAP
497     if (workbuffer_locked)
498     return bitmap_ddsd.lPitch;
499     #endif
500     return DISPLAY_X;
501     }
502    
503    
504     /*
505     * Freshen keyboard state
506     */
507    
508     void C64Display::PollKeyboard(UBYTE *CIA_key_matrix, UBYTE *CIA_rev_matrix, UBYTE *joystick)
509     {
510     //Debug("Display::PollKeyboard\n");
511    
512     #ifdef WORKBUFFER_BITMAP
513     if (workbuffer_locked) {
514     pWork->Unlock(NULL);
515     workbuffer_locked = FALSE;
516     }
517     #endif
518    
519     for (;;)
520     {
521     MSG msg;
522     if (!PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
523     break;
524     if (ThePrefs.SystemKeys)
525     TranslateMessage(&msg);
526     DispatchMessage(&msg);
527     }
528    
529     *joystick = joystate;
530     memcpy(CIA_key_matrix, key_matrix, sizeof(key_matrix));
531     memcpy(CIA_rev_matrix, rev_matrix, sizeof(rev_matrix));
532     }
533    
534     /*
535     * Check if NumLock is down (for switching the joystick keyboard emulation)
536     */
537    
538     bool C64Display::NumLock()
539     {
540     return numlock;
541     }
542    
543    
544     /*
545     * Allocate C64 colors
546     */
547    
548     void C64Display::InitColors(UBYTE *array)
549     {
550     if (colors_depth == 8) {
551     for (int i = 0; i < 256; i++)
552     array[i] = colors[i & 0x0f];
553     }
554     else {
555     for (int i = 0; i < 256; i++)
556     array[i] = i & 0x0f;
557     }
558     }
559    
560    
561     long C64Display::ShowRequester(const char *str, const char *button1, const char *button2)
562     {
563     // This could be a lot nicer but quick and dirty is fine with me.
564     char message[1024];
565     strcpy(message, str);
566     strcat(message, "\nPress OK to ");
567     strcat(message, button1);
568     if (button2) {
569     strcat(message, ", Cancel to ");
570     strcat(message, button2);
571     }
572     strcat(message, ".");
573     UINT type;
574     if (button2)
575     type = MB_OKCANCEL | MB_ICONQUESTION;
576     else
577     type = MB_OK | MB_ICONSTOP;
578     Pause();
579     if (full_screen)
580     StopDirectDraw();
581     int result = MessageBox(hwnd, message, NAME " Error", type);
582     if (full_screen)
583     StartDirectDraw();
584     Resume();
585     if (result == IDCANCEL)
586     return TRUE;
587     return FALSE;
588     }
589    
590     void C64Display::WaitUntilActive()
591     {
592     Debug("waiting until not paused...\n");
593     waiting = TRUE;
594     WindowTitle();
595     for (;;) {
596    
597     // Check for termination condition.
598     if (!paused || quit)
599     break;
600    
601     // Process message queue.
602     MSG msg;
603     if (GetMessage(&msg, NULL, 0, 0) != TRUE)
604     break;
605    
606     // Always translate system keys while paused.
607     TranslateMessage(&msg);
608     DispatchMessage(&msg);
609     }
610     waiting = FALSE;
611     Debug("...done waiting\n");
612     WindowTitle();
613     ResetKeyboardState();
614     }
615    
616     void C64Display::ResetKeyboardState()
617     {
618     memset(keystate, 0, sizeof(keystate));
619     memset(key_matrix, 0xff, sizeof(key_matrix));
620     memset(rev_matrix, 0xff, sizeof(rev_matrix));
621     joystate = 0xff;
622     }
623    
624     BOOL C64Display::MakeWindow()
625     {
626     // Set up and register window class.
627     WNDCLASS wc;
628     wc.style = CS_HREDRAW | CS_VREDRAW;
629     wc.lpfnWndProc = StaticWindowProc;
630     wc.cbClsExtra = 0;
631     wc.cbWndExtra = 0;
632     wc.hInstance = hInstance;
633     wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(FRODO_ICON));
634     wc.hCursor = NULL;
635     wc.hbrBackground = NULL;
636     wc.lpszMenuName = MAKEINTRESOURCE(IDR_MAIN_MENU);
637     wc.lpszClassName = NAME;
638     RegisterClass(&wc);
639    
640     // Set up our preferred styles for our window depending on the mode.
641     windowed_style = WS_VISIBLE | WS_SYSMENU | WS_OVERLAPPED | WS_CAPTION | WS_MINIMIZEBOX | WS_THICKFRAME;
642     fullscreen_style = WS_POPUP | WS_VISIBLE;
643    
644     // Compute the initial window size.
645     DWORD style = windowed_style;
646     RECT rc;
647     int n = ThePrefs.ScalingNumerator;
648     int d = ThePrefs.ScalingDenominator;
649     SetRect(&rc, 0, 0, n*view_x/d, n*view_y/d);
650     BOOL has_menu = wc.lpszMenuName != NULL;
651     AdjustWindowRect(&rc, style, has_menu);
652     if (ThePrefs.ShowLEDs)
653     rc.bottom += led_rows;
654     int x_size = rc.right - rc.left;
655     int y_size = rc.bottom - rc.top;
656    
657     // Create the window and save the initial position.
658     hwnd = CreateWindowEx(0, NAME, TITLE, style, CW_USEDEFAULT, 0, x_size, y_size, NULL, NULL, hInstance, NULL);
659     GetWindowRect(hwnd, &rcLast);
660     SetRect(&rcScreen, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
661    
662     // Load cursors.
663     invisible_cursor = LoadCursor(hInstance, MAKEINTRESOURCE(IDC_INVISIBLE));
664     arrow_cursor = LoadCursor(0, MAKEINTRESOURCE(IDC_ARROW));
665    
666     // Create fonts, pens, brushes, etc.
667     CreateObjects();
668    
669     if (!hwnd)
670     return FALSE;
671    
672     ShowWindow(hwnd, nCmdShow);
673     UpdateWindow(hwnd);
674    
675     return TRUE;
676     }
677    
678     void C64Display::CreateObjects()
679     {
680     // Create fonts.
681     led_font = CreateFont(14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
682     VARIABLE_PITCH | FF_SWISS, "");
683    
684     // Create pens.
685     led_highlight = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_3DHIGHLIGHT));
686     led_shadow = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_3DSHADOW));
687    
688     // Create brushes.
689     LOGBRUSH logbrush;
690     logbrush.lbStyle = BS_SOLID;
691     logbrush.lbHatch = 0;
692     logbrush.lbColor = GetSysColor(COLOR_MENU);
693     led_brush = CreateBrushIndirect(&logbrush);
694     logbrush.lbColor = RGB(0x00, 0x00, 0x00); // black
695     off_brush = CreateBrushIndirect(&logbrush);
696     logbrush.lbColor = RGB(0x00, 0x00, 0x00); // black
697     error_off_brush = CreateBrushIndirect(&logbrush);
698     logbrush.lbColor = RGB(0x00, 0xff, 0x00); // green
699     on_brush = CreateBrushIndirect(&logbrush);
700     logbrush.lbColor = RGB(0xff, 0x00, 0x00); // red
701     error_on_brush = CreateBrushIndirect(&logbrush);
702     }
703    
704     HRESULT CALLBACK C64Display::StaticWindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
705     {
706     return TheDisplay->WindowProc(hWnd, message, wParam, lParam);
707     }
708    
709     long C64Display::WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
710     {
711     Debug("window message: 0x%x\n", message);
712    
713     switch (message) {
714    
715     case WM_SYSCOLORCHANGE:
716     DeleteObjects();
717     CreateObjects();
718     InvalidateRect(hwnd, NULL, FALSE);
719     break;
720    
721     case WM_MOUSEMOVE:
722     SetCursor(ThePrefs.HideCursor ? invisible_cursor : arrow_cursor);
723     break;
724    
725     case WM_MENUCHAR:
726     // Eat Alt-foo characters so that it doesn't beep.
727     if (HIWORD(wParam) == 0)
728     return MAKELONG(0, 1);
729     break;
730    
731     case WM_ENTERSIZEMOVE:
732     Pause();
733     break;
734    
735     case WM_EXITSIZEMOVE:
736     Resume();
737     break;
738    
739     case WM_SIZING:
740     ResizeWindow(wParam, (RECT *) lParam);
741     return TRUE;
742    
743     case WM_SIZE:
744     case WM_MOVE:
745     if (full_screen)
746     SetRect(&rcWindow, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
747     else {
748     GetClientRect(hWnd, &rcWindow);
749     if (ThePrefs.ShowLEDs)
750     rcWindow.bottom -= led_rows;
751     ClientToScreen(hWnd, (LPPOINT) &rcWindow);
752     ClientToScreen(hWnd, (LPPOINT) &rcWindow + 1);
753    
754     // Align the client rect to a four-byte
755     // boundary because this can triple the
756     // speed of a memcpy to the display.
757     int align_to = 4;
758     int misalignment = rcWindow.left % align_to;
759     if (misalignment == 0)
760     Update();
761     else {
762     if (misalignment > align_to/2)
763     misalignment -= align_to;
764     RECT rc;
765     GetWindowRect(hwnd, &rc);
766     MoveWindow(hwnd, rc.left - misalignment,
767     rc.top, rc.right - rc.left,
768     rc.bottom - rc.top, TRUE);
769     }
770     }
771     break;
772    
773     case WM_DISPLAYCHANGE:
774     if (!full_screen)
775     ResumeDirectDraw();
776     SetRect(&rcScreen, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
777     break;
778    
779     case WM_ACTIVATE:
780     Debug("WM_ACTIVATE\n");
781     {
782     int old_active = active;
783     active = LOWORD(wParam) != WA_INACTIVE;
784     if (ThePrefs.AutoPause && active != old_active) {
785     if (!active)
786     Pause();
787     else
788     Resume();
789     }
790     }
791     if (active) {
792     ResumeDirectDraw();
793     ResetKeyboardState();
794     }
795    
796     // Kick the message loop since this was sent to us, not posted.
797     PostMessage(hWnd, WM_USER, 0, 0);
798     break;
799    
800     case WM_COMMAND:
801     {
802     int id = LOWORD(wParam);
803     switch (id) {
804    
805     case ID_FILE_NEW:
806     {
807     OfferSave();
808     Prefs *prefs = new Prefs;
809     TheC64->NewPrefs(prefs);
810     ThePrefs = *prefs;
811     ThePrefsOnDisk = ThePrefs;
812     delete prefs;
813     strcpy(TheApp->prefs_path, "Untitled.fpr");
814     NewPrefs();
815     }
816     break;
817    
818     case ID_FILE_OPEN:
819     Pause();
820     OfferSave();
821     if (FileNameDialog(TheApp->prefs_path)) {
822     Prefs *prefs = new Prefs;
823     prefs->Load(TheApp->prefs_path);
824     TheC64->NewPrefs(prefs);
825     ThePrefs = *prefs;
826     delete prefs;
827     NewPrefs();
828     }
829     Resume();
830     break;
831    
832     case ID_FILE_SAVE:
833     ThePrefs.Save(TheApp->prefs_path);
834     break;
835    
836     case ID_FILE_SAVEAS:
837     Pause();
838     if (FileNameDialog(TheApp->prefs_path, TRUE)) {
839     ThePrefs.Save(TheApp->prefs_path);
840     WindowTitle();
841     }
842     Resume();
843     break;
844    
845     case ID_FILE_EX:
846     PostMessage(hWnd, WM_CLOSE, 0, 0);
847     break;
848    
849     case ID_TOOLS_PREFERENCES:
850     Pause();
851     TheApp->RunPrefsEditor();
852     NewPrefs();
853     Resume();
854     break;
855    
856     case ID_TOOLS_FULLSCREEN:
857     Pause();
858     StopDirectDraw();
859     full_screen = !full_screen;
860     if (!StartDirectDraw()) {
861     StopDirectDraw();
862     full_screen = !full_screen;
863     StartDirectDraw();
864     if (!full_screen)
865     ShowRequester(failure_message, "Continue");
866     }
867     Resume();
868     CheckMenuItem(GetMenu(hWnd), ID_TOOLS_FULLSCREEN, full_screen ? MF_CHECKED : MF_UNCHECKED);
869     if (paused)
870     Update();
871     break;
872    
873     case ID_TOOLS_RESETDIRECTDRAW:
874     ResetDirectDraw();
875     break;
876    
877     case ID_TOOLS_PAUSE:
878     if (!paused)
879     Pause();
880     else {
881     // XXX: Shouldn't happen but be safe.
882     while (paused)
883     Resume();
884     ResetKeyboardState();
885     }
886     CheckMenuItem(GetMenu(hWnd), ID_TOOLS_PAUSE, paused ? MF_CHECKED : MF_UNCHECKED);
887     break;
888    
889     case ID_TOOLS_RESETC64:
890     TheC64->Reset();
891     break;
892    
893     case ID_TOOLS_INSERTNEXTDISK:
894     InsertNextDisk();
895     break;
896    
897     case ID_TOOLS_SAM:
898     Pause();
899     MessageBox(hWnd, "SAM not yet implemented.", NAME, MB_OK);
900     Resume();
901     break;
902    
903     case ID_HELP_CONTENTS:
904     case ID_HELP_KEYBOARD:
905     case ID_HELP_SETTINGS:
906     {
907     const char *html;
908     switch (id) {
909     case ID_HELP_CONTENTS: html = "Main"; break;
910     case ID_HELP_KEYBOARD: html = "keyboard"; break;
911     case ID_HELP_SETTINGS: html = "settings"; break;
912     }
913     char helpfile[256];
914     sprintf(helpfile, "%s\\Docs\\%s.html", AppDirPath, html);
915     ShellExecute(0, 0, helpfile, 0, 0, SW_NORMAL);
916     }
917     break;
918    
919     case ID_HELP_ABOUT:
920     {
921     Pause();
922     char message[256];
923     sprintf(message, "%s by %s\n%s by %s",
924     VERSION_STRING,
925     "Christian Bauer",
926     "WIN32 port",
927     "J. Richard Sladkey");
928     MessageBox(hWnd, message, NAME, MB_OK);
929     Resume();
930     }
931     break;
932     }
933     ResetKeyboardState();
934     }
935     break;
936    
937     case WM_CLOSE:
938     Quit();
939     return 0;
940    
941     case WM_DESTROY:
942     PostQuitMessage(0);
943     break;
944    
945     case WM_QUERYNEWPALETTE:
946     if (!full_screen && pPalette && pPrimary) {
947     SetPalettes();
948     BuildColorTable();
949     if (!active)
950     Update();
951     }
952     break;
953    
954     case WM_PALETTECHANGED:
955     if (!full_screen) {
956     if ((HWND) wParam != hWnd) {
957     need_new_color_table = TRUE;
958     InvalidateRect(hwnd, NULL, FALSE);
959     }
960     }
961     break;
962    
963     case WM_PAINT:
964     if (!full_screen)
965     {
966     PAINTSTRUCT ps;
967     HDC hdc = BeginPaint(hWnd, &ps);
968     EndPaint(hWnd, &ps);
969     if (need_new_color_table) {
970     BuildColorTable();
971     need_new_color_table = FALSE;
972     }
973     if (paused)
974     Update();
975     draw_led_bar();
976     Speedometer(speed_index);
977     return 0;
978     }
979     break;
980    
981     case WM_ENTERMENULOOP:
982     Pause();
983     break;
984    
985     case WM_EXITMENULOOP:
986     Resume();
987     ResetKeyboardState();
988     break;
989    
990     case WM_SYSKEYDOWN:
991     case WM_KEYDOWN:
992     Debug("Display::WindowProc: KEYDOWN: 0x%x\n", wParam);
993     {
994     int kc = VirtKey2C64(wParam, lParam);
995     switch (kc) {
996    
997     case KEY_PAUSE:
998     PostMessage(hWnd, WM_COMMAND, ID_TOOLS_PAUSE, 0);
999     break;
1000    
1001     case KEY_KPPLUS:
1002     if (ThePrefs.SkipFrames < 10)
1003     ThePrefs.SkipFrames++;
1004     break;
1005    
1006     case KEY_KPMINUS:
1007     if (ThePrefs.SkipFrames > 1)
1008     ThePrefs.SkipFrames--;
1009     break;
1010    
1011     case KEY_KPMULT:
1012     ThePrefs.LimitSpeed = !ThePrefs.LimitSpeed;
1013     break;
1014    
1015     case KEY_KPDIV:
1016     {
1017     Prefs *prefs = new Prefs(ThePrefs);
1018     prefs->Emul1541Proc = !prefs->Emul1541Proc;
1019     TheC64->NewPrefs(prefs);
1020     ThePrefs = *prefs;
1021     delete prefs;
1022     }
1023     break;
1024    
1025     case KEY_KPPERIOD:
1026     ThePrefs.JoystickSwap = !ThePrefs.JoystickSwap;
1027     break;
1028    
1029     case KEY_F9:
1030     PostMessage(hWnd, WM_COMMAND, ID_TOOLS_INSERTNEXTDISK, 0);
1031     break;
1032    
1033     case KEY_ALTENTER:
1034     PostMessage(hWnd, WM_COMMAND, ID_TOOLS_FULLSCREEN, 0);
1035     break;
1036    
1037     case KEY_CTRLENTER:
1038     PostMessage(hWnd, WM_COMMAND, ID_TOOLS_RESETDIRECTDRAW, 0);
1039     break;
1040    
1041     case KEY_F10:
1042     PostMessage(hWnd, WM_CLOSE, 0, 0);
1043     break;
1044    
1045     case KEY_F11:
1046     if (!paused)
1047     TheC64->NMI();
1048     break;
1049    
1050     case KEY_F12:
1051     if (!paused)
1052     TheC64->Reset();
1053     break;
1054    
1055     case KEY_FIRE:
1056     joystate &= ~0x10;
1057     break;
1058    
1059     case KEY_JUP:
1060     joystate |= 0x02;
1061     joystate &= ~0x01;
1062     break;
1063    
1064     case KEY_JDN:
1065     joystate |= 0x01;
1066     joystate &= ~0x02;
1067     break;
1068    
1069     case KEY_JLF:
1070     joystate |= 0x08;
1071     joystate &= ~0x04;
1072     break;
1073    
1074     case KEY_JRT:
1075     joystate |= 0x04;
1076     joystate &= ~0x08;
1077     break;
1078    
1079     case KEY_JUPLF:
1080     joystate |= 0x0a;
1081     joystate &= ~0x05;
1082     break;
1083    
1084     case KEY_JUPRT:
1085     joystate |= 0x06;
1086     joystate &= ~0x09;
1087     break;
1088    
1089     case KEY_JDNLF:
1090     joystate |= 0x09;
1091     joystate &= ~0x06;
1092     break;
1093    
1094     case KEY_JDNRT:
1095     joystate |= 0x05;
1096     joystate &= ~0x0a;
1097     break;
1098    
1099     case KEY_CENTER:
1100     joystate |= 0x0f;
1101     break;
1102    
1103     default:
1104     if (kc < 0 || kc >= 256)
1105     break;
1106     if (keystate[kc])
1107     break;
1108     keystate[kc] = 1;
1109     int c64_byte = kc >> 3;
1110     int c64_bit = kc & 7;
1111     int shifted = kc & 128;
1112     c64_byte &= 7;
1113     if (shifted) {
1114     key_matrix[6] &= 0xef;
1115     rev_matrix[4] &= 0xbf;
1116     }
1117     key_matrix[c64_byte] &= ~(1 << c64_bit);
1118     rev_matrix[c64_bit] &= ~(1 << c64_byte);
1119     break;
1120     }
1121     return 0;
1122     }
1123     break;
1124    
1125     case WM_SYSKEYUP:
1126     case WM_KEYUP:
1127     Debug("Display::WindowProc: KEYUP: 0x%x\n", wParam);
1128     {
1129     int kc = VirtKey2C64(wParam, lParam);
1130     switch (kc) {
1131    
1132     case KEY_FIRE:
1133     joystate |= 0x10;
1134     break;
1135    
1136     case KEY_JUP:
1137     joystate |= 0x01;
1138     break;
1139    
1140     case KEY_JDN:
1141     joystate |= 0x02;
1142     break;
1143    
1144     case KEY_JLF:
1145     joystate |= 0x04;
1146     break;
1147    
1148     case KEY_JRT:
1149     joystate |= 0x08;
1150     break;
1151    
1152     case KEY_JUPLF:
1153     joystate |= 0x05;
1154     break;
1155    
1156     case KEY_JUPRT:
1157     joystate |= 0x09;
1158     break;
1159    
1160     case KEY_JDNLF:
1161     joystate |= 0x06;
1162     break;
1163    
1164     case KEY_JDNRT:
1165     joystate |= 0x0a;
1166     break;
1167    
1168     default:
1169     if (kc < 0 || kc >= 256)
1170     break;
1171     if (!keystate[kc])
1172     break;
1173     keystate[kc] = 0;
1174     int c64_byte = kc >> 3;
1175     int c64_bit = kc & 7;
1176     int shifted = kc & 128;
1177     c64_byte &= 7;
1178     if (shifted) {
1179     key_matrix[6] |= 0x10;
1180     rev_matrix[4] |= 0x40;
1181     }
1182     key_matrix[c64_byte] |= (1 << c64_bit);
1183     rev_matrix[c64_bit] |= (1 << c64_byte);
1184     break;
1185     }
1186     return 0;
1187     }
1188     break;
1189     }
1190    
1191     return DefWindowProc(hWnd, message, wParam, lParam);
1192     }
1193    
1194     int C64Display::VirtKey2C64(int virtkey, DWORD keydata)
1195     {
1196     int ext = keydata & 0x01000000;
1197     int sc = (keydata & 0x00ff0000) >> 16;
1198     int result = -1;
1199    
1200     switch (virtkey) {
1201    
1202     case VK_NUMPAD0: numlock = 1; return KEY_FIRE;
1203     case VK_NUMPAD1: numlock = 1; return KEY_JDNLF;
1204     case VK_NUMPAD2: numlock = 1; return KEY_JDN;
1205     case VK_NUMPAD3: numlock = 1; return KEY_JDNRT;
1206     case VK_NUMPAD4: numlock = 1; return KEY_JLF;
1207     case VK_NUMPAD5: numlock = 1; return KEY_CENTER;
1208     case VK_NUMPAD6: numlock = 1; return KEY_JRT;
1209     case VK_NUMPAD7: numlock = 1; return KEY_JUPLF;
1210     case VK_NUMPAD8: numlock = 1; return KEY_JUP;
1211     case VK_NUMPAD9: numlock = 1; return KEY_JUPRT;
1212    
1213     case VK_NUMLOCK: return KEY_NUMLOCK;
1214     case VK_MULTIPLY: return KEY_KPMULT;
1215     case VK_DIVIDE: return KEY_KPDIV;
1216     case VK_SUBTRACT: return KEY_KPMINUS;
1217     case VK_ADD: return KEY_KPPLUS;
1218     case VK_DECIMAL: return KEY_KPPERIOD;
1219    
1220     case VK_F9: return KEY_F9;
1221     case VK_F10: return KEY_F10;
1222     case VK_F11: return KEY_F11;
1223     case VK_F12: return KEY_F12;
1224     case VK_PAUSE: return KEY_PAUSE;
1225    
1226     case VK_BACK: return MATRIX(0,0);
1227     case VK_DELETE: return ext ? MATRIX(0,0) : /*KP*/ KEY_KPPERIOD;
1228     case VK_TAB: return -1;
1229     case VK_RETURN:
1230     if ((GetKeyState(VK_MENU) & 0x8000))
1231     return KEY_ALTENTER;
1232     if ((GetKeyState(VK_CONTROL) & 0x8000))
1233     return KEY_CTRLENTER;
1234     return ext ? /*KP*/ MATRIX(0,1) : MATRIX(0,1);
1235     case VK_SPACE: return MATRIX(7,4);
1236     case VK_ESCAPE: return MATRIX(7,7);
1237     case VK_INSERT: if (!ext) numlock = 0; return ext ? MATRIX(0,0) | 0x80 : /*KP*/ KEY_FIRE;
1238     case VK_HOME: if (!ext) numlock = 0; return ext ? MATRIX(6,3) : /*KP*/ KEY_JUPLF;
1239     case VK_END: if (!ext) numlock = 0; return ext ? MATRIX(6,0) : /*KP*/ KEY_JDNLF;
1240     case VK_PRIOR: if (!ext) numlock = 0; return ext ? MATRIX(6,6) : /*KP*/ KEY_JUPRT;
1241     case VK_NEXT: if (!ext) numlock = 0; return ext ? MATRIX(6,5) : /*KP*/ KEY_JDNRT;
1242     case VK_CLEAR: return KEY_CENTER;
1243    
1244     case VK_SHIFT: return sc == 0x36 ? /*R*/ MATRIX(6,4) : MATRIX(1,7);
1245     case VK_CONTROL: return ext ? /*R*/ MATRIX(7,5) : MATRIX(7,2);
1246     case VK_MENU: return ext ? /*R*/ MATRIX(7,5) : MATRIX(7,5);
1247    
1248     case VK_UP: if (!ext) numlock = 0; return ext ? MATRIX(0,7) | 0x80 : /*KP*/ KEY_JUP;
1249     case VK_DOWN: if (!ext) numlock = 0; return ext ? MATRIX(0,7) : /*KP*/ KEY_JDN;
1250     case VK_LEFT: if (!ext) numlock = 0; return ext ? MATRIX(0,2) | 0x80 : /*KP*/ KEY_JLF;
1251     case VK_RIGHT: if (!ext) numlock = 0; return ext ? MATRIX(0,2) : /*KP*/ KEY_JRT;
1252    
1253     case VK_F1: return MATRIX(0,4);
1254     case VK_F2: return MATRIX(0,4) | 0x80;
1255     case VK_F3: return MATRIX(0,5);
1256     case VK_F4: return MATRIX(0,5) | 0x80;
1257     case VK_F5: return MATRIX(0,6);
1258     case VK_F6: return MATRIX(0,6) | 0x80;
1259     case VK_F7: return MATRIX(0,3);
1260     case VK_F8: return MATRIX(0,3) | 0x80;
1261    
1262     case '0': return MATRIX(4,3);
1263     case '1': return MATRIX(7,0);
1264     case '2': return MATRIX(7,3);
1265     case '3': return MATRIX(1,0);
1266     case '4': return MATRIX(1,3);
1267     case '5': return MATRIX(2,0);
1268     case '6': return MATRIX(2,3);
1269     case '7': return MATRIX(3,0);
1270     case '8': return MATRIX(3,3);
1271     case '9': return MATRIX(4,0);
1272    
1273     case VK_bracketleft: return MATRIX(5,6);
1274     case VK_bracketright: return MATRIX(6,1);
1275     case VK_slash: return MATRIX(6,7);
1276     case VK_semicolon: return MATRIX(5,5);
1277     case VK_grave: return MATRIX(7,1);
1278     case VK_minus: return MATRIX(5,0);
1279     case VK_equal: return MATRIX(5,3);
1280     case VK_comma: return MATRIX(5,7);
1281     case VK_period: return MATRIX(5,4);
1282     case VK_quote: return MATRIX(6,2);
1283     case VK_backslash: return MATRIX(6,6);
1284    
1285     case 'A': result = MATRIX(1,2); break;
1286     case 'B': result = MATRIX(3,4); break;
1287     case 'C': result = MATRIX(2,4); break;
1288     case 'D': result = MATRIX(2,2); break;
1289     case 'E': result = MATRIX(1,6); break;
1290     case 'F': result = MATRIX(2,5); break;
1291     case 'G': result = MATRIX(3,2); break;
1292     case 'H': result = MATRIX(3,5); break;
1293     case 'I': result = MATRIX(4,1); break;
1294     case 'J': result = MATRIX(4,2); break;
1295     case 'K': result = MATRIX(4,5); break;
1296     case 'L': result = MATRIX(5,2); break;
1297     case 'M': result = MATRIX(4,4); break;
1298     case 'N': result = MATRIX(4,7); break;
1299     case 'O': result = MATRIX(4,6); break;
1300     case 'P': result = MATRIX(5,1); break;
1301     case 'Q': result = MATRIX(7,6); break;
1302     case 'R': result = MATRIX(2,1); break;
1303     case 'S': result = MATRIX(1,5); break;
1304     case 'T': result = MATRIX(2,6); break;
1305     case 'U': result = MATRIX(3,6); break;
1306     case 'V': result = MATRIX(3,7); break;
1307     case 'W': result = MATRIX(1,1); break;
1308     case 'X': result = MATRIX(2,7); break;
1309     case 'Y': result = MATRIX(3,1); break;
1310     case 'Z': result = MATRIX(1,4); break;
1311    
1312     }
1313    
1314     if (result != -1 && GetKeyState(VK_CAPITAL))
1315     result |= 0x80;
1316    
1317     return result;
1318     }
1319    
1320     BOOL C64Display::SetupWindow()
1321     {
1322     // Setup the window.
1323     SetupWindowMode(full_screen);
1324    
1325     UpdateWindow(hwnd);
1326    
1327     if (full_screen)
1328     ShowCursor(FALSE);
1329    
1330     return TRUE;
1331     }
1332    
1333     BOOL C64Display::SetupWindowMode(BOOL full_screen_mode)
1334     {
1335     DWORD style;
1336     int x0, y0, x, y;
1337     if (full_screen_mode) {
1338     style = fullscreen_style;
1339     x0 = 0;
1340     y0 = 0;
1341     x = GetSystemMetrics(SM_CXSCREEN);
1342     y = GetSystemMetrics(SM_CYSCREEN);
1343     }
1344     else {
1345     style = windowed_style;
1346     x0 = rcLast.left;
1347     y0 = rcLast.top;
1348     x = rcLast.right - rcLast.left;
1349     y = rcLast.bottom - rcLast.top;
1350     }
1351     SetWindowLong(hwnd, GWL_STYLE, style);
1352     SetWindowPos(hwnd, NULL, x0, y0, x, y, SWP_NOZORDER | SWP_NOACTIVATE);
1353     SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
1354     GetClientRect(hwnd, &rcWindow);
1355     if (!full_screen_mode && ThePrefs.ShowLEDs)
1356     rcWindow.bottom -= led_rows;
1357     ClientToScreen(hwnd, (LPPOINT) &rcWindow);
1358     ClientToScreen(hwnd, (LPPOINT) &rcWindow + 1);
1359    
1360     // Windowed mode has a menu, full screen mode doesn't.
1361     HMENU old_menu = GetMenu(hwnd);
1362     if (old_menu) {
1363     SetMenu(hwnd, NULL);
1364     DestroyMenu(old_menu);
1365     }
1366     if (!full_screen_mode) {
1367     HMENU new_menu = LoadMenu(hInstance, MAKEINTRESOURCE(IDR_MAIN_MENU));
1368     SetMenu(hwnd, new_menu);
1369     }
1370    
1371     return TRUE;
1372     }
1373    
1374     BOOL C64Display::RestoreWindow()
1375     {
1376     if (full_screen)
1377     ShowCursor(TRUE);
1378    
1379     if (!full_screen)
1380     GetWindowRect(hwnd, &rcLast);
1381    
1382     SetupWindowMode(FALSE);
1383    
1384     return TRUE;
1385     }
1386    
1387     HRESULT CALLBACK C64Display::EnumModesCallback(LPDDSURFACEDESC pDDSD, LPVOID lpContext)
1388     {
1389     C64Display *pDisplay = (C64Display *) lpContext;
1390     return pDisplay->EnumModesCallback(pDDSD);
1391     }
1392    
1393     HRESULT C64Display::EnumModesCallback(LPDDSURFACEDESC pDDSD)
1394     {
1395     DisplayMode mode;
1396     mode.x = pDDSD->dwWidth;
1397     mode.y = pDDSD->dwHeight;
1398     mode.depth = pDDSD->ddpfPixelFormat.dwRGBBitCount;
1399     mode.modex = (pDDSD->ddsCaps.dwCaps & DDSCAPS_MODEX) != 0;
1400     Debug("EnumModesCallback: %dx%dx%d (modex: %d)\n",
1401     mode.x, mode.y, mode.depth, mode.modex);
1402     if (display_modes == NULL)
1403     display_modes = new DisplayMode[max_display_modes];
1404     if (num_display_modes == max_display_modes) {
1405     int old_max = max_display_modes;
1406     max_display_modes *= 2;
1407     DisplayMode *new_modes = new DisplayMode[max_display_modes];
1408     memcpy(new_modes, display_modes, sizeof(DisplayMode)*old_max);
1409     delete[] display_modes;
1410     display_modes = new_modes;
1411     }
1412     display_modes[num_display_modes++] = mode;
1413     return DDENUMRET_OK;
1414     }
1415    
1416     int C64Display::CompareModes(const void *e1, const void *e2)
1417     {
1418     DisplayMode *m1 = (DisplayMode *) e1;
1419     DisplayMode *m2 = (DisplayMode *) e2;
1420     if (m1->depth != m2->depth)
1421     return m1->depth - m2->depth;
1422     if (m1->x != m2->x)
1423     return m1->x - m2->x;
1424     if (m1->y != m2->y)
1425     return m1->y - m2->y;
1426     if (m1->modex != m2->modex)
1427     return int(m1->modex) - int(m2->modex);
1428     return 0;
1429     }
1430    
1431     BOOL C64Display::StartDirectDraw()
1432     {
1433     // Setup our window size, position, style, etc.
1434     SetupWindow();
1435    
1436     // Create the main DirectDraw object.
1437     HRESULT ddrval = DirectDrawCreate(NULL, &pDD, NULL);
1438     if (ddrval != DD_OK) {
1439     DebugResult("DirectDrawCreate failed", ddrval);
1440     return Fail("Failed to initialize direct draw.");
1441     }
1442    
1443     if (full_screen) {
1444    
1445     // Set exclusive mode.
1446     ddrval = pDD->SetCooperativeLevel(hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX);
1447     if (ddrval != DD_OK) {
1448     DebugResult("SetCooperativeLevel failed", ddrval);
1449     return Fail("Failed to set exclusive cooperative level.");
1450     }
1451    
1452     if (!display_modes) {
1453    
1454     // Get all available video modes and sort them.
1455     num_display_modes = 0;
1456     pDD->EnumDisplayModes(0, NULL, this, EnumModesCallback);
1457     qsort(display_modes, num_display_modes, sizeof(DisplayMode), CompareModes);
1458     }
1459    
1460     // Set the video mode.
1461     const char *display_mode = ThePrefs.DisplayMode;
1462     if (display_mode[0] == '\0' ||
1463     stricmp(display_mode, "Default") == 0)
1464     display_mode = NULL;
1465     if (display_mode) {
1466     int x, y, depth = 8;
1467     if (sscanf(display_mode, "%dx%dx%d", &x, &y, &depth) < 2)
1468     return Fail("Invalid command line mode format.");
1469     ddrval = pDD->SetDisplayMode(x, y, depth);
1470     if (ddrval != DD_OK) {
1471     DebugResult("SetDisplayMode failed", ddrval);
1472     return Fail("Failed to set the video mode.");
1473     }
1474     }
1475     else {
1476     for (int i = 0; i < num_display_modes; i++) {
1477     DisplayMode *mode = &display_modes[i];
1478     if (mode->x < view_x || mode->y < view_y)
1479     continue;
1480     ddrval = pDD->SetDisplayMode(mode->x, mode->y, mode->depth);
1481     if (ddrval == DD_OK)
1482     break;
1483     }
1484     if (i == num_display_modes)
1485     return Fail("Failed to find a suitable video mode.");
1486     }
1487     }
1488     else {
1489    
1490     // Set normal mode.
1491     ddrval = pDD->SetCooperativeLevel(hwnd, DDSCL_NORMAL);
1492     if (ddrval != DD_OK)
1493     return Fail("Failed to set normal cooperative level.");
1494     }
1495    
1496     // Create the primary surface with one back buffer.
1497     DDSURFACEDESC ddsd;
1498     memset(&ddsd, 0, sizeof(ddsd));
1499     ddsd.dwSize = sizeof(ddsd);
1500     ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
1501     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
1502     ddsd.dwBackBufferCount = 1;
1503     ddrval = pDD->CreateSurface(&ddsd, &pPrimary, NULL);
1504     if (ddrval != DD_OK) {
1505     memset(&ddsd, 0, sizeof(ddsd));
1506     ddsd.dwSize = sizeof(ddsd);
1507     ddsd.dwFlags = DDSD_CAPS;
1508     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
1509     ddrval = pDD->CreateSurface(&ddsd, &pPrimary, NULL);
1510     if (ddrval != DD_OK)
1511     return Fail("Failed to create primary surface.");
1512     }
1513    
1514     if (ddsd.dwBackBufferCount == 1) {
1515     DDSCAPS ddscaps;
1516     ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
1517     ddrval = pPrimary->GetAttachedSurface(&ddscaps, &pBack);
1518     if (ddrval != DD_OK)
1519     return Fail("Failed to get attached surface.");
1520     }
1521    
1522     // Create work surface. It displays correctly without
1523     // this but doesn't handle clipping. We would have to
1524     // do that ourselves.
1525     memset(&ddsd, 0, sizeof(ddsd));
1526     ddsd.dwSize = sizeof(ddsd);
1527     ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
1528     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
1529     if (ThePrefs.SystemMemory)
1530     ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
1531     ddsd.dwHeight = DISPLAY_Y;
1532     ddsd.dwWidth = DISPLAY_X;
1533     ddrval = pDD->CreateSurface(&ddsd, &pWork, NULL);
1534     if (ddrval != DD_OK) {
1535     //return Fail("Failed to create work surface.");
1536     Debug("cannot create work surface: %d\n", ddrval);
1537     }
1538     if (pWork) {
1539     pWork->GetCaps(&ddsd.ddsCaps);
1540     if (ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)
1541     Debug("Work surface is in video memory.\n");
1542     else if (ddsd.ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
1543     Debug("Work surface is in system memory.\n");
1544     else
1545     Debug("Work surface is in unknown memory.\n");
1546     }
1547    
1548     if (!full_screen) {
1549    
1550     // Create clipper object.
1551     ddrval = pDD->CreateClipper(0, &pClipper, NULL);
1552     if (ddrval != DD_OK)
1553     return Fail("Failed to create direct draw clipper.");
1554     ddrval = pClipper->SetHWnd(0, hwnd);
1555     if (ddrval != DD_OK)
1556     return Fail("Failed setting clipper window handle.");
1557     ddrval = pPrimary->SetClipper(pClipper);
1558     if (ddrval != DD_OK)
1559     return Fail("Failed setting primary surface clipper.");
1560     }
1561    
1562     // We need to use a 256 color palette otherwise we get an
1563     // invalid pixel format error when trying to set the palette
1564     // on a windowed surface.
1565     PALETTEENTRY ape[256];
1566     HDC hdc = GetDC(NULL);
1567     int entries = GetSystemPaletteEntries(hdc, 0, 256, ape);
1568     ReleaseDC(NULL, hdc);
1569     if (entries != 256) {
1570     Debug("failed to get 256 system palette entries: %d (%d)\n",
1571     entries, GetLastError());
1572    
1573     // Build a 332 palette as the default. This makes it easy for
1574     // other apps to find colors when they aren't the foreground.
1575     for (int i = 0; i < 256; i++) {
1576     ape[i].peRed = (BYTE)(((i >> 5) & 0x07) * 255 / 7);
1577     ape[i].peGreen = (BYTE)(((i >> 2) & 0x07) * 255 / 7);
1578     ape[i].peBlue = (BYTE)(((i >> 0) & 0x03) * 255 / 3);
1579     ape[i].peFlags = 0;
1580     }
1581     }
1582    
1583     // Now override the first 16 entries with the C64 colors.
1584     // If we were really obsessive we could try to find the
1585     // nearest matches and replace them instead.
1586     for (int i = 0; i < 16; i++) {
1587     ape[i].peRed = palette_red[i];
1588     ape[i].peGreen = palette_green[i];
1589     ape[i].peBlue = palette_blue[i];
1590     ape[i].peFlags = 0;
1591     }
1592    
1593     // Create the palette and set it on all surfaces.
1594     ddrval = pDD->CreatePalette(DDPCAPS_8BIT, ape, &pPalette, NULL);
1595     if (ddrval != DD_OK)
1596     return Fail("Failed to create palette.");
1597     if (!SetPalettes())
1598     return Fail("Failed to set palettes.");
1599     if (!BuildColorTable())
1600     return Fail("Failed to build color table.");
1601    
1602     // Start with a clean slate.
1603     if (!EraseSurfaces()) {
1604     // Some display drivers have bugs, I guess.
1605     // What's a little problem erasing gonna hurt.
1606     #if 0
1607     return Fail("Failed to erase surfaces.");
1608     #endif
1609     }
1610    
1611    
1612     return TRUE;
1613     }
1614    
1615     BOOL C64Display::ResumeDirectDraw()
1616     {
1617     if (!RestoreSurfaces())
1618     ResetDirectDraw();
1619    
1620     return TRUE;
1621     }
1622    
1623     BOOL C64Display::ResetDirectDraw()
1624     {
1625     Pause();
1626     StopDirectDraw();
1627     StartDirectDraw();
1628     Resume();
1629     if (paused)
1630     Update();
1631    
1632     return TRUE;
1633     }
1634    
1635     BOOL C64Display::StopDirectDraw()
1636     {
1637     if (pDD != NULL) {
1638     if (pClipper != NULL) {
1639     pClipper->Release();
1640     pClipper = NULL;
1641     }
1642     if (pWork != NULL) {
1643     pWork->Release();
1644     pWork = NULL;
1645     }
1646     if (pBack != NULL) {
1647     pBack->Release();
1648     pBack = NULL;
1649     }
1650     if (pPrimary != NULL) {
1651     pPrimary->Release();
1652     pPrimary = NULL;
1653     }
1654     if (pPalette != NULL) {
1655     pPalette->Release();
1656     pPalette = NULL;
1657     }
1658     pDD->RestoreDisplayMode();
1659     pDD->Release();
1660     pDD = NULL;
1661     }
1662    
1663     // Restore windowing state, window position, etc.
1664     RestoreWindow();
1665    
1666     return TRUE;
1667     }
1668    
1669    
1670     /*
1671     * This function is called if the initialization function fails
1672     */
1673     BOOL C64Display::Fail(const char *error)
1674     {
1675     Debug(error);
1676     Debug("\n");
1677     strcpy(failure_message, error);
1678     return FALSE;
1679     }
1680    
1681    
1682     BOOL C64Display::SetPalettes()
1683     {
1684     // Only try to set palettes when in 256 color mode.
1685     HDC hdc = GetDC(NULL);
1686     int depth = GetDeviceCaps(hdc, PLANES) * GetDeviceCaps(hdc, BITSPIXEL);
1687     ReleaseDC(NULL, hdc);
1688     if (depth != 8)
1689     return TRUE;
1690    
1691     // Set palette on primary surface.
1692     HRESULT ddrval = pPrimary->SetPalette(pPalette);
1693     if (ddrval == DDERR_SURFACELOST) {
1694     pPrimary->Restore();
1695     ddrval = pPrimary->SetPalette(pPalette);
1696     }
1697     if (ddrval == DDERR_NOT8BITCOLOR)
1698     return TRUE;
1699     if (ddrval != DD_OK) {
1700     DebugResult("failed to set palette on primary", ddrval);
1701     return FALSE;
1702     }
1703    
1704     // Set palette on back surface.
1705     if (pBack) {
1706     FlipSurfaces();
1707     pPrimary->SetPalette(pPalette);
1708     if (ddrval == DDERR_SURFACELOST) {
1709     pPrimary->Restore();
1710     ddrval = pPrimary->SetPalette(pPalette);
1711     }
1712     if (ddrval != DD_OK) {
1713     DebugResult("failed to set palette on back", ddrval);
1714     return FALSE;
1715     }
1716     }
1717    
1718     // Set palette on work surface.
1719     if (pWork) {
1720     ddrval = pWork->SetPalette(pPalette);
1721     if (ddrval == DDERR_SURFACELOST) {
1722     pWork->Restore();
1723     ddrval = pWork->SetPalette(pPalette);
1724     }
1725     if (ddrval != DD_OK) {
1726     DebugResult("failed to set palette on work", ddrval);
1727     return FALSE;
1728     }
1729     }
1730    
1731     return TRUE;
1732     }
1733    
1734     BOOL C64Display::BuildColorTable()
1735     {
1736     if (!pPrimary)
1737     return FALSE;
1738    
1739     // Determine the physical colors corresponding to the 16 C64 colors.
1740     for (int j = 0; j < 16; j++) {
1741    
1742     // Compute the true color in RGB format.
1743     int red = palette_red[j];
1744     int green = palette_green[j];
1745     int blue = palette_blue[j];
1746     COLORREF rgb = RGB(red, green, blue);
1747    
1748     // Set pixel(0, 0) to that value.
1749     LPDIRECTDRAWSURFACE pSurface = pBack ? pBack : pPrimary;
1750     HDC hdc;
1751     if (pSurface->GetDC(&hdc) != DD_OK)
1752     return Fail("Failed getting direct draw device context.");
1753     COLORREF new_rgb = SetPixel(hdc, 0, 0, PALETTERGB(red, green, blue));
1754     Debug("new: %.8x, old %.8x\n", new_rgb, rgb);
1755     pSurface->ReleaseDC(hdc);
1756    
1757     // Read the physical color from linear memory.
1758     DDSURFACEDESC ddsd;
1759     ddsd.dwSize = sizeof(ddsd);
1760     HRESULT ddrval;
1761     for (;;) {
1762     ddrval = pSurface->Lock(NULL, &ddsd, 0, NULL);
1763     if (ddrval != DDERR_WASSTILLDRAWING)
1764     break;
1765     }
1766     if (ddrval != DD_OK)
1767     return Fail("Failed to lock surface.");
1768     colors_depth = ddsd.ddpfPixelFormat.dwRGBBitCount;
1769     DWORD dw = *(DWORD *) ddsd.lpSurface;
1770     Debug("DWORD = %.8x, depth = %d\n", dw, colors_depth);
1771     if (colors_depth != 32)
1772     dw &= (1 << colors_depth) - 1;
1773     pSurface->Unlock(NULL);
1774    
1775     // Store the physical color in the colors array.
1776     colors[j] = dw;
1777     Debug("colors[%d] = %d\n", j, dw);
1778     }
1779    
1780     // Replicate the physical colors into the rest of the color array.
1781     for (int k = 16; k < 256; k++)
1782     colors[k] = colors[k & 0x0f];
1783    
1784     // Tell the VIC all about it;
1785     if (!in_constructor)
1786     TheC64->TheVIC->ReInitColors();
1787    
1788     return TRUE;
1789     }
1790    
1791     /*
1792     * Redraw bitmap using double buffering when possible.
1793     */
1794    
1795     void C64Display::Update()
1796     {
1797     TIMESCOPE(ts0, "Update");
1798    
1799     //Debug("Display::Update\n");
1800    
1801     if (full_screen && !active)
1802     return;
1803    
1804     if (!pPrimary)
1805     return;
1806    
1807     #ifdef WORKBUFFER_BITMAP
1808     // Special case for using the workbuffer as a bitmap.
1809     if (workbuffer_bitmap) {
1810     if (workbuffer_locked) {
1811     pWork->Unlock(NULL);
1812     workbuffer_locked = FALSE;
1813     }
1814     RECT rc;
1815     rc.left = (DISPLAY_X - view_x)/2;
1816     rc.top = (DISPLAY_Y - view_y)/2 - 1;
1817     if (rc.top < 0)
1818     rc.top = 0;
1819     rc.right = rc.left + view_x;
1820     rc.bottom = rc.top + view_y;
1821     CopySurface(rc);
1822     draw_leds();
1823     return;
1824    
1825     }
1826     #endif
1827    
1828     // Work on the backing surface unless there isn't one.
1829     // We'll flip to it when we're done.
1830     LPDIRECTDRAWSURFACE pSurface = pBack ? pBack : pPrimary;
1831    
1832     // Use a work surface when we have to:
1833     // * when always copy is on
1834     // * when possibly clipped
1835     // * when streching
1836     // * when partially offscreen
1837    
1838     if (!full_screen && pWork) {
1839     if (ThePrefs.AlwaysCopy || !active || paused ||
1840     #if 0
1841     GetForegroundWindow() != hwnd ||
1842     #endif
1843     rcWindow.right - rcWindow.left != view_x ||
1844     rcWindow.bottom - rcWindow.top != view_y ||
1845     rcWindow.left < rcScreen.left ||
1846     rcWindow.top < rcScreen.top ||
1847     rcWindow.right > rcScreen.right ||
1848     rcWindow.bottom > rcScreen.bottom) {
1849     pSurface = pWork;
1850     //Debug("using work surface\n");
1851     }
1852     }
1853    
1854     // Lock the surface.
1855     DDSURFACEDESC ddsd;
1856     ddsd.dwSize = sizeof(ddsd);
1857    
1858     for (;;) {
1859     HRESULT ddrval = pSurface->Lock(NULL, &ddsd, 0, NULL);
1860     if (ddrval == DD_OK)
1861     break;
1862     if (ddrval == DDERR_SURFACELOST) {
1863     Debug("surface lost\n");
1864     if (pSurface == pWork)
1865     ddrval = pWork->Restore();
1866     else
1867     ddrval = pPrimary->Restore();
1868     if (ddrval != DD_OK) {
1869     DebugResult("surface Restore failed", ddrval);
1870     return;
1871     }
1872     EraseSurfaces();
1873     BuildColorTable();
1874     }
1875     else if (ddrval != DDERR_WASSTILLDRAWING) {
1876     if (pWork && pSurface != pWork)
1877     pSurface = pWork;
1878     else {
1879     DebugResult("surface Lock failed", ddrval);
1880     return;
1881     }
1882     }
1883     Debug("was still drawing\n");
1884     }
1885    
1886     // Compute the optimal placement of our window depending on
1887     // the screen dimensions.
1888     int x_off, y_off;
1889     int x_beg, y_beg;
1890     int x_siz, y_siz;
1891    
1892     // XXX: Do these calculations only when the parameters change.
1893     if (full_screen) {
1894     if (rcWindow.right >= view_x) {
1895     x_off = (rcWindow.right - view_x)/2;
1896     x_beg = (DISPLAY_X - view_x)/2;
1897     x_siz = view_x;
1898     }
1899     else {
1900     x_off = 0;
1901     x_beg = (DISPLAY_X - rcWindow.right)/2;
1902     x_siz = rcWindow.right;
1903     }
1904     if (rcWindow.bottom >= view_y) {
1905     y_off = (rcWindow.bottom - view_y)/2;
1906     y_beg = (DISPLAY_Y - view_y)/2 - 1;
1907     y_siz = view_y;
1908     }
1909     else {
1910     y_off = 0;
1911     y_beg = (DISPLAY_Y - rcWindow.bottom)/2 - 1;
1912     y_siz = rcWindow.bottom;
1913     }
1914     }
1915     else {
1916     if (pSurface == pWork) {
1917     x_off = 0;
1918     y_off = 0;
1919     }
1920     else {
1921     x_off = rcWindow.left;
1922     y_off = rcWindow.top;
1923     }
1924     x_beg = (DISPLAY_X - view_x)/2;
1925     y_beg = (DISPLAY_Y - view_y)/2 - 1;
1926     x_siz = view_x;
1927     y_siz = view_y;
1928     }
1929     if (y_beg < 0)
1930     y_beg = 0;
1931    
1932     // Translate chunky colors into the surface's linear memory.
1933     int pitch = ddsd.lPitch;
1934     int depth = ddsd.ddpfPixelFormat.dwRGBBitCount;
1935     BYTE *surface = (BYTE *) ddsd.lpSurface + pitch*y_off + x_off*(depth/8);
1936     BYTE *chunky = chunky_buf + DISPLAY_X*y_beg + x_beg;
1937    
1938     // These tight loops are where the display speed action is at.
1939     // Note that MSVC optimizes out the mulitiplications and
1940     // reverses the direction of the loop counters automatically.
1941     if (depth == 8) {
1942    
1943     // Since the VIC is using our palette entries we just copy.
1944     //TIMESCOPE(ts1, "hand blt 8");
1945     BYTE *scanline = surface;
1946     BYTE *scanbuf = chunky;
1947     //Debug("scanline = %8p, scanbuf = %8p\n", scanline, scanbuf);
1948     for (int j = 0; j < y_siz; j++) {
1949     memcpy(scanline, scanbuf, x_siz);
1950     scanline += pitch;
1951     scanbuf += DISPLAY_X;
1952     }
1953     }
1954     else if (depth == 16) {
1955     //TIMESCOPE(ts1, "hand blt 16");
1956     for (int j = 0; j < y_siz; j++) {
1957     WORD *scanline = (WORD *) (surface + pitch*j);
1958     BYTE *scanbuf = chunky + +DISPLAY_X*j;
1959     for (int i = 0; i < x_siz; i++)
1960     *scanline++ = (WORD) colors[*scanbuf++];
1961     }
1962     }
1963     else if (depth == 24) {
1964    
1965     // XXX: Works for little-endian only.
1966     //TIMESCOPE(ts1, "hand blt 24");
1967     for (int j = 0; j < y_siz; j++) {
1968     BYTE *scanline = surface + pitch*j;
1969     BYTE *scanbuf = chunky + +DISPLAY_X*j;
1970     for (int i = 0; i < x_siz; i++) {
1971     *((DWORD *) scanline) = colors[*scanbuf++];
1972     scanline += 3;
1973     }
1974     }
1975     }
1976     else if (depth == 32) {
1977     //TIMESCOPE(ts1, "hand blt 32");
1978     for (int j = 0; j < y_siz; j++) {
1979     DWORD *scanline = (DWORD *) (surface + pitch*j);
1980     BYTE *scanbuf = chunky + +DISPLAY_X*j;
1981     for (int i = 0; i < x_siz; i++)
1982     *scanline++ = colors[*scanbuf++];
1983     }
1984     }
1985     else
1986     Debug("PixelCount not 8, 16, 24, or 32\n");
1987    
1988     // Unlock the surface.
1989     HRESULT ddrval = pSurface->Unlock(NULL);
1990     if (ddrval != DD_OK)
1991     Debug("DirectDrawSurface::Unlock failed\n");
1992    
1993     // Now flip from the primary surface to the backing surface.
1994     if (pSurface == pWork)
1995     CopySurface(rcWork);
1996     else if (full_screen && pBack)
1997     FlipSurfaces();
1998    
1999     // Update drive LEDs
2000     draw_leds();
2001     }
2002    
2003    
2004     BOOL C64Display::CopySurface(RECT &rcWork)
2005     {
2006     // Copy work surface to primary.
2007     for (;;) {
2008     HRESULT ddrval = pPrimary->Blt(&rcWindow, pWork, &rcWork, DDBLT_WAIT, NULL);
2009     if (ddrval == DD_OK)
2010     break;
2011     if (ddrval == DDERR_SURFACELOST) {
2012     ddrval = pPrimary->Restore();
2013     if (ddrval != DD_OK) {
2014     DebugResult("CopySurface Restore failed", ddrval);
2015     return FALSE;
2016     }
2017     }
2018     else if (ddrval != DDERR_WASSTILLDRAWING) {
2019     DebugResult("CopySurface Blt failed", ddrval);
2020     return FALSE;
2021     }
2022     }
2023     return TRUE;
2024     }
2025    
2026     BOOL C64Display::FlipSurfaces()
2027     {
2028     // Flip buffers.
2029     for (;;) {
2030     HRESULT ddrval = pPrimary->Flip(NULL, 0);
2031     if (ddrval == DD_OK)
2032     break;
2033     if (ddrval == DDERR_SURFACELOST) {
2034     ddrval = pPrimary->Restore();
2035     if (ddrval != DD_OK) {
2036     Debug("Restore failed\n");
2037     return FALSE;
2038     }
2039     }
2040     else if (ddrval != DDERR_WASSTILLDRAWING)
2041     return FALSE;
2042     }
2043     return TRUE;
2044     }
2045    
2046     BOOL C64Display::EraseSurfaces()
2047     {
2048     DDBLTFX ddbltfx;
2049     ddbltfx.dwSize = sizeof(ddbltfx);
2050     ddbltfx.dwFillColor = 0;
2051    
2052     // Erase the backing surface.
2053     for (;;) {
2054     if (!pBack)
2055     break;
2056     HRESULT ddrval = pBack->Blt(&rcWindow, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
2057    
2058     if (ddrval == DD_OK)
2059     break;
2060    
2061     if (ddrval == DDERR_SURFACELOST) {
2062     ddrval = pPrimary->Restore();
2063     if (ddrval != DD_OK) {
2064     DebugResult("Restore primary failed", ddrval);
2065     return FALSE;
2066     }
2067     }
2068     else if (ddrval != DDERR_WASSTILLDRAWING) {
2069     DebugResult("Blt erase back failed", ddrval);
2070     return FALSE;
2071     }
2072     }
2073    
2074     // Erase the primary surface.
2075     for (;;) {
2076     HRESULT ddrval = pPrimary->Blt(&rcWindow, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
2077    
2078     if (ddrval == DD_OK)
2079     break;
2080    
2081     if (ddrval == DDERR_SURFACELOST) {
2082     ddrval = pPrimary->Restore();
2083     if (ddrval != DD_OK) {
2084     DebugResult("Restore primary failed", ddrval);
2085     return FALSE;
2086     }
2087     }
2088     else if (ddrval != DDERR_WASSTILLDRAWING) {
2089     DebugResult("Blt erase primary failed", ddrval);
2090     return FALSE;
2091     }
2092     }
2093    
2094     return TRUE;
2095     }
2096    
2097     BOOL C64Display::RestoreSurfaces()
2098     {
2099     if (pPrimary) {
2100     HRESULT ddrval = pPrimary->Restore();
2101     if (ddrval != DD_OK)
2102     return FALSE;
2103     }
2104    
2105     if (pWork) {
2106     HRESULT ddrval = pWork->Restore();
2107     if (ddrval != DD_OK)
2108     return FALSE;
2109     }
2110    
2111     return TRUE;
2112     }
2113    
2114     /*
2115     * Draw LED bar at the bottom of the window
2116     */
2117    
2118     void C64Display::draw_led_bar()
2119     {
2120     if (full_screen || !ThePrefs.ShowLEDs)
2121     return;
2122    
2123     HDC hdc = GetDC(hwnd);
2124     RECT rc;
2125     GetClientRect(hwnd, &rc);
2126     rc.top = rc.bottom - led_rows;
2127     FillRect(hdc, &rc, led_brush);
2128     if (rc.right - rc.left > view_x)
2129     rc.left = rc.right - view_x;
2130     SelectObject(hdc, led_font);
2131     SetTextAlign(hdc, TA_TOP | TA_RIGHT);
2132     SetBkMode(hdc, TRANSPARENT);
2133     SetTextColor(hdc, (COLORREF) GetSysColor(COLOR_MENUTEXT));
2134     for (int i = 0; i < 4; i++) {
2135     char str[128];
2136     if (rc.right - rc.left < view_x)
2137     sprintf(str, "%d", i + 8);
2138     else
2139     sprintf(str, "Drive %d", i + 8);
2140     RECT led;
2141     led_rect(i, rc, led);
2142     SelectObject(hdc, led_shadow);
2143     MoveToEx(hdc, led.left - 1, led.bottom - 1, NULL);
2144     LineTo(hdc, led.left - 1, led.top - 1);
2145     LineTo(hdc, led.right, led.top - 1);
2146     SelectObject(hdc, led_highlight);
2147     LineTo(hdc, led.right, led.bottom);
2148     LineTo(hdc, led.left - 2, led.bottom);
2149     TextOut(hdc, led.left - 4, rc.top + 2, str, strlen(str));
2150     }
2151     ReleaseDC(hwnd, hdc);
2152     draw_leds(TRUE);
2153     }
2154    
2155     /*
2156     * Draw one LED
2157     */
2158    
2159     void C64Display::draw_leds(BOOL force)
2160     {
2161     if (full_screen || !ThePrefs.ShowLEDs)
2162     return;
2163    
2164     if (!force) {
2165     int i;
2166     for (i = 0; i < 4; i++) {
2167     if (led_state[i] != old_led_state[i])
2168     break;
2169     }
2170     if (i == 4)
2171     return;
2172     }
2173    
2174     HDC hdc = GetDC(hwnd);
2175     RECT rc;
2176     GetClientRect(hwnd, &rc);
2177     rc.top = rc.bottom - led_rows;
2178     if (rc.right - rc.left > view_x)
2179     rc.left = rc.right - view_x;
2180     for (int i = 0; i < 4; i++) {
2181     old_led_state[i] = led_state[i];
2182     HBRUSH brush;
2183     switch (led_state[i]) {
2184     case LED_OFF: brush = off_brush; break;
2185     case LED_ERROR_OFF: brush = error_off_brush; break;
2186     case LED_ON: brush = on_brush; break;
2187     case LED_ERROR_ON: brush = error_on_brush; break;
2188     }
2189     RECT led;
2190     led_rect(i, rc, led);
2191     FillRect(hdc, &led, brush);
2192     }
2193     ReleaseDC(hwnd, hdc);
2194     }
2195    
2196     void C64Display::led_rect(int n, RECT &rc, RECT &led)
2197     {
2198     int x = rc.left + (rc.right - rc.left)*(n + 2)/5 - 20;
2199     int y = rc.top + 2 + led_rows/3;
2200     SetRect(&led, x, y, x + 13, y + led_rows/3);
2201     }
2202    
2203     void C64Display::InsertNextDisk()
2204     {
2205     if (strlen(ThePrefs.DrivePath[0]) > 4) {
2206     char str[256];
2207     strcpy(str, ThePrefs.DrivePath[0]);
2208     char *p = str + strlen(str) - 5;
2209    
2210     // If path matches "*.?64", increment character before the '.'
2211     if (p[1] == '.' && p[3] == '6' && p[4] == '4') {
2212     p[0]++;
2213    
2214     // If no such file exists, set character before the '.' to '1', 'a' or 'A'
2215     FILE *file;
2216     if ((file = fopen(str, "rb")) == NULL) {
2217     if (isdigit(p[0]))
2218     p[0] = '1';
2219     else if (isupper(p[0]))
2220     p[0] = 'A';
2221     else
2222     p[0] = 'a';
2223     } else
2224     fclose(file);
2225    
2226     // Set new prefs
2227     Pause();
2228     Prefs *prefs = new Prefs(ThePrefs);
2229     strcpy(prefs->DrivePath[0], str);
2230     TheC64->NewPrefs(prefs);
2231     ThePrefs = *prefs;
2232     delete prefs;
2233     Resume();
2234     }
2235     }
2236     }
2237    
2238     BOOL C64Display::FileNameDialog(char *prefs_path, BOOL save)
2239     {
2240     char filename[256];
2241     strcpy(filename, prefs_path);
2242     OPENFILENAME ofn;
2243     memset(&ofn, 0, sizeof(ofn));
2244     ofn.lStructSize = sizeof(ofn);
2245     ofn.hwndOwner = hwnd;
2246     ofn.hInstance = hInstance;
2247     ofn.lpstrFilter =
2248     "Preferences Files (*.fpr)\0*.fpr\0"
2249     "All Files (*.*)\0*.*\0"
2250     ;
2251     ofn.lpstrCustomFilter = NULL;
2252     ofn.nMaxCustFilter = 0;
2253     ofn.nFilterIndex = 1;
2254     ofn.lpstrFile = filename;
2255     ofn.nMaxFile = sizeof(filename);
2256     ofn.lpstrFileTitle = NULL;
2257     ofn.nMaxFileTitle = 0;
2258     ofn.lpstrInitialDir = NULL;
2259     ofn.lpstrTitle = NULL;
2260     ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_NOTESTFILECREATE |
2261     OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR | OFN_SHAREAWARE;
2262     ofn.nFileOffset = 0;
2263     ofn.nFileExtension = 0;
2264     ofn.lpstrDefExt = "fpr";
2265     ofn.lpfnHook = NULL;
2266     ofn.lpTemplateName = NULL;
2267     BOOL result = save ? GetSaveFileName(&ofn) : GetOpenFileName(&ofn);
2268     if (result) {
2269     char cwd[256];
2270     GetCurrentDirectory(sizeof(cwd), cwd);
2271     int cwd_len = strlen(cwd);
2272     if (cwd_len > 0 && cwd[cwd_len - 1] != '\\') {
2273     strcat(cwd, "\\");
2274     cwd_len++;
2275     }
2276     if (strnicmp(filename, cwd, cwd_len) == 0)
2277     strcpy(prefs_path, filename + cwd_len);
2278     else
2279     strcpy(prefs_path, filename);
2280     }
2281     return result;
2282     }
2283    
2284     void C64Display::WindowTitle()
2285     {
2286     // Show the program name, the current preferences file,
2287     // and the paused state or the speedometer.
2288     const char *prefs_path = TheApp->prefs_path;
2289     int prefs_path_length = strlen(prefs_path);
2290     if (prefs_path_length > 4 &&
2291     stricmp(prefs_path + prefs_path_length - 4, ".fpr") == 0)
2292     prefs_path_length -= 4;
2293     const char *info = NULL;
2294     char tmp[128];
2295     if (waiting)
2296     info = "PAUSED";
2297     else if (!ThePrefs.ShowLEDs && speed_index != 0) {
2298     if (IsFrodoSC)
2299     sprintf(tmp, "%.1f%%", speed_index);
2300     else
2301     sprintf(tmp, "%.0f%%", speed_index);
2302     info = tmp;
2303     }
2304     const char *sep1 = info ? " (" : "";
2305     const char *sep2 = info ? ")" : "";
2306     char title[256];
2307     sprintf(title, "%s - %.*s%s%s%s", TITLE,
2308     prefs_path_length, prefs_path, sep1, info ? info : "", sep2);
2309     SetWindowText(hwnd, title);
2310     }
2311    
2312     void C64Display::NewPrefs()
2313     {
2314     // Resize the window to the new viewport while preserving
2315     // as closely as possible the previous scaling factors.
2316     RECT rc;
2317     GetWindowRect(hwnd, &rc);
2318     int x_nc = rc.right - rc.left - (rcWindow.right - rcWindow.left);
2319     int y_nc = rc.bottom - rc.top - (rcWindow.bottom - rcWindow.top);
2320     if (show_leds)
2321     y_nc -= led_rows;
2322     double x_scale = double(rcWindow.right - rcWindow.left)/view_x;
2323     double y_scale = double(rcWindow.bottom - rcWindow.top)/view_y;
2324     if (CalcViewPort() || show_leds != ThePrefs.ShowLEDs) {
2325     show_leds = ThePrefs.ShowLEDs;
2326     rc.right = int(rc.left + x_scale*view_x + x_nc);
2327     rc.bottom = int(rc.top + y_scale*view_y + y_nc);
2328     if (show_leds)
2329     rc.bottom += led_rows;
2330     ResizeWindow(WMSZ_BOTTOMRIGHT, &rc);
2331     MoveWindow(hwnd, rc.left, rc.top,
2332     rc.right - rc.left,
2333     rc.bottom - rc.top, TRUE);
2334     }
2335    
2336     // The prefs filename might have changed.
2337     WindowTitle();
2338     }
2339    
2340     void C64Display::OfferSave()
2341     {
2342     if (ThePrefs == ThePrefsOnDisk)
2343     return;
2344     const char *str = "Preferences have changed.\nSave preferences now?";
2345     int result = MessageBox(hwnd, str, "Frodo", MB_YESNO | MB_ICONQUESTION);
2346     if (result == IDYES)
2347     ThePrefs.Save(TheApp->prefs_path);
2348     }
2349    
2350     void C64Display::Pause()
2351     {
2352     // It's not safe to call this from the contructor or destructor.
2353     if (in_constructor || in_destructor)
2354     return;
2355    
2356     if (paused == 0)
2357     TheC64->Pause();
2358     paused++;
2359     }
2360    
2361     void C64Display::Resume()
2362     {
2363     // It's not safe to call this from the contructor or destructor.
2364     if (in_constructor || in_destructor)
2365     return;
2366    
2367     if (paused > 0) {
2368     paused--;
2369     if (!paused)
2370     TheC64->Resume();
2371     }
2372     else
2373     _ASSERTE(paused > 0);
2374     }
2375    
2376     void C64Display::Quit()
2377     {
2378     quit = 1;
2379     TheC64->Quit();
2380     }

Christian Bauer">Christian Bauer
ViewVC Help
Powered by ViewVC 1.1.17