e47e474cff
The old input code was getting too messy. A redesign made it easier to modify and add several modes and combos, including one for 1st person games which benefit from a different control scheme. A combo switches between the modes. I also added directional support while the virtual keyboard is visible, using the nub. This allows moving around in the text in some games, and moving the character while typing for others (e.g. AGI) svn-id: r53042
511 lines
17 KiB
C++
511 lines
17 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* 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.
|
|
*
|
|
* $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $
|
|
* $Id: osys_psp.cpp 43618 2009-08-21 22:44:49Z joostp $
|
|
*
|
|
*/
|
|
|
|
#include <pspctrl.h>
|
|
#include "gui/message.h"
|
|
#include "backends/platform/psp/input.h"
|
|
|
|
//#define __PSP_DEBUG_FUNCS__ /* Uncomment for debugging the stack */
|
|
//#define __PSP_DEBUG_PRINT__ /* Uncomment for debug prints */
|
|
#include "backends/platform/psp/trace.h"
|
|
|
|
// Defines for working with PSP buttons
|
|
#define DOWN(x) ((pad.Buttons & (x)) == (x))
|
|
#define UP(x) (!(pad.Buttons & (x)))
|
|
#define PSP_DPAD (PSP_CTRL_DOWN|PSP_CTRL_UP|PSP_CTRL_LEFT|PSP_CTRL_RIGHT)
|
|
#define PSP_4BUTTONS (PSP_CTRL_CROSS | PSP_CTRL_CIRCLE | PSP_CTRL_TRIANGLE | PSP_CTRL_SQUARE)
|
|
#define PSP_TRIGGERS (PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER)
|
|
#define PSP_ALL_BUTTONS (PSP_DPAD | PSP_4BUTTONS | PSP_TRIGGERS | PSP_CTRL_START | PSP_CTRL_SELECT)
|
|
|
|
#define PAD_CHECK_TIME 53
|
|
|
|
Button::Button() {
|
|
clear();
|
|
}
|
|
|
|
inline void Button::clear() {
|
|
_key = Common::KEYCODE_INVALID;
|
|
_ascii = 0;
|
|
_flag = 0;
|
|
_pspEventDown.clear();
|
|
_pspEventUp.clear();
|
|
}
|
|
|
|
inline bool Button::getEvent(Common::Event &event, PspEvent &pspEvent, bool down) {
|
|
if (down) {
|
|
if (!_pspEventDown.isEmpty())
|
|
pspEvent = _pspEventDown;
|
|
} else { // up
|
|
if (!_pspEventUp.isEmpty())
|
|
pspEvent = _pspEventUp;
|
|
}
|
|
if (_key != Common::KEYCODE_INVALID) {
|
|
event.type = down ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
|
|
event.kbd.keycode = _key;
|
|
event.kbd.ascii = _ascii;
|
|
event.kbd.flags |= _flag;
|
|
return true;
|
|
} else if (_flag) { // handle flag only events
|
|
event.type = down ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
|
|
event.kbd.flags |= down ? _flag : 0;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Button::setPspEvent(PspEventType typeDown, uint32 dataDown, PspEventType typeUp, uint32 dataUp) {
|
|
_pspEventDown.type = typeDown;
|
|
_pspEventDown.data = dataDown;
|
|
_pspEventUp.type = typeUp;
|
|
_pspEventUp.data = dataUp;
|
|
}
|
|
|
|
// Translates bitfields to our constants
|
|
// We put combined bitfields first to make sure we pick up diagonals
|
|
const uint32 ButtonPad::_buttonMap[] = {
|
|
PSP_CTRL_UP | PSP_CTRL_LEFT,
|
|
PSP_CTRL_UP | PSP_CTRL_RIGHT,
|
|
PSP_CTRL_DOWN | PSP_CTRL_RIGHT,
|
|
PSP_CTRL_DOWN | PSP_CTRL_LEFT,
|
|
PSP_CTRL_RIGHT, PSP_CTRL_DOWN, PSP_CTRL_LEFT, PSP_CTRL_UP,
|
|
PSP_CTRL_CROSS, PSP_CTRL_CIRCLE, PSP_CTRL_TRIANGLE, PSP_CTRL_SQUARE,
|
|
PSP_CTRL_LTRIGGER, PSP_CTRL_RTRIGGER, PSP_CTRL_START, PSP_CTRL_SELECT
|
|
};
|
|
|
|
ButtonPad::ButtonPad() : _prevButtonState(0), _shifted(UNSHIFTED), _padMode(PAD_MODE_NORMAL),
|
|
_comboMode(false) {
|
|
for (int i = UNSHIFTED; i < SHIFTED_MODE_LAST; i++)
|
|
_buttonsChanged[i] = 0;
|
|
clearButtons();
|
|
}
|
|
|
|
void ButtonPad::clearButtons() {
|
|
for (int i = BTN_UP_LEFT; i < BTN_LAST; i++) {
|
|
_button[i][UNSHIFTED].clear();
|
|
_button[i][SHIFTED].clear();
|
|
}
|
|
}
|
|
|
|
void ButtonPad::initButtons() {
|
|
switch (_padMode) {
|
|
case PAD_MODE_NORMAL:
|
|
initButtonsNormalMode();
|
|
break;
|
|
case PAD_MODE_LOL:
|
|
initButtonsLolMode();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ButtonPad::initButtonsNormalMode() {
|
|
DEBUG_ENTER_FUNC();
|
|
PSP_DEBUG_PRINT("initializing buttons for normal mode\n");
|
|
clearButtons();
|
|
|
|
// Dpad
|
|
_button[BTN_UP_LEFT][UNSHIFTED].setKey(Common::KEYCODE_KP7, '7');
|
|
_button[BTN_LEFT][SHIFTED].setKey(Common::KEYCODE_KP7, '7'); // same as up_left
|
|
_button[BTN_UP][UNSHIFTED].setKey(Common::KEYCODE_KP8, '8');
|
|
_button[BTN_UP_RIGHT][UNSHIFTED].setKey(Common::KEYCODE_KP9, '9');
|
|
_button[BTN_UP][SHIFTED].setKey(Common::KEYCODE_KP9, '9'); // same as up_right
|
|
_button[BTN_LEFT][UNSHIFTED].setKey(Common::KEYCODE_KP4, '4');
|
|
_button[BTN_RIGHT][UNSHIFTED].setKey(Common::KEYCODE_KP6, '6');
|
|
_button[BTN_DOWN_LEFT][UNSHIFTED].setKey(Common::KEYCODE_KP1, '1');
|
|
_button[BTN_DOWN][SHIFTED].setKey(Common::KEYCODE_KP1, '1'); // same as down_left
|
|
_button[BTN_DOWN][UNSHIFTED].setKey(Common::KEYCODE_KP2, '2');
|
|
_button[BTN_DOWN_RIGHT][UNSHIFTED].setKey(Common::KEYCODE_KP3, '3');
|
|
_button[BTN_RIGHT][SHIFTED].setKey(Common::KEYCODE_KP3, '3'); // same as down_right
|
|
|
|
// Other buttons
|
|
_button[BTN_CROSS][UNSHIFTED].setPspEvent(PSP_EVENT_LBUTTON, true, PSP_EVENT_LBUTTON, false);
|
|
_button[BTN_CIRCLE][UNSHIFTED].setPspEvent(PSP_EVENT_RBUTTON, true, PSP_EVENT_RBUTTON, false);
|
|
_button[BTN_TRIANGLE][UNSHIFTED].setKey(Common::KEYCODE_RETURN, '\r');
|
|
_button[BTN_SQUARE][UNSHIFTED].setKey(Common::KEYCODE_PERIOD, '.');
|
|
_button[BTN_SQUARE][SHIFTED].setKey(Common::KEYCODE_SPACE, ' ');
|
|
_button[BTN_LTRIGGER][UNSHIFTED].setKey(Common::KEYCODE_ESCAPE, 27);
|
|
_button[BTN_RTRIGGER][SHIFTED].setPspEvent(PSP_EVENT_SHIFT, true, PSP_EVENT_SHIFT, false);
|
|
_button[BTN_RTRIGGER][UNSHIFTED].setPspEvent(PSP_EVENT_SHIFT, true, PSP_EVENT_SHIFT, false);
|
|
_button[BTN_RTRIGGER][SHIFTED].setKey(Common::KEYCODE_INVALID, 0, Common::KBD_SHIFT);
|
|
_button[BTN_RTRIGGER][UNSHIFTED].setKey(Common::KEYCODE_INVALID, 0, Common::KBD_SHIFT);
|
|
_button[BTN_START][SHIFTED].setKey(Common::KEYCODE_F5, Common::ASCII_F5);
|
|
_button[BTN_START][UNSHIFTED].setKey(Common::KEYCODE_F5, Common::ASCII_F5, Common::KBD_CTRL);
|
|
_button[BTN_SELECT][UNSHIFTED].setPspEvent(PSP_EVENT_SHOW_VIRTUAL_KB, true, PSP_EVENT_NONE, 0);
|
|
}
|
|
|
|
void ButtonPad::initButtonsLolMode() {
|
|
DEBUG_ENTER_FUNC();
|
|
initButtonsNormalMode(); // set normal button configuration
|
|
PSP_DEBUG_PRINT("initializing buttons for LOL mode\n");
|
|
|
|
// Square is our new shift button
|
|
_button[BTN_SQUARE][UNSHIFTED].clear();
|
|
_button[BTN_SQUARE][UNSHIFTED].setPspEvent(PSP_EVENT_SHIFT, true, PSP_EVENT_SHIFT, false);
|
|
_button[BTN_SQUARE][SHIFTED].clear();
|
|
_button[BTN_SQUARE][SHIFTED].setPspEvent(PSP_EVENT_SHIFT, true, PSP_EVENT_SHIFT, false);
|
|
|
|
// Dpad
|
|
_button[BTN_LEFT][UNSHIFTED].clear();
|
|
_button[BTN_LEFT][UNSHIFTED].setKey(Common::KEYCODE_KP7, '7');
|
|
_button[BTN_LEFT][SHIFTED].clear();
|
|
_button[BTN_LEFT][SHIFTED].setKey(Common::KEYCODE_F1, Common::ASCII_F1);
|
|
_button[BTN_UP][SHIFTED].clear();
|
|
_button[BTN_UP][SHIFTED].setKey(Common::KEYCODE_F2, Common::ASCII_F2);
|
|
_button[BTN_RIGHT][UNSHIFTED].clear();
|
|
_button[BTN_RIGHT][UNSHIFTED].setKey(Common::KEYCODE_KP9, '9');
|
|
_button[BTN_RIGHT][SHIFTED].clear();
|
|
_button[BTN_RIGHT][SHIFTED].setKey(Common::KEYCODE_F3, Common::ASCII_F3);
|
|
_button[BTN_DOWN][SHIFTED].clear();
|
|
_button[BTN_DOWN][SHIFTED].setKey(Common::KEYCODE_F4, Common::ASCII_F4);
|
|
|
|
// Buttons
|
|
_button[BTN_LTRIGGER][UNSHIFTED].clear();
|
|
_button[BTN_LTRIGGER][SHIFTED].clear();
|
|
_button[BTN_LTRIGGER][UNSHIFTED].setKey(Common::KEYCODE_KP4, '4'); // Triggers turn
|
|
_button[BTN_RTRIGGER][UNSHIFTED].clear();
|
|
_button[BTN_RTRIGGER][SHIFTED].clear();
|
|
_button[BTN_RTRIGGER][UNSHIFTED].setKey(Common::KEYCODE_KP6, '6');
|
|
_button[BTN_START][SHIFTED].clear();
|
|
_button[BTN_START][SHIFTED].setKey(Common::KEYCODE_ESCAPE, 27);
|
|
}
|
|
|
|
bool ButtonPad::getEvent(Common::Event &event, PspEvent &pspEvent, SceCtrlData &pad) {
|
|
DEBUG_ENTER_FUNC();
|
|
|
|
//PSP_DEBUG_PRINT("buttons[%x]\n", pad.Buttons);
|
|
|
|
uint32 curButtonState = PSP_ALL_BUTTONS & pad.Buttons; // we only care about these
|
|
|
|
modifyButtonsForCombos(pad); // change buttons for combos
|
|
|
|
return getEventFromButtonState(event, pspEvent, curButtonState);
|
|
}
|
|
|
|
bool ButtonPad::getEventFromButtonState(Common::Event &event, PspEvent &pspEvent, uint32 buttonState) {
|
|
DEBUG_ENTER_FUNC();
|
|
_buttonsChanged[_shifted] |= buttonState ^ _prevButtonState; // add any buttons that changed
|
|
_prevButtonState = buttonState;
|
|
|
|
for (int shiftState = UNSHIFTED; shiftState < SHIFTED_MODE_LAST; shiftState++) {
|
|
if (_buttonsChanged[shiftState]) { // any button to address?
|
|
PSP_DEBUG_PRINT("found changed buttons\n");
|
|
ButtonType buttonType = BTN_LAST;
|
|
bool buttonDown = false; // normally we release a button (as in when we're in a different shiftmode)
|
|
|
|
for (int i = BTN_UP_LEFT; i < BTN_LAST; i++) {
|
|
uint32 buttonCode = _buttonMap[i];
|
|
if ((_buttonsChanged[shiftState] & buttonCode) == buttonCode) { // check for this changed button
|
|
buttonType = (ButtonType)i; // we know which button changed
|
|
_buttonsChanged[shiftState] &= ~buttonCode; // save the fact that we treated this button
|
|
if (shiftState == _shifted)
|
|
buttonDown = buttonState & buttonCode ? true : false; // pressed or released?
|
|
|
|
PSP_DEBUG_PRINT("button[%i] pressed\n", i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert (buttonType < BTN_LAST);
|
|
bool haveEvent = _button[buttonType][shiftState].getEvent(event, pspEvent, buttonDown);
|
|
if (haveEvent)
|
|
PSP_DEBUG_PRINT("have event. key[%d] flag[%x] %s\n", event.kbd.ascii, event.kbd.flags, buttonDown ? "down" : "up");
|
|
return haveEvent;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ButtonPad::modifyButtonsForCombos(SceCtrlData &pad) {
|
|
if (DOWN(PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER)) {
|
|
if (!_comboMode) { // we're entering combo mode
|
|
PSP_DEBUG_PRINT("entering combo mode\n");
|
|
_button[BTN_SQUARE][UNSHIFTED].clear();
|
|
_button[BTN_SQUARE][SHIFTED].clear();
|
|
_button[BTN_DOWN][SHIFTED].clear();
|
|
_button[BTN_DOWN][UNSHIFTED].clear();
|
|
_button[BTN_UP][SHIFTED].clear();
|
|
_button[BTN_UP][UNSHIFTED].clear();
|
|
_button[BTN_SQUARE][UNSHIFTED].setPspEvent(PSP_EVENT_MODE_SWITCH, true, PSP_EVENT_NONE, true);
|
|
_button[BTN_SQUARE][SHIFTED].setPspEvent(PSP_EVENT_MODE_SWITCH, true, PSP_EVENT_NONE, true);
|
|
_button[BTN_DOWN][UNSHIFTED].setPspEvent(PSP_EVENT_CHANGE_SPEED, false, PSP_EVENT_NONE, true);
|
|
_button[BTN_DOWN][SHIFTED].setPspEvent(PSP_EVENT_CHANGE_SPEED, false, PSP_EVENT_NONE, true);
|
|
_button[BTN_UP][UNSHIFTED].setPspEvent(PSP_EVENT_CHANGE_SPEED, true, PSP_EVENT_NONE, true);
|
|
_button[BTN_UP][SHIFTED].setPspEvent(PSP_EVENT_CHANGE_SPEED, true, PSP_EVENT_NONE, true);
|
|
_comboMode = true;
|
|
}
|
|
} else { // no combo buttons are pressed now
|
|
if (_comboMode) { // we have been running in combo mode
|
|
initButtons(); // reset the button configuration
|
|
_comboMode = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Nub::getEvent(Common::Event &event, PspEvent &pspEvent, SceCtrlData &pad) {
|
|
DEBUG_ENTER_FUNC();
|
|
|
|
if (_dpadMode) { // Convert the nub to a D-Pad
|
|
uint32 buttonState;
|
|
translateToDpadState(pad.Lx, pad.Ly, buttonState);
|
|
return _buttonPad.getEventFromButtonState(event, pspEvent, buttonState);
|
|
}
|
|
|
|
int32 analogStepX = pad.Lx; // Goes up to 255.
|
|
int32 analogStepY = pad.Ly;
|
|
|
|
analogStepX = modifyNubAxisMotion(analogStepX);
|
|
analogStepY = modifyNubAxisMotion(analogStepY);
|
|
|
|
int32 oldX = _cursor->getX();
|
|
int32 oldY = _cursor->getY();
|
|
|
|
if (analogStepX != 0 || analogStepY != 0) {
|
|
|
|
PSP_DEBUG_PRINT("raw x[%d], y[%d]\n", analogStepX, analogStepY);
|
|
|
|
// If no movement then this has no effect
|
|
if (_shifted) {
|
|
// Fine control mode for analog
|
|
if (analogStepX != 0) {
|
|
if (analogStepX > 0)
|
|
_cursor->increaseXY(2, 0);
|
|
else
|
|
_cursor->increaseXY(-2, 0);
|
|
}
|
|
|
|
if (analogStepY != 0) {
|
|
if (analogStepY > 0)
|
|
_cursor->increaseXY(0, 2);
|
|
else
|
|
_cursor->increaseXY(0, -2);
|
|
}
|
|
} else { // Regular speed movement
|
|
_cursor->increaseXY(analogStepX, 0);
|
|
_cursor->increaseXY(0, analogStepY);
|
|
}
|
|
|
|
int32 newX = _cursor->getX();
|
|
int32 newY = _cursor->getY();
|
|
|
|
if ((oldX != newX) || (oldY != newY)) {
|
|
event.type = Common::EVENT_MOUSEMOVE;
|
|
event.mouse.x = newX;
|
|
event.mouse.y = newY;
|
|
PSP_DEBUG_PRINT("Nub event. X[%d], Y[%d]\n", newX, newY);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Nub::translateToDpadState(int dpadX, int dpadY, uint32 &buttonState) {
|
|
#define MIN_NUB_POSITION 70
|
|
buttonState = 0;
|
|
|
|
if (dpadX > 127 + MIN_NUB_POSITION)
|
|
buttonState |= PSP_CTRL_RIGHT;
|
|
else if (dpadX < 127 - MIN_NUB_POSITION)
|
|
buttonState |= PSP_CTRL_LEFT;
|
|
|
|
if (dpadY > 127 + MIN_NUB_POSITION)
|
|
buttonState |= PSP_CTRL_DOWN;
|
|
else if (dpadY < 127 - MIN_NUB_POSITION)
|
|
buttonState |= PSP_CTRL_UP;
|
|
}
|
|
|
|
inline int32 Nub::modifyNubAxisMotion(int32 input) {
|
|
DEBUG_ENTER_FUNC();
|
|
const int MIN_NUB_MOTION = 30;
|
|
|
|
input -= 128; // Center on 0.
|
|
|
|
if (input < -MIN_NUB_MOTION - 1)
|
|
input += MIN_NUB_MOTION + 1; // reduce the velocity
|
|
else if (input > MIN_NUB_MOTION)
|
|
input -= MIN_NUB_MOTION; // same
|
|
else // between these points, dampen the response to 0
|
|
input = 0;
|
|
|
|
return input;
|
|
}
|
|
|
|
inline bool Nub::isButtonDown() {
|
|
if (_dpadMode) // only relevant in dpad mode
|
|
return _buttonPad.isButtonDown();
|
|
return false;
|
|
}
|
|
|
|
const char *InputHandler::_padModeText[] = {
|
|
"Normal Button Mode",
|
|
"1st Person RPG Button Mode"
|
|
};
|
|
|
|
void InputHandler::init() {
|
|
sceCtrlSetSamplingCycle(0); // set sampling to vsync. n = n usecs
|
|
sceCtrlSetSamplingMode(1); // analog
|
|
|
|
_buttonPad.initButtons();
|
|
}
|
|
|
|
bool InputHandler::getAllInputs(Common::Event &event) {
|
|
DEBUG_ENTER_FUNC();
|
|
|
|
uint32 time = g_system->getMillis(); // may not be necessary with read
|
|
if (time - _lastPadCheckTime < PAD_CHECK_TIME) {
|
|
return false;
|
|
}
|
|
|
|
_lastPadCheckTime = time;
|
|
SceCtrlData pad;
|
|
|
|
sceCtrlPeekBufferPositive(&pad, 1); // Peek doesn't sleep. Read sleeps the thread
|
|
|
|
bool haveEvent;
|
|
//memset(&event, 0, sizeof(event));
|
|
|
|
haveEvent = getEvent(event, pad);
|
|
|
|
if (haveEvent) {
|
|
PSP_DEBUG_PRINT("Have event[%s]. Type[%d]\n", haveEvent ? "true" : "false", event.type);
|
|
}
|
|
|
|
return haveEvent;
|
|
}
|
|
|
|
bool InputHandler::getEvent(Common::Event &event, SceCtrlData &pad) {
|
|
DEBUG_ENTER_FUNC();
|
|
|
|
PspEvent pspEvent;
|
|
bool haveEvent = false;
|
|
|
|
if (_keyboard->isVisible()) {
|
|
haveEvent = _keyboard->processInput(event, pspEvent, pad);
|
|
} else { // only process buttonpad if keyboard invisible
|
|
haveEvent = _buttonPad.getEvent(event, pspEvent, pad);
|
|
}
|
|
|
|
if (!haveEvent && pspEvent.isEmpty())
|
|
haveEvent = _nub.getEvent(event, pspEvent, pad);
|
|
|
|
// handle any pending PSP events
|
|
if (!haveEvent && pspEvent.isEmpty()) {
|
|
if (!_pendingPspEvent.isEmpty()) {
|
|
pspEvent = _pendingPspEvent;
|
|
_pendingPspEvent.clear();
|
|
}
|
|
}
|
|
|
|
// handle any PSP events we might have
|
|
if (!pspEvent.isEmpty())
|
|
haveEvent |= handlePspEvent(event, pspEvent); // overrides any event we might have
|
|
|
|
return haveEvent;
|
|
}
|
|
|
|
bool InputHandler::handlePspEvent(Common::Event &event, PspEvent &pspEvent) {
|
|
bool haveEvent = false;
|
|
|
|
PSP_DEBUG_PRINT("have pspEvent[%d] data[%d]\n", pspEvent.type, pspEvent.data);
|
|
|
|
switch (pspEvent.type) {
|
|
case PSP_EVENT_SHIFT:
|
|
handleShiftEvent((ShiftMode)pspEvent.data);
|
|
break;
|
|
case PSP_EVENT_SHOW_VIRTUAL_KB:
|
|
_keyboard->setVisible((bool)pspEvent.data);
|
|
if ((pspEvent.data && _keyboard->isVisible()) || !pspEvent.data) // don't change mode if keyboard didn't load
|
|
_nub.setDpadMode((bool)pspEvent.data); // set nub to keypad/regular mode
|
|
break;
|
|
case PSP_EVENT_LBUTTON:
|
|
haveEvent = true;
|
|
if (pspEvent.data) // down
|
|
handleMouseEvent(event, Common::EVENT_LBUTTONDOWN, "LButtonDown");
|
|
else
|
|
handleMouseEvent(event, Common::EVENT_LBUTTONUP, "LButtonUp");
|
|
break;
|
|
case PSP_EVENT_RBUTTON:
|
|
haveEvent = true;
|
|
if (pspEvent.data) // down
|
|
handleMouseEvent(event, Common::EVENT_RBUTTONDOWN, "RButtonDown");
|
|
else
|
|
handleMouseEvent(event, Common::EVENT_RBUTTONUP, "RButtonUp");
|
|
break;
|
|
case PSP_EVENT_MODE_SWITCH:
|
|
handleModeSwitchEvent();
|
|
break;
|
|
/*case PSP_EVENT_CHANGE_SPEED:
|
|
handleSpeedChange(pspEvent.data);
|
|
break;*/
|
|
default:
|
|
PSP_ERROR("Unhandled PSP Event[%d]\n", pspEvent.type);
|
|
break;
|
|
}
|
|
|
|
return haveEvent;
|
|
}
|
|
|
|
void InputHandler::handleMouseEvent(Common::Event &event, Common::EventType type, const char *string) {
|
|
event.type = type;
|
|
event.mouse.x = _cursor->getX();
|
|
event.mouse.y = _cursor->getY();
|
|
PSP_DEBUG_PRINT("%s event, x[%d], y[%d]\n", string, event.mouse.x, event.mouse.y);
|
|
}
|
|
|
|
void InputHandler::handleShiftEvent(ShiftMode shifted) {
|
|
_buttonPad.setShifted(shifted);
|
|
_nub.setShifted(shifted);
|
|
}
|
|
|
|
void InputHandler::handleModeSwitchEvent() {
|
|
// check if we can't switch modes right now
|
|
if (_buttonPad.isButtonDown() || _nub.isButtonDown()) { // can't switch yet
|
|
PSP_DEBUG_PRINT("postponing mode switch event\n");
|
|
_pendingPspEvent.type = PSP_EVENT_MODE_SWITCH; // queue it to be done later
|
|
} else { // we can switch
|
|
PSP_DEBUG_PRINT("mode switch event\n");
|
|
_padMode = (PspPadMode)(_padMode + 1);
|
|
if (_padMode >= PAD_MODE_LAST)
|
|
_padMode = PAD_MODE_NORMAL;
|
|
|
|
GUI::TimedMessageDialog dialog(_padModeText[_padMode], 1500);
|
|
dialog.runModal();
|
|
|
|
_buttonPad.setPadMode(_padMode);
|
|
_buttonPad.initButtons();
|
|
}
|
|
}
|
|
|
|
/*
|
|
void InputHandler::handleSpeedChange(bool up) {
|
|
char *dialogMsg;
|
|
|
|
if (up) {
|
|
dialogMsg = "
|
|
|
|
GUI::TimedMessageDialog dialog(_padModeText[_padMode], 1500);
|
|
dialog.runModal();
|
|
}*/
|