← Back to branch summary

~ubuntu-branches/ubuntu/lucid/fceux/lucid

« back to all changes in this revision

Viewing changes to fceu/src/input.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Fabrice Coutadeur
  • Date: 2009-12-14 08:05:17 UTC
  • Revision ID: james.westby@ubuntu.com-20091214080517-abi5tj8avthfan7c
Tags: upstream-2.1.2+repack
Import upstream version 2.1.2+repack

Show diffs side-by-side

added added

removed removed

Lines of Context:
fceu/src/input.cpp
 
1
/* FCE Ultra - NES/Famicom Emulator
 
2
*
 
3
* Copyright notice for this file:
 
4
*  Copyright (C) 1998 BERO
 
5
*  Copyright (C) 2002 Xodnizel
 
6
*
 
7
* This program is free software; you can redistribute it and/or modify
 
8
* it under the terms of the GNU General Public License as published by
 
9
* the Free Software Foundation; either version 2 of the License, or
 
10
* (at your option) any later version.
 
11
*
 
12
* This program is distributed in the hope that it will be useful,
 
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
* GNU General Public License for more details.
 
16
*
 
17
* You should have received a copy of the GNU General Public License
 
18
* along with this program; if not, write to the Free Software
 
19
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
20
*/
 
21
 
 
22
#include <string>
 
23
#include <ostream>
 
24
#include <string.h>
 
25
 
 
26
#include "types.h"
 
27
#include "x6502.h"
 
28
 
 
29
#include "fceu.h"
 
30
#include "sound.h"
 
31
#include "netplay.h"
 
32
#include "movie.h"
 
33
#include "state.h"
 
34
#include "input/zapper.h"
 
35
#ifdef _S9XLUA_H
 
36
#include "fceulua.h"
 
37
#endif
 
38
#include "input.h"
 
39
#include "vsuni.h"
 
40
#include "fds.h"
 
41
#include "driver.h"
 
42
 
 
43
#ifdef WIN32
 
44
#include "drivers/win/main.h"
 
45
#include "drivers/win/memwatch.h"
 
46
#include "drivers/win/cheat.h"
 
47
#include "drivers/win/debugger.h"
 
48
#include "drivers/win/ppuview.h"
 
49
#include "drivers/win/cdlogger.h"
 
50
#include "drivers/win/tracer.h"
 
51
#include "drivers/win/memview.h"
 
52
 
 
53
#endif // WIN32
 
54
 
 
55
//it is easier to declare these input drivers extern here than include a bunch of files
 
56
//-------------
 
57
extern INPUTC *FCEU_InitZapper(int w);
 
58
extern INPUTC *FCEU_InitPowerpadA(int w);
 
59
extern INPUTC *FCEU_InitPowerpadB(int w);
 
60
extern INPUTC *FCEU_InitArkanoid(int w);
 
61
 
 
62
extern INPUTCFC *FCEU_InitArkanoidFC(void);
 
63
extern INPUTCFC *FCEU_InitSpaceShadow(void);
 
64
extern INPUTCFC *FCEU_InitFKB(void);
 
65
extern INPUTCFC *FCEU_InitSuborKB(void);
 
66
extern INPUTCFC *FCEU_InitHS(void);
 
67
extern INPUTCFC *FCEU_InitMahjong(void);
 
68
extern INPUTCFC *FCEU_InitQuizKing(void);
 
69
extern INPUTCFC *FCEU_InitFamilyTrainerA(void);
 
70
extern INPUTCFC *FCEU_InitFamilyTrainerB(void);
 
71
extern INPUTCFC *FCEU_InitOekaKids(void);
 
72
extern INPUTCFC *FCEU_InitTopRider(void);
 
73
extern INPUTCFC *FCEU_InitBarcodeWorld(void);
 
74
//---------------
 
75
 
 
76
//global lag variables
 
77
unsigned int lagCounter;
 
78
bool lagCounterDisplay;
 
79
char lagFlag;
 
80
extern bool frameAdvanceLagSkip;
 
81
extern bool movieSubtitles;
 
82
//-------------
 
83
 
 
84
static uint8 joy_readbit[2];
 
85
uint8 joy[4]={0,0,0,0}; //HACK - should be static but movie needs it
 
86
static uint8 LastStrobe;
 
87
 
 
88
#ifdef _USE_SHARED_MEMORY_
 
89
static uint32 BotPointer = 0; //mbg merge 7/18/06 changed to uint32
 
90
#endif
 
91
 
 
92
//This function is a quick hack to get the NSF player to use emulated gamepad input.
 
93
uint8 FCEU_GetJoyJoy(void)
 
94
{
 
95
        return(joy[0]|joy[1]|joy[2]|joy[3]);
 
96
}
 
97
 
 
98
extern uint8 coinon;
 
99
 
 
100
//set to true if the fourscore is attached
 
101
static bool FSAttached = false;
 
102
 
 
103
JOYPORT joyports[2] = { JOYPORT(0), JOYPORT(1) };
 
104
FCPORT portFC;
 
105
 
 
106
static DECLFR(JPRead)
 
107
{
 
108
        lagFlag = 0;
 
109
        uint8 ret=0;
 
110
 
 
111
        ret|=joyports[A&1].driver->Read(A&1);
 
112
 
 
113
        if(portFC.driver)
 
114
                ret = portFC.driver->Read(A&1,ret);
 
115
 
 
116
        ret|=X.DB&0xC0;
 
117
        return(ret);
 
118
}
 
119
 
 
120
static DECLFW(B4016)
 
121
{
 
122
        if(portFC.driver)
 
123
                portFC.driver->Write(V&7);
 
124
 
 
125
        for(int i=0;i<2;i++)
 
126
                joyports[i].driver->Write(V&1);
 
127
 
 
128
        if((LastStrobe&1) && (!(V&1)))
 
129
        {
 
130
                //old comment:
 
131
                //This strobe code is just for convenience.  If it were
 
132
                //with the code in input / *.c, it would more accurately represent
 
133
                //what's really going on.  But who wants accuracy? ;)
 
134
                //Seriously, though, this shouldn't be a problem.
 
135
                //new comment:
 
136
                
 
137
                //mbg 6/7/08 - I guess he means that the input drivers could track the strobing themselves
 
138
                //I dont see why it is unreasonable here.
 
139
                for(int i=0;i<2;i++)
 
140
                        joyports[i].driver->Strobe(i);
 
141
                if(portFC.driver)
 
142
                        portFC.driver->Strobe();
 
143
        }
 
144
        LastStrobe=V&0x1;
 
145
}
 
146
 
 
147
//a main joystick port driver representing the case where nothing is plugged in
 
148
static INPUTC DummyJPort={0,0,0,0,0,0};
 
149
//and an expansion port driver for the same ting
 
150
static INPUTCFC DummyPortFC={0,0,0,0,0,0};
 
151
 
 
152
 
 
153
//--------4 player driver for expansion port--------
 
154
static uint8 F4ReadBit[2];
 
155
static void StrobeFami4(void)
 
156
{
 
157
        F4ReadBit[0]=F4ReadBit[1]=0;
 
158
}
 
159
 
 
160
static uint8 ReadFami4(int w, uint8 ret)
 
161
{
 
162
        ret&=1;
 
163
 
 
164
        ret |= ((joy[2+w]>>(F4ReadBit[w]))&1)<<1;
 
165
        if(F4ReadBit[w]>=8) ret|=2;
 
166
        else F4ReadBit[w]++;
 
167
 
 
168
        return(ret);
 
169
}
 
170
 
 
171
static INPUTCFC FAMI4C={ReadFami4,0,StrobeFami4,0,0,0};
 
172
//------------------
 
173
 
 
174
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
175
 
 
176
 
 
177
static uint8 ReadGPVS(int w)
 
178
{
 
179
        uint8 ret=0;
 
180
 
 
181
        if(joy_readbit[w]>=8)
 
182
                ret=1;
 
183
        else
 
184
        {
 
185
                ret = ((joy[w]>>(joy_readbit[w]))&1);
 
186
                if(!fceuindbg)
 
187
                        joy_readbit[w]++;
 
188
        }
 
189
        return ret;
 
190
}
 
191
 
 
192
static void UpdateGP(int w, void *data, int arg)
 
193
{
 
194
        if(w==0)        //adelikat, 3/14/09: Changing the joypads to inclusive OR the user's joypad + the Lua joypad, this way lua only takes over the buttons it explicity says to
 
195
        {                       //FatRatKnight: Assume lua is always good. If it's doing nothing in particular using my logic, it'll pass-through the values anyway.
 
196
                #ifdef _S9XLUA_H
 
197
                joy[0]= *(uint32 *)joyports[0].ptr;
 
198
                joy[0]= FCEU_LuaReadJoypad(0,joy[0]);
 
199
                joy[2]= *(uint32 *)joyports[0].ptr >> 16;
 
200
                joy[2]= FCEU_LuaReadJoypad(2,joy[2]);
 
201
                #else // without this, there seems to be no input at all without Lua
 
202
                joy[0] = *(uint32 *)joyports[0].ptr;;
 
203
                joy[2] = *(uint32 *)joyports[0].ptr >> 16;
 
204
                #endif
 
205
        }
 
206
        else
 
207
        {
 
208
                #ifdef _S9XLUA_H
 
209
                joy[1]= *(uint32 *)joyports[1].ptr >> 8;
 
210
                joy[1]= FCEU_LuaReadJoypad(1,joy[1]);
 
211
                joy[3]= *(uint32 *)joyports[1].ptr >> 24;
 
212
                joy[3]= FCEU_LuaReadJoypad(3,joy[3]);
 
213
                #else // same goes for the other two pads
 
214
                joy[1] = *(uint32 *)joyports[1].ptr >> 8;
 
215
                joy[3] = *(uint32 *)joyports[1].ptr >> 24;
 
216
                #endif
 
217
        }
 
218
 
 
219
}
 
220
 
 
221
static void LogGP(int w, MovieRecord* mr)
 
222
{
 
223
        if(w==0)
 
224
        {
 
225
                mr->joysticks[0] = joy[0];
 
226
                mr->joysticks[2] = joy[2];
 
227
        }
 
228
        else
 
229
        {
 
230
                mr->joysticks[1] = joy[1];
 
231
                mr->joysticks[3] = joy[3];
 
232
        }
 
233
}
 
234
 
 
235
static void LoadGP(int w, MovieRecord* mr)
 
236
{
 
237
        if(w==0)
 
238
        {
 
239
                joy[0] = mr->joysticks[0];
 
240
                if(FSAttached) joy[2] = mr->joysticks[2];
 
241
        }
 
242
        else
 
243
        {
 
244
                joy[1] = mr->joysticks[1];
 
245
                if(FSAttached) joy[3] = mr->joysticks[3];
 
246
        }
 
247
}
 
248
 
 
249
 
 
250
//basic joystick port driver
 
251
static uint8 ReadGP(int w)
 
252
{
 
253
        uint8 ret;
 
254
 
 
255
        if(joy_readbit[w]>=8)
 
256
                ret = ((joy[2+w]>>(joy_readbit[w]&7))&1);
 
257
        else
 
258
                ret = ((joy[w]>>(joy_readbit[w]))&1);
 
259
        if(joy_readbit[w]>=16) ret=0;
 
260
        if(!FSAttached)
 
261
        {
 
262
                if(joy_readbit[w]>=8) ret|=1;
 
263
        }
 
264
        else
 
265
        {
 
266
                if(joy_readbit[w]==19-w) ret|=1;
 
267
        }
 
268
        if(!fceuindbg)
 
269
                joy_readbit[w]++;
 
270
        return ret;
 
271
}
 
272
 
 
273
static void StrobeGP(int w)
 
274
{
 
275
        joy_readbit[w]=0;
 
276
}
 
277
 
 
278
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^6
 
279
 
 
280
 
 
281
static INPUTC GPC={ReadGP,0,StrobeGP,UpdateGP,0,0,LogGP,LoadGP};
 
282
static INPUTC GPCVS={ReadGPVS,0,StrobeGP,UpdateGP,0,0,LogGP,LoadGP};
 
283
 
 
284
void FCEU_DrawInput(uint8 *buf)
 
285
{
 
286
        for(int pad=0;pad<2;pad++)
 
287
                joyports[pad].driver->Draw(pad,buf,joyports[pad].attrib);
 
288
        if(portFC.driver)
 
289
                portFC.driver->Draw(buf,portFC.attrib);
 
290
}
 
291
 
 
292
 
 
293
void FCEU_UpdateInput(void)
 
294
{
 
295
        //tell all drivers to poll input and set up their logical states
 
296
        if(!FCEUMOV_Mode(MOVIEMODE_PLAY))
 
297
        {
 
298
                for(int port=0;port<2;port++)
 
299
                        joyports[port].driver->Update(port,joyports[port].ptr,joyports[port].attrib);
 
300
                portFC.driver->Update(portFC.ptr,portFC.attrib);
 
301
        } 
 
302
 
 
303
        if(GameInfo->type==GIT_VSUNI)
 
304
                if(coinon) coinon--;
 
305
 
 
306
        if(FCEUnetplay)
 
307
                NetplayUpdate(joy);
 
308
 
 
309
        FCEUMOV_AddInputState();
 
310
        
 
311
        //TODO - should this apply to the movie data? should this be displayed in the input hud?
 
312
        if(GameInfo->type==GIT_VSUNI)
 
313
                FCEU_VSUniSwap(&joy[0],&joy[1]);
 
314
}
 
315
 
 
316
static DECLFR(VSUNIRead0)
 
317
{
 
318
        lagFlag = 0;
 
319
        uint8 ret=0;
 
320
 
 
321
        ret|=(joyports[0].driver->Read(0))&1;
 
322
 
 
323
        ret|=(vsdip&3)<<3;
 
324
        if(coinon)
 
325
                ret|=0x4;
 
326
        return ret;
 
327
}
 
328
 
 
329
static DECLFR(VSUNIRead1)
 
330
{
 
331
        lagFlag = 0;
 
332
        uint8 ret=0;
 
333
 
 
334
        ret|=(joyports[1].driver->Read(1))&1;
 
335
        ret|=vsdip&0xFC;
 
336
        return ret;
 
337
}
 
338
 
 
339
 
 
340
 
 
341
//calls from the ppu;
 
342
//calls the SLHook for any driver that needs it
 
343
void InputScanlineHook(uint8 *bg, uint8 *spr, uint32 linets, int final)
 
344
{
 
345
        for(int port=0;port<2;port++)
 
346
                joyports[port].driver->SLHook(port,bg,spr,linets,final);
 
347
        portFC.driver->SLHook(bg,spr,linets,final);
 
348
}
 
349
 
 
350
//binds JPorts[pad] to the driver specified in JPType[pad]
 
351
static void SetInputStuff(int port)
 
352
{
 
353
        switch(joyports[port].type)
 
354
        {
 
355
        case SI_GAMEPAD:
 
356
                if(GameInfo->type==GIT_VSUNI)
 
357
                        joyports[port].driver = &GPCVS;
 
358
                else
 
359
                        joyports[port].driver= &GPC;
 
360
                break;
 
361
        case SI_ARKANOID:
 
362
                joyports[port].driver=FCEU_InitArkanoid(port);
 
363
                break;
 
364
        case SI_ZAPPER:
 
365
                joyports[port].driver=FCEU_InitZapper(port);
 
366
                break;
 
367
        case SI_POWERPADA:
 
368
                joyports[port].driver=FCEU_InitPowerpadA(port);
 
369
                break;
 
370
        case SI_POWERPADB:
 
371
                joyports[port].driver=FCEU_InitPowerpadB(port);
 
372
                break;
 
373
        case SI_NONE:
 
374
                joyports[port].driver=&DummyJPort;
 
375
                break;
 
376
        }
 
377
}
 
378
 
 
379
static void SetInputStuffFC()
 
380
{
 
381
        switch(portFC.type)
 
382
        {
 
383
        case SIFC_NONE: 
 
384
                portFC.driver=&DummyPortFC;
 
385
                break;
 
386
        case SIFC_ARKANOID:
 
387
                portFC.driver=FCEU_InitArkanoidFC();
 
388
                break;
 
389
        case SIFC_SHADOW:
 
390
                portFC.driver=FCEU_InitSpaceShadow();
 
391
                break;
 
392
        case SIFC_OEKAKIDS:
 
393
                portFC.driver=FCEU_InitOekaKids();
 
394
                break;
 
395
        case SIFC_4PLAYER:
 
396
                portFC.driver=&FAMI4C;
 
397
                memset(&F4ReadBit,0,sizeof(F4ReadBit));
 
398
                break;
 
399
        case SIFC_FKB:
 
400
                portFC.driver=FCEU_InitFKB();
 
401
                break;
 
402
        case SIFC_SUBORKB:
 
403
                portFC.driver=FCEU_InitSuborKB();
 
404
                break;
 
405
        case SIFC_HYPERSHOT:
 
406
                portFC.driver=FCEU_InitHS();
 
407
                break;
 
408
        case SIFC_MAHJONG:
 
409
                portFC.driver=FCEU_InitMahjong();
 
410
                break;
 
411
        case SIFC_QUIZKING:
 
412
                portFC.driver=FCEU_InitQuizKing();
 
413
                break;
 
414
        case SIFC_FTRAINERA:
 
415
                portFC.driver=FCEU_InitFamilyTrainerA();
 
416
                break;
 
417
        case SIFC_FTRAINERB:
 
418
                portFC.driver=FCEU_InitFamilyTrainerB();
 
419
                break;
 
420
        case SIFC_BWORLD:
 
421
                portFC.driver=FCEU_InitBarcodeWorld();
 
422
                break;
 
423
        case SIFC_TOPRIDER:
 
424
                portFC.driver=FCEU_InitTopRider();
 
425
                break;
 
426
        }
 
427
}
 
428
 
 
429
void FCEUI_SetInput(int port, ESI type, void *ptr, int attrib)
 
430
{
 
431
        joyports[port].attrib = attrib;
 
432
        joyports[port].type = type;
 
433
        joyports[port].ptr = ptr;
 
434
        SetInputStuff(port);
 
435
}
 
436
 
 
437
void FCEUI_SetInputFC(ESIFC type, void *ptr, int attrib)
 
438
{
 
439
        portFC.attrib = attrib;
 
440
        portFC.type = type;
 
441
        portFC.ptr = ptr;
 
442
        SetInputStuffFC();
 
443
}
 
444
 
 
445
 
 
446
//initializes the input system to power-on state
 
447
void InitializeInput(void)
 
448
{
 
449
        memset(joy_readbit,0,sizeof(joy_readbit));
 
450
        memset(joy,0,sizeof(joy));
 
451
        LastStrobe = 0;
 
452
 
 
453
        if(GameInfo->type==GIT_VSUNI)
 
454
        {
 
455
                SetReadHandler(0x4016,0x4016,VSUNIRead0);
 
456
                SetReadHandler(0x4017,0x4017,VSUNIRead1);
 
457
        }
 
458
        else
 
459
                SetReadHandler(0x4016,0x4017,JPRead);
 
460
 
 
461
        SetWriteHandler(0x4016,0x4016,B4016);
 
462
 
 
463
        //force the port drivers to be setup
 
464
        SetInputStuff(0);
 
465
        SetInputStuff(1);
 
466
        SetInputStuffFC();
 
467
}
 
468
 
 
469
 
 
470
bool FCEUI_GetInputFourscore()
 
471
{
 
472
        return FSAttached;
 
473
}
 
474
void FCEUI_SetInputFourscore(bool attachFourscore)
 
475
{
 
476
        FSAttached = attachFourscore;
 
477
}
 
478
 
 
479
//mbg 6/18/08 HACK
 
480
extern ZAPPER ZD[2];
 
481
SFORMAT FCEUCTRL_STATEINFO[]={
 
482
        { joy_readbit,  2, "JYRB"},
 
483
        { joy,                  4, "JOYS"},
 
484
        { &LastStrobe,  1, "LSTS"},
 
485
        { &ZD[0].bogo,  1, "ZBG0"},
 
486
        { &ZD[1].bogo,  1, "ZBG1"},
 
487
        { &lagFlag,             1, "LAGF"},
 
488
        { &lagCounter,  4, "LAGC"},
 
489
        { &currFrameCounter, 4, "FRAM"},
 
490
        { 0 }
 
491
};
 
492
 
 
493
void FCEU_DoSimpleCommand(int cmd)
 
494
{
 
495
        switch(cmd)
 
496
        {
 
497
        case FCEUNPCMD_FDSINSERT: FCEU_FDSInsert();break;
 
498
        case FCEUNPCMD_FDSSELECT: FCEU_FDSSelect();break;
 
499
        case FCEUNPCMD_VSUNICOIN: FCEU_VSUniCoin(); break;
 
500
        case FCEUNPCMD_VSUNIDIP0: 
 
501
        case FCEUNPCMD_VSUNIDIP0+1:
 
502
        case FCEUNPCMD_VSUNIDIP0+2:
 
503
        case FCEUNPCMD_VSUNIDIP0+3:
 
504
        case FCEUNPCMD_VSUNIDIP0+4:
 
505
        case FCEUNPCMD_VSUNIDIP0+5:
 
506
        case FCEUNPCMD_VSUNIDIP0+6:
 
507
        case FCEUNPCMD_VSUNIDIP0+7:     FCEU_VSUniToggleDIP(cmd - FCEUNPCMD_VSUNIDIP0);break;
 
508
        case FCEUNPCMD_POWER: PowerNES();break;
 
509
        case FCEUNPCMD_RESET: ResetNES();break;
 
510
        }
 
511
}
 
512
 
 
513
void FCEU_QSimpleCommand(int cmd)
 
514
{
 
515
        if(FCEUnetplay)
 
516
                FCEUNET_SendCommand(cmd, 0);
 
517
        else
 
518
        {
 
519
                FCEU_DoSimpleCommand(cmd);
 
520
                if(FCEUMOV_Mode(MOVIEMODE_RECORD))
 
521
                        FCEUMOV_AddCommand(cmd);
 
522
        }
 
523
}
 
524
 
 
525
void FCEUI_FDSSelect(void)
 
526
{
 
527
        FCEU_QSimpleCommand(FCEUNPCMD_FDSSELECT);
 
528
}
 
529
 
 
530
void FCEUI_FDSInsert(void)
 
531
{
 
532
        FCEU_QSimpleCommand(FCEUNPCMD_FDSINSERT);
 
533
}
 
534
 
 
535
 
 
536
void FCEUI_VSUniToggleDIP(int w)
 
537
{
 
538
        FCEU_QSimpleCommand(FCEUNPCMD_VSUNIDIP0 + w);
 
539
}
 
540
 
 
541
void FCEUI_VSUniCoin(void)
 
542
{
 
543
        FCEU_QSimpleCommand(FCEUNPCMD_VSUNICOIN);
 
544
}
 
545
 
 
546
//Resets the frame counter if movie inactive and rom is reset or power-cycle
 
547
void ResetFrameCounter()
 
548
{
 
549
extern EMOVIEMODE movieMode;
 
550
        if(movieMode == MOVIEMODE_INACTIVE)
 
551
                currFrameCounter = 0;
 
552
}
 
553
 
 
554
//Resets the NES
 
555
void FCEUI_ResetNES(void)
 
556
{
 
557
        if(!FCEU_IsValidUI(FCEUI_RESET))
 
558
                return;
 
559
        FCEU_QSimpleCommand(FCEUNPCMD_RESET);
 
560
        ResetFrameCounter();
 
561
}
 
562
 
 
563
//Powers off the NES
 
564
void FCEUI_PowerNES(void)
 
565
{
 
566
        if(!FCEU_IsValidUI(FCEUI_POWER))
 
567
                return;
 
568
        FCEU_QSimpleCommand(FCEUNPCMD_POWER);
 
569
        ResetFrameCounter();
 
570
}
 
571
 
 
572
const char* FCEUI_CommandTypeNames[]=
 
573
{
 
574
        "Misc.",
 
575
        "Speed",
 
576
        "State",
 
577
        "Movie",
 
578
        "Sound",
 
579
        "AVI",
 
580
        "FDS",
 
581
        "VS Sys",
 
582
        "Tools",
 
583
};
 
584
 
 
585
static void CommandUnImpl(void);
 
586
static void CommandToggleDip(void);
 
587
static void CommandStateLoad(void);
 
588
static void CommandStateSave(void);
 
589
static void CommandSelectSaveSlot(void);
 
590
static void CommandEmulationSpeed(void);
 
591
static void CommandSoundAdjust(void);
 
592
static void CommandUsePreset(void);
 
593
static void BackgroundDisplayToggle(void);
 
594
static void ObjectDisplayToggle(void);
 
595
static void LagCounterToggle(void);
 
596
static void ViewSlots(void);
 
597
static void LaunchMemoryWatch(void);
 
598
static void LaunchCheats(void);
 
599
static void LaunchDebugger(void);
 
600
static void LaunchPPU(void);
 
601
static void LaunchHex(void);
 
602
static void LaunchTraceLogger(void);
 
603
static void LaunchCodeDataLogger(void);
 
604
static void LaunchRamWatch(void);
 
605
static void LaunchRamSearch(void);
 
606
static void FA_SkipLag(void);
 
607
static void OpenRom(void);
 
608
static void CloseRom(void);
 
609
static void MovieSubtitleToggle(void);
 
610
static void UndoRedoSavestate(void);
 
611
static void FCEUI_DoExit(void);
 
612
static void ToggleFullscreen(void);
 
613
 
 
614
struct EMUCMDTABLE FCEUI_CommandTable[]=
 
615
{
 
616
        { EMUCMD_POWER,                                                 EMUCMDTYPE_MISC,        FCEUI_PowerNES,           0, 0, "Power", 0 },
 
617
        { EMUCMD_RESET,                                                 EMUCMDTYPE_MISC,        FCEUI_ResetNES,           0, 0, "Reset", 0 },
 
618
        { EMUCMD_PAUSE,                                                 EMUCMDTYPE_MISC,        FCEUI_ToggleEmulationPause, 0, 0, "Pause", EMUCMDFLAG_TASEDIT },
 
619
        { EMUCMD_FRAME_ADVANCE,                                 EMUCMDTYPE_MISC,        FCEUI_FrameAdvance, FCEUI_FrameAdvanceEnd, 0, "Frame Advance", EMUCMDFLAG_TASEDIT },
 
620
        { EMUCMD_SCREENSHOT,                                    EMUCMDTYPE_MISC,        FCEUI_SaveSnapshot,       0, 0, "Screenshot", EMUCMDFLAG_TASEDIT },
 
621
        { EMUCMD_HIDE_MENU_TOGGLE,                              EMUCMDTYPE_MISC,        FCEUD_HideMenuToggle, 0, 0, "Hide Menu Toggle", EMUCMDFLAG_TASEDIT },
 
622
        { EMUCMD_EXIT,                                                  EMUCMDTYPE_MISC,        FCEUI_DoExit,                     0, 0, "Exit", 0},
 
623
        { EMUCMD_SPEED_SLOWEST,                                 EMUCMDTYPE_SPEED,       CommandEmulationSpeed, 0, 0, "Slowest Speed", 0 },
 
624
        { EMUCMD_SPEED_SLOWER,                                  EMUCMDTYPE_SPEED,       CommandEmulationSpeed, 0, 0, "Speed Down", 0 },
 
625
        { EMUCMD_SPEED_NORMAL,                                  EMUCMDTYPE_SPEED,       CommandEmulationSpeed, 0, 0, "Normal Speed", 0 },
 
626
        { EMUCMD_SPEED_FASTER,                                  EMUCMDTYPE_SPEED,       CommandEmulationSpeed, 0, 0, "Speed Up", 0 },
 
627
        { EMUCMD_SPEED_FASTEST,                                 EMUCMDTYPE_SPEED,       CommandEmulationSpeed, 0, 0, "Fastest Speed", 0 },
 
628
        { EMUCMD_SPEED_TURBO,                                   EMUCMDTYPE_SPEED,       FCEUD_TurboOn, FCEUD_TurboOff, 0, "Turbo", EMUCMDFLAG_TASEDIT },
 
629
        { EMUCMD_SPEED_TURBO_TOGGLE,                    EMUCMDTYPE_SPEED,       FCEUD_TurboToggle, 0, 0, "Turbo Toggle", EMUCMDFLAG_TASEDIT },
 
630
 
 
631
        { EMUCMD_SAVE_SLOT_0,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 0", 0 },
 
632
        { EMUCMD_SAVE_SLOT_1,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 1", 0 },
 
633
        { EMUCMD_SAVE_SLOT_2,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 2", 0 },
 
634
        { EMUCMD_SAVE_SLOT_3,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 3", 0 },
 
635
        { EMUCMD_SAVE_SLOT_4,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 4", 0 },
 
636
        { EMUCMD_SAVE_SLOT_5,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 5", 0 },
 
637
        { EMUCMD_SAVE_SLOT_6,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 6", 0 },
 
638
        { EMUCMD_SAVE_SLOT_7,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 7", 0 },
 
639
        { EMUCMD_SAVE_SLOT_8,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 8", 0 },
 
640
        { EMUCMD_SAVE_SLOT_9,                                   EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Savestate Slot 9", 0 },
 
641
        { EMUCMD_SAVE_SLOT_NEXT,                                EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Next Savestate Slot", 0 },
 
642
        { EMUCMD_SAVE_SLOT_PREV,                                EMUCMDTYPE_STATE,       CommandSelectSaveSlot, 0, 0, "Previous Savestate Slot", 0 },
 
643
        { EMUCMD_SAVE_STATE,                                    EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State", 0 },
 
644
        { EMUCMD_SAVE_STATE_AS,                                 EMUCMDTYPE_STATE,       FCEUD_SaveStateAs, 0, 0, "Save State As...", 0 },
 
645
        { EMUCMD_SAVE_STATE_SLOT_0,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 0", 0 },
 
646
        { EMUCMD_SAVE_STATE_SLOT_1,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 1", 0 },
 
647
        { EMUCMD_SAVE_STATE_SLOT_2,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 2", 0 },
 
648
        { EMUCMD_SAVE_STATE_SLOT_3,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 3", 0 },
 
649
        { EMUCMD_SAVE_STATE_SLOT_4,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 4", 0 },
 
650
        { EMUCMD_SAVE_STATE_SLOT_5,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 5", 0 },
 
651
        { EMUCMD_SAVE_STATE_SLOT_6,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 6", 0 },
 
652
        { EMUCMD_SAVE_STATE_SLOT_7,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 7", 0 },
 
653
        { EMUCMD_SAVE_STATE_SLOT_8,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 8", 0 },
 
654
        { EMUCMD_SAVE_STATE_SLOT_9,                             EMUCMDTYPE_STATE,       CommandStateSave, 0, 0, "Save State to Slot 9", 0 },
 
655
        { EMUCMD_LOAD_STATE,                                    EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State", 0 },
 
656
        { EMUCMD_LOAD_STATE_FROM,                               EMUCMDTYPE_STATE,       FCEUD_LoadStateFrom, 0, 0, "Load State From...", 0 },
 
657
        { EMUCMD_LOAD_STATE_SLOT_0,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 0", 0 },
 
658
        { EMUCMD_LOAD_STATE_SLOT_1,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 1", 0 },
 
659
        { EMUCMD_LOAD_STATE_SLOT_2,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 2", 0 },
 
660
        { EMUCMD_LOAD_STATE_SLOT_3,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 3", 0 },
 
661
        { EMUCMD_LOAD_STATE_SLOT_4,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 4", 0 },
 
662
        { EMUCMD_LOAD_STATE_SLOT_5,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 5", 0 },
 
663
        { EMUCMD_LOAD_STATE_SLOT_6,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 6", 0 },
 
664
        { EMUCMD_LOAD_STATE_SLOT_7,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 7", 0 },
 
665
        { EMUCMD_LOAD_STATE_SLOT_8,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 8", 0 },
 
666
        { EMUCMD_LOAD_STATE_SLOT_9,                             EMUCMDTYPE_STATE,       CommandStateLoad, 0, 0, "Load State from Slot 9", 0 },
 
667
        
 
668
        { EMUCMD_MOVIE_RECORD_TO,                               EMUCMDTYPE_MOVIE,       FCEUD_MovieRecordTo, 0, 0, "Record Movie To...",0  },
 
669
        { EMUCMD_MOVIE_REPLAY_FROM,                             EMUCMDTYPE_MOVIE,       FCEUD_MovieReplayFrom, 0, 0, "Play Movie From...", },
 
670
        { EMUCMD_MOVIE_PLAY_FROM_BEGINNING,             EMUCMDTYPE_MOVIE,       FCEUI_MoviePlayFromBeginning, 0, 0, "Play Movie From Beginning", 0 },
 
671
        { EMUCMD_MOVIE_STOP,                                    EMUCMDTYPE_MOVIE,       FCEUI_StopMovie, 0, 0, "Stop Movie", 0 },
 
672
        { EMUCMD_MOVIE_READONLY_TOGGLE,                 EMUCMDTYPE_MOVIE,       FCEUI_MovieToggleReadOnly, 0, 0, "Toggle Read-Only", EMUCMDFLAG_TASEDIT },
 
673
        { EMUCMD_MOVIE_FRAME_DISPLAY_TOGGLE,    EMUCMDTYPE_MOVIE,       FCEUI_MovieToggleFrameDisplay, 0, 0, "Frame Display Toggle", 0 },
 
674
 
 
675
        { EMUCMD_MOVIE_INPUT_DISPLAY_TOGGLE,    EMUCMDTYPE_MISC,        FCEUI_ToggleInputDisplay, 0, 0, "Toggle Input Display", 0 },
 
676
        { EMUCMD_MOVIE_ICON_DISPLAY_TOGGLE,             EMUCMDTYPE_MISC,        FCEUD_ToggleStatusIcon, 0, 0, "Toggle Status Icon", 0 },
 
677
 
 
678
        #ifdef _S9XLUA_H
 
679
        { EMUCMD_SCRIPT_RELOAD,                                 EMUCMDTYPE_MISC,        FCEU_ReloadLuaCode, 0, 0, "Reload current Lua script", },
 
680
        #endif
 
681
 
 
682
        { EMUCMD_SOUND_TOGGLE,                                  EMUCMDTYPE_SOUND,       FCEUD_SoundToggle, 0, 0, "Sound Mute Toggle", EMUCMDFLAG_TASEDIT },
 
683
        { EMUCMD_SOUND_VOLUME_UP,                               EMUCMDTYPE_SOUND,       CommandSoundAdjust, 0, 0, "Sound Volume Up", EMUCMDFLAG_TASEDIT },
 
684
        { EMUCMD_SOUND_VOLUME_DOWN,                             EMUCMDTYPE_SOUND,       CommandSoundAdjust, 0, 0, "Sound Volume Down", EMUCMDFLAG_TASEDIT },
 
685
        { EMUCMD_SOUND_VOLUME_NORMAL,                   EMUCMDTYPE_SOUND,       CommandSoundAdjust, 0, 0, "Sound Volume Normal", EMUCMDFLAG_TASEDIT },
 
686
 
 
687
        { EMUCMD_AVI_RECORD_AS,                                 EMUCMDTYPE_AVI,         FCEUD_AviRecordTo, 0, 0, "Record AVI As...", 0 },
 
688
        { EMUCMD_AVI_STOP,                                              EMUCMDTYPE_AVI,         FCEUD_AviStop, 0, 0, "Stop AVI", 0 },
 
689
 
 
690
        { EMUCMD_FDS_EJECT_INSERT,                              EMUCMDTYPE_FDS,         FCEUI_FDSInsert, 0, 0, "Eject or Insert FDS Disk", 0 },
 
691
        { EMUCMD_FDS_SIDE_SELECT,                               EMUCMDTYPE_FDS,         FCEUI_FDSSelect, 0, 0, "Switch FDS Disk Side", 0 },
 
692
 
 
693
        { EMUCMD_VSUNI_COIN,                                    EMUCMDTYPE_VSUNI,       FCEUI_VSUniCoin, 0, 0, "Insert Coin", 0 },
 
694
        { EMUCMD_VSUNI_TOGGLE_DIP_0,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 0", 0 },
 
695
        { EMUCMD_VSUNI_TOGGLE_DIP_1,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 1", 0 },
 
696
        { EMUCMD_VSUNI_TOGGLE_DIP_2,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 2", 0 },
 
697
        { EMUCMD_VSUNI_TOGGLE_DIP_3,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 3", 0 },
 
698
        { EMUCMD_VSUNI_TOGGLE_DIP_4,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 4", 0 },
 
699
        { EMUCMD_VSUNI_TOGGLE_DIP_5,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 5", 0 },
 
700
        { EMUCMD_VSUNI_TOGGLE_DIP_6,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 6", 0 },
 
701
        { EMUCMD_VSUNI_TOGGLE_DIP_7,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 7", 0 },
 
702
        { EMUCMD_VSUNI_TOGGLE_DIP_8,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 8", 0 },
 
703
        { EMUCMD_VSUNI_TOGGLE_DIP_9,                    EMUCMDTYPE_VSUNI,       CommandToggleDip, 0, 0, "Toggle Dipswitch 9", 0 },
 
704
        { EMUCMD_MISC_AUTOSAVE,                                 EMUCMDTYPE_MISC,        FCEUI_Autosave,   0, 0, "Load Last Auto-save", 0},
 
705
        { EMUCMD_MISC_SHOWSTATES,                               EMUCMDTYPE_MISC,        ViewSlots,        0, 0, "View save slots",    0 },
 
706
        { EMUCMD_MISC_USE_INPUT_PRESET_1,               EMUCMDTYPE_MISC,        CommandUsePreset, 0, 0, "Use Input Preset 1", 0 },
 
707
        { EMUCMD_MISC_USE_INPUT_PRESET_2,               EMUCMDTYPE_MISC,        CommandUsePreset, 0, 0, "Use Input Preset 2", 0 },
 
708
        { EMUCMD_MISC_USE_INPUT_PRESET_3,               EMUCMDTYPE_MISC,        CommandUsePreset, 0, 0, "Use Input Preset 3", 0 },
 
709
        { EMUCMD_MISC_DISPLAY_BG_TOGGLE,                EMUCMDTYPE_MISC,        BackgroundDisplayToggle, 0, 0, "Toggle Background Display", 0 },
 
710
        { EMUCMD_MISC_DISPLAY_OBJ_TOGGLE,               EMUCMDTYPE_MISC,        ObjectDisplayToggle, 0, 0, "Toggle Object Display", 0 },
 
711
        { EMUCMD_MISC_DISPLAY_LAGCOUNTER_TOGGLE,EMUCMDTYPE_MISC,        LagCounterToggle, 0, 0, "Lag Counter Toggle", 0 },
 
712
        { EMUCMD_MISC_LAGCOUNTER_RESET,                 EMUCMDTYPE_MISC,        LagCounterReset,  0, 0, "Lag Counter Reset", 0},
 
713
        { EMUCMD_TOOL_OPENMEMORYWATCH,                  EMUCMDTYPE_TOOL,        LaunchMemoryWatch,0, 0, "Open Memory Watch", 0},
 
714
        { EMUCMD_TOOL_OPENCHEATS,                               EMUCMDTYPE_TOOL,        LaunchCheats,     0, 0, "Open Cheats", 0},
 
715
        { EMUCMD_TOOL_OPENDEBUGGER,                             EMUCMDTYPE_TOOL,        LaunchDebugger,   0, 0, "Open Debugger", 0},
 
716
        { EMUCMD_TOOL_OPENHEX,                                  EMUCMDTYPE_TOOL,        LaunchHex,                0, 0, "Open Hex Editor", 0},
 
717
        { EMUCMD_TOOL_OPENPPU,                                  EMUCMDTYPE_TOOL,        LaunchPPU,                0, 0, "Open PPU Viewer", 0},
 
718
        { EMUCMD_TOOL_OPENTRACELOGGER,                  EMUCMDTYPE_TOOL,        LaunchTraceLogger, 0, 0, "Open Trace Logger", 0},
 
719
        { EMUCMD_TOOL_OPENCDLOGGER,                             EMUCMDTYPE_TOOL,        LaunchCodeDataLogger, 0, 0, "Open Code/Data Logger", 0},
 
720
        { EMUCMD_FRAMEADV_SKIPLAG,                              EMUCMDTYPE_MISC,        FA_SkipLag,               0, 0,  "Frame Adv.-Skip Lag", 0},
 
721
        { EMUCMD_OPENROM,                                               EMUCMDTYPE_TOOL,        OpenRom,                  0, 0,  "Open ROM", 0},
 
722
        { EMUCMD_CLOSEROM,                                              EMUCMDTYPE_TOOL,        CloseRom,                 0, 0,  "Close ROM", 0},
 
723
        { EMUCMD_MISC_DISPLAY_MOVIESUBTITLES,   EMUCMDTYPE_MISC,        MovieSubtitleToggle,0,0,"Toggle Movie Subtitles", 0},
 
724
        { EMUCMD_MISC_UNDOREDOSAVESTATE,                EMUCMDTYPE_MISC,        UndoRedoSavestate,  0,0,"Undo/Redo Savestate",    0},
 
725
        { EMUCMD_MISC_TOGGLEFULLSCREEN,                 EMUCMDTYPE_MISC,        ToggleFullscreen, 0, 0, "Toggle Fullscreen",      0},
 
726
        { EMUCMD_TOOL_OPENRAMWATCH,                             EMUCMDTYPE_TOOL,        LaunchRamWatch,   0, 0, "Open Ram Watch",                 0},
 
727
        { EMUCMD_TOOL_OPENRAMSEARCH,                    EMUCMDTYPE_TOOL,        LaunchRamSearch,  0, 0, "Open Ram Search",                0},
 
728
};
 
729
 
 
730
#define NUM_EMU_CMDS            (sizeof(FCEUI_CommandTable)/sizeof(FCEUI_CommandTable[0]))
 
731
 
 
732
static int execcmd, i;
 
733
 
 
734
void FCEUI_HandleEmuCommands(TestCommandState* testfn)
 
735
{
 
736
        bool tasedit = FCEUMOV_Mode(MOVIEMODE_TASEDIT);
 
737
        for(i=0; i<NUM_EMU_CMDS; ++i)
 
738
        {
 
739
                int new_state;
 
740
                int old_state = FCEUI_CommandTable[i].state;
 
741
                execcmd = FCEUI_CommandTable[i].cmd;
 
742
                new_state = (*testfn)(execcmd);
 
743
                //in tasedit, forbid commands without the tasedit flag
 
744
                bool allow = true;
 
745
                if(tasedit && !(FCEUI_CommandTable[i].flags & EMUCMDFLAG_TASEDIT))
 
746
                        allow = false;
 
747
                
 
748
                if(allow)
 
749
                {
 
750
                        if (new_state == 1 && old_state == 0 && FCEUI_CommandTable[i].fn_on)
 
751
                                (*(FCEUI_CommandTable[i].fn_on))();
 
752
                        else if (new_state == 0 && old_state == 1 && FCEUI_CommandTable[i].fn_off)
 
753
                                (*(FCEUI_CommandTable[i].fn_off))();
 
754
                }
 
755
                FCEUI_CommandTable[i].state = new_state;
 
756
        }
 
757
}
 
758
 
 
759
static void CommandUnImpl(void)
 
760
{
 
761
        FCEU_DispMessage("command '%s' unimplemented.", FCEUI_CommandTable[i].name);
 
762
}
 
763
 
 
764
static void CommandToggleDip(void)
 
765
{
 
766
        if (GameInfo->type==GIT_VSUNI)
 
767
                FCEUI_VSUniToggleDIP(execcmd-EMUCMD_VSUNI_TOGGLE_DIP_0);
 
768
}
 
769
 
 
770
static void CommandEmulationSpeed(void)
 
771
{
 
772
        FCEUD_SetEmulationSpeed(EMUSPEED_SLOWEST+(execcmd-EMUCMD_SPEED_SLOWEST));
 
773
}
 
774
 
 
775
void FCEUI_SelectStateNext(int);
 
776
 
 
777
static void ViewSlots(void)
 
778
{
 
779
        FCEUI_SelectState(CurrentState, 1);
 
780
}
 
781
 
 
782
static void CommandSelectSaveSlot(void)
 
783
{
 
784
        if(execcmd <= EMUCMD_SAVE_SLOT_9)
 
785
                FCEUI_SelectState(execcmd-EMUCMD_SAVE_SLOT_0, 1);
 
786
        else if(execcmd == EMUCMD_SAVE_SLOT_NEXT)
 
787
                FCEUI_SelectStateNext(1);
 
788
        else if(execcmd == EMUCMD_SAVE_SLOT_PREV)
 
789
                FCEUI_SelectStateNext(-1);
 
790
}
 
791
 
 
792
static void CommandStateSave(void)
 
793
{
 
794
        //      FCEU_PrintError("execcmd=%d, EMUCMD_SAVE_STATE_SLOT_0=%d, EMUCMD_SAVE_STATE_SLOT_9=%d", execcmd,EMUCMD_SAVE_STATE_SLOT_0,EMUCMD_SAVE_STATE_SLOT_9);
 
795
        if(execcmd >= EMUCMD_SAVE_STATE_SLOT_0 && execcmd <= EMUCMD_SAVE_STATE_SLOT_9)
 
796
        {
 
797
                int oldslot=FCEUI_SelectState(execcmd-EMUCMD_SAVE_STATE_SLOT_0, 0);
 
798
                FCEUI_SaveState(0);
 
799
                FCEUI_SelectState(oldslot, 0);
 
800
        }
 
801
        else
 
802
                FCEUI_SaveState(0);
 
803
}
 
804
 
 
805
static void CommandStateLoad(void)
 
806
{
 
807
        if(execcmd >= EMUCMD_LOAD_STATE_SLOT_0 && execcmd <= EMUCMD_LOAD_STATE_SLOT_9)
 
808
        {
 
809
                int oldslot=FCEUI_SelectState(execcmd-EMUCMD_LOAD_STATE_SLOT_0, 0);
 
810
                FCEUI_LoadState(0);
 
811
                FCEUI_SelectState(oldslot, 0);
 
812
        }
 
813
        else
 
814
                FCEUI_LoadState(0);
 
815
}
 
816
 
 
817
static void CommandSoundAdjust(void)
 
818
{
 
819
        int n=0;
 
820
        switch(execcmd)
 
821
        {
 
822
        case EMUCMD_SOUND_VOLUME_UP:            n=1;  break;
 
823
        case EMUCMD_SOUND_VOLUME_DOWN:          n=-1;  break;
 
824
        case EMUCMD_SOUND_VOLUME_NORMAL:        n=0;  break;
 
825
        }
 
826
 
 
827
        FCEUD_SoundVolumeAdjust(n);
 
828
}
 
829
 
 
830
 
 
831
static void CommandUsePreset(void)
 
832
{
 
833
        FCEUI_UseInputPreset(execcmd-EMUCMD_MISC_USE_INPUT_PRESET_1);
 
834
}
 
835
 
 
836
static void BackgroundDisplayToggle(void)
 
837
{
 
838
        bool spr, bg;
 
839
        FCEUI_GetRenderPlanes(spr,bg);
 
840
        bg = !bg;
 
841
        FCEUI_SetRenderPlanes(spr,bg);
 
842
}
 
843
 
 
844
static void ObjectDisplayToggle(void)
 
845
{
 
846
        bool spr, bg;
 
847
        FCEUI_GetRenderPlanes(spr,bg);
 
848
        spr = !spr;
 
849
        FCEUI_SetRenderPlanes(spr,bg);
 
850
}
 
851
 
 
852
void LagCounterReset()
 
853
{
 
854
        lagCounter = 0;
 
855
}
 
856
 
 
857
static void LagCounterToggle(void)
 
858
{
 
859
        lagCounterDisplay ^= 1;
 
860
}
 
861
 
 
862
static void LaunchMemoryWatch(void)
 
863
{
 
864
#ifdef WIN32
 
865
        CreateMemWatch();
 
866
#endif
 
867
}
 
868
 
 
869
static void LaunchDebugger(void)
 
870
{
 
871
#ifdef WIN32
 
872
        DoDebug(0);
 
873
#endif
 
874
}
 
875
 
 
876
static void LaunchPPU(void)
 
877
{
 
878
#ifdef WIN32
 
879
        DoPPUView();
 
880
#endif
 
881
}
 
882
 
 
883
static void LaunchHex(void)
 
884
{
 
885
#ifdef WIN32
 
886
        DoMemView();
 
887
#endif
 
888
}
 
889
 
 
890
static void LaunchTraceLogger(void)
 
891
{
 
892
#ifdef WIN32
 
893
        DoTracer();
 
894
#endif
 
895
}
 
896
 
 
897
static void LaunchCodeDataLogger(void)
 
898
{
 
899
#ifdef WIN32
 
900
        DoCDLogger();
 
901
#endif
 
902
}
 
903
 
 
904
static void LaunchCheats(void)
 
905
{
 
906
#ifdef WIN32
 
907
        extern HWND pwindow;
 
908
        ConfigCheats(pwindow);
 
909
#endif
 
910
}
 
911
 
 
912
static void LaunchRamWatch(void)
 
913
{
 
914
#ifdef WIN32
 
915
        extern void OpenRamWatch();     //adelikat: Blah blah hacky, I know
 
916
        OpenRamWatch();
 
917
#endif
 
918
}
 
919
 
 
920
static void LaunchRamSearch(void)
 
921
{
 
922
#ifdef WIN32
 
923
        extern void OpenRamSearch();
 
924
        OpenRamSearch();
 
925
#endif
 
926
}
 
927
 
 
928
 
 
929
 
 
930
static void FA_SkipLag(void)
 
931
{
 
932
        frameAdvanceLagSkip ^= 1;
 
933
}
 
934
 
 
935
static void OpenRom(void)
 
936
{
 
937
#ifdef WIN32
 
938
        extern HWND hAppWnd;
 
939
        LoadNewGamey(hAppWnd, 0);
 
940
#endif
 
941
}
 
942
 
 
943
static void CloseRom(void)
 
944
{
 
945
#ifdef WIN32
 
946
        CloseGame();
 
947
#endif
 
948
}
 
949
 
 
950
static void MovieSubtitleToggle(void)
 
951
{
 
952
        movieSubtitles ^= 1;
 
953
        if (movieSubtitles)     FCEU_DispMessage("Movie subtitles on");
 
954
        else FCEU_DispMessage("Movie subtitles off");
 
955
}
 
956
 
 
957
static void UndoRedoSavestate(void)
 
958
{
 
959
        if (lastSavestateMade && (undoSS || redoSS))
 
960
                SwapSaveState();
 
961
}
 
962
 
 
963
static void FCEUI_DoExit(void)
 
964
{
 
965
#ifdef WIN32
 
966
        DoFCEUExit();
 
967
#endif
 
968
}
 
969
 
 
970
static void ToggleFullscreen(void)
 
971
{
 
972
#ifdef WIN32
 
973
        extern int SetVideoMode(int fs);                //adelikat: Yeah, I know, hacky
 
974
        extern void UpdateCheckedMenuItems();
 
975
        
 
976
        UpdateCheckedMenuItems();
 
977
        changerecursive=1;
 
978
        if(!SetVideoMode(fullscreen^1))
 
979
                SetVideoMode(fullscreen);
 
980
        changerecursive=0;
 
981
#endif
 
982
}
 
 
b'\\ No newline at end of file'