void InputListener::onEvent(const sf::Event& event)
{
switch (event.type)
{
/* Window */
case sf::Event::LostFocus: onFocusLost(); break;
case sf::Event::GainedFocus: onFocusGained(); break;
case sf::Event::Closed: onWindowClosed(); break;
case sf::Event::Resized: onWindowResized(event.size); break;
/* Keyboard */
case sf::Event::TextEntered: onTextEntered(event.text); break;
case sf::Event::KeyPressed: onKeyPressed(event.key); break;
case sf::Event::KeyReleased: onKeyReleased(event.key); break;
/* Mouse */
case sf::Event::MouseEntered: onMouseEntered(); break;
case sf::Event::MouseLeft: onMouseLeft(); break;
case sf::Event::MouseMoved: onMouseMoved(event.mouseMove); break;
case sf::Event::MouseWheelMoved: onMouseWheelMoved(event.mouseWheel); break;
case sf::Event::MouseButtonPressed: onMouseButtonPressed(event.mouseButton); break;
case sf::Event::MouseButtonReleased: onMouseButtonReleased(event.mouseButton); break;
/* Joystick */
case sf::Event::JoystickConnected: onJoystickConnected(event.joystickConnect); break;
case sf::Event::JoystickDisconnected: onJoystickDisconnected(event.joystickConnect); break;
case sf::Event::JoystickButtonPressed: onJoystickButtonPressed(event.joystickButton); break;
case sf::Event::JoystickButtonReleased: onJoystickButtonReleased(event.joystickButton); break;
case sf::Event::JoystickMoved: onJoystickMoved(event.joystickMove); break;
default:
Logger::log("Warning", "Unknow event type: %d", event.type);
break;
}
}
void SFMLInputSource::dispatchOne(sf::Event const& event) {
switch (event.type) {
case sf::Event::KeyPressed:
onKeyPressed(event.key);
break;
case sf::Event::KeyReleased:
onKeyReleased(event.key);
break;
case sf::Event::MouseButtonPressed:
onMouseButtonPressed(event.mouseButton);
break;
case sf::Event::MouseButtonReleased:
onMouseButtonReleased(event.mouseButton);
break;
case sf::Event::MouseMoved:
onMouseMoved(event.mouseMove);
break;
case sf::Event::MouseWheelMoved:
onMouseWheelMoved(event.mouseWheel);
break;
default:
break;
}
}
void Application::onCharacterReceived(KeyListenerEventData & e){
ofKeyEventArgs args;
args.key = (int)e.character;
// These if's have been added because we get
// capital letters A, B, C and D when pressing
// arrows on the keyboard via terminal.
switch(args.key){
case 'A':
args.key = OF_KEY_UP;
break;
case 'B':
args.key = OF_KEY_DOWN;
break;
case 'C':
args.key = OF_KEY_RIGHT;
break;
case 'D':
args.key = OF_KEY_LEFT;
break;
}
cout << "TermListener: " << e.character << endl;
onKeyPressed(args);
};
bool AGameController::handleEvent(sf::Event const& event) {
switch (event.type) {
case sf::Event::MouseMoved:
return onMouseOver(event);
case sf::Event::MouseButtonPressed:
return onMouseClick(event);
case sf::Event::MouseButtonReleased:
return onMouseClickReleased(event);
case sf::Event::KeyPressed:
return onKeyPressed(event);
case sf::Event::Closed:
return onClose(event);
case sf::Event::TextEntered:
return onText(event);
default:
break;
}
return false;
}
void ofxDatGuiComponent::onKeyPressed(ofKeyEventArgs &e)
{
onKeyPressed(e.key);
if ((e.key == OF_KEY_RETURN || e.key == OF_KEY_TAB)){
onFocusLost();
ofRemoveListener(ofEvents().keyPressed, this, &ofxDatGuiComponent::onKeyPressed);
}
}
void Window::InputLoop()//TODO bad function, but already I not have any idea.
{
Events::EventArgs stdArg;
sf::Event ev;
bool con;
while (settings.opened && window.isOpen())
{
mutexGraph.lock();
con = window.pollEvent(ev);
mutexGraph.unlock();
while(con)// must use var opened because if window was closed after previous condition and before pollEvent program tried call to nullptr object
{
switch (ev.type) {
case sf::Event::EventType::Closed:
onClose(); break;
case sf::Event::EventType::GainedFocus:
OnEvent<Events::EventArgs>(GainedFocus, &GainedFocusAsync, stdArg); break;
case sf::Event::EventType::LostFocus:
OnEvent<Events::EventArgs>(LostFocus, &LostFocusAsync, stdArg); break;
case sf::Event::EventType::Resized:
OnEvent<Events::ResizeArgs>(Resize, &ResizeAsync, ev.size); break;
case sf::Event::EventType::JoystickButtonPressed:
OnEvent<Events::JoystickButtonArgs>(JoystickButtonPressed, &JoystickButtonPressedAsync, ev.joystickButton); break;
case sf::Event::EventType::JoystickButtonReleased:
OnEvent<Events::JoystickButtonArgs>(JoystickButtonRelease, &JoystickButtonReleaseAsync, ev.joystickButton); break;
case sf::Event::EventType::JoystickConnected:
OnEvent<Events::JoystickArgs>(JoystickConnect, &JoystickConnectAsync, ev.joystickConnect); break;
case sf::Event::EventType::JoystickDisconnected:
OnEvent<Events::JoystickArgs>(JoystickDisconnect, &JoystickDisconnectAsync, ev.joystickConnect); break;
case sf::Event::EventType::JoystickMoved:
OnEvent<Events::JoystickMoveArgs>(JoystickMove, &JoystickMoveAsync, ev.joystickMove); break;
case sf::Event::EventType::KeyPressed:
onKeyPressed(ev.key); break;
case sf::Event::EventType::KeyReleased:
onKeyRelease(ev.key); break;
case sf::Event::EventType::MouseButtonPressed:
onClick(ev.mouseButton); break;
case sf::Event::EventType::MouseButtonReleased:
onReleaseMouse(ev.mouseButton); break;
case sf::Event::EventType::MouseEntered:
OnEvent<Events::EventArgs>(MouseEnter, &MouseEnterAsync, stdArg); break;
case sf::Event::EventType::MouseLeft:
OnEvent<Events::EventArgs>(MouseLeft, &MouseLeftAsync, stdArg); break;
case sf::Event::EventType::MouseMoved:
onMouseMove(ev.mouseMove); break;
case sf::Event::EventType::MouseWheelScrolled:
OnEvent<Events::MouseWheelArgs>(MouseWheel, &MouseWheelAsync, ev.mouseWheel); break;
case sf::Event::EventType::TextEntered:
onTextType(ev.text); break;
}
mutexGraph.lock();
con = window.pollEvent(ev);
mutexGraph.unlock();
};
onWindowRender();
}
}
static inline void keyboardCheck() {
if (!(PINC & _BV(2))) {
if (key_pressed[KEY_PLUS] < 0xff) {
key_pressed[KEY_PLUS]++;
if (key_pressed[KEY_PLUS] == KEY_PRESSED_COUNT) {
onKeyPressed(KEY_PLUS);
}
}
} else {
key_pressed[KEY_PLUS] = 0;
}
if (!(PINC & _BV(3))) {
if (key_pressed[KEY_MINUS] < 0xff) {
key_pressed[KEY_MINUS]++;
if (key_pressed[KEY_MINUS] == KEY_PRESSED_COUNT) {
onKeyPressed(KEY_MINUS);
}
}
} else {
key_pressed[KEY_MINUS] = 0;
}
if (!(PINC & _BV(4))) {
if (key_pressed[KEY_ENTER] < 0xff) {
key_pressed[KEY_ENTER]++;
if (key_pressed[KEY_ENTER] == KEY_PRESSED_COUNT) {
onKeyPressed(KEY_ENTER);
}
}
} else {
key_pressed[KEY_ENTER] = 0;
}
if (!(PINC & _BV(5))) {
if (key_pressed[KEY_BACK] < 0xff) {
key_pressed[KEY_BACK]++;
if (key_pressed[KEY_BACK] == KEY_PRESSED_COUNT) {
onKeyPressed(KEY_BACK);
}
}
} else {
key_pressed[KEY_BACK] = 0;
}
}
bool ScriptUnitView::eventFilter(QObject *sender, QEvent *event)
{
if (event->type() == QEvent::KeyPress) {
QKeyEvent *key = static_cast<QKeyEvent *>(event);
if (onKeyPressed(key))
return true;
}
// standard event processing
return QObject::eventFilter(sender, event);
}
void Game::handleEvent(sf::Event event) {
switch(event.Type) {
case sf::Event::Closed:
onClose();
break;
case sf::Event::KeyPressed:
onKeyPressed(event);
break;
default:
break;
}
}
void KeyboardCheck() {
if (key_test_pressed()) {
if (keyRepeatCount[KEY_TEST] < 0xff) {
keyRepeatCount[KEY_TEST]++;
}
} else {
keyRepeatCount[KEY_TEST] = 0;
}
if (keyRepeatCount[KEY_TEST] == KEY_PRESS_TIME) {
onKeyPressed(KEY_TEST);
}
if (!IsFullMode()) {
if (key_up_pressed()) {
if (keyRepeatCount[KEY_UP] < 0xff) {
keyRepeatCount[KEY_UP]++;
}
} else {
keyRepeatCount[KEY_UP] = 0;
}
if (key_down_pressed()) {
if (keyRepeatCount[KEY_DOWN] < 0xff) {
keyRepeatCount[KEY_DOWN]++;
}
} else {
keyRepeatCount[KEY_DOWN] = 0;
}
if (keyRepeatCount[KEY_UP] == KEY_PRESS_TIME) {
onKeyPressed(KEY_UP);
}
if (keyRepeatCount[KEY_DOWN] == KEY_PRESS_TIME) {
onKeyPressed(KEY_DOWN);
}
}
}
void Event::eventProc(SDL_Event* e)
{
switch (e->type) {
case SDL_WINDOWEVENT:
break;
case SDL_KEYDOWN: //key pressed
onKeyPressed(e->key.keysym);
break;
case SDL_KEYUP: //key released
onKeyReleased(e->key.keysym);
break;
case SDL_MOUSEMOTION:
onMouseMove(e->motion);
break;
case SDL_MOUSEBUTTONDOWN:
if (e->button.button == SDL_BUTTON_LEFT)
onLMouseButtonPressed(e->button);
else if (e->button.button == SDL_BUTTON_RIGHT)
onRMouseButtonPressed(e->button);
else if (e->button.button == SDL_BUTTON_MIDDLE)
onMMouseButtonPressed(e->button);
else
;
break;
case SDL_MOUSEBUTTONUP:
if (e->button.button == SDL_BUTTON_LEFT)
onLMouseButtonReleased(e->button);
else if (e->button.button == SDL_BUTTON_RIGHT)
onRMouseButtonReleased(e->button);
else if (e->button.button == SDL_BUTTON_MIDDLE)
onMMouseButtonReleased(e->button);
else
;
break;
case SDL_MOUSEWHEEL:
onMouseWheelMove(e->wheel);
break;
case SDL_QUIT:
onExit();
break;
default:
onUser();
}
}
void Window::TestEvents(sf::Event &ev)
{
Events::EventArgs stdArg;
OnEvent<Events::EventArgs>(GainedFocus, &GainedFocusAsync, stdArg);
OnEvent<Events::EventArgs>(LostFocus, &LostFocusAsync, stdArg);
OnEvent<Events::ResizeArgs>(Resize, &ResizeAsync, ev.size);
OnEvent<Events::JoystickButtonArgs>(JoystickButtonPressed, &JoystickButtonPressedAsync, ev.joystickButton);
OnEvent<Events::JoystickButtonArgs>(JoystickButtonRelease, &JoystickButtonReleaseAsync, ev.joystickButton);
OnEvent<Events::JoystickArgs>(JoystickConnect, &JoystickConnectAsync, ev.joystickConnect);
OnEvent<Events::JoystickArgs>(JoystickDisconnect, &JoystickDisconnectAsync, ev.joystickConnect);
OnEvent<Events::JoystickMoveArgs>(JoystickMove, &JoystickMoveAsync, ev.joystickMove);
onKeyPressed(ev.key);
onKeyRelease(ev.key);
onClick(ev.mouseButton);
onReleaseMouse(ev.mouseButton);
OnEvent<Events::EventArgs>(MouseEnter, &MouseEnterAsync, stdArg);
OnEvent<Events::EventArgs>(MouseLeft, &MouseLeftAsync, stdArg);
OnEvent<Events::MouseWheelArgs>(MouseWheel, &MouseWheelAsync, ev.mouseWheel);
onTextType(ev.text);
}
bool EventListenerKeyboard::init()
{
auto listener = [this](Event* event){
auto keyboardEvent = static_cast<EventKeyboard*>(event);
if (keyboardEvent->_isPressed)
{
if (onKeyPressed != nullptr)
onKeyPressed(keyboardEvent->_keyCode, event);
}
else
{
if (onKeyReleased != nullptr)
onKeyReleased(keyboardEvent->_keyCode, event);
}
};
if (EventListener::init(Type::KEYBOARD, LISTENER_ID, listener))
{
return true;
}
return false;
}
//
// CGLib 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 CGLib; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// Copyright 2007 Carlos Martinho
#include "KeyboardEventNotifier.h"
namespace cg {
SINGLETON_IMPLEMENTATION(KeyboardEventNotifier)
void KeyboardEventNotifier::handleKeyPressed(unsigned char key) {
FOR_EACH_LISTENER(onKeyPressed(key))
}
void KeyboardEventNotifier::handleKeyReleased(unsigned char key) {
FOR_EACH_LISTENER(onKeyReleased(key))
}
void KeyboardEventNotifier::handleSpecialKeyPressed(int key) {
FOR_EACH_LISTENER(onSpecialKeyPressed(key))
}
void KeyboardEventNotifier::handleSpecialKeyReleased(int key) {
FOR_EACH_LISTENER(onSpecialKeyReleased(key))
}
}
void GlutApp::injectKeyPress(unsigned char key, int x, int y)
{
onKeyPressed(key, x, y);
}
