x11.cpp

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

{
#ifdef USE_AIDO
    if (Settings.AIDOShmId)
        return;
#endif

    XStoreName (GUI.display, GUI.window, string);
    XFlush (GUI.display);
}
    
bool8 S9xReadMousePosition (int which1, int &x, int &y, uint32 &buttons)
{
    if (which1 == 0)
    {
	x = GUI.mouse_x;
	y = GUI.mouse_y;
	buttons = GUI.mouse_buttons;
	return (TRUE);
    }
    return (FALSE);
}

bool8 S9xReadSuperScopePosition (int &x, int &y, uint32 &buttons)
{
    x = (int) ((GUI.mouse_x - GUI.box.x) * 
	       (256.0 / (double) GUI.box.width));
    y = (int) ((GUI.mouse_y - GUI.box.y) * 
	       (224.0 / (double) GUI.box.height));
    buttons = (GUI.mouse_buttons & 3) | (GUI.superscope_turbo << 2) |
	      (GUI.superscope_pause << 3);

    return (TRUE);
}

bool JustifierOffscreen()
{
  return (bool)(GUI.mouse_buttons&2);
}

void JustifierButtons(uint32& justifiers)
{
  if(IPPU.Controller==SNES_JUSTIFIER_2)
  {
    if((GUI.mouse_buttons&1)||(GUI.mouse_buttons&2))
    {
      justifiers|=0x00200;
    }
    if(GUI.mouse_buttons&4)
    {
      justifiers|=0x00800;
    }
  }
  else
  {
    if((GUI.mouse_buttons&1)||(GUI.mouse_buttons&2))
    {
      justifiers|=0x00100;
    }
    if(GUI.mouse_buttons&4)
    {
      justifiers|=0x00400;
    }
  }
}

#ifdef SELECT_BROKEN_FOR_SIGNALS
#include <sys/ioctl.h>
#endif

static bool8 CheckForPendingXEvents (Display *display)
{
#ifdef SELECT_BROKEN_FOR_SIGNALS
    int arg = 0;

    return (XEventsQueued (display, QueuedAlready) ||
	    ioctl (ConnectionNumber (display), FIONREAD, &arg) == 0 && arg);
#else
    return (XPending (display));
#endif
}

#include "movie.h"
static const char *S9xChooseMovieFilename(bool8 read_only)
{
    char def [PATH_MAX + 1];
    char title [PATH_MAX + 1];
    char drive [_MAX_DRIVE + 1];
    char dir [_MAX_DIR + 1];
    char ext [_MAX_EXT + 1];

    _splitpath (Memory.ROMFilename, drive, dir, def, ext);
    strcat (def, ".smv");
    sprintf (title, "Choose movie %s filename", read_only ? "playback" : "record");
    const char *filename;

    S9xSetSoundMute (TRUE);
    filename = S9xSelectFilename (def, S9xGetSnapshotDirectory (), "smv", title);
    S9xSetSoundMute (FALSE);
    return (filename);
}

static void S9xInfoMessage(const char *msg)
{
    S9xSetInfoString(msg);
    if(Settings.Paused) puts(msg);
}

static uint32 GetNormalSpeed()
{
    return Settings.PAL ? Settings.FrameTimePAL : Settings.FrameTimeNTSC;
}
static unsigned GetSpeedPercentage()
{
    const uint32 normalspeed = GetNormalSpeed();
    return normalspeed * 100 / Settings.FrameTime;
}
static void SetSpeedPercentage(unsigned p)
{
    const uint32 normalspeed = GetNormalSpeed();
    Settings.FrameTime = normalspeed * 100 / p;
}

#include <map>
using namespace std;
static class KeyboardSetup
{
public:
    /* List of all possible keyboard-accessible functions */
    enum functiontype
    {
        FUNC_NONE=0,
        PLAYING_KEY,
        TOGGLE_SOUND,
        WRITE_SAVE_NUM,
        WRITE_SAVE_ASK,
        LOAD_SAVE_NUM,
        LOAD_SAVE_ASK,
        TOGGLE_LAYER,
        WRITE_SPC_ASK,
        FRAMETIME_INC,
        FRAMETIME_DEC,
        FRAMESKIP_INC,
        FRAMESKIP_DEC,
        PAUSE,
        DGA_FULLSCREEN,
        SCREENSHOT,
        SPC7110LOG,
        TOGGLE_HDMA,
        TOGGLE_JOYSWAP,
        TOGGLE_GL_CUBE,
        TOGGLE_BG_HACK,
        TOGGLE_TRANSP,
        TOGGLE_CLIPWIN,
        TOGGLE_CONTROLLER,
        TOGGLE_INTERPSOUND,
        TOGGLE_SYNCSOUND,
        TOGGLE_MODE7INTERP,
        TURBO_ENABLE,
        SUPERSCOPE_TURBO,
        SUPERSCOPE_PAUSE_ENABLE,
        EXIT,
        WRITE_MOVIE_ASK,
        LOAD_MOVIE_ASK,
        STOP_MOVIE,
        
        FUNC_LAST = STOP_MOVIE /* update this to match the last token */
    };
    static const char* GetFuncName(functiontype func)
    {
        switch(func)
        {
            case PLAYING_KEY: return             "PLAYING_KEY";
            case TOGGLE_SOUND: return            "TOGGLE_SOUND";
            case WRITE_SAVE_NUM: return          "WRITE_SAVE_NUM";
            case WRITE_SAVE_ASK: return          "WRITE_SAVE_ASK";
            case LOAD_SAVE_NUM: return           "LOAD_SAVE_NUM";
            case LOAD_SAVE_ASK: return           "LOAD_SAVE_ASK";
            case TOGGLE_LAYER: return            "TOGGLE_LAYER";
            case WRITE_SPC_ASK: return           "WRITE_SPC_ASK";
            case FRAMETIME_INC: return           "FRAMETIME_INC";
            case FRAMETIME_DEC: return           "FRAMETIME_DEC";
            case FRAMESKIP_INC: return           "FRAMESKIP_INC";
            case FRAMESKIP_DEC: return           "FRAMESKIP_DEC";
            case PAUSE: return                   "PAUSE";
            case DGA_FULLSCREEN: return          "DGA_FULLSCREEN";
            case SCREENSHOT: return              "SCREENSHOT";
            case SPC7110LOG: return              "SPC7110LOG";
            case TOGGLE_HDMA: return             "TOGGLE_HDMA";
            case TOGGLE_JOYSWAP: return          "TOGGLE_JOYSWAP";
            case TOGGLE_GL_CUBE: return          "TOGGLE_GL_CUBE";
            case TOGGLE_BG_HACK: return          "TOGGLE_BG_HACK";
            case TOGGLE_TRANSP: return           "TOGGLE_TRANSP";
            case TOGGLE_CLIPWIN: return          "TOGGLE_CLIPWIN";
            case TOGGLE_CONTROLLER: return       "TOGGLE_CONTROLLER";
            case TOGGLE_INTERPSOUND: return      "TOGGLE_INTERPSOUND";
            case TOGGLE_SYNCSOUND: return        "TOGGLE_SYNCSOUND";
            case TOGGLE_MODE7INTERP: return      "TOGGLE_MODE7INTERP";
            case TURBO_ENABLE: return            "TURBO_ENABLE";
            case SUPERSCOPE_TURBO: return        "SUPERSCOPE_TURBO";
            case SUPERSCOPE_PAUSE_ENABLE: return "SUPERSCOPE_PAUSE_ENABLE";
            case EXIT: return                    "EXIT";
            case WRITE_MOVIE_ASK: return         "WRITE_MOVIE_ASK";
            case LOAD_MOVIE_ASK: return          "LOAD_MOVIE_ASK";
            case STOP_MOVIE: return              "STOP_MOVIE";
            default: return "unknown";
        }
    }
    static const char *GetKeySymName(int sym)
    {
        static char Buf[64];
        sprintf(Buf, "'%c'(%d)", sym,sym);
        return Buf;
    }
    struct Keyfunction
    {
        functiontype func;
        unsigned param;
        bool inited;
        int sym; const char *prefix;
    private:
        /* ensure nobody uses the assignment operator on us */
        void operator=(const Keyfunction& b);
    public:
        Keyfunction(): func(FUNC_NONE), inited(false) {}
        Keyfunction(functiontype f,unsigned p): func(f),param(p), inited(true) {}
        void Assign(const Keyfunction& b)
        {
            if(inited)
            {
                fprintf(stderr,
                   "[Input] Warning: Key %s%s had %s[0x%X], overwriting by %s[0x%X]\n",
                   prefix, GetKeySymName(sym),
                   GetFuncName(func), param,
                   GetFuncName(b.func), b.param);
            }
            func   = b.func;
            param  = b.param;
            inited = b.inited;
        }
        void SetName(int s, const char* p) { sym=s; prefix=p; }
    };
    struct Keydata
    {
        Keyfunction plain, shift, ctrl, alt;
    public:
        Keydata() {}
        void DefineAs(int sym)
        {
            plain.SetName(sym,"");
            shift.SetName(sym,"shift+");
            ctrl.SetName(sym,"ctrl+");
            alt.SetName(sym,"alt+");
        }
    };
private:
    enum masktype { MaskNone,MaskCtrl,MaskShift,MaskAlt };
    map<int, Keydata> keydata;
    
    void Define(int sym, masktype mask, functiontype func, unsigned param)
    {
        Keyfunction result(func, param);
        Keydata& target = keydata[sym];
        target.DefineAs(sym);
        switch(mask)
        {
            case MaskCtrl: target.ctrl.Assign(result); break;
            case MaskShift: target.shift.Assign(result); break;
            case MaskAlt: target.alt.Assign(result); break;
            case MaskNone:
            {
                target.plain.Assign(result);

                result.inited = false;
                /* so we'll not get warnings when overwriting
                 * these extra fields later: */
                if(!target.shift.inited) target.shift.Assign(result);
                if(!target.ctrl.inited) target.ctrl.Assign(result);
                if(!target.alt.inited) target.alt.Assign(result);
                break;
            }
        }
    }
    void VerifySetup()
    {
        bool8 Defined[(unsigned)FUNC_LAST + 1] = {FALSE};
        map<int, Keydata>::const_iterator i;
        for(i=keydata.begin(); i!=keydata.end(); ++i)
        {
            Defined[i->second.plain.func] = TRUE;
            Defined[i->second.shift.func] = TRUE;
            Defined[i->second.ctrl.func] = TRUE;
            Defined[i->second.alt.func] = TRUE;
        }
        for(unsigned a=0; a<sizeof(Defined); ++a)
            if(a != FUNC_NONE && !Defined[a])
            {
                fprintf(stderr, "[Input] Warning: No key assigned for %s\n",
                    GetFuncName((functiontype)a) );
            }
    }
private:
    struct Key
    {
        int symbol;
        masktype mask;
    public:
        Key(): symbol(0), mask(MaskNone) {}
        Key(int sym): symbol(sym), mask(MaskNone) {}
        Key(int sym,masktype m): symbol(sym), mask(m) {}
    };
    static Key Shift(int symbol) { return Key(symbol,MaskShift); }
    static Key Ctrl(int symbol) { return Key(symbol,MaskCtrl); }
    static Key Alt(int symbol) { return Key(symbol,MaskAlt); }
private:
    void Define(functiontype func, unsigned param,
                Key k1,
                Key k2 = Key(),
                Key k3 = Key(),
                Key k4 = Key()
               )
    {
        if(k1.symbol) Define(k1.symbol, k1.mask, func, param);
        if(k2.symbol) Define(k2.symbol, k2.mask, func, param);
        if(k3.symbol) Define(k3.symbol, k3.mask, func, param);
        if(k4.symbol) Define(k4.symbol, k4.mask, func, param);
    }
public:
    /* Contruct the keyboard setup upon program start. */
    KeyboardSetup()
    {
        // player 1: tr,tl, x,a
        Define(PLAYING_KEY, 0x00000010, XK_z, XK_w, XK_b);
        Define(PLAYING_KEY, 0x00000020, XK_a, XK_q, XK_v);
        Define(PLAYING_KEY, 0x00000040, XK_s, XK_e, XK_m);
        Define(PLAYING_KEY, 0x00000080, XK_d, XK_t, XK_period);
        // player 1: right,left,down,up
        Define(PLAYING_KEY, 0x00000100, XK_k, XK_Right);
        Define(PLAYING_KEY, 0x00000200, XK_h, XK_Left);
        Define(PLAYING_KEY, 0x00000400, XK_j, XK_n, XK_Down);
        Define(PLAYING_KEY, 0x00000800, XK_u, XK_Up);
        // player 1: start,select, y,b
        Define(PLAYING_KEY, 0x00001000, XK_Return);
        Define(PLAYING_KEY, 0x00002000, XK_space);
        Define(PLAYING_KEY, 0x00004000, XK_x, XK_r, XK_comma);
        Define(PLAYING_KEY, 0x00008000, XK_y, XK_c);
        // player 2: tr,tl, x,a
        Define(PLAYING_KEY, 0x00100000, XK_Delete);
        Define(PLAYING_KEY, 0x00200000, XK_Insert);
        Define(PLAYING_KEY, 0x00400000, XK_Home);
        Define(PLAYING_KEY, 0x00800000, XK_Prior);
        // player 2: right,left,down,up
        Define(PLAYING_KEY, 0x01000000, XK_KP_4);
        Define(PLAYING_KEY, 0x02000000, XK_KP_6);
        Define(PLAYING_KEY, 0x04000000, XK_KP_2);
        Define(PLAYING_KEY, 0x08000000, XK_KP_8);
        // player 2: start,select,y,b
        Define(PLAYING_KEY, 0x10000000, XK_KP_Enter);
        Define(PLAYING_KEY, 0x20000000, XK_KP_Add);
        Define(PLAYING_KEY, 0x40000000, XK_End);
        Define(PLAYING_KEY, 0x80000000, XK_Next);
        // toggle sound channels
        // Careful: alt + f-keys might be bound to the window manager!
        Define(TOGGLE_SOUND, 0,         Alt(XK_F4), Ctrl(XK_F4));
        Define(TOGGLE_SOUND, 1,         Alt(XK_F5), Ctrl(XK_F5));
        Define(TOGGLE_SOUND, 2,         Alt(XK_F6), Ctrl(XK_F6));
        Define(TOGGLE_SOUND, 3,         Alt(XK_F7), Ctrl(XK_F7));
        Define(TOGGLE_SOUND, 4,         Alt(XK_F8), Ctrl(XK_F8));
        Define(TOGGLE_SOUND, 5,         Alt(XK_F9), Ctrl(XK_F9));
        Define(TOGGLE_SOUND, 6,         Alt(XK_F10), Ctrl(XK_F10));
        Define(TOGGLE_SOUND, 7,         Alt(XK_F11), Ctrl(XK_F11));
        // re-enable all sound channels
        Define(TOGGLE_SOUND, 8,         Alt(XK_F12), Ctrl(XK_F12));
        // numbered quicksaves
        Define(WRITE_SAVE_NUM, 0,       XK_F1);
        Define(WRITE_SAVE_NUM, 1,       XK_F2);
        Define(WRITE_SAVE_NUM, 2,       XK_F3);
        Define(WRITE_SAVE_NUM, 3,       XK_F4);
        Define(WRITE_SAVE_NUM, 4,       XK_F5);
        Define(WRITE_SAVE_NUM, 5,       XK_F6);
        Define(WRITE_SAVE_NUM, 6,       XK_F7);
        Define(WRITE_SAVE_NUM, 7,       XK_F8);
        Define(WRITE_SAVE_NUM, 8,       XK_F9);
        Define(WRITE_SAVE_NUM, 9,       XK_F10);
        Define(LOAD_SAVE_NUM, 0,       Shift(XK_F1));
        Define(LOAD_SAVE_NUM, 1,       Shift(XK_F2));
        Define(LOAD_SAVE_NUM, 2,       Shift(XK_F3));
        Define(LOAD_SAVE_NUM, 3,       Shift(XK_F4));
        Define(LOAD_SAVE_NUM, 4,       Shift(XK_F5));
        Define(LOAD_SAVE_NUM, 5,       Shift(XK_F6));
        Define(LOAD_SAVE_NUM, 6,       Shift(XK_F7));
        Define(LOAD_SAVE_NUM, 7,       Shift(XK_F8));
        Define(LOAD_SAVE_NUM, 8,       Shift(XK_F9));
        Define(LOAD_SAVE_NUM, 9,       Shift(XK_F10));
        // layer toggles
        Define(TOGGLE_LAYER,  0,       XK_1);
        Define(TOGGLE_LAYER,  1,       XK_2);
        Define(TOGGLE_LAYER,  2,       XK_3);
        Define(TOGGLE_LAYER,  3,       XK_4);
        // sprite layer toggle
        Define(TOGGLE_LAYER,  4,       XK_5);
        // named saves
        Define(LOAD_SAVE_ASK,  0,      Alt(XK_F2), Ctrl(XK_F2), XK_F11);
        Define(WRITE_SAVE_ASK, 0,      Alt(XK_F3), Ctrl(XK_F3), XK_F12);
        Define(WRITE_SPC_ASK, 0,       Alt(XK_F1), Ctrl(XK_F1));
        // timings
        Define(FRAMETIME_INC, 0,       Shift(XK_equal), Shift(XK_plus));
        Define(FRAMETIME_DEC, 0,       Shift(XK_minus));
        Define(FRAMESKIP_INC, 0,       XK_equal, XK_plus);
        Define(FRAMESKIP_DEC, 0,       XK_minus);
        // pause
        Define(PAUSE, 0,               XK_Pause, XK_Break, XK_Scroll_Lock);
        // misc functions
        Define(DGA_FULLSCREEN, 0,      Alt(XK_Return));
        Define(SCREENSHOT, 0,          XK_Print);
        Define(SPC7110LOG, 0,          XK_Sys_Req);
        Define(TOGGLE_HDMA, 0,         XK_0);
        Define(TOGGLE_JOYSWAP, 0,      XK_6);
        Define(TOGGLE_GL_CUBE, 0,      Shift(XK_6));
        Define(TOGGLE_BG_HACK, 0,      XK_8);
        Define(TOGGLE_TRANSP, 0,       XK_9);
        Define(TOGGLE_CLIPWIN, 0,      XK_BackSpace);