Mercurial > vba-clojure

comparison src/win32/MainWndOptions.cpp @ 1:f9f4f1b99eed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
importing src directory
author Robert McIntyre <rlm@mit.edu>
date Sat, 03 Mar 2012 10:31:27 -0600
parents
children
comparison
equal deleted inserted replaced
0:8ced16adf2e1 1:f9f4f1b99eed
1 #include "stdafx.h"
2 #include "resource.h"
3 #include "MainWnd.h"
4 #include "Associate.h"
5 #include "Directories.h"
6 #include "FileDlg.h"
7 #include "GBColorDlg.h"
8 #include "Joypad.h"
9 #include "MaxScale.h"
10 #include "ModeConfirm.h"
11 #include "Reg.h"
12 #include "RewindInterval.h"
13 #include "Throttle.h"
14 #include "TextOptions.h"
15 #include "WinResUtil.h"
16 #include "VBA.h"
17
18 #include "../gba/GBA.h"
19 #include "../gba/GBAGlobals.h"
20 #include "../gba/Flash.h"
21 #include "../gba/GBASound.h"
22 #include "../gba/agbprint.h"
23 #include "../gb/GB.h"
24 #include "../gb/gbGlobals.h"
25 #include "../gb/gbPrinter.h"
26 #include "../common/inputGlobal.h"
27 #include "../common/movie.h"
28 #include "../version.h"
29
30 extern int emulating;
31
32 #define VBA_CONFIRM_MODE WM_APP + 100
33
34 void MainWnd::OnOptionsFrameskipThrottleNothrottle()
35 {
36 systemSetThrottle(0);
37 }
38
39 void MainWnd::OnUpdateOptionsFrameskipThrottleNothrottle(CCmdUI*pCmdUI)
40 {
41 pCmdUI->SetCheck(theApp.throttle == 0);
42 }
43
44 void MainWnd::OnOptionsFrameskipThrottle6()
45 {
46 systemSetThrottle(6);
47 }
48
49 void MainWnd::OnUpdateOptionsFrameskipThrottle6(CCmdUI*pCmdUI)
50 {
51 pCmdUI->SetCheck(theApp.throttle == 6);
52 }
53
54 void MainWnd::OnOptionsFrameskipThrottle15()
55 {
56 systemSetThrottle(15);
57 }
58
59 void MainWnd::OnUpdateOptionsFrameskipThrottle15(CCmdUI*pCmdUI)
60 {
61 pCmdUI->SetCheck(theApp.throttle == 15);
62 }
63
64 void MainWnd::OnOptionsFrameskipThrottle25()
65 {
66 systemSetThrottle(25);
67 }
68
69 void MainWnd::OnUpdateOptionsFrameskipThrottle25(CCmdUI*pCmdUI)
70 {
71 pCmdUI->SetCheck(theApp.throttle == 25);
72 }
73
74 void MainWnd::OnOptionsFrameskipThrottle50()
75 {
76 systemSetThrottle(50);
77 }
78
79 void MainWnd::OnUpdateOptionsFrameskipThrottle50(CCmdUI*pCmdUI)
80 {
81 pCmdUI->SetCheck(theApp.throttle == 50);
82 }
83
84 void MainWnd::OnOptionsFrameskipThrottle75()
85 {
86 systemSetThrottle(75);
87 }
88
89 void MainWnd::OnUpdateOptionsFrameskipThrottle75(CCmdUI*pCmdUI)
90 {
91 pCmdUI->SetCheck(theApp.throttle == 75);
92 }
93
94 void MainWnd::OnOptionsFrameskipThrottle100()
95 {
96 systemSetThrottle(100);
97 }
98
99 void MainWnd::OnUpdateOptionsFrameskipThrottle100(CCmdUI*pCmdUI)
100 {
101 pCmdUI->SetCheck(theApp.throttle == 100);
102 }
103
104 void MainWnd::OnOptionsFrameskipThrottle125()
105 {
106 systemSetThrottle(125);
107 }
108
109 void MainWnd::OnUpdateOptionsFrameskipThrottle125(CCmdUI*pCmdUI)
110 {
111 pCmdUI->SetCheck(theApp.throttle == 125);
112 }
113
114 void MainWnd::OnOptionsFrameskipThrottle150()
115 {
116 systemSetThrottle(150);
117 }
118
119 void MainWnd::OnUpdateOptionsFrameskipThrottle150(CCmdUI*pCmdUI)
120 {
121 pCmdUI->SetCheck(theApp.throttle == 150);
122 }
123
124 void MainWnd::OnOptionsFrameskipThrottle200()
125 {
126 systemSetThrottle(200);
127 }
128
129 void MainWnd::OnUpdateOptionsFrameskipThrottle200(CCmdUI*pCmdUI)
130 {
131 pCmdUI->SetCheck(theApp.throttle == 200);
132 }
133
134 void MainWnd::OnOptionsFrameskipThrottle300()
135 {
136 systemSetThrottle(300);
137 }
138
139 void MainWnd::OnUpdateOptionsFrameskipThrottle300(CCmdUI*pCmdUI)
140 {
141 pCmdUI->SetCheck(theApp.throttle == 300);
142 }
143
144 void MainWnd::OnOptionsFrameskipThrottle400()
145 {
146 systemSetThrottle(400);
147 }
148
149 void MainWnd::OnUpdateOptionsFrameskipThrottle400(CCmdUI*pCmdUI)
150 {
151 pCmdUI->SetCheck(theApp.throttle == 400);
152 }
153
154 void MainWnd::OnOptionsFrameskipThrottle600()
155 {
156 systemSetThrottle(600);
157 }
158
159 void MainWnd::OnUpdateOptionsFrameskipThrottle600(CCmdUI*pCmdUI)
160 {
161 pCmdUI->SetCheck(theApp.throttle == 600);
162 }
163
164 void MainWnd::OnOptionsFrameskipThrottle1000()
165 {
166 systemSetThrottle(1000);
167 }
168
169 void MainWnd::OnUpdateOptionsFrameskipThrottle1000(CCmdUI*pCmdUI)
170 {
171 pCmdUI->SetCheck(theApp.throttle == 1000);
172 }
173
174 void MainWnd::OnOptionsFrameskipThrottleOther()
175 {
176 Throttle dlg;
177 int v = dlg.DoModal();
178 if (v)
179 systemSetThrottle(v);
180 }
181
182 void MainWnd::OnUpdateOptionsFrameskipThrottleOther(CCmdUI*pCmdUI)
183 {
184 }
185
186 void MainWnd::OnOptionsFrameskipThrottleIncrease()
187 {
188 systemIncreaseThrottle();
189 }
190
191 void MainWnd::OnUpdateOptionsFrameskipThrottleIncrease(CCmdUI*pCmdUI)
192 {
193 }
194
195 void MainWnd::OnOptionsFrameskipThrottleDecrease()
196 {
197 systemDecreaseThrottle();
198 }
199
200 void MainWnd::OnUpdateOptionsFrameskipThrottleDecrease(CCmdUI*pCmdUI)
201 {
202 }
203
204 /*
205 void MainWnd::OnOptionsFrameskipAutomatic()
206 {
207 theApp.autoFrameSkip = !theApp.autoFrameSkip;
208 if(!theApp.autoFrameSkip && emulating)
209 theApp.updateFrameSkip();
210 }
211
212 void MainWnd::OnUpdateOptionsFrameskipAutomatic(CCmdUI* pCmdUI)
213 {
214 pCmdUI->SetCheck(theApp.autoFrameSkip);
215 }
216 */
217
218 void MainWnd::OnOptionsFrameskipAccuratePitch()
219 {
220 theApp.accuratePitchThrottle = true;
221 }
222
223 void MainWnd::OnUpdateOptionsFrameskipAccuratePitch(CCmdUI*pCmdUI)
224 {
225 pCmdUI->SetCheck(theApp.accuratePitchThrottle);
226 pCmdUI->Enable(!soundOffFlag && synchronize);
227 }
228
229 void MainWnd::OnOptionsFrameskipAccurateSpeed()
230 {
231 theApp.accuratePitchThrottle = false;
232 }
233
234 void MainWnd::OnUpdateOptionsFrameskipAccurateSpeed(CCmdUI*pCmdUI)
235 {
236 pCmdUI->SetCheck(!theApp.accuratePitchThrottle);
237 pCmdUI->Enable(!soundOffFlag && synchronize);
238 }
239
240 BOOL MainWnd::OnOptionsFrameskip(UINT nID)
241 {
242 switch (nID)
243 {
244 case ID_OPTIONS_VIDEO_FRAMESKIP_0:
245 case ID_OPTIONS_VIDEO_FRAMESKIP_1:
246 case ID_OPTIONS_VIDEO_FRAMESKIP_2:
247 case ID_OPTIONS_VIDEO_FRAMESKIP_3:
248 case ID_OPTIONS_VIDEO_FRAMESKIP_4:
249 case ID_OPTIONS_VIDEO_FRAMESKIP_5:
250 case ID_OPTIONS_VIDEO_FRAMESKIP_6:
251 case ID_OPTIONS_VIDEO_FRAMESKIP_7:
252 case ID_OPTIONS_VIDEO_FRAMESKIP_8:
253 case ID_OPTIONS_VIDEO_FRAMESKIP_9:
254 if (systemCartridgeType == 0)
255 {
256 frameSkip = nID - ID_OPTIONS_VIDEO_FRAMESKIP_0;
257 }
258 else
259 {
260 gbFrameSkip = nID - ID_OPTIONS_VIDEO_FRAMESKIP_0;
261 }
262 if (emulating)
263 theApp.updateFrameSkip();
264 return TRUE;
265 break;
266 }
267 return FALSE;
268 }
269
270 void MainWnd::OnUpdateOptionsVideoFrameskip0(CCmdUI*pCmdUI)
271 {
272 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 0 : gbFrameSkip == 0);
273 }
274
275 void MainWnd::OnUpdateOptionsVideoFrameskip1(CCmdUI*pCmdUI)
276 {
277 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 1 : gbFrameSkip == 1);
278 }
279
280 void MainWnd::OnUpdateOptionsVideoFrameskip2(CCmdUI*pCmdUI)
281 {
282 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 2 : gbFrameSkip == 2);
283 }
284
285 void MainWnd::OnUpdateOptionsVideoFrameskip3(CCmdUI*pCmdUI)
286 {
287 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 3 : gbFrameSkip == 3);
288 }
289
290 void MainWnd::OnUpdateOptionsVideoFrameskip4(CCmdUI*pCmdUI)
291 {
292 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 4 : gbFrameSkip == 4);
293 }
294
295 void MainWnd::OnUpdateOptionsVideoFrameskip5(CCmdUI*pCmdUI)
296 {
297 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 5 : gbFrameSkip == 5);
298 }
299
300 void MainWnd::OnUpdateOptionsVideoFrameskip6(CCmdUI*pCmdUI)
301 {
302 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 6 : gbFrameSkip == 6);
303 }
304
305 void MainWnd::OnUpdateOptionsVideoFrameskip7(CCmdUI*pCmdUI)
306 {
307 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 7 : gbFrameSkip == 7);
308 }
309
310 void MainWnd::OnUpdateOptionsVideoFrameskip8(CCmdUI*pCmdUI)
311 {
312 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 8 : gbFrameSkip == 8);
313 }
314
315 void MainWnd::OnUpdateOptionsVideoFrameskip9(CCmdUI*pCmdUI)
316 {
317 pCmdUI->SetCheck(systemCartridgeType == 0 ? frameSkip == 9 : gbFrameSkip == 9);
318 }
319
320 void MainWnd::OnOptionsVideoVsync()
321 {
322 theApp.vsync = !theApp.vsync;
323 }
324
325 void MainWnd::OnUpdateOptionsVideoVsync(CCmdUI*pCmdUI)
326 {
327 pCmdUI->SetCheck(theApp.vsync);
328 }
329
330 void MainWnd::OnUpdateOptionsVideoX1(CCmdUI*pCmdUI)
331 {
332 pCmdUI->SetCheck(theApp.videoOption == VIDEO_1X);
333 }
334
335 void MainWnd::OnUpdateOptionsVideoX2(CCmdUI*pCmdUI)
336 {
337 pCmdUI->SetCheck(theApp.videoOption == VIDEO_2X);
338 }
339
340 void MainWnd::OnUpdateOptionsVideoX3(CCmdUI*pCmdUI)
341 {
342 pCmdUI->SetCheck(theApp.videoOption == VIDEO_3X);
343 }
344
345 void MainWnd::OnUpdateOptionsVideoX4(CCmdUI*pCmdUI)
346 {
347 pCmdUI->SetCheck(theApp.videoOption == VIDEO_4X);
348 }
349
350 void MainWnd::OnUpdateOptionsVideoFullscreen320x240(CCmdUI*pCmdUI)
351 {
352 pCmdUI->Enable(theApp.mode320Available);
353 pCmdUI->SetCheck(theApp.videoOption == VIDEO_320x240);
354 }
355
356 void MainWnd::OnUpdateOptionsVideoFullscreen640x480(CCmdUI*pCmdUI)
357 {
358 pCmdUI->Enable(theApp.mode640Available);
359 pCmdUI->SetCheck(theApp.videoOption == VIDEO_640x480);
360 }
361
362 void MainWnd::OnUpdateOptionsVideoFullscreen800x600(CCmdUI*pCmdUI)
363 {
364 pCmdUI->Enable(theApp.mode800Available);
365 pCmdUI->SetCheck(theApp.videoOption == VIDEO_800x600);
366 }
367
368 BOOL MainWnd::OnOptionVideoSize(UINT nID)
369 {
370 theApp.updateVideoSize(nID);
371 theApp.m_pMainWnd->PostMessage(VBA_CONFIRM_MODE);
372 return TRUE;
373 }
374
375 void MainWnd::OnOptionsVideoFullscreen320x240()
376 {
377 OnOptionVideoSize(ID_OPTIONS_VIDEO_FULLSCREEN320X240);
378 }
379
380 void MainWnd::OnOptionsVideoFullscreen640x480()
381 {
382 OnOptionVideoSize(ID_OPTIONS_VIDEO_FULLSCREEN640X480);
383 }
384
385 void MainWnd::OnOptionsVideoFullscreen800x600()
386 {
387 OnOptionVideoSize(ID_OPTIONS_VIDEO_FULLSCREEN800X600);
388 }
389
390 void MainWnd::OnOptionsVideoFullscreen()
391 {
392 theApp.winCheckFullscreen();
393 GUID *pGUID = NULL;
394 int size = theApp.display->selectFullScreenMode(&pGUID);
395 if (size != -1)
396 {
397 int width = (size >> 12) & 4095;
398 int height = (size & 4095);
399 int colorDepth = (size >> 24);
400 if (width != theApp.fsWidth ||
401 height != theApp.fsHeight ||
402 colorDepth != theApp.fsColorDepth ||
403 pGUID != theApp.pVideoDriverGUID ||
404 theApp.videoOption != VIDEO_OTHER)
405 {
406 theApp.fsForceChange = true;
407 theApp.fsWidth = width;
408 theApp.fsHeight = height;
409 theApp.fsColorDepth = colorDepth;
410 theApp.pVideoDriverGUID = pGUID;
411 if (pGUID)
412 {
413 theApp.videoDriverGUID = *pGUID;
414 regSetDwordValue("defaultVideoDriver", FALSE);
415 regSetBinaryValue("videoDriverGUID",
416 (char *)pGUID, sizeof(GUID));
417 }
418 else
419 {
420 regSetDwordValue("defaultVideoDriver", TRUE);
421 }
422 theApp.updateVideoSize(ID_OPTIONS_VIDEO_FULLSCREEN);
423 theApp.m_pMainWnd->PostMessage(VBA_CONFIRM_MODE);
424 }
425 }
426 }
427
428 void MainWnd::OnUpdateOptionsVideoFullscreen(CCmdUI*pCmdUI)
429 {
430 pCmdUI->SetCheck(theApp.videoOption == VIDEO_OTHER);
431 }
432
433 void MainWnd::OnOptionsVideoDisablesfx()
434 {
435 cpuDisableSfx = !cpuDisableSfx;
436 if (emulating && systemCartridgeType == 0)
437 CPUUpdateRender();
438 }
439
440 void MainWnd::OnUpdateOptionsVideoDisablesfx(CCmdUI*pCmdUI)
441 {
442 pCmdUI->SetCheck(cpuDisableSfx);
443 }
444
445 void MainWnd::OnOptionsVideoFullscreenstretchtofit()
446 {
447 theApp.fullScreenStretch = !theApp.fullScreenStretch;
448 theApp.updateWindowSize(theApp.videoOption);
449 if (theApp.display)
450 theApp.display->clear();
451 }
452
453 void MainWnd::OnUpdateOptionsVideoFullscreenstretchtofit(CCmdUI*pCmdUI)
454 {
455 pCmdUI->SetCheck(theApp.fullScreenStretch);
456 }
457
458 BOOL MainWnd::OnVideoLayer(UINT nID)
459 {
460 layerSettings ^= 0x0100 << ((nID & 0xFFFF) - ID_OPTIONS_VIDEO_LAYERS_BG0);
461 layerEnable = DISPCNT & layerSettings;
462 CPUUpdateRenderBuffers(false);
463 return TRUE;
464 }
465
466 void MainWnd::OnUpdateVideoLayer(CCmdUI *pCmdUI)
467 {
468 pCmdUI->SetCheck((layerSettings >> (8 + pCmdUI->m_nID - ID_OPTIONS_VIDEO_LAYERS_BG0)) & 1);
469 switch (pCmdUI->m_nID)
470 {
471 case ID_OPTIONS_VIDEO_LAYERS_BG1:
472 case ID_OPTIONS_VIDEO_LAYERS_BG2:
473 case ID_OPTIONS_VIDEO_LAYERS_BG3:
474 case ID_OPTIONS_VIDEO_LAYERS_WIN1:
475 case ID_OPTIONS_VIDEO_LAYERS_OBJWIN:
476 pCmdUI->Enable(systemCartridgeType == 0);
477 break;
478 }
479 }
480
481 void MainWnd::OnOptionsVideoRendermethodGdi()
482 {
483 theApp.renderMethod = GDI;
484 theApp.updateRenderMethod(false);
485 }
486
487 void MainWnd::OnUpdateOptionsVideoRendermethodGdi(CCmdUI*pCmdUI)
488 {
489 pCmdUI->SetCheck(theApp.renderMethod == GDI);
490 }
491
492 void MainWnd::OnOptionsVideoRendermethodDirectdraw()
493 {
494 theApp.renderMethod = DIRECT_DRAW;
495 theApp.updateRenderMethod(false);
496 }
497
498 void MainWnd::OnUpdateOptionsVideoRendermethodDirectdraw(CCmdUI*pCmdUI)
499 {
500 pCmdUI->SetCheck(theApp.renderMethod == DIRECT_DRAW);
501 }
502
503 void MainWnd::OnOptionsVideoRendermethodDirect3d()
504 {
505 theApp.renderMethod = DIRECT_3D;
506 theApp.updateRenderMethod(false);
507 }
508
509 void MainWnd::OnUpdateOptionsVideoRendermethodDirect3d(CCmdUI*pCmdUI)
510 {
511 pCmdUI->SetCheck(theApp.renderMethod == DIRECT_3D);
512 }
513
514 void MainWnd::OnOptionsVideoRendermethodOpengl()
515 {
516 theApp.renderMethod = OPENGL;
517 theApp.updateRenderMethod(false);
518 }
519
520 void MainWnd::OnUpdateOptionsVideoRendermethodOpengl(CCmdUI*pCmdUI)
521 {
522 pCmdUI->SetCheck(theApp.renderMethod == OPENGL);
523 }
524
525 void MainWnd::OnOptionsVideoTriplebuffering()
526 {
527 theApp.tripleBuffering = !theApp.tripleBuffering;
528 }
529
530 void MainWnd::OnUpdateOptionsVideoTriplebuffering(CCmdUI*pCmdUI)
531 {
532 pCmdUI->SetCheck(theApp.tripleBuffering);
533 }
534
535 void MainWnd::OnOptionsVideoDdrawemulationonly()
536 {
537 theApp.ddrawEmulationOnly = !theApp.ddrawEmulationOnly;
538 }
539
540 void MainWnd::OnUpdateOptionsVideoDdrawemulationonly(CCmdUI*pCmdUI)
541 {
542 pCmdUI->SetCheck(theApp.ddrawEmulationOnly);
543 }
544
545 void MainWnd::OnOptionsVideoDdrawusevideomemory()
546 {
547 theApp.ddrawUseVideoMemory = !theApp.ddrawUseVideoMemory;
548 }
549
550 void MainWnd::OnUpdateOptionsVideoDdrawusevideomemory(CCmdUI*pCmdUI)
551 {
552 pCmdUI->SetCheck(theApp.ddrawUseVideoMemory);
553 }
554
555 void MainWnd::OnOptionsVideoRenderoptionsD3dnofilter()
556 {
557 theApp.d3dFilter = 0;
558 if (theApp.display)
559 theApp.display->setOption("d3dFilter", 0);
560 }
561
562 void MainWnd::OnUpdateOptionsVideoRenderoptionsD3dnofilter(CCmdUI*pCmdUI)
563 {
564 pCmdUI->SetCheck(theApp.d3dFilter == 0);
565 }
566
567 void MainWnd::OnOptionsVideoRenderoptionsD3dbilinear()
568 {
569 theApp.d3dFilter = 1;
570 if (theApp.display)
571 theApp.display->setOption("d3dFilter", 1);
572 }
573
574 void MainWnd::OnUpdateOptionsVideoRenderoptionsD3dbilinear(CCmdUI*pCmdUI)
575 {
576 pCmdUI->SetCheck(theApp.d3dFilter == 1);
577 }
578
579 void MainWnd::OnOptionsVideoRenderoptionsGlnearest()
580 {
581 theApp.glFilter = 0;
582 if (theApp.display)
583 theApp.display->setOption("glFilter", 0);
584 }
585
586 void MainWnd::OnUpdateOptionsVideoRenderoptionsGlnearest(CCmdUI*pCmdUI)
587 {
588 pCmdUI->SetCheck(theApp.glFilter == 0);
589 }
590
591 void MainWnd::OnOptionsVideoRenderoptionsGlbilinear()
592 {
593 theApp.glFilter = 1;
594 if (theApp.display)
595 theApp.display->setOption("glFilter", 1);
596 }
597
598 void MainWnd::OnUpdateOptionsVideoRenderoptionsGlbilinear(CCmdUI*pCmdUI)
599 {
600 pCmdUI->SetCheck(theApp.glFilter == 1);
601 }
602
603 void MainWnd::OnOptionsVideoRenderoptionsGltriangle()
604 {
605 theApp.glType = 0;
606 if (theApp.display)
607 theApp.display->setOption("glType", 0);
608 }
609
610 void MainWnd::OnUpdateOptionsVideoRenderoptionsGltriangle(CCmdUI*pCmdUI)
611 {
612 pCmdUI->SetCheck(theApp.glType == 0);
613 }
614
615 void MainWnd::OnOptionsVideoRenderoptionsGlquads()
616 {
617 theApp.glType = 1;
618 if (theApp.display)
619 theApp.display->setOption("glType", 1);
620 }
621
622 void MainWnd::OnUpdateOptionsVideoRenderoptionsGlquads(CCmdUI*pCmdUI)
623 {
624 pCmdUI->SetCheck(theApp.glType == 1);
625 }
626
627 void MainWnd::OnOptionsVideoRenderoptionsSelectskin()
628 {}
629
630 void MainWnd::OnUpdateOptionsVideoRenderoptionsSelectskin(CCmdUI*pCmdUI)
631 {}
632
633 void MainWnd::OnOptionsVideoRenderoptionsSkin()
634 {}
635
636 void MainWnd::OnUpdateOptionsVideoRenderoptionsSkin(CCmdUI*pCmdUI)
637 {}
638
639 void MainWnd::OnOptionsEmulatorAssociate()
640 {
641 theApp.winCheckFullscreen();
642 Associate dlg;
643 dlg.DoModal();
644 }
645
646 void MainWnd::OnOptionsEmulatorDirectories()
647 {
648 theApp.winCheckFullscreen();
649 Directories dlg;
650 dlg.DoModal();
651 }
652
653 void MainWnd::OnOptionsEmulatorFilenamePreference(UINT nID)
654 {
655 theApp.filenamePreference = nID - ID_OPTIONS_PREFER_ARCHIVE_NAME;
656 }
657
658 void MainWnd::OnUpdateOptionsEmulatorFilenamePreference(CCmdUI *pCmdUI)
659 {
660 pCmdUI->SetRadio(pCmdUI->m_nID == theApp.filenamePreference + ID_OPTIONS_PREFER_ARCHIVE_NAME);
661 }
662
663 void MainWnd::OnOptionsVideoDisablestatusmessages()
664 {
665 theApp.disableStatusMessage = !theApp.disableStatusMessage;
666 }
667
668 void MainWnd::OnUpdateOptionsVideoDisablestatusmessages(CCmdUI*pCmdUI)
669 {
670 pCmdUI->SetCheck(theApp.disableStatusMessage);
671 }
672
673 void MainWnd::OnOptionsEmulatorSynchronize()
674 {
675 synchronize = !synchronize;
676 }
677
678 void MainWnd::OnUpdateOptionsEmulatorSynchronize(CCmdUI*pCmdUI)
679 {
680 pCmdUI->SetCheck(synchronize);
681 }
682
683 void MainWnd::OnOptionsEmulatorAlwaysOnTop()
684 {
685 theApp.alwaysOnTop = !theApp.alwaysOnTop;
686 SetWindowPos((theApp.alwaysOnTop ? &wndTopMost : &wndNoTopMost), 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
687 }
688
689 void MainWnd::OnUpdateOptionsEmulatorAlwaysOnTop(CCmdUI*pCmdUI)
690 {
691 pCmdUI->SetCheck(theApp.alwaysOnTop);
692 }
693
694 void MainWnd::OnOptionsEmulatorPausewheninactive()
695 {
696 theApp.pauseWhenInactive = !theApp.pauseWhenInactive;
697 }
698
699 void MainWnd::OnUpdateOptionsEmulatorPausewheninactive(CCmdUI*pCmdUI)
700 {
701 pCmdUI->SetCheck(theApp.pauseWhenInactive);
702 }
703
704 void MainWnd::OnOptionsEmulatorEnableBackgroundInput()
705 {
706 theApp.enableBackgroundInput = !theApp.enableBackgroundInput;
707 }
708
709 void MainWnd::OnUpdateOptionsEmulatorEnableBackgroundInput(CCmdUI*pCmdUI)
710 {
711 pCmdUI->SetCheck(theApp.enableBackgroundInput);
712 }
713
714 BOOL MainWnd::OnOptionsPriority(UINT nID)
715 {
716 switch (nID)
717 {
718 case ID_OPTIONS_PRIORITY_HIGHEST:
719 theApp.threadPriority = 0;
720 break;
721 case ID_OPTIONS_PRIORITY_ABOVENORMAL:
722 theApp.threadPriority = 1;
723 break;
724 case ID_OPTIONS_PRIORITY_NORMAL:
725 theApp.threadPriority = 2;
726 break;
727 case ID_OPTIONS_PRIORITY_BELOWNORMAL:
728 theApp.threadPriority = 3;
729 break;
730 default:
731 return FALSE;
732 }
733 theApp.updatePriority();
734
735 return TRUE;
736 }
737
738 void MainWnd::OnUpdateOptionsPriority(CCmdUI *pCmdUI)
739 {
740 switch (pCmdUI->m_nID)
741 {
742 case ID_OPTIONS_PRIORITY_HIGHEST:
743 pCmdUI->SetCheck(theApp.threadPriority == 0);
744 break;
745 case ID_OPTIONS_PRIORITY_ABOVENORMAL:
746 pCmdUI->SetCheck(theApp.threadPriority == 1);
747 break;
748 case ID_OPTIONS_PRIORITY_NORMAL:
749 pCmdUI->SetCheck(theApp.threadPriority == 2);
750 break;
751 case ID_OPTIONS_PRIORITY_BELOWNORMAL:
752 pCmdUI->SetCheck(theApp.threadPriority == 3);
753 break;
754 }
755 }
756
757 void MainWnd::OnOptionsEmulatorSpeeduptoggle()
758 {
759 theApp.speedupToggle = !theApp.speedupToggle;
760 }
761
762 void MainWnd::OnUpdateOptionsEmulatorSpeeduptoggle(CCmdUI*pCmdUI)
763 {
764 pCmdUI->SetCheck(theApp.speedupToggle);
765 }
766
767 void MainWnd::OnOptionsEmulatorRemoveintrosgba()
768 {
769 // theApp.removeIntros = !theApp.removeIntros;
770 }
771
772 void MainWnd::OnUpdateOptionsEmulatorRemoveintrosgba(CCmdUI*pCmdUI)
773 {
774 pCmdUI->Enable(false);
775 // pCmdUI->SetCheck(theApp.removeIntros);
776 }
777
778 void MainWnd::OnOptionsEmulatorAutomaticallyipspatch()
779 {
780 theApp.autoIPS = !theApp.autoIPS;
781 }
782
783 void MainWnd::OnUpdateOptionsEmulatorAutomaticallyipspatch(CCmdUI*pCmdUI)
784 {
785 pCmdUI->SetCheck(theApp.autoIPS);
786 }
787
788 void MainWnd::OnOptionsEmulatorAgbprint()
789 {
790 agbPrintEnable(!agbPrintIsEnabled());
791 }
792
793 void MainWnd::OnUpdateOptionsEmulatorAgbprint(CCmdUI*pCmdUI)
794 {
795 pCmdUI->SetCheck(agbPrintIsEnabled());
796 }
797
798 void MainWnd::OnOptionsEmulatorRealtimeclock()
799 {
800 theApp.winRtcEnable = !theApp.winRtcEnable;
801 }
802
803 void MainWnd::OnUpdateOptionsEmulatorRealtimeclock(CCmdUI*pCmdUI)
804 {
805 pCmdUI->SetCheck(theApp.winRtcEnable);
806 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
807 }
808
809 void MainWnd::OnOptionsEmulatorAutohidemenu()
810 {
811 theApp.autoHideMenu = !theApp.autoHideMenu;
812 }
813
814 void MainWnd::OnUpdateOptionsEmulatorAutohidemenu(CCmdUI*pCmdUI)
815 {
816 pCmdUI->SetCheck(theApp.autoHideMenu);
817 }
818
819 void MainWnd::OnOptionsEmulatorRewindinterval()
820 {
821 RewindInterval dlg((float)theApp.rewindTimer/6.0f, theApp.rewindSlots);
822 int v = dlg.DoModal();
823
824 if (v >= 0)
825 {
826 int interval = v & 0x0000ffff;
827 int slots = (v & 0xffff0000) >> 16;
828
829 int prevSlots = theApp.rewindSlots;
830
831 theApp.rewindTimer = interval; // already converted to a multiple of 10 frames
832 theApp.rewindSlots = slots;
833 if (interval == 0 || slots == 0)
834 {
835 theApp.rewindTimer = theApp.rewindSlots = 0;
836 regSetDwordValue("rewindTimer", interval);
837 regSetDwordValue("rewindSlots", slots);
838 if (theApp.rewindMemory)
839 free(theApp.rewindMemory);
840 theApp.rewindMemory = NULL;
841 theApp.rewindCount = 0;
842 theApp.rewindCounter = 0;
843 theApp.rewindSaveNeeded = false;
844 }
845 else
846 {
847 regSetDwordValue("rewindTimer", interval);
848 regSetDwordValue("rewindSlots", slots);
849 if (slots != prevSlots)
850 {
851 if (theApp.rewindMemory)
852 free(theApp.rewindMemory);
853 theApp.rewindMemory = NULL;
854 theApp.rewindPos = 0;
855 }
856 if (theApp.rewindMemory == NULL)
857 theApp.rewindMemory = (char *)malloc(theApp.rewindSlots*REWIND_SIZE);
858 theApp.rewindCount = 0;
859 theApp.rewindSaveNeeded = true;
860 }
861 }
862 }
863
864 BOOL MainWnd::OnOptionsEmulatorShowSpeed(UINT nID)
865 {
866 switch (nID)
867 {
868 case ID_OPTIONS_EMULATOR_SHOWSPEED_NONE:
869 theApp.showSpeed = 0;
870 systemSetTitle(VBA_NAME_AND_VERSION);
871 break;
872 case ID_OPTIONS_EMULATOR_SHOWSPEED_PERCENTAGE:
873 theApp.showSpeed = 1;
874 break;
875 case ID_OPTIONS_EMULATOR_SHOWSPEED_DETAILED:
876 theApp.showSpeed = 2;
877 break;
878 case ID_OPTIONS_EMULATOR_SHOWSPEED_TRANSPARENT:
879 theApp.showSpeedTransparent = !theApp.showSpeedTransparent;
880 break;
881 default:
882 return FALSE;
883 }
884 return TRUE;
885 }
886
887 void MainWnd::OnUpdateOptionsEmulatorShowSpeed(CCmdUI *pCmdUI)
888 {
889 switch (pCmdUI->m_nID)
890 {
891 case ID_OPTIONS_EMULATOR_SHOWSPEED_NONE:
892 pCmdUI->SetCheck(theApp.showSpeed == 0);
893 break;
894 case ID_OPTIONS_EMULATOR_SHOWSPEED_PERCENTAGE:
895 pCmdUI->SetCheck(theApp.showSpeed == 1);
896 break;
897 case ID_OPTIONS_EMULATOR_SHOWSPEED_DETAILED:
898 pCmdUI->SetCheck(theApp.showSpeed == 2);
899 break;
900 case ID_OPTIONS_EMULATOR_SHOWSPEED_TRANSPARENT:
901 pCmdUI->SetCheck(theApp.showSpeedTransparent);
902 break;
903 }
904 }
905
906 void MainWnd::OnOptionsEmulatorSavetypeAutomatic()
907 {
908 theApp.winSaveType = 0;
909 }
910
911 void MainWnd::OnUpdateOptionsEmulatorSavetypeAutomatic(CCmdUI*pCmdUI)
912 {
913 pCmdUI->SetCheck(theApp.winSaveType == 0);
914 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
915 }
916
917 void MainWnd::OnOptionsEmulatorSavetypeEeprom()
918 {
919 theApp.winSaveType = 1;
920 }
921
922 void MainWnd::OnUpdateOptionsEmulatorSavetypeEeprom(CCmdUI*pCmdUI)
923 {
924 pCmdUI->SetCheck(theApp.winSaveType == 1);
925 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
926 }
927
928 void MainWnd::OnOptionsEmulatorSavetypeSram()
929 {
930 theApp.winSaveType = 2;
931 }
932
933 void MainWnd::OnUpdateOptionsEmulatorSavetypeSram(CCmdUI*pCmdUI)
934 {
935 pCmdUI->SetCheck(theApp.winSaveType == 2);
936 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
937 }
938
939 void MainWnd::OnOptionsEmulatorSavetypeFlash()
940 {
941 theApp.winSaveType = 3;
942 }
943
944 void MainWnd::OnUpdateOptionsEmulatorSavetypeFlash(CCmdUI*pCmdUI)
945 {
946 pCmdUI->SetCheck(theApp.winSaveType == 3);
947 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
948 }
949
950 void MainWnd::OnOptionsEmulatorSavetypeEepromsensor()
951 {
952 theApp.winSaveType = 4;
953 }
954
955 void MainWnd::OnUpdateOptionsEmulatorSavetypeEepromsensor(CCmdUI*pCmdUI)
956 {
957 pCmdUI->SetCheck(theApp.winSaveType == 4);
958 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
959 }
960
961 void MainWnd::OnOptionsEmulatorSavetypeNone()
962 {
963 theApp.winSaveType = 5;
964 }
965
966 void MainWnd::OnUpdateOptionsEmulatorSavetypeNone(CCmdUI*pCmdUI)
967 {
968 pCmdUI->SetCheck(theApp.winSaveType == 5);
969 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
970 }
971
972 void MainWnd::OnOptionsEmulatorSavetypeFlash512k()
973 {
974 flashSetSize(0x10000);
975 theApp.winFlashSize = 0x10000;
976 }
977
978 void MainWnd::OnUpdateOptionsEmulatorSavetypeFlash512k(CCmdUI*pCmdUI)
979 {
980 pCmdUI->SetCheck(theApp.winFlashSize == 0x10000);
981 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
982 }
983
984 void MainWnd::OnOptionsEmulatorSavetypeFlash1m()
985 {
986 flashSetSize(0x20000);
987 theApp.winFlashSize = 0x20000;
988 }
989
990 void MainWnd::OnUpdateOptionsEmulatorSavetypeFlash1m(CCmdUI*pCmdUI)
991 {
992 pCmdUI->SetCheck(theApp.winFlashSize == 0x20000);
993 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
994 }
995
996 void MainWnd::OnOptionsEmulatorUsebiosfile()
997 {
998 if (!theApp.biosFileName.IsEmpty())
999 theApp.useBiosFile = !theApp.useBiosFile;
1000 }
1001
1002 void MainWnd::OnUpdateOptionsEmulatorUsebiosfile(CCmdUI*pCmdUI)
1003 {
1004 pCmdUI->SetCheck(theApp.useBiosFile);
1005 pCmdUI->Enable(!theApp.biosFileName.IsEmpty() && (!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL)));
1006 }
1007
1008 void MainWnd::OnOptionsEmulatorSkipbios()
1009 {
1010 theApp.skipBiosFile = !theApp.skipBiosFile;
1011 }
1012
1013 void MainWnd::OnUpdateOptionsEmulatorSkipbios(CCmdUI*pCmdUI)
1014 {
1015 pCmdUI->SetCheck(theApp.skipBiosFile);
1016 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1017 }
1018
1019 void MainWnd::OnOptionsEmulatorUseOldGBTiming()
1020 {
1021 useOldFrameTiming = !useOldFrameTiming;
1022 }
1023
1024 void MainWnd::OnUpdateOptionsEmulatorUseOldGBTiming(CCmdUI*pCmdUI)
1025 {
1026 pCmdUI->SetCheck(useOldFrameTiming);
1027 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1028 }
1029
1030 void MainWnd::OnOptionsEmulatorUseGBNullInputKludge()
1031 {
1032 if (VBAMovieActive())
1033 gbNullInputHackTempEnabled = !gbNullInputHackTempEnabled;
1034 else
1035 gbNullInputHackTempEnabled = gbNullInputHackEnabled = !gbNullInputHackEnabled;
1036 }
1037
1038 void MainWnd::OnUpdateOptionsEmulatorUseGBNullInputKludge(CCmdUI*pCmdUI)
1039 {
1040 pCmdUI->SetCheck(VBAMovieActive() || GetAsyncKeyState(VK_CONTROL) ? gbNullInputHackTempEnabled : gbNullInputHackEnabled);
1041 pCmdUI->Enable((!VBAMovieActive() && !useOldFrameTiming) || GetAsyncKeyState(VK_CONTROL));
1042 }
1043
1044 void MainWnd::OnOptionsEmulatorGBALag()
1045 {
1046 extern void TogglePrefetchHack();
1047 TogglePrefetchHack();
1048 memLagEnabled = memLagTempEnabled; // memLagEnabled is only to hold the last value that the user chose, so temporary changes
1049 // don't get into the registry
1050 }
1051
1052 void MainWnd::OnUpdateOptionsEmulatorGBALag(CCmdUI*pCmdUI)
1053 {
1054 pCmdUI->SetCheck(!memLagTempEnabled);
1055 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1056 }
1057
1058 void MainWnd::OnOptionsEmulatorSelectbiosfile()
1059 {
1060 theApp.winCheckFullscreen();
1061 LPCTSTR exts[] = { NULL };
1062 CString filter = winResLoadFilter(IDS_FILTER_BIOS);
1063 CString title = winResLoadString(IDS_SELECT_BIOS_FILE);
1064
1065 FileDlg dlg(this,
1066 theApp.biosFileName,
1067 filter,
1068 0,
1069 "BIOS",
1070 exts,
1071 "",
1072 title,
1073 false);
1074
1075 if (dlg.DoModal() == IDOK)
1076 {
1077 theApp.biosFileName = dlg.GetPathName();
1078 }
1079 }
1080
1081 void MainWnd::OnOptionsEmulatorPngformat()
1082 {
1083 theApp.captureFormat = 0;
1084 }
1085
1086 void MainWnd::OnUpdateOptionsEmulatorPngformat(CCmdUI*pCmdUI)
1087 {
1088 pCmdUI->SetCheck(theApp.captureFormat == 0);
1089 }
1090
1091 void MainWnd::OnOptionsEmulatorBmpformat()
1092 {
1093 theApp.captureFormat = 1;
1094 }
1095
1096 void MainWnd::OnUpdateOptionsEmulatorBmpformat(CCmdUI*pCmdUI)
1097 {
1098 pCmdUI->SetCheck(theApp.captureFormat == 1);
1099 }
1100
1101 void MainWnd::OnOptionsSoundDisable()
1102 {
1103 if (soundOffFlag)
1104 {
1105 soundOffFlag = false;
1106 soundInit();
1107 }
1108 else
1109 {
1110 soundOffFlag = true;
1111 soundShutdown();
1112 }
1113 }
1114
1115 void MainWnd::OnUpdateOptionsSoundDisable(CCmdUI*pCmdUI)
1116 {
1117 pCmdUI->SetCheck(soundOffFlag);
1118 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1119 }
1120
1121 static void OnSoundToggleEnabled(int c)
1122 {
1123 if (soundGetEnabledChannels() & c)
1124 {
1125 soundDisableChannels(c);
1126 }
1127 else
1128 {
1129 soundEnableChannels(c);
1130 }
1131 }
1132
1133 void MainWnd::OnOptionsSoundMute()
1134 {
1135 if ((soundGetEnabledChannels() & 0x030f) == 0)
1136 soundEnableChannels(0x030f);
1137 else
1138 soundDisableChannels(0x030f);
1139 }
1140
1141 void MainWnd::OnUpdateOptionsSoundMute(CCmdUI*pCmdUI)
1142 {
1143 pCmdUI->SetCheck((soundGetEnabledChannels() & 0x030f) == 0);
1144 }
1145
1146 void MainWnd::OnOptionsSoundOff()
1147 {
1148 soundDisableChannels(0x030f);
1149 }
1150
1151 void MainWnd::OnUpdateOptionsSoundOff(CCmdUI*pCmdUI)
1152 {
1153 pCmdUI->SetCheck((soundGetEnabledChannels() & 0x030f) == 0);
1154 }
1155
1156 void MainWnd::OnOptionsSoundOn()
1157 {
1158 soundEnableChannels(0x030f);
1159 }
1160
1161 void MainWnd::OnUpdateOptionsSoundOn(CCmdUI*pCmdUI)
1162 {
1163 pCmdUI->SetCheck(soundGetEnabledChannels() == 0x030f);
1164 }
1165
1166 void MainWnd::OnOptionsSoundUseoldsynchronization()
1167 {
1168 theApp.useOldSync = !theApp.useOldSync;
1169 systemMessage(IDS_SETTING_WILL_BE_EFFECTIVE,
1170 "Setting will be effective the next time you start the emulator");
1171 }
1172
1173 void MainWnd::OnUpdateOptionsSoundUseoldsynchronization(CCmdUI*pCmdUI)
1174 {
1175 pCmdUI->SetCheck(theApp.useOldSync);
1176 }
1177
1178 void MainWnd::OnOptionsSoundEcho()
1179 {
1180 soundEcho = !soundEcho;
1181 }
1182
1183 void MainWnd::OnUpdateOptionsSoundEcho(CCmdUI*pCmdUI)
1184 {
1185 pCmdUI->SetCheck(soundEcho);
1186 }
1187
1188 void MainWnd::OnOptionsSoundLowpassfilter()
1189 {
1190 soundLowPass = !soundLowPass;
1191 }
1192
1193 void MainWnd::OnUpdateOptionsSoundLowpassfilter(CCmdUI*pCmdUI)
1194 {
1195 pCmdUI->SetCheck(soundLowPass);
1196 }
1197
1198 void MainWnd::OnOptionsSoundReversestereo()
1199 {
1200 soundReverse = !soundReverse;
1201 }
1202
1203 void MainWnd::OnUpdateOptionsSoundReversestereo(CCmdUI*pCmdUI)
1204 {
1205 pCmdUI->SetCheck(soundReverse);
1206 }
1207
1208 void MainWnd::OnOptionsSoundMuteFrameAdvance()
1209 {
1210 theApp.muteFrameAdvance = !theApp.muteFrameAdvance;
1211 }
1212
1213 void MainWnd::OnUpdateOptionsSoundMuteFrameAdvance(CCmdUI*pCmdUI)
1214 {
1215 pCmdUI->SetCheck(theApp.muteFrameAdvance);
1216 }
1217
1218 void MainWnd::OnOptionsSoundMuteWhenInactive()
1219 {
1220 theApp.muteWhenInactive = !theApp.muteWhenInactive;
1221 }
1222
1223 void MainWnd::OnUpdateOptionsSoundMuteWhenInactive(CCmdUI*pCmdUI)
1224 {
1225 pCmdUI->SetCheck(theApp.muteWhenInactive);
1226 }
1227
1228 void MainWnd::OnOptionsSound11khz()
1229 {
1230 if (systemCartridgeType == 0)
1231 soundSetQuality(4);
1232 else
1233 gbSoundSetQuality(4);
1234 }
1235
1236 void MainWnd::OnUpdateOptionsSound11khz(CCmdUI*pCmdUI)
1237 {
1238 pCmdUI->SetCheck(soundQuality == 4);
1239 pCmdUI->Enable((!VBAMovieActive() ||
1240 GetAsyncKeyState(VK_CONTROL)) && !(theApp.soundRecording || theApp.aviRecording || theApp.nvAudioLog));
1241 }
1242
1243 void MainWnd::OnOptionsSound22khz()
1244 {
1245 if (systemCartridgeType == 0)
1246 soundSetQuality(2);
1247 else
1248 gbSoundSetQuality(2);
1249 }
1250
1251 void MainWnd::OnUpdateOptionsSound22khz(CCmdUI*pCmdUI)
1252 {
1253 pCmdUI->SetCheck(soundQuality == 2);
1254 pCmdUI->Enable((!VBAMovieActive() ||
1255 GetAsyncKeyState(VK_CONTROL)) && !(theApp.soundRecording || theApp.aviRecording || theApp.nvAudioLog));
1256 }
1257
1258 void MainWnd::OnOptionsSound44khz()
1259 {
1260 systemSoundSetQuality(1);
1261 }
1262
1263 void MainWnd::OnUpdateOptionsSound44khz(CCmdUI*pCmdUI)
1264 {
1265 pCmdUI->SetCheck(soundQuality == 1);
1266 pCmdUI->Enable(!(theApp.soundRecording || theApp.aviRecording || theApp.nvAudioLog));
1267 }
1268
1269 BOOL MainWnd::OnOptionsSoundVolume(UINT nID)
1270 {
1271 soundVolume = nID - ID_OPTIONS_SOUND_VOLUME_1X;
1272 return TRUE;
1273 }
1274
1275 void MainWnd::OnUpdateOptionsSoundVolume(CCmdUI *pCmdUI)
1276 {
1277 pCmdUI->SetCheck(soundVolume == (int)(pCmdUI->m_nID - ID_OPTIONS_SOUND_VOLUME_1X));
1278 }
1279
1280 void MainWnd::OnOptionsSoundVolume25x()
1281 {
1282 soundVolume = 4;
1283 }
1284
1285 void MainWnd::OnUpdateOptionsSoundVolume25x(CCmdUI*pCmdUI)
1286 {
1287 pCmdUI->SetCheck(soundVolume == 4);
1288 }
1289
1290 void MainWnd::OnOptionsSoundVolume5x()
1291 {
1292 soundVolume = 5;
1293 }
1294
1295 void MainWnd::OnUpdateOptionsSoundVolume5x(CCmdUI*pCmdUI)
1296 {
1297 pCmdUI->SetCheck(soundVolume == 5);
1298 }
1299
1300 void MainWnd::OnOptionsSoundChannel1()
1301 {
1302 OnSoundToggleEnabled(0x01);
1303 }
1304
1305 void MainWnd::OnUpdateOptionsSoundChannel1(CCmdUI*pCmdUI)
1306 {
1307 pCmdUI->SetCheck(soundGetEnabledChannels() & 0x01);
1308 }
1309
1310 void MainWnd::OnOptionsSoundChannel2()
1311 {
1312 OnSoundToggleEnabled(0x02);
1313 }
1314
1315 void MainWnd::OnUpdateOptionsSoundChannel2(CCmdUI*pCmdUI)
1316 {
1317 pCmdUI->SetCheck(soundGetEnabledChannels() & 0x02);
1318 }
1319
1320 void MainWnd::OnOptionsSoundChannel3()
1321 {
1322 OnSoundToggleEnabled(0x04);
1323 }
1324
1325 void MainWnd::OnUpdateOptionsSoundChannel3(CCmdUI*pCmdUI)
1326 {
1327 pCmdUI->SetCheck(soundGetEnabledChannels() & 0x04);
1328 }
1329
1330 void MainWnd::OnOptionsSoundChannel4()
1331 {
1332 OnSoundToggleEnabled(0x08);
1333 }
1334
1335 void MainWnd::OnUpdateOptionsSoundChannel4(CCmdUI*pCmdUI)
1336 {
1337 pCmdUI->SetCheck(soundGetEnabledChannels() & 0x08);
1338 }
1339
1340 void MainWnd::OnOptionsSoundDirectsounda()
1341 {
1342 OnSoundToggleEnabled(0x0100);
1343 }
1344
1345 void MainWnd::OnUpdateOptionsSoundDirectsounda(CCmdUI*pCmdUI)
1346 {
1347 pCmdUI->SetCheck(soundGetEnabledChannels() & 0x0100);
1348 //pCmdUI->Enable(systemCartridgeType == 0);
1349 }
1350
1351 void MainWnd::OnOptionsSoundDirectsoundb()
1352 {
1353 OnSoundToggleEnabled(0x0200);
1354 }
1355
1356 void MainWnd::OnUpdateOptionsSoundDirectsoundb(CCmdUI*pCmdUI)
1357 {
1358 pCmdUI->SetCheck(soundGetEnabledChannels() & 0x0200);
1359 //pCmdUI->Enable(systemCartridgeType == 0);
1360 }
1361
1362 void MainWnd::OnOptionsGameboyBorder()
1363 {
1364 theApp.winGbBorderOn = !theApp.winGbBorderOn;
1365 gbBorderOn = theApp.winGbBorderOn;
1366 if (emulating && systemCartridgeType == 1 && gbBorderOn)
1367 {
1368 gbSgbRenderBorder();
1369 }
1370 theApp.updateWindowSize(theApp.videoOption);
1371 }
1372
1373 void MainWnd::OnUpdateOptionsGameboyBorder(CCmdUI*pCmdUI)
1374 {
1375 pCmdUI->SetCheck(theApp.winGbBorderOn);
1376 }
1377
1378 void MainWnd::OnOptionsGameboyPrinter()
1379 {
1380 theApp.winGbPrinterEnabled = !theApp.winGbPrinterEnabled;
1381 if (theApp.winGbPrinterEnabled)
1382 gbSerialFunction = gbPrinterSend;
1383 else
1384 gbSerialFunction = NULL;
1385 }
1386
1387 void MainWnd::OnUpdateOptionsGameboyPrinter(CCmdUI*pCmdUI)
1388 {
1389 pCmdUI->SetCheck(gbSerialFunction == gbPrinterSend);
1390 }
1391
1392 void MainWnd::OnOptionsGameboyBorderAutomatic()
1393 {
1394 gbBorderAutomatic = !gbBorderAutomatic;
1395 if (emulating && systemCartridgeType == 1 && gbBorderOn)
1396 {
1397 gbSgbRenderBorder();
1398 theApp.updateWindowSize(theApp.videoOption);
1399 }
1400 }
1401
1402 void MainWnd::OnUpdateOptionsGameboyBorderAutomatic(CCmdUI*pCmdUI)
1403 {
1404 pCmdUI->SetCheck(gbBorderAutomatic);
1405 }
1406
1407 void MainWnd::OnOptionsGameboyAutomatic()
1408 {
1409 gbEmulatorType = 0;
1410 }
1411
1412 void MainWnd::OnUpdateOptionsGameboyAutomatic(CCmdUI*pCmdUI)
1413 {
1414 pCmdUI->SetCheck(gbEmulatorType == 0);
1415 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1416 }
1417
1418 void MainWnd::OnOptionsGameboyGba()
1419 {
1420 gbEmulatorType = 4;
1421 }
1422
1423 void MainWnd::OnUpdateOptionsGameboyGba(CCmdUI*pCmdUI)
1424 {
1425 pCmdUI->SetCheck(gbEmulatorType == 4);
1426 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1427 }
1428
1429 void MainWnd::OnOptionsGameboyCgb()
1430 {
1431 gbEmulatorType = 1;
1432 }
1433
1434 void MainWnd::OnUpdateOptionsGameboyCgb(CCmdUI*pCmdUI)
1435 {
1436 pCmdUI->SetCheck(gbEmulatorType == 1);
1437 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1438 }
1439
1440 void MainWnd::OnOptionsGameboySgb()
1441 {
1442 gbEmulatorType = 2;
1443 }
1444
1445 void MainWnd::OnUpdateOptionsGameboySgb(CCmdUI*pCmdUI)
1446 {
1447 pCmdUI->SetCheck(gbEmulatorType == 2);
1448 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1449 }
1450
1451 void MainWnd::OnOptionsGameboySgb2()
1452 {
1453 gbEmulatorType = 5;
1454 }
1455
1456 void MainWnd::OnUpdateOptionsGameboySgb2(CCmdUI*pCmdUI)
1457 {
1458 pCmdUI->SetCheck(gbEmulatorType == 5);
1459 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1460 }
1461
1462 void MainWnd::OnOptionsGameboyGb()
1463 {
1464 gbEmulatorType = 3;
1465 }
1466
1467 void MainWnd::OnUpdateOptionsGameboyGb(CCmdUI*pCmdUI)
1468 {
1469 pCmdUI->SetCheck(gbEmulatorType == 3);
1470 pCmdUI->Enable(!VBAMovieActive() || GetAsyncKeyState(VK_CONTROL));
1471 }
1472
1473 void MainWnd::OnOptionsGameboyRealcolors()
1474 {
1475 gbColorOption = 0;
1476 }
1477
1478 void MainWnd::OnUpdateOptionsGameboyRealcolors(CCmdUI*pCmdUI)
1479 {
1480 pCmdUI->SetCheck(gbColorOption == 0);
1481 }
1482
1483 void MainWnd::OnOptionsGameboyGameboycolors()
1484 {
1485 gbColorOption = 1;
1486 }
1487
1488 void MainWnd::OnUpdateOptionsGameboyGameboycolors(CCmdUI*pCmdUI)
1489 {
1490 pCmdUI->SetCheck(gbColorOption == 1);
1491 }
1492
1493 void MainWnd::OnOptionsGameboyColors()
1494 {
1495 theApp.winCheckFullscreen();
1496 GBColorDlg dlg;
1497 if (dlg.DoModal())
1498 {
1499 gbPaletteOption = dlg.getWhich();
1500 memcpy(systemGbPalette, dlg.getColors(), 24*sizeof(u16));
1501 if (emulating && systemCartridgeType == 1)
1502 {
1503 memcpy(gbPalette, &systemGbPalette[dlg.getWhich()*8], 8*sizeof(u16));
1504 }
1505 }
1506 }
1507
1508 BOOL MainWnd::OnOptionsFilter(UINT nID)
1509 {
1510 switch (nID)
1511 {
1512 case ID_OPTIONS_FILTER_NORMAL:
1513 theApp.filterType = 0;
1514 break;
1515 case ID_OPTIONS_FILTER_TVMODE:
1516 theApp.filterType = 1;
1517 break;
1518 case ID_OPTIONS_FILTER_2XSAI:
1519 theApp.filterType = 2;
1520 break;
1521 case ID_OPTIONS_FILTER_SUPER2XSAI:
1522 theApp.filterType = 3;
1523 break;
1524 case ID_OPTIONS_FILTER_SUPEREAGLE:
1525 theApp.filterType = 4;
1526 break;
1527 case ID_OPTIONS_FILTER16BIT_PIXELATEEXPERIMENTAL:
1528 theApp.filterType = 5;
1529 break;
1530 case ID_OPTIONS_FILTER16BIT_MOTIONBLUREXPERIMENTAL:
1531 theApp.filterType = 6;
1532 break;
1533 case ID_OPTIONS_FILTER16BIT_ADVANCEMAMESCALE2X:
1534 theApp.filterType = 7;
1535 break;
1536 case ID_OPTIONS_FILTER16BIT_SIMPLE2X:
1537 theApp.filterType = 8;
1538 break;
1539 case ID_OPTIONS_FILTER_BILINEAR:
1540 theApp.filterType = 9;
1541 break;
1542 case ID_OPTIONS_FILTER_BILINEARPLUS:
1543 theApp.filterType = 10;
1544 break;
1545 case ID_OPTIONS_FILTER_SCANLINES:
1546 theApp.filterType = 11;
1547 break;
1548 case ID_OPTIONS_FILTER_HQ2X2:
1549 theApp.filterType = 12;
1550 break;
1551 case ID_OPTIONS_FILTER_HQ2X:
1552 theApp.filterType = 13;
1553 break;
1554 case ID_OPTIONS_FILTER_LQ2X:
1555 theApp.filterType = 14;
1556 break;
1557 case ID_OPTIONS_FILTER_HQ3X2:
1558 theApp.filterType = 15;
1559 break;
1560 case ID_OPTIONS_FILTER_HQ3X:
1561 theApp.filterType = 16;
1562 break;
1563 case ID_OPTIONS_FILTER16BIT_SIMPLE3X:
1564 theApp.filterType = 17;
1565 break;
1566 case ID_OPTIONS_FILTER16BIT_SIMPLE4X:
1567 theApp.filterType = 18;
1568 break;
1569 case ID_OPTIONS_FILTER16BIT_PIXELATEEXPERIMENTAL3X:
1570 theApp.filterType = 19;
1571 break;
1572 case ID_OPTIONS_FILTER16BIT_PIXELATEEXPERIMENTAL4X:
1573 theApp.filterType = 20;
1574 break;
1575 default:
1576 return FALSE;
1577 }
1578 theApp.updateFilter();
1579 return TRUE;
1580 }
1581
1582 void MainWnd::OnUpdateOptionsFilter(CCmdUI *pCmdUI)
1583 {
1584 pCmdUI->Enable(systemColorDepth == 16 || systemColorDepth == 32);
1585 switch (pCmdUI->m_nID)
1586 {
1587 case ID_OPTIONS_FILTER_NORMAL:
1588 pCmdUI->SetCheck(theApp.filterType == 0);
1589 break;
1590 case ID_OPTIONS_FILTER_TVMODE:
1591 pCmdUI->SetCheck(theApp.filterType == 1);
1592 break;
1593 case ID_OPTIONS_FILTER_2XSAI:
1594 pCmdUI->SetCheck(theApp.filterType == 2);
1595 break;
1596 case ID_OPTIONS_FILTER_SUPER2XSAI:
1597 pCmdUI->SetCheck(theApp.filterType == 3);
1598 break;
1599 case ID_OPTIONS_FILTER_SUPEREAGLE:
1600 pCmdUI->SetCheck(theApp.filterType == 4);
1601 break;
1602 case ID_OPTIONS_FILTER16BIT_PIXELATEEXPERIMENTAL:
1603 pCmdUI->SetCheck(theApp.filterType == 5);
1604 break;
1605 case ID_OPTIONS_FILTER16BIT_MOTIONBLUREXPERIMENTAL:
1606 pCmdUI->SetCheck(theApp.filterType == 6);
1607 break;
1608 case ID_OPTIONS_FILTER16BIT_ADVANCEMAMESCALE2X:
1609 pCmdUI->SetCheck(theApp.filterType == 7);
1610 break;
1611 case ID_OPTIONS_FILTER16BIT_SIMPLE2X:
1612 pCmdUI->SetCheck(theApp.filterType == 8);
1613 break;
1614 case ID_OPTIONS_FILTER_BILINEAR:
1615 pCmdUI->SetCheck(theApp.filterType == 9);
1616 break;
1617 case ID_OPTIONS_FILTER_BILINEARPLUS:
1618 pCmdUI->SetCheck(theApp.filterType == 10);
1619 break;
1620 case ID_OPTIONS_FILTER_SCANLINES:
1621 pCmdUI->SetCheck(theApp.filterType == 11);
1622 break;
1623 case ID_OPTIONS_FILTER_HQ2X2:
1624 pCmdUI->SetCheck(theApp.filterType == 12);
1625 break;
1626 case ID_OPTIONS_FILTER_HQ2X:
1627 pCmdUI->SetCheck(theApp.filterType == 13);
1628 break;
1629 case ID_OPTIONS_FILTER_LQ2X:
1630 pCmdUI->SetCheck(theApp.filterType == 14);
1631 break;
1632 case ID_OPTIONS_FILTER_HQ3X2:
1633 pCmdUI->SetCheck(theApp.filterType == 15);
1634 break;
1635 case ID_OPTIONS_FILTER_HQ3X:
1636 pCmdUI->SetCheck(theApp.filterType == 16);
1637 break;
1638 case ID_OPTIONS_FILTER16BIT_SIMPLE3X:
1639 pCmdUI->SetCheck(theApp.filterType == 17);
1640 break;
1641 case ID_OPTIONS_FILTER16BIT_SIMPLE4X:
1642 pCmdUI->SetCheck(theApp.filterType == 18);
1643 break;
1644 case ID_OPTIONS_FILTER16BIT_PIXELATEEXPERIMENTAL3X:
1645 pCmdUI->SetCheck(theApp.filterType == 19);
1646 break;
1647 case ID_OPTIONS_FILTER16BIT_PIXELATEEXPERIMENTAL4X:
1648 pCmdUI->SetCheck(theApp.filterType == 20);
1649 break;
1650 }
1651 }
1652
1653 BOOL MainWnd::OnOptionsFilterIFB(UINT nID)
1654 {
1655 switch (nID)
1656 {
1657 case ID_OPTIONS_FILTER_INTERFRAMEBLENDING_NONE:
1658 theApp.ifbType = 0;
1659 break;
1660 case ID_OPTIONS_FILTER_INTERFRAMEBLENDING_MOTIONBLUR:
1661 theApp.ifbType = 1;
1662 break;
1663 case ID_OPTIONS_FILTER_INTERFRAMEBLENDING_SMART:
1664 theApp.ifbType = 2;
1665 break;
1666 default:
1667 return FALSE;
1668 }
1669 theApp.updateIFB();
1670 return TRUE;
1671 }
1672
1673 void MainWnd::OnUpdateOptionsFilterIFB(CCmdUI *pCmdUI)
1674 {
1675 switch (pCmdUI->m_nID)
1676 {
1677 case ID_OPTIONS_FILTER_INTERFRAMEBLENDING_NONE:
1678 pCmdUI->SetCheck(theApp.ifbType == 0);
1679 break;
1680 case ID_OPTIONS_FILTER_INTERFRAMEBLENDING_MOTIONBLUR:
1681 pCmdUI->SetCheck(theApp.ifbType == 1);
1682 break;
1683 case ID_OPTIONS_FILTER_INTERFRAMEBLENDING_SMART:
1684 pCmdUI->SetCheck(theApp.ifbType == 2);
1685 break;
1686 }
1687 }
1688
1689 void MainWnd::OnOptionsFilterDisablemmx()
1690 {
1691 theApp.disableMMX = !theApp.disableMMX;
1692 if (!theApp.disableMMX)
1693 cpu_mmx = theApp.detectMMX();
1694 else
1695 cpu_mmx = 0;
1696 }
1697
1698 void MainWnd::OnUpdateOptionsFilterDisablemmx(CCmdUI*pCmdUI)
1699 {
1700 pCmdUI->SetCheck(theApp.disableMMX);
1701 }
1702
1703 void MainWnd::OnOptionsLanguageSystem()
1704 {
1705 theApp.winSetLanguageOption(0, false);
1706 }
1707
1708 void MainWnd::OnUpdateOptionsLanguageSystem(CCmdUI*pCmdUI)
1709 {
1710 pCmdUI->SetCheck(theApp.languageOption == 0);
1711 }
1712
1713 void MainWnd::OnOptionsLanguageEnglish()
1714 {
1715 theApp.winSetLanguageOption(1, false);
1716 }
1717
1718 void MainWnd::OnUpdateOptionsLanguageEnglish(CCmdUI*pCmdUI)
1719 {
1720 pCmdUI->SetCheck(theApp.languageOption == 1);
1721 }
1722
1723 void MainWnd::OnOptionsLanguageOther()
1724 {
1725 theApp.winCheckFullscreen();
1726 theApp.winSetLanguageOption(2, false);
1727 }
1728
1729 void MainWnd::OnUpdateOptionsLanguageOther(CCmdUI*pCmdUI)
1730 {
1731 pCmdUI->SetCheck(theApp.languageOption == 2);
1732 }
1733
1734 void MainWnd::OnOptionsJoypadConfigure1()
1735 {
1736 theApp.winCheckFullscreen();
1737 JoypadConfig dlg(0);
1738 dlg.DoModal();
1739 }
1740
1741 void MainWnd::OnUpdateOptionsJoypadConfigure1(CCmdUI*pCmdUI)
1742 {
1743 pCmdUI->Enable(theApp.videoOption != VIDEO_320x240);
1744 }
1745
1746 void MainWnd::OnOptionsJoypadConfigure2()
1747 {
1748 theApp.winCheckFullscreen();
1749 JoypadConfig dlg(1);
1750 dlg.DoModal();
1751 }
1752
1753 void MainWnd::OnUpdateOptionsJoypadConfigure2(CCmdUI*pCmdUI)
1754 {
1755 pCmdUI->Enable(theApp.videoOption != VIDEO_320x240);
1756 }
1757
1758 void MainWnd::OnOptionsJoypadConfigure3()
1759 {
1760 theApp.winCheckFullscreen();
1761 JoypadConfig dlg(2);
1762 dlg.DoModal();
1763 }
1764
1765 void MainWnd::OnUpdateOptionsJoypadConfigure3(CCmdUI*pCmdUI)
1766 {
1767 pCmdUI->Enable(theApp.videoOption != VIDEO_320x240);
1768 }
1769
1770 void MainWnd::OnOptionsJoypadConfigure4()
1771 {
1772 theApp.winCheckFullscreen();
1773 JoypadConfig dlg(3);
1774 dlg.DoModal();
1775 }
1776
1777 void MainWnd::OnUpdateOptionsJoypadConfigure4(CCmdUI*pCmdUI)
1778 {
1779 pCmdUI->Enable(theApp.videoOption != VIDEO_320x240);
1780 }
1781
1782 BOOL MainWnd::OnOptionsJoypadDefault(UINT nID)
1783 {
1784 theApp.joypadDefault = nID - ID_OPTIONS_JOYPAD_DEFAULTJOYPAD_1;
1785 return TRUE;
1786 }
1787
1788 void MainWnd::OnUpdateOptionsJoypadDefault(CCmdUI *pCmdUI)
1789 {
1790 pCmdUI->SetCheck(theApp.joypadDefault == (int)(pCmdUI->m_nID - ID_OPTIONS_JOYPAD_DEFAULTJOYPAD_1));
1791 }
1792
1793 void MainWnd::OnOptionsJoypadMotionconfigure()
1794 {
1795 theApp.winCheckFullscreen();
1796 MotionConfig dlg;
1797 dlg.DoModal();
1798 }
1799
1800 void MainWnd::OnUpdateOptionsJoypadMotionconfigure(CCmdUI*pCmdUI)
1801 {
1802 pCmdUI->Enable(theApp.videoOption != VIDEO_320x240);
1803 }
1804
1805 void MainWnd::OnOptionsJoypadAllowLeftRight()
1806 {
1807 theApp.allowLeftRight = !theApp.allowLeftRight;
1808 }
1809
1810 void MainWnd::OnUpdateOptionsJoypadAllowLeftRight(CCmdUI*pCmdUI)
1811 {
1812 pCmdUI->SetCheck(theApp.allowLeftRight);
1813 }
1814
1815 void MainWnd::OnOptionsJoypadAutofireAccountForLag()
1816 {
1817 theApp.autofireAccountForLag = !theApp.autofireAccountForLag;
1818 }
1819
1820 void MainWnd::OnUpdateOptionsJoypadAutofireAccountForLag(CCmdUI*pCmdUI)
1821 {
1822 pCmdUI->SetCheck(theApp.autofireAccountForLag);
1823 }
1824
1825 BOOL MainWnd::OnOptionsJoypadAutofire(UINT nID)
1826 {
1827 int & autoFire = (theApp.autoFireToggle ? theApp.autoFire : theApp.autoFire2);
1828 int & autoFire2 = (theApp.autoFireToggle ? theApp.autoFire2 : theApp.autoFire);
1829 int autoFires = (theApp.autoFire | theApp.autoFire2);
1830
1831 switch (nID)
1832 {
1833 case ID_OPTIONS_JOYPAD_AUTOFIRE_A:
1834 if (autoFires & BUTTON_MASK_A)
1835 {
1836 autoFire &= ~BUTTON_MASK_A;
1837 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_A_DISABLED));
1838 }
1839 else
1840 {
1841 autoFire |= BUTTON_MASK_A;
1842 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_A));
1843 }
1844 autoFire2 &= ~BUTTON_MASK_A;
1845 theApp.autoHold &= ~BUTTON_MASK_A;
1846 break;
1847 case ID_OPTIONS_JOYPAD_AUTOFIRE_B:
1848 if (autoFires & BUTTON_MASK_B)
1849 {
1850 autoFire &= ~BUTTON_MASK_B;
1851 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_B_DISABLED));
1852 }
1853 else
1854 {
1855 autoFire |= BUTTON_MASK_B;
1856 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_B));
1857 }
1858 autoFire2 &= ~BUTTON_MASK_B;
1859 theApp.autoHold &= ~BUTTON_MASK_B;
1860 break;
1861 case ID_OPTIONS_JOYPAD_AUTOFIRE_L:
1862 if (autoFires & BUTTON_MASK_L)
1863 {
1864 autoFire &= ~BUTTON_MASK_L;
1865 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_L_DISABLED));
1866 }
1867 else
1868 {
1869 autoFire |= BUTTON_MASK_L;
1870 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_L));
1871 }
1872 autoFire2 &= ~BUTTON_MASK_L;
1873 theApp.autoHold &= ~BUTTON_MASK_L;
1874 break;
1875 case ID_OPTIONS_JOYPAD_AUTOFIRE_R:
1876 if (autoFires & BUTTON_MASK_R)
1877 {
1878 autoFire &= ~BUTTON_MASK_R;
1879 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_R_DISABLED));
1880 }
1881 else
1882 {
1883 autoFire |= BUTTON_MASK_R;
1884 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_R));
1885 }
1886 autoFire2 &= ~BUTTON_MASK_R;
1887 theApp.autoHold &= ~BUTTON_MASK_R;
1888 break;
1889 case ID_OPTIONS_JOYPAD_AUTOFIRE_START:
1890 if (autoFires & BUTTON_MASK_START)
1891 {
1892 autoFire &= ~BUTTON_MASK_START;
1893 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_START_DISABLED));
1894 }
1895 else
1896 {
1897 autoFire |= BUTTON_MASK_START;
1898 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_START));
1899 }
1900 autoFire2 &= ~BUTTON_MASK_START;
1901 theApp.autoHold &= ~BUTTON_MASK_START;
1902 break;
1903 case ID_OPTIONS_JOYPAD_AUTOFIRE_SELECT:
1904 if (autoFires & BUTTON_MASK_SELECT)
1905 {
1906 autoFire &= ~BUTTON_MASK_SELECT;
1907 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_SELECT_DISABLED));
1908 }
1909 else
1910 {
1911 autoFire |= BUTTON_MASK_SELECT;
1912 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_SELECT));
1913 }
1914 autoFire2 &= ~BUTTON_MASK_SELECT;
1915 theApp.autoHold &= ~BUTTON_MASK_SELECT;
1916 break;
1917 case ID_OPTIONS_JOYPAD_AUTOFIRE_UP:
1918 if (autoFires & BUTTON_MASK_UP)
1919 {
1920 autoFire &= ~BUTTON_MASK_UP;
1921 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_UP_DISABLED));
1922 }
1923 else
1924 {
1925 autoFire |= BUTTON_MASK_UP;
1926 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_UP));
1927 }
1928 autoFire2 &= ~BUTTON_MASK_UP;
1929 theApp.autoHold &= ~BUTTON_MASK_UP;
1930 break;
1931 case ID_OPTIONS_JOYPAD_AUTOFIRE_DOWN:
1932 if (autoFires & BUTTON_MASK_DOWN)
1933 {
1934 autoFire &= ~BUTTON_MASK_DOWN;
1935 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_DOWN_DISABLED));
1936 }
1937 else
1938 {
1939 autoFire |= BUTTON_MASK_DOWN;
1940 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_DOWN));
1941 }
1942 autoFire2 &= ~BUTTON_MASK_DOWN;
1943 theApp.autoHold &= ~BUTTON_MASK_DOWN;
1944 break;
1945 case ID_OPTIONS_JOYPAD_AUTOFIRE_LEFT:
1946 if (autoFires & BUTTON_MASK_LEFT)
1947 {
1948 autoFire &= ~BUTTON_MASK_LEFT;
1949 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_LEFT_DISABLED));
1950 }
1951 else
1952 {
1953 autoFire |= BUTTON_MASK_LEFT;
1954 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_LEFT));
1955 }
1956 autoFire2 &= ~BUTTON_MASK_LEFT;
1957 theApp.autoHold &= ~BUTTON_MASK_LEFT;
1958 break;
1959 case ID_OPTIONS_JOYPAD_AUTOFIRE_RIGHT:
1960 if (autoFires & BUTTON_MASK_RIGHT)
1961 {
1962 autoFire &= ~BUTTON_MASK_RIGHT;
1963 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_RIGHT_DISABLED));
1964 }
1965 else
1966 {
1967 autoFire |= BUTTON_MASK_RIGHT;
1968 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_RIGHT));
1969 }
1970 autoFire2 &= ~BUTTON_MASK_RIGHT;
1971 theApp.autoHold &= ~BUTTON_MASK_RIGHT;
1972 break;
1973 case ID_OPTIONS_JOYPAD_AUTOFIRE_CLEAR:
1974 if (autoFires != 0)
1975 {
1976 theApp.autoFire = theApp.autoFire2 = 0;
1977 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_DISABLED));
1978 }
1979 else
1980 {
1981 /// systemScreenMessage(winResLoadString(IDS_AUTOFIRE_ALREADY_DISABLED));
1982 systemScreenMessage("already cleared");
1983 }
1984 break;
1985 default:
1986 return FALSE;
1987 }
1988
1989 extern void VBAUpdateButtonPressDisplay(); VBAUpdateButtonPressDisplay();
1990
1991 return TRUE;
1992 }
1993
1994 void MainWnd::OnUpdateOptionsJoypadAutofire(CCmdUI *pCmdUI)
1995 {
1996 /// pCmdUI->Enable(emulating); // FIXME: this is right, but disabling menu items screws up accelerators until you view the
1997 // menu!
1998 pCmdUI->Enable(TRUE); // TEMP
1999
2000 int autoFires = (theApp.autoFire | theApp.autoFire2);
2001
2002 bool check = true;
2003 switch (pCmdUI->m_nID)
2004 {
2005 case ID_OPTIONS_JOYPAD_AUTOFIRE_A:
2006 check = (autoFires & BUTTON_MASK_A) != 0;
2007 break;
2008 case ID_OPTIONS_JOYPAD_AUTOFIRE_B:
2009 check = (autoFires & BUTTON_MASK_B) != 0;
2010 break;
2011 case ID_OPTIONS_JOYPAD_AUTOFIRE_L:
2012 check = (autoFires & BUTTON_MASK_L) != 0;
2013 /// extern int gbSgbMode; // from gbSGB.cpp
2014 /// if(emulating && systemCartridgeType != 0 && !gbSgbMode) // regular GB has no L button
2015 /// pCmdUI->Enable(false); // FIXME: this is right, but disabling menu items screws up accelerators until you view the
2016 // menu!
2017 break;
2018 case ID_OPTIONS_JOYPAD_AUTOFIRE_R:
2019 check = (autoFires & BUTTON_MASK_R) != 0;
2020 /// extern int gbSgbMode; // from gbSGB.cpp
2021 /// if(emulating && systemCartridgeType != 0 && !gbSgbMode) // regular GB has no R button
2022 /// pCmdUI->Enable(false); // FIXME: this is right, but disabling menu items screws up accelerators until you view the
2023 // menu!
2024 break;
2025 case ID_OPTIONS_JOYPAD_AUTOFIRE_START:
2026 check = (autoFires & BUTTON_MASK_START) != 0;
2027 break;
2028 case ID_OPTIONS_JOYPAD_AUTOFIRE_SELECT:
2029 check = (autoFires & BUTTON_MASK_SELECT) != 0;
2030 break;
2031 case ID_OPTIONS_JOYPAD_AUTOFIRE_UP:
2032 check = (autoFires & BUTTON_MASK_UP) != 0;
2033 break;
2034 case ID_OPTIONS_JOYPAD_AUTOFIRE_DOWN:
2035 check = (autoFires & BUTTON_MASK_DOWN) != 0;
2036 break;
2037 case ID_OPTIONS_JOYPAD_AUTOFIRE_LEFT:
2038 check = (autoFires & BUTTON_MASK_LEFT) != 0;
2039 break;
2040 case ID_OPTIONS_JOYPAD_AUTOFIRE_RIGHT:
2041 check = (autoFires & BUTTON_MASK_RIGHT) != 0;
2042 break;
2043 case ID_OPTIONS_JOYPAD_AUTOFIRE_CLEAR:
2044 check = (autoFires == 0);
2045 /// pCmdUI->Enable(!check); // FIXME: this is right, but disabling menu items screws up accelerators until you view the menu!
2046 break;
2047 }
2048 pCmdUI->SetCheck(check);
2049 }
2050
2051 BOOL MainWnd::OnOptionsJoypadSticky(UINT nID)
2052 {
2053 switch (nID)
2054 {
2055 case ID_STICKY_A:
2056 if (theApp.autoHold & BUTTON_MASK_A)
2057 {
2058 theApp.autoHold &= ~BUTTON_MASK_A;
2059 /// systemScreenMessage(winResLoadString(IDS_STICKY_A_DISABLED));
2060 }
2061 else
2062 {
2063 theApp.autoHold |= BUTTON_MASK_A;
2064 /// systemScreenMessage(winResLoadString(IDS_STICKY_A));
2065 }
2066 theApp.autoFire &= ~BUTTON_MASK_A;
2067 theApp.autoFire2 &= ~BUTTON_MASK_A;
2068 break;
2069 case ID_STICKY_B:
2070 if (theApp.autoHold & BUTTON_MASK_B)
2071 {
2072 theApp.autoHold &= ~BUTTON_MASK_B;
2073 /// systemScreenMessage(winResLoadString(IDS_STICKY_B_DISABLED));
2074 }
2075 else
2076 {
2077 theApp.autoHold |= BUTTON_MASK_B;
2078 /// systemScreenMessage(winResLoadString(IDS_STICKY_B));
2079 }
2080 theApp.autoFire &= ~BUTTON_MASK_B;
2081 theApp.autoFire2 &= ~BUTTON_MASK_B;
2082 break;
2083 case ID_STICKY_L:
2084 if (theApp.autoHold & BUTTON_MASK_L)
2085 {
2086 theApp.autoHold &= ~BUTTON_MASK_L;
2087 /// systemScreenMessage(winResLoadString(IDS_STICKY_L_DISABLED));
2088 }
2089 else
2090 {
2091 theApp.autoHold |= BUTTON_MASK_L;
2092 /// systemScreenMessage(winResLoadString(IDS_STICKY_L));
2093 }
2094 theApp.autoFire &= ~BUTTON_MASK_L;
2095 theApp.autoFire2 &= ~BUTTON_MASK_L;
2096 break;
2097 case ID_STICKY_R:
2098 if (theApp.autoHold & BUTTON_MASK_R)
2099 {
2100 theApp.autoHold &= ~BUTTON_MASK_R;
2101 /// systemScreenMessage(winResLoadString(IDS_STICKY_R_DISABLED));
2102 }
2103 else
2104 {
2105 theApp.autoHold |= BUTTON_MASK_R;
2106 /// systemScreenMessage(winResLoadString(IDS_STICKY_R));
2107 }
2108 theApp.autoFire &= ~BUTTON_MASK_R;
2109 theApp.autoFire2 &= ~BUTTON_MASK_R;
2110 break;
2111 case ID_STICKY_START:
2112 if (theApp.autoHold & BUTTON_MASK_START)
2113 {
2114 theApp.autoHold &= ~BUTTON_MASK_START;
2115 /// systemScreenMessage(winResLoadString(IDS_STICKY_START_DISABLED));
2116 }
2117 else
2118 {
2119 theApp.autoHold |= BUTTON_MASK_START;
2120 /// systemScreenMessage(winResLoadString(IDS_STICKY_START));
2121 }
2122 theApp.autoFire &= ~BUTTON_MASK_START;
2123 theApp.autoFire2 &= ~BUTTON_MASK_START;
2124 break;
2125 case ID_STICKY_SELECT:
2126 if (theApp.autoHold & BUTTON_MASK_SELECT)
2127 {
2128 theApp.autoHold &= ~BUTTON_MASK_SELECT;
2129 /// systemScreenMessage(winResLoadString(IDS_STICKY_SELECT_DISABLED));
2130 }
2131 else
2132 {
2133 theApp.autoHold |= BUTTON_MASK_SELECT;
2134 /// systemScreenMessage(winResLoadString(IDS_STICKY_SELECT));
2135 }
2136 theApp.autoFire &= ~BUTTON_MASK_SELECT;
2137 theApp.autoFire2 &= ~BUTTON_MASK_SELECT;
2138 break;
2139 case ID_STICKY_UP:
2140 if (theApp.autoHold & BUTTON_MASK_UP)
2141 {
2142 theApp.autoHold &= ~BUTTON_MASK_UP;
2143 /// systemScreenMessage(winResLoadString(IDS_STICKY_UP_DISABLED));
2144 }
2145 else
2146 {
2147 theApp.autoHold |= BUTTON_MASK_UP;
2148 /// systemScreenMessage(winResLoadString(IDS_STICKY_UP));
2149 }
2150 theApp.autoFire &= ~BUTTON_MASK_UP;
2151 theApp.autoFire2 &= ~BUTTON_MASK_UP;
2152 if (!theApp.allowLeftRight)
2153 theApp.autoHold &= ~BUTTON_MASK_DOWN;
2154 break;
2155 case ID_STICKY_DOWN:
2156 if (theApp.autoHold & BUTTON_MASK_DOWN)
2157 {
2158 theApp.autoHold &= ~BUTTON_MASK_DOWN;
2159 /// systemScreenMessage(winResLoadString(IDS_STICKY_DOWN_DISABLED));
2160 }
2161 else
2162 {
2163 theApp.autoHold |= BUTTON_MASK_DOWN;
2164 /// systemScreenMessage(winResLoadString(IDS_STICKY_DOWN));
2165 }
2166 theApp.autoFire &= ~BUTTON_MASK_DOWN;
2167 theApp.autoFire2 &= ~BUTTON_MASK_DOWN;
2168 if (!theApp.allowLeftRight)
2169 theApp.autoHold &= ~BUTTON_MASK_UP;
2170 break;
2171 case ID_STICKY_LEFT:
2172 if (theApp.autoHold & BUTTON_MASK_LEFT)
2173 {
2174 theApp.autoHold &= ~BUTTON_MASK_LEFT;
2175 /// systemScreenMessage(winResLoadString(IDS_STICKY_LEFT_DISABLED));
2176 }
2177 else
2178 {
2179 theApp.autoHold |= BUTTON_MASK_LEFT;
2180 /// systemScreenMessage(winResLoadString(IDS_STICKY_LEFT));
2181 }
2182 theApp.autoFire &= ~BUTTON_MASK_LEFT;
2183 theApp.autoFire2 &= ~BUTTON_MASK_LEFT;
2184 if (!theApp.allowLeftRight)
2185 theApp.autoHold &= ~BUTTON_MASK_RIGHT;
2186 break;
2187 case ID_STICKY_RIGHT:
2188 if (theApp.autoHold & BUTTON_MASK_RIGHT)
2189 {
2190 theApp.autoHold &= ~BUTTON_MASK_RIGHT;
2191 /// systemScreenMessage(winResLoadString(IDS_STICKY_RIGHT_DISABLED));
2192 }
2193 else
2194 {
2195 theApp.autoHold |= BUTTON_MASK_RIGHT;
2196 /// systemScreenMessage(winResLoadString(IDS_STICKY_RIGHT));
2197 }
2198 theApp.autoFire &= ~BUTTON_MASK_RIGHT;
2199 theApp.autoFire2 &= ~BUTTON_MASK_RIGHT;
2200 if (!theApp.allowLeftRight)
2201 theApp.autoHold &= ~BUTTON_MASK_LEFT;
2202 break;
2203 case ID_STICKY_CLEAR:
2204 if (theApp.autoHold != 0)
2205 {
2206 theApp.autoHold = 0;
2207 /// systemScreenMessage(winResLoadString(IDS_STICKY_DISABLED));
2208 }
2209 else
2210 {
2211 /// systemScreenMessage(winResLoadString(IDS_STICKY_ALREADY_DISABLED));
2212 systemScreenMessage("already cleared");
2213 }
2214 break;
2215 default:
2216 return FALSE;
2217 }
2218
2219 extern void VBAUpdateButtonPressDisplay(); VBAUpdateButtonPressDisplay();
2220
2221 return TRUE;
2222 }
2223
2224 void MainWnd::OnUpdateOptionsJoypadSticky(CCmdUI *pCmdUI)
2225 {
2226 /// pCmdUI->Enable(emulating); // FIXME: this is right, but disabling menu items screws up accelerators until you view the
2227 // menu!
2228 pCmdUI->Enable(TRUE); // TEMP
2229
2230 bool check = true;
2231 switch (pCmdUI->m_nID)
2232 {
2233 case ID_STICKY_A:
2234 check = (theApp.autoHold & BUTTON_MASK_A) != 0;
2235 break;
2236 case ID_STICKY_B:
2237 check = (theApp.autoHold & BUTTON_MASK_B) != 0;
2238 break;
2239 case ID_STICKY_L:
2240 check = (theApp.autoHold & BUTTON_MASK_L) != 0;
2241 /// extern int gbSgbMode; // from gbSGB.cpp
2242 /// if(emulating && systemCartridgeType != 0 && !gbSgbMode) // regular GB has no L button
2243 /// pCmdUI->Enable(false); // FIXME: this is right, but disabling menu items screws up accelerators until you view the
2244 // menu!
2245 break;
2246 case ID_STICKY_R:
2247 check = (theApp.autoHold & BUTTON_MASK_R) != 0;
2248 /// extern int gbSgbMode; // from gbSGB.cpp
2249 /// if(emulating && systemCartridgeType != 0 && !gbSgbMode) // regular GB has no R button
2250 /// pCmdUI->Enable(false); // FIXME: this is right, but disabling menu items screws up accelerators until you view the
2251 // menu!
2252 break;
2253 case ID_STICKY_START:
2254 check = (theApp.autoHold & BUTTON_MASK_START) != 0;
2255 break;
2256 case ID_STICKY_SELECT:
2257 check = (theApp.autoHold & BUTTON_MASK_SELECT) != 0;
2258 break;
2259 case ID_STICKY_UP:
2260 check = (theApp.autoHold & BUTTON_MASK_UP) != 0;
2261 break;
2262 case ID_STICKY_DOWN:
2263 check = (theApp.autoHold & BUTTON_MASK_DOWN) != 0;
2264 break;
2265 case ID_STICKY_LEFT:
2266 check = (theApp.autoHold & BUTTON_MASK_LEFT) != 0;
2267 break;
2268 case ID_STICKY_RIGHT:
2269 check = (theApp.autoHold & BUTTON_MASK_RIGHT) != 0;
2270 break;
2271 case ID_STICKY_CLEAR:
2272 check = (theApp.autoHold == 0);
2273 /// pCmdUI->Enable(!check); // FIXME: this is right, but disabling menu items screws up accelerators until you view the menu!
2274 break;
2275 }
2276 pCmdUI->SetCheck(check);
2277 }
2278
2279 LRESULT MainWnd::OnConfirmMode(WPARAM, LPARAM)
2280 {
2281 // we need to do this separately or the window will not have the right
2282 // parent. must be related to the way MFC does modal dialogs
2283 winConfirmMode();
2284 return 0;
2285 }
2286
2287 void MainWnd::OnOptionsVideoFullscreenmaxscale()
2288 {
2289 MaxScale dlg;
2290
2291 theApp.winCheckFullscreen();
2292
2293 dlg.DoModal();
2294 }
2295
2296 void MainWnd::OnOptionsVideoTextdisplayoptions()
2297 {
2298 TextOptions dlg;
2299
2300 theApp.winCheckFullscreen();
2301
2302 dlg.DoModal();
2303 }
2304
2305 void MainWnd::OnUpdateOptionsVideoTextdisplayoptions(CCmdUI *pCmdUI)
2306 {
2307 pCmdUI->Enable(TRUE);
2308 }
2309