From d38156ec26cb784d7e28654ffc6ce3a6dcef70db Mon Sep 17 00:00:00 2001 From: Yousef Khadadeh Date: Thu, 5 Mar 2026 21:09:30 +0300 Subject: [PATCH] Touch events are handled differently in GUI --- src/DrawCamera.cpp | 4 +- src/DrawCamera.hpp | 4 +- src/DrawingProgram/DrawingProgram.cpp | 8 - .../Tools/DrawingProgramToolBase.cpp | 2 - .../Tools/DrawingProgramToolBase.hpp | 2 - src/InputManager.cpp | 206 +++++++++--------- src/InputManager.hpp | 34 ++- src/MainProgram.cpp | 22 +- src/MainProgram.hpp | 8 +- src/Toolbar.cpp | 71 +++--- src/Toolbar.hpp | 2 + src/World.cpp | 14 +- src/World.hpp | 6 +- 13 files changed, 203 insertions(+), 180 deletions(-) diff --git a/src/DrawCamera.cpp b/src/DrawCamera.cpp index a968816..984e4e2 100755 --- a/src/DrawCamera.cpp +++ b/src/DrawCamera.cpp @@ -201,7 +201,7 @@ void DrawCamera::input_mouse_wheel_callback(World& w, const InputManager::MouseW } } -void DrawCamera::input_multi_finger_touch_callback(World& w, const InputManager::MultiFingerTouchArgs& touch) { +void DrawCamera::input_multi_finger_touch_callback(World& w, const InputManager::MultiFingerTouchCallbackArgs& touch) { if(!smoothMove.occurring && !isAccurateZooming && !isTouchTransforming && touch.down) { touchInitialPositions = touch.pos; touchInitialC = c; @@ -211,7 +211,7 @@ void DrawCamera::input_multi_finger_touch_callback(World& w, const InputManager: isTouchTransforming = false; } -void DrawCamera::input_multi_finger_motion_callback(World& w, const InputManager::MultiFingerMotionArgs& motion) { +void DrawCamera::input_multi_finger_motion_callback(World& w, const InputManager::MultiFingerMotionCallbackArgs& motion) { if(!smoothMove.occurring && !isAccurateZooming && isTouchTransforming) { c = touchInitialC; diff --git a/src/DrawCamera.hpp b/src/DrawCamera.hpp index ec86db7..db6d42e 100644 --- a/src/DrawCamera.hpp +++ b/src/DrawCamera.hpp @@ -34,8 +34,8 @@ class DrawCamera { void input_mouse_button_on_canvas_callback(World& w, const InputManager::MouseButtonCallbackArgs& button); void input_mouse_motion_callback(World& w, const InputManager::MouseMotionCallbackArgs& motion); void input_mouse_wheel_callback(World& w, const InputManager::MouseWheelCallbackArgs& wheel); - void input_multi_finger_touch_callback(World& w, const InputManager::MultiFingerTouchArgs& touch); - void input_multi_finger_motion_callback(World& w, const InputManager::MultiFingerMotionArgs& motion); + void input_multi_finger_touch_callback(World& w, const InputManager::MultiFingerTouchCallbackArgs& touch); + void input_multi_finger_motion_callback(World& w, const InputManager::MultiFingerMotionCallbackArgs& motion); private: struct SmoothMove { CoordSpaceHelper start; diff --git a/src/DrawingProgram/DrawingProgram.cpp b/src/DrawingProgram/DrawingProgram.cpp index af9ab5a..77fc341 100644 --- a/src/DrawingProgram/DrawingProgram.cpp +++ b/src/DrawingProgram/DrawingProgram.cpp @@ -227,14 +227,6 @@ void DrawingProgram::input_key_callback(const InputManager::KeyCallbackArgs& key drawTool->input_key_callback(key); } -void DrawingProgram::input_pure_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button) { - drawTool->input_pure_mouse_button_callback(button); -} - -void DrawingProgram::input_pure_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) { - drawTool->input_pure_mouse_motion_callback(motion); -} - void DrawingProgram::input_pen_button_callback(const InputManager::PenButtonCallbackArgs& button) { pen_tool_switch_check(); drawTool->input_pen_button_callback(button); diff --git a/src/DrawingProgram/Tools/DrawingProgramToolBase.cpp b/src/DrawingProgram/Tools/DrawingProgramToolBase.cpp index 39057e5..453ef28 100644 --- a/src/DrawingProgram/Tools/DrawingProgramToolBase.cpp +++ b/src/DrawingProgram/Tools/DrawingProgramToolBase.cpp @@ -58,8 +58,6 @@ std::unique_ptr DrawingProgramToolBase::allocate_tool_ty void DrawingProgramToolBase::input_key_callback(const InputManager::KeyCallbackArgs& key) {} void DrawingProgramToolBase::input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button) {} void DrawingProgramToolBase::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {} -void DrawingProgramToolBase::input_pure_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button) {} -void DrawingProgramToolBase::input_pure_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {} void DrawingProgramToolBase::input_pen_button_callback(const InputManager::PenButtonCallbackArgs& button) {} void DrawingProgramToolBase::input_pen_touch_callback(const InputManager::PenTouchCallbackArgs& touch) {} void DrawingProgramToolBase::input_pen_motion_callback(const InputManager::PenMotionCallbackArgs& motion) {} diff --git a/src/DrawingProgram/Tools/DrawingProgramToolBase.hpp b/src/DrawingProgram/Tools/DrawingProgramToolBase.hpp index 0269cb5..b4420ee 100644 --- a/src/DrawingProgram/Tools/DrawingProgramToolBase.hpp +++ b/src/DrawingProgram/Tools/DrawingProgramToolBase.hpp @@ -39,8 +39,6 @@ class DrawingProgramToolBase { virtual void input_key_callback(const InputManager::KeyCallbackArgs& key); virtual void input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button); virtual void input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion); - virtual void input_pure_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button); - virtual void input_pure_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion); virtual void input_pen_button_callback(const InputManager::PenButtonCallbackArgs& button); virtual void input_pen_touch_callback(const InputManager::PenTouchCallbackArgs& touch); virtual void input_pen_motion_callback(const InputManager::PenMotionCallbackArgs& motion); diff --git a/src/InputManager.cpp b/src/InputManager.cpp index 479c9a7..4eba2f1 100644 --- a/src/InputManager.cpp +++ b/src/InputManager.cpp @@ -394,13 +394,13 @@ void InputManager::backend_mouse_button_up_update(const SDL_MouseButtonEvent& e) else if(e.button == 3) mouse.rightDown = false; MouseButtonCallbackArgs args{ + .deviceType = MouseDeviceType::MOUSE, .button = static_cast(e.button), .down = e.down, .clicks = e.clicks, .pos = mousePos }; main.input_mouse_button_callback(args); - main.input_pure_mouse_button_callback(args); isTouchDevice = false; } @@ -422,13 +422,13 @@ void InputManager::backend_mouse_button_down_update(const SDL_MouseButtonEvent& mouse.rightClicks = e.clicks; } MouseButtonCallbackArgs args{ + .deviceType = MouseDeviceType::MOUSE, .button = static_cast(e.button), .down = e.down, .clicks = e.clicks, .pos = mousePos }; main.input_mouse_button_callback(args); - main.input_pure_mouse_button_callback(args); isTouchDevice = false; } @@ -438,11 +438,8 @@ void InputManager::backend_mouse_motion_update(const SDL_MouseMotionEvent& e) { mouse.set_pos(mouseNewPos); Vector2f mouseRel = {e.xrel * main.window.density, e.yrel * main.window.density}; - main.input_pure_mouse_motion_callback({ - .pos = mouseNewPos, - .move = mouseRel - }); main.input_mouse_motion_callback({ + .deviceType = MouseDeviceType::MOUSE, .pos = mouseNewPos, .move = mouseRel }); @@ -476,6 +473,7 @@ void InputManager::backend_pen_button_down_update(const SDL_PenButtonEvent& e) { if(e.button == main.toolbar.tabletOptions.middleClickButton) { main.input_mouse_button_callback({ + .deviceType = MouseDeviceType::PEN, .button = MouseButton::MIDDLE, .down = e.down, .clicks = 1, @@ -484,6 +482,7 @@ void InputManager::backend_pen_button_down_update(const SDL_PenButtonEvent& e) { } else if(e.button == main.toolbar.tabletOptions.rightClickButton) { main.input_mouse_button_callback({ + .deviceType = MouseDeviceType::PEN, .button = MouseButton::RIGHT, .down = e.down, .clicks = 1, @@ -510,6 +509,7 @@ void InputManager::backend_pen_button_up_update(const SDL_PenButtonEvent& e) { if(e.button == main.toolbar.tabletOptions.middleClickButton) { main.input_mouse_button_callback({ + .deviceType = MouseDeviceType::PEN, .button = MouseButton::MIDDLE, .down = e.down, .clicks = 1, @@ -518,6 +518,7 @@ void InputManager::backend_pen_button_up_update(const SDL_PenButtonEvent& e) { } else if(e.button == main.toolbar.tabletOptions.rightClickButton) { main.input_mouse_button_callback({ + .deviceType = MouseDeviceType::PEN, .button = MouseButton::RIGHT, .down = e.down, .clicks = 1, @@ -549,6 +550,7 @@ void InputManager::backend_pen_touch_down_update(const SDL_PenTouchEvent& e) { pen.isEraser = e.eraser; main.input_mouse_button_callback({ + .deviceType = MouseDeviceType::PEN, .button = MouseButton::LEFT, .down = e.down, .clicks = mouse.leftClicks, @@ -574,6 +576,7 @@ void InputManager::backend_pen_touch_up_update(const SDL_PenTouchEvent& e) { pen.pressure = 0.0; main.input_mouse_button_callback({ + .deviceType = MouseDeviceType::PEN, .button = MouseButton::LEFT, .down = e.down, .clicks = 0, @@ -597,6 +600,7 @@ void InputManager::backend_pen_motion_update(const SDL_PenMotionEvent& e) { pen.isEraser = e.pen_state & SDL_PEN_INPUT_ERASER_TIP; main.input_mouse_motion_callback({ + .deviceType = MouseDeviceType::PEN, .pos = mouseNewPos, .move = mouseRel }); @@ -640,21 +644,75 @@ std::vector InputManager::get_multiple_finger_motions() { return pos; } +void InputManager::touch_finger_do_mouse_down() { + auto& prevTouch = touch.fingers[0]; + Vector2f mouseNewPos = {prevTouch.x * main.window.size.x() * main.window.density, prevTouch.y * main.window.size.y() * main.window.density}; + mouse.set_pos(mouseNewPos); + mouse.leftDown = true; + + if((std::chrono::steady_clock::now() - touch.lastLeftClickTime) > std::chrono::milliseconds(500)) + touch.leftClicksSaved = 0; + touch.leftClicksSaved++; + touch.lastLeftClickTime = std::chrono::steady_clock::now(); + mouse.leftClicks = touch.leftClicksSaved; + + main.input_mouse_button_callback({ + .deviceType = MouseDeviceType::TOUCH, + .button = MouseButton::LEFT, + .down = true, + .clicks = mouse.leftClicks, + .pos = mouseNewPos + }); +} + +void InputManager::touch_finger_do_mouse_up(const SDL_TouchFingerEvent& e) { + Vector2f mouseNewPos = {e.x * main.window.size.x() * main.window.density, e.y * main.window.size.y() * main.window.density}; + mouse.set_pos(mouseNewPos); + mouse.leftDown = false; + + main.input_mouse_button_callback({ + .deviceType = MouseDeviceType::TOUCH, + .button = MouseButton::LEFT, + .down = false, + .clicks = 0, + .pos = mouseNewPos + }); +} + +void InputManager::touch_finger_do_mouse_motion(const SDL_TouchFingerEvent& e) { + Vector2f mouseNewPos = {e.x * main.window.size.x() * main.window.density, e.y * main.window.size.y() * main.window.density}; + mouse.set_pos(mouseNewPos); + Vector2f mouseRel = {e.dx * main.window.size.x() * main.window.density, e.dy * main.window.size.y() * main.window.density}; + main.input_mouse_motion_callback({ + .deviceType = MouseDeviceType::TOUCH, + .pos = mouseNewPos, + .move = mouseRel + }); +} + void InputManager::backend_touch_finger_down_update(const SDL_TouchFingerEvent& e) { touch.fingers.emplace_back(e); + auto fingerPosVec = get_multiple_finger_positions(); switch(touch.touchEventType) { case Touch::NO_TOUCH_EVENT: { if(touch.fingers.size() == 2) { - touch.isDown = true; touch.touchEventType = Touch::TWO_FINGER_EVENT; main.input_multi_finger_touch_callback({ .down = true, - .pos = get_multiple_finger_positions() + .pos = fingerPosVec }); } break; } case Touch::ONE_FINGER_EVENT: { + if(touch.fingers.size() == 2) { + touch_finger_do_mouse_up(e); + touch.touchEventType = Touch::TWO_FINGER_EVENT; + main.input_multi_finger_touch_callback({ + .down = true, + .pos = fingerPosVec + }); + } break; } case Touch::TWO_FINGER_EVENT: { @@ -667,63 +725,41 @@ void InputManager::backend_touch_finger_down_update(const SDL_TouchFingerEvent& } } + + if((std::chrono::steady_clock::now() - touch.lastFingerTapTime) > std::chrono::milliseconds(500)) + touch.fingerTapsSaved = 0; + touch.fingerTapsSaved++; + touch.lastFingerTapTime = std::chrono::steady_clock::now(); + + main.input_finger_touch_callback({ + .fingerID = e.fingerID, + .down = true, + .pos = fingerPosVec.back(), + .fingerDownCount = touch.fingers.size(), + .fingerTapCount = touch.fingerTapsSaved + }); + isTouchDevice = true; } void InputManager::backend_touch_finger_up_update(const SDL_TouchFingerEvent& e) { switch(touch.touchEventType) { case Touch::NO_TOUCH_EVENT: { - Vector2f mouseNewPos = {e.x * main.window.size.x() * main.window.density, e.y * main.window.size.y() * main.window.density}; - mouse.set_pos(mouseNewPos); - touch.isDown = false; - mouse.leftDown = false; - - if((std::chrono::steady_clock::now() - touch.lastLeftClickTime) > std::chrono::milliseconds(300)) - touch.leftClicksSaved = 0; - touch.leftClicksSaved++; - mouse.leftClicks = touch.leftClicksSaved; - touch.lastLeftClickTime = std::chrono::steady_clock::now(); - - main.input_mouse_button_callback({ - .button = MouseButton::LEFT, - .down = true, - .clicks = mouse.leftClicks, - .pos = mouseNewPos - }); - main.input_mouse_button_callback({ - .button = MouseButton::LEFT, - .down = false, - .clicks = 0, - .pos = mouseNewPos - }); - + touch_finger_do_mouse_down(); + touch_finger_do_mouse_up(e); touch.touchEventType = Touch::EVENT_DONE; break; } case Touch::ONE_FINGER_EVENT: { - Vector2f mouseNewPos = {e.x * main.window.size.x() * main.window.density, e.y * main.window.size.y() * main.window.density}; - mouse.set_pos(mouseNewPos); - touch.isDown = false; - mouse.leftDown = false; - - main.input_mouse_button_callback({ - .button = MouseButton::LEFT, - .down = false, - .clicks = 0, - .pos = mouseNewPos - }); - + touch_finger_do_mouse_up(e); touch.touchEventType = Touch::EVENT_DONE; break; } case Touch::TWO_FINGER_EVENT: { - touch.isDown = false; - main.input_multi_finger_touch_callback({ .down = false, .pos = get_multiple_finger_positions() }); - touch.touchEventType = Touch::EVENT_DONE; break; } @@ -731,6 +767,15 @@ void InputManager::backend_touch_finger_up_update(const SDL_TouchFingerEvent& e) break; } } + + main.input_finger_touch_callback({ + .fingerID = e.fingerID, + .down = false, + .pos = {e.x * main.window.size.x() * main.window.density, e.y * main.window.size.y() * main.window.density}, + .fingerDownCount = touch.fingers.size(), + .fingerTapCount = 0 + }); + std::erase_if(touch.fingers, [&e](auto& tE) { return e.fingerID == tE.fingerID; }); @@ -741,46 +786,13 @@ void InputManager::backend_touch_finger_up_update(const SDL_TouchFingerEvent& e) void InputManager::backend_touch_finger_motion_update(const SDL_TouchFingerEvent& e) { switch(touch.touchEventType) { case Touch::NO_TOUCH_EVENT: { - { - auto& prevTouch = touch.fingers[0]; - Vector2f mouseNewPos = {prevTouch.x * main.window.size.x() * main.window.density, prevTouch.y * main.window.size.y() * main.window.density}; - mouse.set_pos(mouseNewPos); - mouse.leftDown = true; - - if((std::chrono::steady_clock::now() - touch.lastLeftClickTime) > std::chrono::milliseconds(300)) - touch.leftClicksSaved = 0; - touch.leftClicksSaved++; - mouse.leftClicks = touch.leftClicksSaved; - touch.lastLeftClickTime = std::chrono::steady_clock::now(); - - main.input_mouse_button_callback({ - .button = MouseButton::LEFT, - .down = true, - .clicks = mouse.leftClicks, - .pos = mouseNewPos - }); - } - { - Vector2f mouseNewPos = {e.x * main.window.size.x() * main.window.density, e.y * main.window.size.y() * main.window.density}; - mouse.set_pos(mouseNewPos); - Vector2f mouseRel = {e.dx * main.window.size.x() * main.window.density, e.dy * main.window.size.y() * main.window.density}; - main.input_mouse_motion_callback({ - .pos = mouseNewPos, - .move = mouseRel - }); - } - + touch_finger_do_mouse_down(); + touch_finger_do_mouse_motion(e); touch.touchEventType = Touch::ONE_FINGER_EVENT; break; } case Touch::ONE_FINGER_EVENT: { - Vector2f mouseNewPos = {e.x * main.window.size.x() * main.window.density, e.y * main.window.size.y() * main.window.density}; - mouse.set_pos(mouseNewPos); - Vector2f mouseRel = {e.dx * main.window.size.x() * main.window.density, e.dy * main.window.size.y() * main.window.density}; - main.input_mouse_motion_callback({ - .pos = mouseNewPos, - .move = mouseRel - }); + touch_finger_do_mouse_motion(e); break; } case Touch::TWO_FINGER_EVENT: { @@ -801,6 +813,13 @@ void InputManager::backend_touch_finger_motion_update(const SDL_TouchFingerEvent } } + main.input_finger_motion_callback({ + .fingerID = e.fingerID, + .pos = {e.x * main.window.size.x() * main.window.density, e.y * main.window.size.y() * main.window.density}, + .move = {e.dx * main.window.size.x() * main.window.density, e.dy * main.window.size.y() * main.window.density}, + .fingerDownCount = touch.fingers.size() + }); + isTouchDevice = true; } @@ -1134,25 +1153,8 @@ void InputManager::Mouse::set_pos(const Vector2f& newPos) { } void InputManager::update() { - - if(touch.touchEventType == Touch::NO_TOUCH_EVENT && (SDL_GetTicksNS() - touch.fingers[0].timestamp) > (100 * 1000000)) { // 100ms to determine whether touch is with a single finger - auto& prevTouch = touch.fingers[0]; - Vector2f mouseNewPos = {prevTouch.x * main.window.size.x() * main.window.density, prevTouch.y * main.window.size.y() * main.window.density}; - mouse.set_pos(mouseNewPos); - mouse.leftDown = true; - - if((std::chrono::steady_clock::now() - touch.lastLeftClickTime) > std::chrono::milliseconds(300)) - touch.leftClicksSaved = 0; - touch.leftClicksSaved++; - mouse.leftClicks = touch.leftClicksSaved; - touch.lastLeftClickTime = std::chrono::steady_clock::now(); - - main.input_mouse_button_callback({ - .button = MouseButton::LEFT, - .down = true, - .clicks = mouse.leftClicks, - .pos = mouseNewPos - }); + if(touch.touchEventType == Touch::NO_TOUCH_EVENT && (SDL_GetTicksNS() - touch.fingers[0].timestamp) > (200 * 1000000)) { // 200ms to determine whether touch is with a single finger + touch_finger_do_mouse_down(); touch.touchEventType = Touch::ONE_FINGER_EVENT; } } diff --git a/src/InputManager.hpp b/src/InputManager.hpp index cdbed7a..598a03a 100644 --- a/src/InputManager.hpp +++ b/src/InputManager.hpp @@ -1,5 +1,6 @@ #pragma once #include +#include #include #include "RichText/TextStyleModifier.hpp" #include "RichText/TextBox.hpp" @@ -75,9 +76,10 @@ struct InputManager { } mouse; struct Touch { - bool isDown = false; int leftClicksSaved = 0; + int fingerTapsSaved = 0; std::chrono::steady_clock::time_point lastLeftClickTime; + std::chrono::steady_clock::time_point lastFingerTapTime; std::vector fingers; enum TypeOfTouchEvent { NO_TOUCH_EVENT, @@ -220,6 +222,9 @@ struct InputManager { void set_key_down(const SDL_KeyboardEvent& e, KeyCode kCode); std::vector get_multiple_finger_positions(); std::vector get_multiple_finger_motions(); + void touch_finger_do_mouse_down(); + void touch_finger_do_mouse_up(const SDL_TouchFingerEvent& f); + void touch_finger_do_mouse_motion(const SDL_TouchFingerEvent& f); void backend_drop_file_event(const SDL_DropEvent& e); void backend_drop_text_event(const SDL_DropEvent& e); @@ -269,7 +274,14 @@ struct InputManager { RIGHT } button; + enum class MouseDeviceType { + MOUSE, + PEN, + TOUCH + }; + struct MouseButtonCallbackArgs { + MouseDeviceType deviceType; MouseButton button; bool down; uint8_t clicks; @@ -277,6 +289,7 @@ struct InputManager { }; struct MouseMotionCallbackArgs { + MouseDeviceType deviceType; Vector2f pos; Vector2f move; }; @@ -316,16 +329,31 @@ struct InputManager { const char* data; }; - struct MultiFingerTouchArgs { + struct MultiFingerTouchCallbackArgs { bool down; std::vector pos; }; - struct MultiFingerMotionArgs { + struct MultiFingerMotionCallbackArgs { std::vector pos; std::vector move; }; + struct FingerTouchCallbackArgs { + SDL_FingerID fingerID; + bool down; + Vector2f pos; + size_t fingerDownCount; + int fingerTapCount; + }; + + struct FingerMotionCallbackArgs { + SDL_FingerID fingerID; + Vector2f pos; + Vector2f move; + size_t fingerDownCount; + }; + MainProgram& main; }; diff --git a/src/MainProgram.cpp b/src/MainProgram.cpp index 166ceec..f4d6ae4 100755 --- a/src/MainProgram.cpp +++ b/src/MainProgram.cpp @@ -350,16 +350,6 @@ void MainProgram::input_mouse_wheel_callback(const InputManager::MouseWheelCallb world->input_mouse_wheel_callback(wheel); } -void MainProgram::input_pure_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button) { - if(world) - world->input_pure_mouse_button_callback(button); -} - -void MainProgram::input_pure_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) { - if(world) - world->input_pure_mouse_motion_callback(motion); -} - void MainProgram::input_pen_button_callback(const InputManager::PenButtonCallbackArgs& button) { if(world) world->input_pen_button_callback(button); @@ -380,16 +370,24 @@ void MainProgram::input_pen_axis_callback(const InputManager::PenAxisCallbackArg world->input_pen_axis_callback(axis); } -void MainProgram::input_multi_finger_touch_callback(const InputManager::MultiFingerTouchArgs& touch) { +void MainProgram::input_multi_finger_touch_callback(const InputManager::MultiFingerTouchCallbackArgs& touch) { if(world) world->input_multi_finger_touch_callback(touch); } -void MainProgram::input_multi_finger_motion_callback(const InputManager::MultiFingerMotionArgs& motion) { +void MainProgram::input_multi_finger_motion_callback(const InputManager::MultiFingerMotionCallbackArgs& motion) { if(world) world->input_multi_finger_motion_callback(motion); } +void MainProgram::input_finger_touch_callback(const InputManager::FingerTouchCallbackArgs& touch) { + toolbar.input_finger_touch_callback(touch); +} + +void MainProgram::input_finger_motion_callback(const InputManager::FingerMotionCallbackArgs& motion) { + toolbar.input_finger_motion_callback(motion); +} + bool MainProgram::network_being_used() { for(auto& w : worlds) { if(w->netObjMan.is_connected()) diff --git a/src/MainProgram.hpp b/src/MainProgram.hpp index f3edccc..9c5dcbd 100644 --- a/src/MainProgram.hpp +++ b/src/MainProgram.hpp @@ -126,14 +126,14 @@ class MainProgram { void input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button); void input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion); void input_mouse_wheel_callback(const InputManager::MouseWheelCallbackArgs& wheel); - void input_pure_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button); - void input_pure_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion); void input_pen_button_callback(const InputManager::PenButtonCallbackArgs& button); void input_pen_touch_callback(const InputManager::PenTouchCallbackArgs& touch); void input_pen_motion_callback(const InputManager::PenMotionCallbackArgs& motion); void input_pen_axis_callback(const InputManager::PenAxisCallbackArgs& axis); - void input_multi_finger_touch_callback(const InputManager::MultiFingerTouchArgs& touch); - void input_multi_finger_motion_callback(const InputManager::MultiFingerMotionArgs& motion); + void input_multi_finger_touch_callback(const InputManager::MultiFingerTouchCallbackArgs& touch); + void input_multi_finger_motion_callback(const InputManager::MultiFingerMotionCallbackArgs& motion); + void input_finger_touch_callback(const InputManager::FingerTouchCallbackArgs& touch); + void input_finger_motion_callback(const InputManager::FingerMotionCallbackArgs& motion); ~MainProgram(); private: diff --git a/src/Toolbar.cpp b/src/Toolbar.cpp index e9efb3d..0d7bc40 100644 --- a/src/Toolbar.cpp +++ b/src/Toolbar.cpp @@ -2348,47 +2348,64 @@ void Toolbar::input_key_callback(const InputManager::KeyCallbackArgs& key) { } void Toolbar::input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button) { - io->mouse.globalPos = button.pos / final_gui_scale(); - if(button.down) { - switch(button.button) { - case InputManager::MouseButton::LEFT: { - io->mouse.leftClick = std::max(io->mouse.leftClick, button.clicks); - io->mouse.leftHeld = true; - break; + if(button.deviceType != InputManager::MouseDeviceType::TOUCH) { + io->mouse.globalPos = button.pos / final_gui_scale(); + if(button.down) { + switch(button.button) { + case InputManager::MouseButton::LEFT: { + io->mouse.leftClick = std::max(io->mouse.leftClick, button.clicks); + io->mouse.leftHeld = true; + break; + } + case InputManager::MouseButton::RIGHT: { + io->mouse.rightClick = std::max(io->mouse.rightClick, button.clicks); + io->mouse.rightHeld = true; + break; + } + default: + break; } - case InputManager::MouseButton::RIGHT: { - io->mouse.rightClick = std::max(io->mouse.rightClick, button.clicks); - io->mouse.rightHeld = true; - break; - } - default: - break; } - } - else { - switch(button.button) { - case InputManager::MouseButton::LEFT: { - io->mouse.leftHeld = false; - break; + else { + switch(button.button) { + case InputManager::MouseButton::LEFT: { + io->mouse.leftHeld = false; + break; + } + case InputManager::MouseButton::RIGHT: { + io->mouse.rightHeld = false; + break; + } + default: + break; } - case InputManager::MouseButton::RIGHT: { - io->mouse.rightHeld = false; - break; - } - default: - break; } } } void Toolbar::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) { - io->mouse.globalPos = motion.pos / final_gui_scale(); + if(motion.deviceType != InputManager::MouseDeviceType::TOUCH) + io->mouse.globalPos = motion.pos / final_gui_scale(); } void Toolbar::input_mouse_wheel_callback(const InputManager::MouseWheelCallbackArgs& wheel) { io->mouse.scroll = wheel.amount; } +void Toolbar::input_finger_touch_callback(const InputManager::FingerTouchCallbackArgs& touch) { + io->mouse.globalPos = touch.pos / final_gui_scale(); + if(touch.down) { + io->mouse.leftClick = std::max(io->mouse.leftClick, touch.fingerTapCount); + io->mouse.leftHeld = true; + } + else + io->mouse.leftHeld = false; +} + +void Toolbar::input_finger_motion_callback(const InputManager::FingerMotionCallbackArgs& motion) { + io->mouse.globalPos = motion.pos / final_gui_scale(); +} + void Toolbar::start_gui() { SDL_Rect windowRect; if(SDL_GetWindowSafeArea(main.window.sdlWindow, &windowRect)) { diff --git a/src/Toolbar.hpp b/src/Toolbar.hpp index 807ca93..6d1b93a 100644 --- a/src/Toolbar.hpp +++ b/src/Toolbar.hpp @@ -44,6 +44,8 @@ class Toolbar { void input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button); void input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion); void input_mouse_wheel_callback(const InputManager::MouseWheelCallbackArgs& wheel); + void input_finger_touch_callback(const InputManager::FingerTouchCallbackArgs& touch); + void input_finger_motion_callback(const InputManager::FingerMotionCallbackArgs& motion); void update(); void draw(SkCanvas* canvas); void color_selector_left(Vector4f* color); diff --git a/src/World.cpp b/src/World.cpp index 1f6768c..8be6410 100644 --- a/src/World.cpp +++ b/src/World.cpp @@ -295,16 +295,6 @@ void World::input_mouse_wheel_callback(const InputManager::MouseWheelCallbackArg drawData.cam.input_mouse_wheel_callback(*this, wheel); } -void World::input_pure_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button) { - if(!clientStillConnecting) - drawProg.input_pure_mouse_button_callback(button); -} - -void World::input_pure_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) { - if(!clientStillConnecting) - drawProg.input_pure_mouse_motion_callback(motion); -} - void World::input_pen_button_callback(const InputManager::PenButtonCallbackArgs& button) { if(!clientStillConnecting) drawProg.input_pen_button_callback(button); @@ -325,12 +315,12 @@ void World::input_pen_axis_callback(const InputManager::PenAxisCallbackArgs& axi drawProg.input_pen_axis_callback(axis); } -void World::input_multi_finger_touch_callback(const InputManager::MultiFingerTouchArgs& touch) { +void World::input_multi_finger_touch_callback(const InputManager::MultiFingerTouchCallbackArgs& touch) { if(!clientStillConnecting) drawData.cam.input_multi_finger_touch_callback(*this, touch); } -void World::input_multi_finger_motion_callback(const InputManager::MultiFingerMotionArgs& motion) { +void World::input_multi_finger_motion_callback(const InputManager::MultiFingerMotionCallbackArgs& motion) { if(!clientStillConnecting) drawData.cam.input_multi_finger_motion_callback(*this, motion); } diff --git a/src/World.hpp b/src/World.hpp index 27d371a..1bd41a2 100644 --- a/src/World.hpp +++ b/src/World.hpp @@ -107,14 +107,12 @@ class World { void input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button); void input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion); void input_mouse_wheel_callback(const InputManager::MouseWheelCallbackArgs& wheel); - void input_pure_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button); - void input_pure_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion); void input_pen_button_callback(const InputManager::PenButtonCallbackArgs& button); void input_pen_touch_callback(const InputManager::PenTouchCallbackArgs& touch); void input_pen_motion_callback(const InputManager::PenMotionCallbackArgs& motion); void input_pen_axis_callback(const InputManager::PenAxisCallbackArgs& axis); - void input_multi_finger_touch_callback(const InputManager::MultiFingerTouchArgs& touch); - void input_multi_finger_motion_callback(const InputManager::MultiFingerMotionArgs& motion); + void input_multi_finger_touch_callback(const InputManager::MultiFingerTouchCallbackArgs& touch); + void input_multi_finger_motion_callback(const InputManager::MultiFingerMotionCallbackArgs& motion); private: void load_empty_canvas();