mirror of
https://github.com/PCSX2/pcsx2.git
synced 2026-11-19 20:44:21 +01:00
The legacy version is the version 1.3 The new version is the version 2.0. It would be based on SDL2 only Distribution information. If you link wxWidget with SDL, you will need to be sure it is SDL2 or upgrade. You can build wxWidget with SDL2 with the following trick export SDL_CONFIG=/usr/bin/sdl2-config ./configure --with-sdl .....
312 lines
9.5 KiB
C++
312 lines
9.5 KiB
C++
/* OnePAD - author: arcum42(@gmail.com)
|
|
* Copyright (C) 2009
|
|
*
|
|
* Based on ZeroPAD, author zerofrog@gmail.com
|
|
* Copyright (C) 2006-2007
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
/*
|
|
* Theoretically, this header is for anything to do with keyboard input.
|
|
* Pragmatically, event handing's going in here too.
|
|
*/
|
|
|
|
#include <gtk/gtk.h>
|
|
#include <gdk/gdkkeysyms.h>
|
|
#include "keyboard.h"
|
|
|
|
#ifdef _WIN32
|
|
char *KeysymToChar(int keysym)
|
|
{
|
|
LPWORD temp;
|
|
|
|
ToAscii((UINT)keysym, NULL, NULL, temp, NULL);
|
|
return (char *)temp;
|
|
}
|
|
#endif
|
|
|
|
void SetAutoRepeat(bool autorep)
|
|
{
|
|
#if defined(__unix__)
|
|
if (toggleAutoRepeat) {
|
|
if (autorep)
|
|
XAutoRepeatOn(GSdsp);
|
|
else
|
|
XAutoRepeatOff(GSdsp);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if defined(__unix__)
|
|
static bool s_grab_input = false;
|
|
static bool s_Shift = false;
|
|
static unsigned int s_previous_mouse_x = 0;
|
|
static unsigned int s_previous_mouse_y = 0;
|
|
void AnalyzeKeyEvent(keyEvent &evt)
|
|
{
|
|
KeySym key = (KeySym)evt.key;
|
|
int pad = 0;
|
|
int index = -1;
|
|
|
|
for (int cpad = 0; cpad < GAMEPAD_NUMBER; cpad++) {
|
|
int tmp_index = get_keyboard_key(cpad, key);
|
|
if (tmp_index != -1) {
|
|
pad = cpad;
|
|
index = tmp_index;
|
|
}
|
|
}
|
|
|
|
switch (evt.evt) {
|
|
case KeyPress:
|
|
// Shift F12 is not yet use by pcsx2. So keep it to grab/ungrab input
|
|
// I found it very handy vs the automatic fullscreen detection
|
|
// 1/ Does not need to detect full-screen
|
|
// 2/ Can use a debugger in full-screen
|
|
// 3/ Can grab input in window without the need of a pixelated full-screen
|
|
if (key == XK_Shift_R || key == XK_Shift_L)
|
|
s_Shift = true;
|
|
if (key == XK_F12 && s_Shift) {
|
|
if (!s_grab_input) {
|
|
s_grab_input = true;
|
|
XGrabPointer(GSdsp, GSwin, True, ButtonPressMask, GrabModeAsync, GrabModeAsync, GSwin, None, CurrentTime);
|
|
XGrabKeyboard(GSdsp, GSwin, True, GrabModeAsync, GrabModeAsync, CurrentTime);
|
|
} else {
|
|
s_grab_input = false;
|
|
XUngrabPointer(GSdsp, CurrentTime);
|
|
XUngrabKeyboard(GSdsp, CurrentTime);
|
|
}
|
|
}
|
|
|
|
// Analog controls.
|
|
if (IsAnalogKey(index)) {
|
|
switch (index) {
|
|
case PAD_R_LEFT:
|
|
case PAD_R_UP:
|
|
case PAD_L_LEFT:
|
|
case PAD_L_UP:
|
|
key_status->press(pad, index, -MAX_ANALOG_VALUE);
|
|
break;
|
|
case PAD_R_RIGHT:
|
|
case PAD_R_DOWN:
|
|
case PAD_L_RIGHT:
|
|
case PAD_L_DOWN:
|
|
key_status->press(pad, index, MAX_ANALOG_VALUE);
|
|
break;
|
|
}
|
|
} else if (index != -1)
|
|
key_status->press(pad, index);
|
|
|
|
//PAD_LOG("Key pressed:%d\n", index);
|
|
|
|
event.evt = KEYPRESS;
|
|
event.key = key;
|
|
break;
|
|
|
|
case KeyRelease:
|
|
if (key == XK_Shift_R || key == XK_Shift_L)
|
|
s_Shift = false;
|
|
|
|
if (index != -1)
|
|
key_status->release(pad, index);
|
|
|
|
event.evt = KEYRELEASE;
|
|
event.key = key;
|
|
break;
|
|
|
|
case FocusIn:
|
|
//XAutoRepeatOff(GSdsp);
|
|
break;
|
|
|
|
case FocusOut:
|
|
//XAutoRepeatOn(GSdsp);
|
|
s_Shift = false;
|
|
break;
|
|
|
|
case ButtonPress:
|
|
if (index != -1)
|
|
key_status->press(pad, index);
|
|
break;
|
|
|
|
case ButtonRelease:
|
|
if (index != -1)
|
|
key_status->release(pad, index);
|
|
break;
|
|
|
|
case MotionNotify:
|
|
// FIXME: How to handle when the mouse does not move, no event generated!!!
|
|
// 1/ small move == no move. Cons : can not do small movement
|
|
// 2/ use a watchdog timer thread
|
|
// 3/ ??? idea welcome ;)
|
|
if (conf->pad_options[pad].mouse_l | conf->pad_options[pad].mouse_r) {
|
|
unsigned int pad_x;
|
|
unsigned int pad_y;
|
|
// Note when both PADOPTION_MOUSE_R and PADOPTION_MOUSE_L are set, take only the right one
|
|
if (conf->pad_options[pad].mouse_r) {
|
|
pad_x = PAD_R_RIGHT;
|
|
pad_y = PAD_R_UP;
|
|
} else {
|
|
pad_x = PAD_L_RIGHT;
|
|
pad_y = PAD_L_UP;
|
|
}
|
|
|
|
unsigned x = evt.key & 0xFFFF;
|
|
unsigned int value = (s_previous_mouse_x > x) ? s_previous_mouse_x - x : x - s_previous_mouse_x;
|
|
value *= conf->get_sensibility();
|
|
|
|
if (x == 0)
|
|
key_status->press(pad, pad_x, -MAX_ANALOG_VALUE);
|
|
else if (x == 0xFFFF)
|
|
key_status->press(pad, pad_x, MAX_ANALOG_VALUE);
|
|
else if (x < (s_previous_mouse_x - 2))
|
|
key_status->press(pad, pad_x, -value);
|
|
else if (x > (s_previous_mouse_x + 2))
|
|
key_status->press(pad, pad_x, value);
|
|
else
|
|
key_status->release(pad, pad_x);
|
|
|
|
|
|
unsigned y = evt.key >> 16;
|
|
value = (s_previous_mouse_y > y) ? s_previous_mouse_y - y : y - s_previous_mouse_y;
|
|
value *= conf->get_sensibility();
|
|
|
|
if (y == 0)
|
|
key_status->press(pad, pad_y, -MAX_ANALOG_VALUE);
|
|
else if (y == 0xFFFF)
|
|
key_status->press(pad, pad_y, MAX_ANALOG_VALUE);
|
|
else if (y < (s_previous_mouse_y - 2))
|
|
key_status->press(pad, pad_y, -value);
|
|
else if (y > (s_previous_mouse_y + 2))
|
|
key_status->press(pad, pad_y, value);
|
|
else
|
|
key_status->release(pad, pad_y);
|
|
|
|
s_previous_mouse_x = x;
|
|
s_previous_mouse_y = y;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
void PollForX11KeyboardInput()
|
|
{
|
|
keyEvent evt = {0};
|
|
XEvent E = {0};
|
|
|
|
// Keyboard input send by PCSX2
|
|
while (!ev_fifo.empty()) {
|
|
AnalyzeKeyEvent(ev_fifo.front());
|
|
pthread_spin_lock(&mutex_KeyEvent);
|
|
ev_fifo.pop();
|
|
pthread_spin_unlock(&mutex_KeyEvent);
|
|
}
|
|
|
|
// keyboard input
|
|
while (XPending(GSdsp) > 0) {
|
|
XNextEvent(GSdsp, &E);
|
|
|
|
// Change the format of the structure to be compatible with GSOpen2
|
|
// mode (event come from pcsx2 not X)
|
|
evt.evt = E.type;
|
|
switch (E.type) {
|
|
case MotionNotify:
|
|
evt.key = (E.xbutton.x & 0xFFFF) | (E.xbutton.y << 16);
|
|
break;
|
|
case ButtonRelease:
|
|
case ButtonPress:
|
|
evt.key = E.xbutton.button;
|
|
break;
|
|
default:
|
|
evt.key = (int)XLookupKeysym(&E.xkey, 0);
|
|
}
|
|
|
|
AnalyzeKeyEvent(evt);
|
|
}
|
|
}
|
|
|
|
bool PollX11KeyboardMouseEvent(u32 &pkey)
|
|
{
|
|
GdkEvent *ev = gdk_event_get();
|
|
|
|
if (ev != NULL) {
|
|
if (ev->type == GDK_KEY_PRESS) {
|
|
pkey = ev->key.keyval != GDK_KEY_Escape ? ev->key.keyval : 0;
|
|
return true;
|
|
} else if (ev->type == GDK_BUTTON_PRESS) {
|
|
pkey = ev->button.button;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#else
|
|
LRESULT WINAPI PADwndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
static bool lbutton = false, rbutton = false;
|
|
key_status->keyboard_state_acces(cpad);
|
|
|
|
switch (msg) {
|
|
case WM_KEYDOWN:
|
|
if (lParam & 0x40000000)
|
|
return TRUE;
|
|
|
|
for (int pad = 0; pad < GAMEPAD_NUMBER; ++pad) {
|
|
for (int i = 0; i < MAX_KEYS; i++) {
|
|
if (wParam == get_key(pad, i)) {
|
|
key_status->press(pad, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
event.evt = KEYPRESS;
|
|
event.key = wParam;
|
|
break;
|
|
|
|
case WM_KEYUP:
|
|
for (int pad = 0; pad < GAMEPAD_NUMBER; ++pad) {
|
|
for (int i = 0; i < MAX_KEYS; i++) {
|
|
if (wParam == get_key(pad, i)) {
|
|
key_status->release(pad, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
event.evt = KEYRELEASE;
|
|
event.key = wParam;
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
case WM_QUIT:
|
|
event.evt = KEYPRESS;
|
|
event.key = VK_ESCAPE;
|
|
return GSwndProc(hWnd, msg, wParam, lParam);
|
|
|
|
default:
|
|
return GSwndProc(hWnd, msg, wParam, lParam);
|
|
}
|
|
|
|
for (int pad = 0; pad < GAMEPAD_NUMBER; ++pad)
|
|
key_status->commit_status(pad);
|
|
|
|
return TRUE;
|
|
}
|
|
#endif
|