x11.cpp

SFC游戏模拟器 snes9x 1.43 的原代码

        Define(TOGGLE_CONTROLLER, 0,   XK_7);
        Define(TOGGLE_INTERPSOUND, 0,  XK_bracketleft, Alt(XK_8));
        Define(TOGGLE_SYNCSOUND, 0,    XK_bracketright, Alt(XK_9));
        Define(TOGGLE_MODE7INTERP, 0,  Shift(XK_9));
        Define(TURBO_ENABLE, 0,        XK_Tab);
        Define(SUPERSCOPE_TURBO, 0,    XK_grave, XK_asciitilde, XK_numbersign);
        Define(SUPERSCOPE_PAUSE_ENABLE, 0, XK_slash);
        // escape from fullscreen, escape from emulator
        Define(EXIT, 0,                XK_Escape);
        // movie functions
        Define(WRITE_MOVIE_ASK, 0,     Shift(XK_1));
        Define(LOAD_MOVIE_ASK, 0,      Shift(XK_2));
        Define(STOP_MOVIE, 0,          Shift(XK_3));
        
        VerifySetup();
    }
public:
    const Keyfunction& GetKeyFunction(int keycode, unsigned keymask) const
    {
        static Keyfunction notfound;
        map<int, Keydata>::const_iterator i = keydata.find(keycode);
        //fprintf(stderr, "Pressed key %d (mask %X)\n", keycode, keymask);
        if(i != keydata.end())
        {
            // ShiftMask: shift ($0001)
            // LockMask:  capslock ($0002)
            // Mod1Mask:  alt ($0008)
            // Mod4Mask:  numlock ($0010)
            //         :  altgr ($2000)
            // Mod5Mask:  scrolllock ($0080)
            // Button1Mask: left mouse button ($0100)
            // Button2Mask: middle mouse button ($0200)
            // Button3Mask: right mouse button ($0400)
            
            if(keymask & (Mod1Mask | 0x2000)) return i->second.alt;
            if(keymask & (ControlMask)) return i->second.ctrl;
            if(keymask & (ShiftMask)) return i->second.shift;
            return i->second.plain;
        }
        return notfound;
    }
} KBSetup;

void S9xProcessEvents (bool8 block)
{
#ifdef USE_AIDO
    if (Settings.AIDOShmId)
    {
        S9xAIDOProcessEvents(block);
        return;
    }
#endif

    while (block || CheckForPendingXEvents (GUI.display))
    {
        XEvent event;

        XNextEvent (GUI.display, &event);
        block = FALSE;

#if 0
        if (event.xany.window != window)
        {
            app->x11ProcessEvent (&event);
            continue;
        }
#endif
        switch (event.type)
        {
        case KeyPress:
        case KeyRelease:
        {
            int key = XKeycodeToKeysym (GUI.display, event.xkey.keycode, 0);
            
            const KeyboardSetup::Keyfunction& func
                = KBSetup.GetKeyFunction(key, event.xkey.state);
            switch(func.func)
            {
                case KeyboardSetup::FUNC_NONE:
                {
                    break;
                }
                case KeyboardSetup::PLAYING_KEY:
                {
                    uint16 word1 = (func.param      ) & 0xFFFF;
                    uint16 word2 = (func.param >> 16) & 0xFFFF;
                    if(event.type == KeyPress)
                    {
                        joypads[0] |= word1;
                        joypads[1] |= word2;
                    }
                    else
                    {
                        joypads[0] &= ~word1;
                        joypads[1] &= ~word2;
                    }
                    break;
                }
                case KeyboardSetup::TOGGLE_SOUND:
                {
                    if(event.type != KeyPress) break;
                    if(func.param > 8) break;
                    
                    S9xToggleSoundChannel(func.param);
                    if(func.param == 8)
                        S9xInfoMessage ("All sound channels on");
                    else
                    {
                        sprintf (GUI.info_string, "Sound channel %d %s", func.param,
                                   (so.sound_switch & (1 << (func.param))) ? "on" : "off");
                        S9xInfoMessage (GUI.info_string);
                    }
                    break;
                }
                case KeyboardSetup::WRITE_SAVE_NUM:
                {
                    if(event.type != KeyPress) break;
                    if(func.param > 999) break;
                    
                    char def [PATH_MAX];
                    char filename [PATH_MAX];
                    char drive [_MAX_DRIVE];
                    char dir [_MAX_DIR];
                    char ext [_MAX_EXT];

                    _splitpath (Memory.ROMFilename, drive, dir, def, ext);
                    sprintf (filename, "%s%s%s.%03d",
                             S9xGetSnapshotDirectory (), SLASH_STR, def,
                             func.param);
                    sprintf (GUI.info_string, "%s.%03d saved", def, func.param);
                    S9xInfoMessage (GUI.info_string);
                    S9xFreezeGame (filename);
                    break;
                }
                case KeyboardSetup::WRITE_SAVE_ASK:
                {
                    if(event.type != KeyPress) break;
                    
                    S9xFreezeGame (S9xChooseFilename (FALSE));
                    break;
                }
                case KeyboardSetup::LOAD_SAVE_NUM:
                {
                    if(event.type != KeyPress) break;
                    if(func.param > 999) break;
                    
                    char def [PATH_MAX];
                    char filename [PATH_MAX];
                    char drive [_MAX_DRIVE];
                    char dir [_MAX_DIR];
                    char ext [_MAX_EXT];

                    _splitpath (Memory.ROMFilename, drive, dir, def, ext);
                    sprintf (filename, "%s%s%s.%03d",
                             S9xGetSnapshotDirectory (), SLASH_STR, def,
                             func.param);
                    if (S9xUnfreezeGame (filename))
                    {
                        sprintf (GUI.info_string, "%s.%03d loaded", def, func.param);
                        S9xInfoMessage (GUI.info_string);
                    }
                    else
                    {
                        static char *digits = "t123456789";
                        _splitpath (Memory.ROMFilename, drive, dir, def, ext);
                        sprintf (filename, "%s%s%s.zs%c",
                                 S9xGetSnapshotDirectory (), SLASH_STR, 
                                 def, digits [func.param]);
                        if (S9xUnfreezeGame (filename))
                        {
                            sprintf (GUI.info_string, "Loaded ZSNES freeze file %s.zs%c",
                                     def, digits [func.param]);
                            S9xInfoMessage (GUI.info_string);
                        }
                        else
                        {
                            sprintf (GUI.info_string, "Freeze file %u not found",
                                     func.param);
                            S9xMessage (S9X_ERROR, S9X_FREEZE_FILE_NOT_FOUND,
                                        GUI.info_string);
                        }
                    }
                    break;
                }
                case KeyboardSetup::LOAD_SAVE_ASK:
                {
                    if(event.type != KeyPress) break;
                    
                    S9xUnfreezeGame (S9xChooseFilename (TRUE));
                    break;
                }
                case KeyboardSetup::TOGGLE_LAYER:
                {
                    if(event.type != KeyPress) break;
                    if(func.param > 4) break;
                    
                    unsigned mask = 1 << func.param;
                    PPU.BG_Forced ^= mask;
                    if(func.param == 4)
                        sprintf(GUI.info_string, "Sprites");
                    else
                        sprintf(GUI.info_string, "BG#%d", func.param);
                    S9xDisplayStateChange (GUI.info_string, !(PPU.BG_Forced & mask));
                    break;
                }
                case KeyboardSetup::WRITE_SPC_ASK:
                {
                    if(event.type != KeyPress) break;
                    
                    char def [PATH_MAX];
                    char filename [PATH_MAX];
                    char drive [_MAX_DRIVE];
                    char dir [_MAX_DIR];
                    char ext [_MAX_EXT];

                    _splitpath (Memory.ROMFilename, drive, dir, def, ext);
                    strcpy (ext, "spc");
                    _makepath (filename, drive, S9xGetSnapshotDirectory (), 
                               def, ext);
                    if (S9xSPCDump (filename))
                        sprintf (GUI.info_string, "%s.%s saved", def, ext);
                    else
                        sprintf (GUI.info_string, "%s.%s not saved (%s)", def, ext,
                                 strerror (errno));
                    
                    S9xInfoMessage (GUI.info_string);
                    break;
                }
                case KeyboardSetup::FRAMETIME_INC:
                {
                    if(event.type != KeyPress) break;
                    
                    unsigned CurSpeed = GetSpeedPercentage();
                    if(CurSpeed < 10) ++CurSpeed;
                    else if(CurSpeed < 150) CurSpeed += 5;
                    else if(CurSpeed < 200) CurSpeed += 10;
                    else if(CurSpeed < 400) CurSpeed += 20;
                    else if(CurSpeed < 500) CurSpeed += 50;
                    else if(CurSpeed < 1500) CurSpeed += 100;
                    
                    SetSpeedPercentage(CurSpeed);
                    sprintf (GUI.info_string, "Emulated speed: %d%% (%.1f FPS)",
                        CurSpeed, 1e6 / Settings.FrameTime);
                    S9xInfoMessage (GUI.info_string);
                    break;
                }
                case KeyboardSetup::FRAMETIME_DEC:
                {
                    if(event.type != KeyPress) break;
                    
                    unsigned CurSpeed = GetSpeedPercentage();
                    if(CurSpeed <= 1) {}
                    else if(CurSpeed <= 10) --CurSpeed;
                    else if(CurSpeed <= 150) CurSpeed -= 5;
                    else if(CurSpeed <= 200) CurSpeed -= 10;
                    else if(CurSpeed <= 400) CurSpeed -= 20;
                    else if(CurSpeed <= 500) CurSpeed -= 50;
                    else CurSpeed -= 100;
                    
                    SetSpeedPercentage(CurSpeed);
                    sprintf (GUI.info_string, "Emulated speed: %d%% (%.1f FPS)",
                        CurSpeed, 1e6 / Settings.FrameTime);
                    S9xInfoMessage (GUI.info_string);
                    break;
                }
                case KeyboardSetup::FRAMESKIP_INC:
                {
                    if(event.type != KeyPress) break;
                    
                    if (Settings.SkipFrames == AUTO_FRAMERATE)
                        Settings.SkipFrames = 1;
                    else
                    if (Settings.SkipFrames < 10)
                        Settings.SkipFrames++;

                    if (Settings.SkipFrames == AUTO_FRAMERATE)
                        S9xInfoMessage ("Auto frame skip");
                    else
                    {
                        sprintf (GUI.info_string, "Frame skip: %d",
                                 Settings.SkipFrames - 1);
                        S9xInfoMessage (GUI.info_string);
                    }
                    break;
                }
                case KeyboardSetup::FRAMESKIP_DEC:
                {
                    if(event.type != KeyPress) break;
                    
                    if (Settings.SkipFrames <= 1)
                        Settings.SkipFrames = AUTO_FRAMERATE;
                    else
                        if (Settings.SkipFrames != AUTO_FRAMERATE)
                            Settings.SkipFrames--;

                    if (Settings.SkipFrames == AUTO_FRAMERATE)
                        S9xInfoMessage ("Auto frame skip");
                    else
                    {
                        sprintf (GUI.info_string, "Frame skip: %d",
                                 Settings.SkipFrames - 1);
                        S9xInfoMessage (GUI.info_string);
                    }
                    break;
                }
                case KeyboardSetup::PAUSE:
                {
                    if(event.type != KeyPress) break;
                    
                    Settings.Paused ^= 1;
                    S9xDisplayStateChange ("Pause", Settings.Paused);
                    
                    break;
                }
                case KeyboardSetup::DGA_FULLSCREEN:
                {
                    if(event.type != KeyPress) break;
                    
#ifdef USE_DGA_EXTENSION
                    S9xSwitchToFullScreen (!XF86.is_full_screen);
#endif
                    break;
                }
                case KeyboardSetup::SCREENSHOT:
                {
                    if(event.type != KeyPress) break;
                    
                    Settings.TakeScreenshot = TRUE; 
                    break;
                }
                case KeyboardSetup::SPC7110LOG:
                {
                    if(event.type != KeyPress) break;
                    
                    if(Settings.SPC7110)
                        Do7110Logging();
                    break;
                }
                case KeyboardSetup::TOGGLE_HDMA:
                {
                    if(event.type != KeyPress) break;
                    
                    Settings.DisableHDMA = !Settings.DisableHDMA;
                    S9xDisplayStateChange ("HDMA emulation", !Settings.DisableHDMA);
                    break;
                }
                case KeyboardSetup::TOGGLE_JOYSWAP:
                {
                    if(event.type != KeyPress) break;
                    
                    Settings.SwapJoypads = !Settings.SwapJoypads;
                    S9xDisplayStateChange ("Joypad swapping", Settings.SwapJoypads);
                    break;
                }
                case KeyboardSetup::TOGGLE_GL_CUBE:
                {
                    if(event.type != KeyPress) break;
                    
#ifdef USE_OPENGL
                    OpenGL.draw_cube ^= TRUE;
#endif
                    break;
                }
                case KeyboardSetup::TOGGLE_BG_HACK:
                {
                    if(event.type != KeyPress) break;
                    
                    Settings.BGLayering = !Settings.BGLayering;
                    S9xDisplayStateChange ("Background layering hack", 
                                           Settings.BGLayering);
                    break;
                }
                case KeyboardSetup::TOGGLE_TRANSP:
                {
                    if(event.type != KeyPress) break;
                    
                    if (Settings.SixteenBit)
                    {
                        Settings.Transparency = !Settings.Transparency;
                        S9xDisplayStateChange ("Transparency effects", 
                                               Settings.Transparency);
                    }
                    break;
                }
                case KeyboardSetup::TOGGLE_CLIPWIN:
                {
                    if(event.type != KeyPress) break;
                    
                    Settings.DisableGraphicWindows = !Settings.DisableGraphicWindows;
                    S9xDisplayStateChange ("Graphic clip windows",
                                           !Settings.DisableGraphicWindows);
                
                    break;
                }
                case KeyboardSetup::TOGGLE_CONTROLLER:
                {
                    if(event.type != KeyPress) break;
                    
                    static char *controllers [] = {
                        "Multiplayer 5 on #0", "Joypad on #0", "Mouse on #1",
                        "Mouse on #0", "Superscope on #1"
                    };
                    S9xNextController ();
                    S9xInfoMessage (controllers [IPPU.Controller]);
                    break;
                }
                case KeyboardSetup::TOGGLE_INTERPSOUND:
                {
                    if(event.type != KeyPress) break;
                    
                    Settings.InterpolatedSound ^= 1;
                    S9xDisplayStateChange ("Interpolated sound",
                                           Settings.InterpolatedSound);
                    break;
                }
                case KeyboardSetup::TOGGLE_SYNCSOUND:
                {
                    if(event.type != KeyPress) break;
                    
                    Settings.SoundSync ^= 1;
                    S9xDisplayStateChange ("Synchronised sound",