sylar/OmniaFramework
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Streamlined the Signal System

Browse source
This commit is contained in:
OmniaX-Dev 2026-04-04 01:38:44 +02:00
parent 92089ed177
commit 41abab36aa
18 changed files with 127 additions and 248 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
other/build.nr
View file

@ -1 +1 @@
2040
2041

36
src/ogfx/gui/RawTextInput.cpp
View file

@ -28,20 +28,20 @@ namespace ogfx
{
RawTextInput::EventListener::EventListener(RawTextInput& _parent) : parent(_parent)
{
connectSignal(ostd::tBuiltinSignals::KeyPressed);
connectSignal(ostd::tBuiltinSignals::KeyReleased);
connectSignal(ostd::tBuiltinSignals::TextEntered);
connectSignal(ostd::tBuiltinSignals::MouseDragged);
connectSignal(ostd::tBuiltinSignals::MouseMoved);
connectSignal(ostd::tBuiltinSignals::MousePressed);
connectSignal(ostd::tBuiltinSignals::MouseReleased);
connectSignal(ostd::tBuiltinSignals::OnGuiEvent);
connectSignal(ostd::tBuiltinSignals::WindowResized);
connectSignal(ostd::BuiltinSignals::KeyPressed);
connectSignal(ostd::BuiltinSignals::KeyReleased);
connectSignal(ostd::BuiltinSignals::TextEntered);
connectSignal(ostd::BuiltinSignals::MouseDragged);
connectSignal(ostd::BuiltinSignals::MouseMoved);
connectSignal(ostd::BuiltinSignals::MousePressed);
connectSignal(ostd::BuiltinSignals::MouseReleased);
connectSignal(ostd::BuiltinSignals::OnGuiEvent);
connectSignal(ostd::BuiltinSignals::WindowResized);
}
void RawTextInput::EventListener::handleSignal(ostd::tSignal& signal)
void RawTextInput::EventListener::handleSignal(ostd::Signal& signal)
{
if (signal.ID == ostd::tBuiltinSignals::TextEntered)
if (signal.ID == ostd::BuiltinSignals::TextEntered)
{
if (m_lastEvent != eEventType::TextEntered)
{
@ -75,7 +75,7 @@ namespace ogfx
parent.m_cursorState = true;
}
}
else if (signal.ID == ostd::tBuiltinSignals::KeyPressed)
else if (signal.ID == ostd::BuiltinSignals::KeyPressed)
{
if (m_lastEvent != eEventType::KeyPressed)
{
@ -132,17 +132,17 @@ namespace ogfx
parent.m_keyRepeatCounter.start();
parent.m_lastKeyCode = data.keyCode;
ActionEventData aed(parent, parent.getName(), eActionEventType::Enter, ostd::BaseObject::InvalidRef());
ostd::SignalHandler::emitSignal(RawTextInput::actionEventSignalID, ostd::tSignalPriority::RealTime, aed);
ostd::SignalHandler::emitSignal(RawTextInput::actionEventSignalID, ostd::Signal::Priority::RealTime, aed);
}
else if (data.keyCode == SDLK_TAB)
{
parent.m_keyRepeatCounter.start();
parent.m_lastKeyCode = data.keyCode;
ActionEventData aed(parent, parent.getName(), eActionEventType::Tab, ostd::BaseObject::InvalidRef());
ostd::SignalHandler::emitSignal(RawTextInput::actionEventSignalID, ostd::tSignalPriority::RealTime, aed);
ostd::SignalHandler::emitSignal(RawTextInput::actionEventSignalID, ostd::Signal::Priority::RealTime, aed);
}
}
else if (signal.ID == ostd::tBuiltinSignals::MouseMoved)
else if (signal.ID == ostd::BuiltinSignals::MouseMoved)
{
auto& data = (ogfx::MouseEventData&)signal.userData;
if (parent.contains((float)data.position_x, (float)data.position_y))
@ -150,7 +150,7 @@ namespace ogfx
else
parent.m_mouseInside = false;
}
else if (signal.ID == ostd::tBuiltinSignals::MousePressed)
else if (signal.ID == ostd::BuiltinSignals::MousePressed)
{
auto& data = (ogfx::MouseEventData&)signal.userData;
if (data.button == ogfx::MouseEventData::eButton::Left && parent.m_gfx != nullptr && parent.m_mouseInside)
@ -284,9 +284,9 @@ namespace ogfx
void RawTextInputEventListener::onSignalHandled(ostd::tSignal& signal)
void RawTextInputEventListener::onSignalHandled(ostd::Signal& signal)
{
if (signal.ID == ostd::tBuiltinSignals::MouseMoved)
if (signal.ID == ostd::BuiltinSignals::MouseMoved)
{
auto& data = (ogfx::MouseEventData&)signal.userData;
if (getParent().isMouseInside())

6
src/ogfx/gui/RawTextInput.hpp
View file

@ -34,8 +34,8 @@ namespace ogfx
public: enum class eEventType { None = 0, TextEntered, KeyPressed, KeyReleased };
public:
EventListener(RawTextInput& _parent);
virtual void handleSignal(ostd::tSignal& signal) override;
inline virtual void onSignalHandled(ostd::tSignal& signal) { }
virtual void handleSignal(ostd::Signal& signal) override;
inline virtual void onSignalHandled(ostd::Signal& signal) { }
inline RawTextInput& getParent(void) { return parent; }
private:
@ -171,7 +171,7 @@ namespace ogfx
{
public:
inline RawTextInputEventListener(ogfx::gui::RawTextInput& _parent, ogfx::WindowCore& _window) : ogfx::gui::RawTextInput::EventListener::EventListener(_parent), window(_window) { }
void onSignalHandled(ostd::tSignal& signal) override;
void onSignalHandled(ostd::Signal& signal) override;
public:
ogfx::WindowCore& window;

73
src/ogfx/gui/Window.cpp
View file

@ -71,18 +71,18 @@ namespace ogfx
validate();
setSize(m_windowWidth, m_windowHeight);
connectSignal(ostd::tBuiltinSignals::KeyPressed);
connectSignal(ostd::tBuiltinSignals::KeyReleased);
connectSignal(ostd::tBuiltinSignals::TextEntered);
connectSignal(ostd::tBuiltinSignals::MousePressed);
connectSignal(ostd::tBuiltinSignals::MouseReleased);
connectSignal(ostd::tBuiltinSignals::MouseMoved);
connectSignal(ostd::tBuiltinSignals::MouseMoved);
connectSignal(ostd::tBuiltinSignals::OnGuiEvent);
connectSignal(ostd::tBuiltinSignals::WindowClosed);
connectSignal(ostd::tBuiltinSignals::WindowResized);
connectSignal(ostd::tBuiltinSignals::WindowFocused);
connectSignal(ostd::tBuiltinSignals::WindowLostFocus);
connectSignal(ostd::BuiltinSignals::KeyPressed);
connectSignal(ostd::BuiltinSignals::KeyReleased);
connectSignal(ostd::BuiltinSignals::TextEntered);
connectSignal(ostd::BuiltinSignals::MousePressed);
connectSignal(ostd::BuiltinSignals::MouseReleased);
connectSignal(ostd::BuiltinSignals::MouseMoved);
connectSignal(ostd::BuiltinSignals::MouseMoved);
connectSignal(ostd::BuiltinSignals::OnGuiEvent);
connectSignal(ostd::BuiltinSignals::WindowClosed);
connectSignal(ostd::BuiltinSignals::WindowResized);
connectSignal(ostd::BuiltinSignals::WindowFocused);
connectSignal(ostd::BuiltinSignals::WindowLostFocus);
__on_window_init(width, height, title);
}
@ -97,14 +97,14 @@ namespace ogfx
{
__on_window_close();
m_running = false;
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowClosed, ostd::tSignalPriority::Normal, *this);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowClosed, ostd::Signal::Priority::Normal, *this);
}
void WindowCore::setSize(int32_t width, int32_t height)
{
if (!isInitialized()) return;
SDL_SetWindowSize(m_window, width, height);
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowResized, ostd::tSignalPriority::RealTime);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowResized, ostd::Signal::Priority::RealTime);
}
void WindowCore::setTitle(const ostd::String& title)
@ -166,7 +166,7 @@ namespace ogfx
SDL_PushEvent(&e);
}
void WindowCore::handleSignal(ostd::tSignal& signal)
void WindowCore::handleSignal(ostd::Signal& signal)
{
__on_signal(signal);
}
@ -215,6 +215,7 @@ namespace ogfx
void WindowCore::after_render(void)
{
SDL_RenderPresent(m_renderer);
ostd::SignalHandler::handleDelegateSignals();
}
void WindowCore::__handle_event(SDL_Event& event)
@ -229,11 +230,11 @@ namespace ogfx
}
else if (event.type == SDL_EVENT_WINDOW_FOCUS_GAINED)
{
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowFocused, ostd::tSignalPriority::RealTime, *this);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowFocused, ostd::Signal::Priority::RealTime, *this);
}
else if (event.type == SDL_EVENT_WINDOW_FOCUS_LOST)
{
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowLostFocus, ostd::tSignalPriority::RealTime, *this);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowLostFocus, ostd::Signal::Priority::RealTime, *this);
}
else if (event.type == SDL_EVENT_WINDOW_RESIZED)
{
@ -241,17 +242,17 @@ namespace ogfx
SDL_GetWindowSize(m_window, &m_windowWidth, &m_windowHeight);
wrd.new_width = m_windowWidth;
wrd.new_height = m_windowHeight;
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowResized, ostd::tSignalPriority::RealTime, wrd);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowResized, ostd::Signal::Priority::RealTime, wrd);
}
else if (event.type == SDL_EVENT_MOUSE_MOTION)
{
MouseEventData mmd = get_mouse_state();
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::MouseMoved, ostd::tSignalPriority::RealTime, mmd);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::MouseMoved, ostd::Signal::Priority::RealTime, mmd);
}
else if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN)
{
MouseEventData mmd = get_mouse_state();
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::MousePressed, ostd::tSignalPriority::RealTime, mmd);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::MousePressed, ostd::Signal::Priority::RealTime, mmd);
}
else if (event.type == SDL_EVENT_MOUSE_BUTTON_UP)
{
@ -263,22 +264,22 @@ namespace ogfx
case SDL_BUTTON_MASK(3): mmd.button = MouseEventData::eButton::Right; break;
default: mmd.button = MouseEventData::eButton::None; break;
}
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::MouseReleased, ostd::tSignalPriority::RealTime, mmd);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::MouseReleased, ostd::Signal::Priority::RealTime, mmd);
}
else if (event.type == SDL_EVENT_KEY_DOWN)
{
KeyEventData ked(*this, (int32_t)event.key.key, 0, KeyEventData::eKeyEvent::Pressed);
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::KeyPressed, ostd::tSignalPriority::RealTime, ked);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::KeyPressed, ostd::Signal::Priority::RealTime, ked);
}
else if (event.type == SDL_EVENT_KEY_UP)
{
KeyEventData ked(*this, (int32_t)event.key.key, 0, KeyEventData::eKeyEvent::Released);
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::KeyReleased, ostd::tSignalPriority::RealTime, ked);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::KeyReleased, ostd::Signal::Priority::RealTime, ked);
}
else if (event.type == SDL_EVENT_TEXT_INPUT)
{
KeyEventData ked(*this, 0, event.text.text[0], KeyEventData::eKeyEvent::Text);
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::TextEntered, ostd::tSignalPriority::RealTime, ked);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::TextEntered, ostd::Signal::Priority::RealTime, ked);
}
__on_event(event);
}
@ -325,7 +326,7 @@ namespace ogfx
m_fpsUpdateTimer.update();
}
void GraphicsWindow::__on_signal(ostd::tSignal& signal)
void GraphicsWindow::__on_signal(ostd::Signal& signal)
{
onSignal(signal);
}
@ -384,54 +385,54 @@ namespace ogfx
}
}
void Window::__on_signal(ostd::tSignal& signal)
void Window::__on_signal(ostd::Signal& signal)
{
Event evt(*this);
if (signal.ID == ostd::tBuiltinSignals::WindowClosed)
if (signal.ID == ostd::BuiltinSignals::WindowClosed)
{
m_rootWidget.__onWindowClosed(evt);
}
else if (signal.ID == ostd::tBuiltinSignals::WindowFocused)
else if (signal.ID == ostd::BuiltinSignals::WindowFocused)
{
m_rootWidget.__onWIndowFocused(evt);
}
else if (signal.ID == ostd::tBuiltinSignals::WindowLostFocus)
else if (signal.ID == ostd::BuiltinSignals::WindowLostFocus)
{
m_rootWidget.__onWindowFocusLost(evt);
}
else if (signal.ID == ostd::tBuiltinSignals::WindowResized)
else if (signal.ID == ostd::BuiltinSignals::WindowResized)
{
evt.windowResized = &(ogfx::WindowResizedData&)signal.userData;
m_rootWidget.__onWindowResized(evt);
}
else if (signal.ID == ostd::tBuiltinSignals::MouseMoved)
else if (signal.ID == ostd::BuiltinSignals::MouseMoved)
{
evt.mouse = &(ogfx::MouseEventData&)signal.userData;
m_rootWidget.__onMouseMoved(evt);
}
else if (signal.ID == ostd::tBuiltinSignals::MousePressed)
else if (signal.ID == ostd::BuiltinSignals::MousePressed)
{
evt.mouse = &(ogfx::MouseEventData&)signal.userData;
m_rootWidget.__onMousePressed(evt);
}
else if (signal.ID == ostd::tBuiltinSignals::MouseReleased)
else if (signal.ID == ostd::BuiltinSignals::MouseReleased)
{
evt.mouse = &(ogfx::MouseEventData&)signal.userData;
m_rootWidget.__onMouseReleased(evt);
}
else if (signal.ID == ostd::tBuiltinSignals::KeyPressed)
else if (signal.ID == ostd::BuiltinSignals::KeyPressed)
{
evt.keyboard = &(ogfx::KeyEventData&)signal.userData;
m_rootWidget.__onKeyPressed(evt);
}
else if (signal.ID == ostd::tBuiltinSignals::KeyReleased)
else if (signal.ID == ostd::BuiltinSignals::KeyReleased)
{
evt.keyboard = &(ogfx::KeyEventData&)signal.userData;
m_rootWidget.__onKeyReleased(evt);
if (evt.keyboard->keyCode == SDLK_ESCAPE)
close();
}
else if (signal.ID == ostd::tBuiltinSignals::TextEntered)
else if (signal.ID == ostd::BuiltinSignals::TextEntered)
{
evt.keyboard = &(ogfx::KeyEventData&)signal.userData;
m_rootWidget.__onTextEntered(evt);

12
src/ogfx/gui/Window.hpp
View file

@ -49,7 +49,7 @@ namespace ogfx
void setIcon(const ostd::String& iconFilePath);
void setBlockingEventsRefreshFPS(uint32_t fps);
void requestRedraw(void);
void handleSignal(ostd::tSignal& signal) override;
void handleSignal(ostd::Signal& signal) override;
inline bool isInitialized(void) const { return m_initialized; }
inline bool isRunning(void) const { return m_running; }
@ -77,7 +77,7 @@ namespace ogfx
inline virtual void __on_window_init(int32_t width, int32_t height, const ostd::String& title) { }
inline virtual void __on_window_destroy(void) { }
inline virtual void __on_window_close(void) { }
inline virtual void __on_signal(ostd::tSignal& signal) { }
inline virtual void __on_signal(ostd::Signal& signal) { }
inline virtual void __main_loop(void) = 0;
private:
@ -126,7 +126,7 @@ namespace ogfx
inline virtual void onDestroy(void) { }
inline virtual void onClose(void) { }
inline virtual void onSDLEvent(SDL_Event& event) { }
inline virtual void onSignal(ostd::tSignal& signal) { }
inline virtual void onSignal(ostd::Signal& signal) { }
inline int32_t getFPS(void) const { return m_fps; }
@ -136,7 +136,7 @@ namespace ogfx
void __on_window_destroy(void) override;
void __on_window_close(void) override;
void __main_loop(void) override;
void __on_signal(ostd::tSignal& signal) override;
void __on_signal(ostd::Signal& signal) override;
private:
int32_t m_fps { 0 };
@ -161,7 +161,7 @@ namespace ogfx
inline virtual void onClose(void) { }
inline virtual void onSDLEvent(SDL_Event& event) { }
inline virtual void onRedraw(BasicRenderer2D& gfx) { }
inline virtual void onSignal(ostd::tSignal& signal) { }
inline virtual void onSignal(ostd::Signal& signal) { }
inline const gui::Theme& theme(void) const { return *m_guiTheme; }
void setTheme(const gui::Theme& theme);
@ -173,7 +173,7 @@ namespace ogfx
void __on_window_destroy(void) override;
void __on_window_close(void) override;
void __main_loop(void) override;
void __on_signal(ostd::tSignal& signal) override;
void __on_signal(ostd::Signal& signal) override;
private:
BasicRenderer2D m_gfx;

6
src/ogfx/render/FontUtils.cpp
View file

@ -26,14 +26,14 @@ namespace ogfx
TTFRenderer::SignalHandler::SignalHandler(TTFRenderer& parent) : m_parent(parent)
{
enableSignals();
connectSignal(ostd::tBuiltinSignals::BeforeSDLShutdown);
connectSignal(ostd::BuiltinSignals::BeforeSDLShutdown);
setTypeName("ostd::GraphicsWindowOutputHandler::SignalHandler");
validate();
}
void TTFRenderer::SignalHandler::handleSignal(ostd::tSignal& signal)
void TTFRenderer::SignalHandler::handleSignal(ostd::Signal& signal)
{
if (signal.ID == ostd::tBuiltinSignals::BeforeSDLShutdown)
if (signal.ID == ostd::BuiltinSignals::BeforeSDLShutdown)
{
m_parent.closeFont();
}

2
src/ogfx/render/FontUtils.hpp
View file

@ -32,7 +32,7 @@ namespace ogfx
{
public:
SignalHandler(TTFRenderer& parent);
void handleSignal(ostd::tSignal& signal) override;
void handleSignal(ostd::Signal& signal) override;
private:
TTFRenderer& m_parent;

6
src/ogfx/render/PixelRenderer.cpp
View file

@ -144,14 +144,14 @@ namespace ogfx
m_windowHeight = parent.getWindowHeight();
setTypeName("ogfx::PixelRenderer");
enableSignals();
connectSignal(ostd::tBuiltinSignals::WindowResized);
connectSignal(ostd::BuiltinSignals::WindowResized);
validate();
}
void PixelRenderer::handleSignal(ostd::tSignal& signal)
void PixelRenderer::handleSignal(ostd::Signal& signal)
{
if (isInvalid()) return;
if (signal.ID == ostd::tBuiltinSignals::WindowResized)
if (signal.ID == ostd::BuiltinSignals::WindowResized)
{
m_pixels = ostd::Memory::resizeArray<uint32_t>(m_pixels, m_parent->getWindowWidth() * m_parent->getWindowHeight());
SDL_DestroyTexture(m_texture);

2
src/ogfx/render/PixelRenderer.hpp
View file

@ -84,7 +84,7 @@ namespace ogfx
inline PixelRenderer(void) { invalidate(); }
~PixelRenderer(void);
void initialize(WindowCore& parent);
void handleSignal(ostd::tSignal& signal) override;
void handleSignal(ostd::Signal& signal) override;
void updateBuffer(void);
void displayBuffer(void);
inline uint32_t* getScreenPixels(void) { return m_pixels; }

2
src/ogfx/utils/SDLInclude.hpp
View file

@ -69,7 +69,7 @@ namespace ogfx
static inline void shutdown_sdl(void)
{
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::BeforeSDLShutdown, ostd:: tSignalPriority::RealTime);
ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::BeforeSDLShutdown, ostd:: Signal::Priority::RealTime);
TTF_Quit();
SDL_Quit();
}

6
src/ostd/data/BaseObject.cpp
View file

@ -9,7 +9,7 @@ namespace ostd
BaseObject::BaseObject(const BaseObject& copy)
{
m_uid = copy.m_uid;
m_oid = copy.m_oid;
m_oid = BaseObject::s_next_oid++;
m_valid = copy.m_valid;
m_typeName = copy.m_typeName;
m_signalsEnabled = copy.m_signalsEnabled;
@ -18,7 +18,7 @@ namespace ostd
BaseObject& BaseObject::operator=(const BaseObject& copy)
{
m_uid = copy.m_uid;
m_oid = copy.m_oid;
m_oid = BaseObject::s_next_oid++;
m_valid = copy.m_valid;
m_typeName = copy.m_typeName;
m_signalsEnabled = copy.m_signalsEnabled;
@ -52,7 +52,7 @@ namespace ostd
SignalHandler::connect(*this, signal_id);
}
void BaseObject::__handle_signal(tSignal& signal)
void BaseObject::__handle_signal(Signal& signal)
{
if (m_signalsEnabled)
handleSignal(signal);

6
src/ostd/data/BaseObject.hpp
View file

@ -27,7 +27,7 @@
namespace ostd
{
class OutputHandlerBase;
struct tSignal;
struct Signal;
class BaseObject
{
public:
@ -59,10 +59,10 @@ namespace ostd
virtual inline String toString(void) const { return getObjectHeaderString(); };
virtual void print(bool newLine = true, OutputHandlerBase* __destination = nullptr) const;
virtual inline void handleSignal(tSignal& signal) { }
virtual inline void handleSignal(Signal& signal) { }
void connectSignal(uint32_t signal_id);
void __handle_signal(tSignal& signal);
void __handle_signal(Signal& signal);
friend std::ostream& operator<<(std::ostream& os, const BaseObject& obj);

14
src/ostd/math/Spline.cpp
View file

@ -6,7 +6,7 @@ namespace ostd
{
}
void Spline::handleSignal(tSignal& signal)
void Spline::handleSignal(Signal& signal)
{
// if (!isEditable()) return;
// if (isUsingCustomEventHandler() && m_eventHandlerCallback)
@ -14,7 +14,7 @@ namespace ostd
// m_eventHandlerCallback(signal);
// return;
// }
// if (signal.ID == tBuiltinSignals::MousePressed)
// if (signal.ID == BuiltinSignals::MousePressed)
// {
// ogfx::MouseEventData& evt = static_cast<ogfx::MouseEventData&>(signal.userData);
// for (auto& node : m_points)
@ -26,13 +26,13 @@ namespace ostd
// }
// }
// }
// else if (signal.ID == tBuiltinSignals::MouseReleased)
// else if (signal.ID == BuiltinSignals::MouseReleased)
// {
// if (m_selectedNode != nullptr)
// updateTotalLength();
// m_selectedNode = nullptr;
// }
// else if (signal.ID == tBuiltinSignals::MouseMoved)
// else if (signal.ID == BuiltinSignals::MouseMoved)
// {
// ogfx::MouseEventData& evt = static_cast<ogfx::MouseEventData&>(signal.userData);
// if (m_selectedNode != nullptr)
@ -140,9 +140,9 @@ namespace ostd
void Spline::connectSignals(void)
{
if (m_signalsConnected) return;
connectSignal(tBuiltinSignals::MouseMoved);
connectSignal(tBuiltinSignals::MousePressed);
connectSignal(tBuiltinSignals::MouseReleased);
connectSignal(BuiltinSignals::MouseMoved);
connectSignal(BuiltinSignals::MousePressed);
connectSignal(BuiltinSignals::MouseReleased);
m_signalsConnected = true;
}

4
src/ostd/math/Spline.hpp
View file

@ -35,12 +35,12 @@ namespace ostd
class Spline : public BaseObject
{
public:
using EventHandlerCallback = std::function<void(tSignal&)>;
using EventHandlerCallback = std::function<void(Signal&)>;
using DrawCallback = std::function<void(float resolution, float lineWidth, float controlPointSize)>;
public:
Spline(void);
void handleSignal(tSignal& signal) override;
void handleSignal(Signal& signal) override;
tSplineNode getPoint(float t);
tSplineNode getGradient(float t);
float updateSegmentLength(int32_t node);

122
src/ostd/utils/Signals.cpp
View file

@ -1,136 +1,44 @@
#include "Signals.hpp"
#include "../data/BaseObject.hpp"
#include "../io/Logger.hpp"
namespace ostd
{
void SignalHandler::init(bool allow_reinit)
{
if (m_initialized && !allow_reinit) return;
SignalHandler::m_customRecievers.clear();
SignalHandler::m_customRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_mousePressedRecievers.clear();
SignalHandler::m_mousePressedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_mouseReleasedRecievers.clear();
SignalHandler::m_mouseReleasedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_keyPressedRecievers.clear();
SignalHandler::m_keyPressedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_keyReleasedRecievers.clear();
SignalHandler::m_keyReleasedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_mouseMovedRecievers.clear();
SignalHandler::m_mouseMovedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_mouseDraggedRecievers.clear();
SignalHandler::m_mouseDraggedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_textEnteredRecievers.clear();
SignalHandler::m_textEnteredRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_windowResizedRecievers.clear();
SignalHandler::m_windowResizedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_windowClosedRecievers.clear();
SignalHandler::m_windowClosedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_windowFocusedRecievers.clear();
SignalHandler::m_windowFocusedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_windowLostFocusRecievers.clear();
SignalHandler::m_windowLostFocusRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_delegatedSignals.clear();
SignalHandler::m_delegatedSignals.reserve(SignalHandler::__DELEGATED_SIGNALS_BUFFER_START_SIZE);
SignalHandler::m_onGuiEventRecievers.clear();
SignalHandler::m_onGuiEventRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_beforeSDLShutdownRecievers.clear();
SignalHandler::m_beforeSDLShutdownRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
m_recievers.clear();
m_recievers.reserve(__SIGNAL_BUFFER_START_SIZE);
m_DelegateRecievers.clear();
m_DelegateRecievers.reserve(__DELEGATE_SIGNALS_BUFFER_START_SIZE);
m_initialized = true;
}
void SignalHandler::refresh(void)
void SignalHandler::handleDelegateSignals(void)
{
for (auto& ds : SignalHandler::m_delegatedSignals)
SignalHandler::emitSignal(ds.id, tSignalPriority::RealTime, ds.ud);
SignalHandler::m_delegatedSignals.clear();
//m_delegatedSignals.reserve(__DELEGATED_SIGNALS_BUFFER_START_SIZE);
for (auto& delegate : m_DelegateRecievers)
emitSignal(delegate.id, Signal::Priority::RealTime, delegate.ud);
m_DelegateRecievers.clear();
}
void SignalHandler::emitSignal(uint32_t signal_id, uint8_t prio, BaseObject& userData)
{
if (prio == tSignalPriority::Normal)
if (prio == Signal::Priority::Normal)
{
SignalHandler::m_delegatedSignals.push_back({ signal_id, userData });
SignalHandler::m_DelegateRecievers.push_back({ signal_id, userData });
return;
}
tSignal signal { signal_id, userData, prio };
std::vector<tSignalObjPair>* sig_list = nullptr;
if (signal_id == tBuiltinSignals::MousePressed)
sig_list = &m_mousePressedRecievers;
else if (signal_id == tBuiltinSignals::MouseReleased)
sig_list = &m_mouseReleasedRecievers;
else if (signal_id == tBuiltinSignals::KeyPressed)
sig_list = &m_keyPressedRecievers;
else if (signal_id == tBuiltinSignals::KeyReleased)
sig_list = &m_keyReleasedRecievers;
else if (signal_id == tBuiltinSignals::MouseMoved)
sig_list = &m_mouseMovedRecievers;
else if (signal_id == tBuiltinSignals::MouseDragged)
sig_list = &m_mouseDraggedRecievers;
else if (signal_id == tBuiltinSignals::TextEntered)
sig_list = &m_textEnteredRecievers;
else if (signal_id == tBuiltinSignals::WindowResized)
sig_list = &m_windowResizedRecievers;
else if (signal_id == tBuiltinSignals::WindowClosed)
sig_list = &m_windowClosedRecievers;
else if (signal_id == tBuiltinSignals::WindowLostFocus)
sig_list = &m_windowLostFocusRecievers;
else if (signal_id == tBuiltinSignals::WindowFocused)
sig_list = &m_windowFocusedRecievers;
else if (signal_id == tBuiltinSignals::OnGuiEvent)
sig_list = &m_onGuiEventRecievers;
else if (signal_id == tBuiltinSignals::BeforeSDLShutdown)
sig_list = &m_beforeSDLShutdownRecievers;
else if (signal_id > tBuiltinSignals::CustomSignalBase)
sig_list = &m_customRecievers;
if (sig_list == nullptr)
{
OX_WARN("ox::SignalHandler::emitSignal(...): Unknown signal ID: <%d>", signal_id);
Signal signal { signal_id, userData, prio };
if (m_recievers.count(signal_id) < 1)
return;
}
for (auto& sop : *sig_list)
for (auto& obj : m_recievers[signal_id])
{
if (sop.signal_id == signal_id)
{
sop.object->__handle_signal(signal);
obj->__handle_signal(signal);
if (signal.handled) return;
}
}
}
void SignalHandler::connect(BaseObject& object, uint32_t signal_id)
{
if (signal_id == tBuiltinSignals::MousePressed)
m_mousePressedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::MouseReleased)
m_mouseReleasedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::KeyPressed)
m_keyPressedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::KeyReleased)
m_keyReleasedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::MouseMoved)
m_mouseMovedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::MouseDragged)
m_mouseDraggedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::TextEntered)
m_textEnteredRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::WindowResized)
m_windowResizedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::WindowClosed)
m_windowClosedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::WindowLostFocus)
m_windowLostFocusRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::WindowFocused)
m_windowFocusedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::OnGuiEvent)
m_onGuiEventRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::BeforeSDLShutdown)
m_beforeSDLShutdownRecievers.push_back({ &object, signal_id });
else if (signal_id > tBuiltinSignals::CustomSignalBase)
m_customRecievers.push_back({ &object, signal_id });
else
OX_WARN("ox::SignalHandler::connect(...): Unknown signal ID: <%d>", signal_id);
m_recievers[signal_id].push_back(&object);
}
}

60
src/ostd/utils/Signals.hpp
View file

@ -22,15 +22,12 @@
#include <ostd/data/Types.hpp>
#include <ostd/data/BaseObject.hpp>
#include <unordered_map>
#include <vector>
namespace ostd
{
//INFO: (Note to self) When adding new Builtin signals, the corresponding static list must
// be addeed to the ox::SignalHandler class, and the appropriate branch must be added
// to the ox::SignalHandler::emitSignal and the ox::SignalHandler::connect functions.
// Also, correct initialization in the ox::SignalHandler::init function must be added
struct tBuiltinSignals
struct BuiltinSignals
{
inline static constexpr uint32_t NoSignal = 0x0000;
@ -56,68 +53,41 @@ namespace ostd
inline static constexpr uint32_t CustomSignalBase = 0xFF0000;
};
struct tSignalPriority
struct Signal
{
struct Priority
{
inline static constexpr uint8_t RealTime = 0;
inline static constexpr uint8_t Normal = 1;
};
struct tSignal
{
const uint8_t priority;
const uint32_t ID;
bool handled { false };
BaseObject& userData;
inline tSignal(uint32_t id, BaseObject& _userData = BaseObject::InvalidRef(), uint8_t prio = tSignalPriority::Normal) : priority(prio), ID(id), userData(_userData) { }
inline Signal(uint32_t id, BaseObject& _userData = BaseObject::InvalidRef(), uint8_t prio = Signal::Priority::Normal) : priority(prio), ID(id), userData(_userData) { }
};
class SignalHandler
{
private: struct tSignalObjPair
{
BaseObject* object { nullptr };
uint32_t signal_id { tBuiltinSignals::NoSignal };
};
private: struct tDelegateSignal
private: struct DelegateSignal
{
uint32_t id;
BaseObject& ud;
inline tDelegateSignal(uint32_t _id, BaseObject& _ud) : id(_id), ud(_ud) { }
inline DelegateSignal(uint32_t _id, BaseObject& _ud) : id(_id), ud(_ud) { }
};
public:
static void init(bool allow_reinit = false);
static void refresh(void);
static void emitSignal(uint32_t signal_id, uint8_t prio = tSignalPriority::Normal, BaseObject& userData = BaseObject::InvalidRef());
static void handleDelegateSignals(void);
static void emitSignal(uint32_t signal_id, uint8_t prio = Signal::Priority::RealTime, BaseObject& userData = BaseObject::InvalidRef());
static void connect(BaseObject& object, uint32_t signal_id);
inline static uint32_t newCustomSignal(uint32_t sub_id) { return tBuiltinSignals::CustomSignalBase + sub_id; }
inline static uint32_t newCustomSignal(uint32_t sub_id) { return BuiltinSignals::CustomSignalBase + sub_id; }
private:
inline static std::vector<tSignalObjPair> m_customRecievers;
inline static std::vector<tDelegateSignal> m_delegatedSignals;
/** Builtin signal recievers lists **/
inline static std::vector<tSignalObjPair> m_mousePressedRecievers;
inline static std::vector<tSignalObjPair> m_mouseReleasedRecievers;
inline static std::vector<tSignalObjPair> m_keyPressedRecievers;
inline static std::vector<tSignalObjPair> m_keyReleasedRecievers;
inline static std::vector<tSignalObjPair> m_mouseMovedRecievers;
inline static std::vector<tSignalObjPair> m_mouseDraggedRecievers;
inline static std::vector<tSignalObjPair> m_textEnteredRecievers;
inline static std::vector<tSignalObjPair> m_windowResizedRecievers;
inline static std::vector<tSignalObjPair> m_windowClosedRecievers;
inline static std::vector<tSignalObjPair> m_windowFocusedRecievers;
inline static std::vector<tSignalObjPair> m_windowLostFocusRecievers;
inline static std::vector<tSignalObjPair> m_onGuiEventRecievers;
inline static std::vector<tSignalObjPair> m_beforeSDLShutdownRecievers;
/************************************/
inline static constexpr uint16_t __SIGNAL_BUFFER_START_SIZE { 128 };
inline static constexpr uint16_t __DELEGATED_SIGNALS_BUFFER_START_SIZE { 128 };
inline static std::unordered_map<uint32_t, std::vector<BaseObject*>> m_recievers;
inline static std::vector<DelegateSignal> m_DelegateRecievers;
inline static constexpr uint16_t __SIGNAL_BUFFER_START_SIZE { 2048 };
inline static constexpr uint16_t __DELEGATE_SIGNALS_BUFFER_START_SIZE { 2048 };
inline static bool m_initialized { false };
};
}

4
src/test/GraphicsWindowTest.cpp
View file

@ -41,9 +41,9 @@ class Window : public ogfx::GraphicsWindow
m_textInput.getTheme().extraPaddingTop = 3;
}
inline void handleSignal(ostd::tSignal& signal) override
inline void handleSignal(ostd::Signal& signal) override
{
if (signal.ID == ostd::tBuiltinSignals::KeyReleased)
if (signal.ID == ostd::BuiltinSignals::KeyReleased)
{
auto& evtData = (ogfx::KeyEventData&)signal.userData;
if (evtData.keyCode == SDLK_ESCAPE)

4
src/test/GuiTest.cpp
View file

@ -66,9 +66,9 @@ class Window : public ogfx::gui::Window
setTheme(m_theme);
}
inline void onSignal(ostd::tSignal& signal) override
inline void onSignal(ostd::Signal& signal) override
{
if (signal.ID == ostd::tBuiltinSignals::KeyReleased)
if (signal.ID == ostd::BuiltinSignals::KeyReleased)
{
auto& evtData = (ogfx::KeyEventData&)signal.userData;
if (evtData.keyCode == SDLK_ESCAPE)