scummvm/backends/platform/psp/input.h

/* 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 $
 *
 */

#ifndef PSP_INPUT_H
#define PSP_INPUT_H

#include "common/scummsys.h"
#include "common/events.h"
#include "backends/platform/psp/pspkeyboard.h"
#include "backends/platform/psp/cursor.h"
#include <pspctrl.h>

enum PspEventType {
	PSP_EVENT_NONE = 0,
	PSP_EVENT_SHIFT,
	PSP_EVENT_SHOW_VIRTUAL_KB,
	PSP_EVENT_LBUTTON,
	PSP_EVENT_RBUTTON,
	PSP_EVENT_MODE_SWITCH,
	PSP_EVENT_CHANGE_SPEED,
	PSP_EVENT_LAST
};


struct PspEvent {
	PspEventType type;
	uint32 data;
	PspEvent() { clear(); }
	void clear() { 
		type = PSP_EVENT_NONE;
		data = 0;
	}
	bool isEmpty() { return type == PSP_EVENT_NONE; }	
};

enum PspPadMode {
	PAD_MODE_NORMAL,
	PAD_MODE_LOL,
	PAD_MODE_LAST
};

enum ShiftMode {
	UNSHIFTED = 0,
	SHIFTED = 1,
	SHIFTED_MODE_LAST
};


class Button {
private:
	Common::KeyCode _key;
	uint32 _ascii;
	uint32 _flag;
	PspEvent _pspEventDown;	// event when we press
	PspEvent _pspEventUp;	// event when we release
public:	
	Button();
	void clear();
	bool getEvent(Common::Event &event, PspEvent &pspEvent, bool buttonDown);
	void setKey(Common::KeyCode key, uint32 ascii = 0, uint32 flag = 0) { _key = key; _ascii = ascii; _flag = flag; }
	void setPspEvent(PspEventType typeDown, uint32 dataDown, PspEventType typeUp, uint32 dataUp);
};

class ButtonPad {
public:
	enum ButtonType {	// must match the buttonMap
		BTN_UP_LEFT,
		BTN_UP_RIGHT,
		BTN_DOWN_RIGHT,
		BTN_DOWN_LEFT,
		BTN_RIGHT,
		BTN_DOWN,
		BTN_LEFT,
		BTN_UP,
		BTN_CROSS,
		BTN_CIRCLE,
		BTN_TRIANGLE,
		BTN_SQUARE,
		BTN_LTRIGGER,
		BTN_RTRIGGER,
		BTN_START,
		BTN_SELECT,
		BTN_LAST
	};

private:	
	Button _button[BTN_LAST][SHIFTED_MODE_LAST];
	uint32 _buttonsChanged[SHIFTED_MODE_LAST];		// normal and shifted
	uint32 _prevButtonState;
	ShiftMode _shifted;
	PspPadMode _padMode;
	bool _comboMode;								// are we in the middle of combos
	static const uint32 _buttonMap[];						// maps the buttons to their values

	void initButtonsNormalMode();
	void initButtonsLolMode();
	void modifyButtonsForCombos(SceCtrlData &pad);
	void clearButtons();

public:
	ButtonPad();
	bool getEvent(Common::Event &event, PspEvent &pspEvent, SceCtrlData &pad);
	bool getEventFromButtonState(Common::Event &event, PspEvent &pspEvent, uint32 buttonState);
	void setShifted(ShiftMode shifted) { _shifted = shifted; }
	void setPadMode(PspPadMode mode) { _padMode = mode; }
	bool isButtonDown() { return _prevButtonState; }
	void initButtons();
};
	
class Nub {
private:
	Cursor *_cursor;		// to enable changing/getting cursor position

	ButtonPad _buttonPad;	// private buttonpad for dpad mode
	ShiftMode _shifted;
	bool _dpadMode;

public:	
	Nub() : _shifted(UNSHIFTED), _dpadMode(false) { _buttonPad.initButtons(); }

	void setCursor(Cursor *cursor) { _cursor = cursor; }	
	void setDpadMode(bool active) { _dpadMode = active; }
	void setShifted(ShiftMode shifted) { _shifted = shifted; }
	bool isButtonDown();
	
	bool getEvent(Common::Event &event, PspEvent &pspEvent, SceCtrlData &pad);
	int32 modifyNubAxisMotion(int32 input);
	void translateToDpadState(int dpadX, int dpadY, uint32 &buttonState);	// convert nub data to dpad data
};	

class InputHandler {
public:
	InputHandler() : _keyboard(0), _cursor(0), _padMode(PAD_MODE_NORMAL), _lastPadCheckTime(0) {}
	void setKeyboard(PSPKeyboard *keyboard) { _keyboard = keyboard; }
	void setCursor(Cursor *cursor) { _cursor = cursor; _nub.setCursor(cursor); }
	
	void init();	
	bool getAllInputs(Common::Event &event);
	
private:
	PSPKeyboard *_keyboard;
	Cursor *_cursor;
	
	Nub _nub;	
	ButtonPad _buttonPad;
	
	PspPadMode _padMode;				// whice mode we're in
	PspEvent _pendingPspEvent;			// an event that can't be handled yet
	uint32	_lastPadCheckTime;
	static const char *_padModeText[];

	bool getEvent(Common::Event &event, SceCtrlData &pad);
	bool handlePspEvent(Common::Event &event, PspEvent &pspEvent);
	void handleMouseEvent(Common::Event &event, Common::EventType type, const char *string);
	void handleShiftEvent(ShiftMode shifted);
	void handleModeSwitchEvent();
};

#endif /* PSP_INPUT_H */