bool ControllerKeyboardCallback::processKeyRelease(QKeyEvent* event)
{
if (onKeyRelease)
return onKeyRelease(event);
return false;
}
//--------------------------------------------------------------
void ofxMSAInteractiveObject::_keyReleased(ofKeyEventArgs &e) {
int key = e.key;
if(verbose) printf("ofxMSAInteractiveObject::_keyReleased(key: %i)\n", key);
if(!enabled) return;
if(isMouseOver()) onKeyRelease(key);
keyReleased(key);
}
// The GTK keyrelease callback
bool EventManager::onDialogKeyRelease(GdkEventKey* ev, Gtk::Window* window)
{
// Pass the key event to the connected dialog window and see if it can process it (returns TRUE)
// greebo: gtkmm is not exposing this function??
bool keyProcessed = gtk_window_propagate_key_event(window->gobj(), ev);
// Get the focus widget, is it an editable widget?
Gtk::Widget* focus = window->get_focus();
bool isEditableWidget = dynamic_cast<Gtk::Editable*>(focus) != NULL || dynamic_cast<Gtk::TextView*>(focus) != NULL;
if (isEditableWidget && ev->keyval != GDK_Escape)
{
// never pass onKeyPress event to the accelerator manager if an editable widget is focused
return keyProcessed;
}
if (!keyProcessed)
{
// The dialog window returned FALSE, pass the key on to the default key handler
onKeyRelease(ev, window);
}
// If we return true here, the dialog window could process the key, and the GTK callback chain is stopped
return keyProcessed;
}
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();
}
}
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);
}
void KankerApp::switchState(int newstate) {
if (newstate == state) {
RX_VERBOSE("warning: trying to switch to the same state? %d", state);
}
state = newstate;
switch (state) {
case KSTATE_CHAR_INPUT_TITLE: {
title_font.write("Type a character to record:");
break;
}
case KSTATE_CHAR_INPUT_DRAWING: {
info_font.write("Drag with the mouse to add points to the character. "
"Press backspace to restart. Space when happy with the character.");
verbose_font.write((char)kanker_glyph->charcode);
break;
}
case KSTATE_CHAR_EDIT: {
info_font.write("Position the origin (dot) and set advance-x. Press space when ready.");
if (kanker_glyph) {
if (kanker_glyph->advance_x == 0.0f) {
/* Auto calc advance x. (just the width). */
advance_x = kanker_glyph->min_x + kanker_glyph->width;
advance_x = CLAMP(advance_x, gui_width, painter.width() - gui_width);
}
else {
advance_x = gui_width + kanker_glyph->advance_x;
}
/* Set the initial (or loaded) advance_x on the glyph. */
kanker_glyph->advance_x = (advance_x - gui_width);
kanker_glyph->origin_x = origin_x;
}
break;
}
case KSTATE_CHAR_PREVIEW: {
if (kanker_glyph) {
if (0.0f == kanker_glyph->advance_x) {
RX_ERROR("The glyph advance_x is 0.0 expect incorrect results..");
}
KankerGlyph copy = *kanker_glyph;
preview_drawer.updateVertices(copy);
}
else {
RX_WARNING("Changing to preview state, but the glyph is NULL.");
}
break;
}
case KSTATE_CHAR_OVERVIEW: {
glyph_dx = -1;
onKeyRelease(GLFW_KEY_RIGHT, 0, 0);
info_font.write("Press left and right arrows to switch character.");
break;
}
default: {
break;
}
}
}
void Keyboard::keyReleased( const KeyEvent& keyEvent )
{
keyState[(int)keyEvent.keyCode] = false;
onKeyRelease(keyEvent);
}
void KeyboardCommon::onInputFocusLost() {
for( size_t keyIndex = 0; keyIndex < _keyStates.size(); ++keyIndex )
if( _keyStates[keyIndex] == KeyState::Pressed )
onKeyRelease( static_cast<Key>(keyIndex) );
}
void Sprite::keyReleaseEvent(QKeyEvent *event)
{
emit onKeyRelease(event->key());
}
//==============================================================================
void CEvent::onEvent(SDL_Event *anEvent) {
switch(anEvent->type) {
case SDL_WINDOWEVENT: {
switch(anEvent->window.event) {
case SDL_WINDOWEVENT_ENTER:{
onMouseFocus();
break;
}
case SDL_WINDOWEVENT_LEAVE:{
onMouseBlur();
break;
}
case SDL_WINDOWEVENT_FOCUS_GAINED: {
onInputFocus();
break;
}
case SDL_WINDOWEVENT_FOCUS_LOST: {
onInputBlur();
break;
}
case SDL_WINDOWEVENT_RESTORED: {
onRestore();
break;
}
case SDL_WINDOWEVENT_MINIMIZED: {
onMinimize();
break;
}
}
break;
}
case SDL_KEYDOWN: {
onKeyPress(anEvent->key.keysym.sym, anEvent->key.keysym.mod);
break;
}
case SDL_KEYUP: {
onKeyRelease(anEvent->key.keysym.sym,anEvent->key.keysym.mod);
break;
}
case SDL_MOUSEMOTION: {
onMouseMove(anEvent->motion.x, anEvent->motion.y, anEvent->motion.xrel, anEvent->motion.yrel,(anEvent->motion.state&SDL_BUTTON(SDL_BUTTON_LEFT))!=0,(anEvent->motion.state&SDL_BUTTON(SDL_BUTTON_RIGHT))!=0,(anEvent->motion.state&SDL_BUTTON(SDL_BUTTON_MIDDLE))!=0);
break;
}
case SDL_MOUSEBUTTONDOWN: {
switch(anEvent->button.button) {
case SDL_BUTTON_LEFT: {
onLButtonDown(anEvent->button.x,anEvent->button.y);
break;
}
case SDL_BUTTON_RIGHT: {
onRButtonDown(anEvent->button.x,anEvent->button.y);
break;
}
case SDL_BUTTON_MIDDLE: {
onMButtonDown(anEvent->button.x,anEvent->button.y);
break;
}
}
break;
}
case SDL_MOUSEBUTTONUP: {
switch(anEvent->button.button) {
case SDL_BUTTON_LEFT: {
onLButtonUp(anEvent->button.x,anEvent->button.y);
break;
}
case SDL_BUTTON_RIGHT: {
onRButtonUp(anEvent->button.x,anEvent->button.y);
break;
}
case SDL_BUTTON_MIDDLE: {
onMButtonUp(anEvent->button.x,anEvent->button.y);
break;
}
}
break;
}
case SDL_QUIT: {
onExit();
break;
}
case SDL_SYSWMEVENT: {
//Ignore
break;
}
case SDL_WINDOWEVENT_RESIZED: {
onResize(anEvent->window.data1,anEvent->window.data2);
break;
}
case SDL_WINDOWEVENT_EXPOSED: {
onExpose();
break;
}
default: {
onUser(anEvent->user.type,anEvent->user.code,anEvent->user.data1,anEvent->user.data2);
break;
}
}
}
LRESULT CALLBACK WindowsWindow::dispatch(
const HWND hWnd
, const UINT message
, const WPARAM wParam
, const LPARAM lParam)
{
assert(!m_hWnd || hWnd == m_hWnd);
if (!m_hWnd)
return DefWindowProc(hWnd, message, wParam, lParam);
// Windows Messages: http://msdn.microsoft.com/en-us/library/windows/desktop/ms644927(v=vs.85).aspx#windows_messages
switch (message)
{
case WM_QUIT:
case WM_CLOSE:
onClose();
break;
case WM_DESTROY:
onDestroy();
break;
case WM_SIZE:
onResize(LOWORD(lParam), HIWORD(lParam));
break;
case WM_PAINT:
onRepaint();
break;
case WM_USER_IDLE:
onIdle();
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
if(!onKeyPress(LOWORD(wParam)))
DefWindowProc(hWnd, message, wParam, lParam);
break;
case WM_KEYUP:
case WM_SYSKEYUP:
if(!onKeyRelease(LOWORD(wParam)))
DefWindowProc(hWnd, message, wParam, lParam);
break;
//case WM_ACTIVATE:
// // Check for minimization.
// if (!HIWORD(wParam))
// m_eventHandler->activateEvent();
// else
// m_eventHandler->minimizeEvent();
// break;
case WM_SYSCOMMAND:
// Absorb some system commands.
switch (wParam)
{
case SC_SCREENSAVE:
case SC_MONITORPOWER:
return 0;
}
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
