reflexion 0.3.14 → 0.3.15

data/src/osx/device.mm

@@ -9,11 +9,14 @@ namespace Reflex
 {
 
 
+	#pragma GCC diagnostic push
+	#pragma GCC diagnostic ignored "-Wmissing-noreturn"
 	void
 	vibrate ()
 	{
 		not_implemented_error(__FILE__, __LINE__);
 	}
+	#pragma GCC diagnostic pop
 
 
 }// Reflex

data/src/sdl/application.cpp

@@ -2,6 +2,9 @@
 
 
 #include <SDL.h>
+#ifdef WASM
+	#include <emscripten.h>
+#endif
 #include <xot/time.h>
 #include "reflex/exception.h"
 #include "reflex/debug.h"
@@ -51,8 +54,8 @@ namespace Reflex
 		return Window_dispatch_event(win, event);
 	}
 
-	static bool
-	dispatch_events ()
+	static void
+	dispatch_events (Application* app)
 	{
 		SDL_Event event;
 		while (SDL_PollEvent(&event))
@@ -60,13 +63,9 @@ namespace Reflex
 			if (dispatch_window_event(event))
 				continue;
 
-			switch (event.type)
-			{
-				case SDL_QUIT: return false;
-			}
+			if (event.type == SDL_QUIT)
+				app->quit();
 		}
-
-		return true;
 	}
 
 	static void
@@ -76,18 +75,15 @@ namespace Reflex
 			Window_update(it->get());
 	}
 
-	void
-	Application::start ()
+	static void
+	main_loop (Application* app)
 	{
-		Event e;
-		Application_call_start(this, &e);
-
-		ApplicationData* self = get_data(this);
+		ApplicationData* self = get_data(app);
 
 		double prev = Xot::time();
 		while (!self->quit)
 		{
-			if (!dispatch_events()) break;
+			dispatch_events(app);
 
 			static const double INTERVAL  = 1.0 / 60.0;
 			static const double SLEEPABLE = INTERVAL * 0.9;
@@ -100,11 +96,39 @@ namespace Reflex
 				continue;
 			}
 
-			update_all_windows(this);
+			update_all_windows(app);
 			prev = now;
 		}
 	}
 
+#ifdef WASM
+	static void
+	emscripten_main_loop (void* arg)
+	{
+		Application* app = (Application*) arg;
+
+		dispatch_events(app);
+
+		if (get_data(app)->quit)
+			emscripten_cancel_main_loop();
+		else
+			update_all_windows(app);
+	}
+#endif
+
+	void
+	Application::start ()
+	{
+		Event e;
+		Application_call_start(this, &e);
+
+#ifdef WASM
+		emscripten_set_main_loop_arg(emscripten_main_loop, this, 0, true);
+#else
+		main_loop(this);
+#endif
+	}
+
 	void
 	Application::quit ()
 	{

data/src/sdl/event.cpp

@@ -0,0 +1,176 @@
+// -*- c++ -*-
+#include "event.h"
+
+
+#include "reflex/exception.h"
+#include "reflex/debug.h"
+
+
+namespace Reflex
+{
+
+
+	static uint
+	get_modifiers (SDL_Keymod mod)
+	{
+		uint ret = 0;
+		if (mod & KMOD_CAPS)   ret |= MOD_CAPS;
+		if (mod & KMOD_SHIFT)  ret |= MOD_SHIFT;
+		if (mod & KMOD_CTRL)   ret |= MOD_CONTROL;
+		if (mod & KMOD_ALT)    ret |= MOD_ALT;
+		if (mod & KMOD_GUI)    ret |= MOD_WIN;
+		if (mod & KMOD_NUM)    ret |= MOD_NUMPAD;
+		if (mod & KMOD_SCROLL) ret |= MOD_SCROLL;
+		return ret;
+	}
+
+	uint
+	KeyEvent_get_modifiers ()
+	{
+		return get_modifiers(SDL_GetModState());
+	}
+
+
+	static const char*
+	get_chars (const SDL_KeyboardEvent& e)
+	{
+		static char buf[2] = {0};
+
+		const char* name = SDL_GetKeyName(e.keysym.sym);
+		if (name && strlen(name) == 1)
+		{
+			if (e.keysym.mod & KMOD_SHIFT)
+				buf[0] = name[0];
+			else
+				buf[0] = tolower(name[0]);
+			return buf;
+		}
+
+		switch (e.keysym.sym)
+		{
+			case SDLK_RETURN:    buf[0] = '\r'; break;
+			case SDLK_TAB:       buf[0] = '\t'; break;
+			case SDLK_BACKSPACE: buf[0] = '\b'; break;
+			case SDLK_DELETE:    buf[0] = 0x7f; break;
+			case SDLK_ESCAPE:    buf[0] = 0x1b; break;
+			case SDLK_SPACE:     buf[0] = ' ';  break;
+			default:             buf[0] = '\0'; break;
+		}
+		return buf;
+	}
+
+	NativeKeyEvent::NativeKeyEvent (const SDL_KeyboardEvent& e, Action action)
+	:	KeyEvent(
+			action,
+			get_chars(e),
+			(KeyCode) e.keysym.scancode,
+			get_modifiers((SDL_Keymod) e.keysym.mod),
+			e.repeat ? 1 : 0)
+	{
+	}
+
+
+	static uint
+	get_pointer_type (Uint8 button)
+	{
+		uint type = Pointer::MOUSE;
+		switch (button)
+		{
+			case SDL_BUTTON_LEFT:   type |= Pointer::MOUSE_LEFT;   break;
+			case SDL_BUTTON_RIGHT:  type |= Pointer::MOUSE_RIGHT;  break;
+			case SDL_BUTTON_MIDDLE: type |= Pointer::MOUSE_MIDDLE; break;
+		}
+		return type;
+	}
+
+	static uint
+	get_current_pointer_type (Uint32 state)
+	{
+		uint type = Pointer::MOUSE;
+		if (state & SDL_BUTTON_LMASK) type |= Pointer::MOUSE_LEFT;
+		if (state & SDL_BUTTON_RMASK) type |= Pointer::MOUSE_RIGHT;
+		if (state & SDL_BUTTON_MMASK) type |= Pointer::MOUSE_MIDDLE;
+		return type;
+	}
+
+	NativePointerEvent::NativePointerEvent (
+		const SDL_MouseButtonEvent& e, SDL_Window* window, Pointer::Action action)
+	{
+		PointerEvent_add_pointer(this, Pointer(
+			0,
+			get_pointer_type(e.button),
+			action,
+			Point(e.x, e.y),
+			get_modifiers(SDL_GetModState()),
+			(uint) e.clicks,
+			false,
+			time()));
+	}
+
+	NativePointerEvent::NativePointerEvent (
+		const SDL_MouseMotionEvent& e, SDL_Window* window)
+	{
+		PointerEvent_add_pointer(this, Pointer(
+			0,
+			get_current_pointer_type(e.state),
+			Pointer::MOVE,
+			Point(e.x, e.y),
+			get_modifiers(SDL_GetModState()),
+			0,
+			e.state & (SDL_BUTTON_LMASK | SDL_BUTTON_RMASK | SDL_BUTTON_MMASK),
+			time()));
+	}
+
+	NativePointerEvent::NativePointerEvent (
+		const SDL_TouchFingerEvent& e, SDL_Window* window, Pointer::Action action)
+	{
+		uint mods = get_modifiers(SDL_GetModState());
+		double t  = time();
+
+		int w = 0, h = 0;
+		if (window) SDL_GetWindowSize(window, &w, &h);
+
+		PointerEvent_add_pointer(this, Pointer(
+			(uint) e.fingerId,
+			Pointer::TOUCH,
+			action,
+			Point(e.x * w, e.y * h),
+			mods,
+			0,
+			action == Pointer::MOVE,
+			t));
+
+		int size = SDL_GetNumTouchFingers(e.touchId);
+		for (int i = 0; i < size; ++i)
+		{
+			SDL_Finger* finger = SDL_GetTouchFinger(e.touchId, i);
+			if (!finger || finger->id == e.fingerId) continue;
+			PointerEvent_add_pointer(this, Pointer(
+				(uint) finger->id,
+				Pointer::TOUCH,
+				Pointer::STAY,
+				Point(finger->x * w, finger->y * h),
+				mods,
+				0,
+				true,
+				t));
+		}
+	}
+
+
+	NativeWheelEvent::NativeWheelEvent (
+		const SDL_MouseWheelEvent& e, SDL_Window* window)
+	:	WheelEvent(
+			0, 0, 0,
+			e.direction == SDL_MOUSEWHEEL_FLIPPED ? -e.preciseX : e.preciseX,
+			e.direction == SDL_MOUSEWHEEL_FLIPPED ? -e.preciseY : e.preciseY,
+			0,
+			get_modifiers(SDL_GetModState()))
+	{
+		int mx, my;
+		SDL_GetMouseState(&mx, &my);
+		WheelEvent_set_position(this, Point(mx, my));
+	}
+
+
+}// Reflex

data/src/sdl/event.h

@@ -0,0 +1,58 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_SDL_EVENT_H__
+#define __REFLEX_SRC_SDL_EVENT_H__
+
+
+#include <SDL.h>
+#include "../event.h"
+
+
+namespace Reflex
+{
+
+
+	class NativeKeyEvent : public KeyEvent
+	{
+
+		public:
+
+			NativeKeyEvent (const SDL_KeyboardEvent& event, Action action);
+
+	};// NativeKeyEvent
+
+
+	class NativePointerEvent : public PointerEvent
+	{
+
+		public:
+
+			NativePointerEvent (
+				const SDL_MouseButtonEvent& event, SDL_Window* window,
+				Pointer::Action action);
+
+			NativePointerEvent (
+				const SDL_MouseMotionEvent& event, SDL_Window* window);
+
+			NativePointerEvent (
+				const SDL_TouchFingerEvent& event, SDL_Window* window,
+				Pointer::Action action);
+
+	};// NativePointerEvent
+
+
+	class NativeWheelEvent : public WheelEvent
+	{
+
+		public:
+
+			NativeWheelEvent (
+				const SDL_MouseWheelEvent& event, SDL_Window* window);
+
+	};// NativeWheelEvent
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/sdl/window.cpp

@@ -5,6 +5,7 @@
 #include "reflex/debug.h"
 #include "reflex/screen.h"
 #include "../view.h"
+#include "event.h"
 #include "screen.h"
 #include "opengl.h"
 
@@ -68,7 +69,7 @@ namespace Reflex
 
 		Uint32 to_sdl_flags (uint flags)
 		{
-			Uint32 sdl_flags = SDL_WINDOW_OPENGL;
+			Uint32 sdl_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI;
 
 			if (Xot::has_flag(flags, Window::FLAG_RESIZABLE))
 				sdl_flags |= SDL_WINDOW_RESIZABLE;
@@ -298,15 +299,16 @@ namespace Reflex
 			return 1;
 
 		SDL_Window* native = get_native(const_cast<Window*>(&win));
-		int display_index  = SDL_GetWindowDisplayIndex(native);
-		if (display_index < 0)
+		if (!native)
 			return 1;
 
-		float dpi = 0;
-		if (SDL_GetDisplayDPI(display_index, &dpi, NULL, NULL) != 0)
+		int win_w = 0, draw_w = 0;
+		SDL_GetWindowSize(     native, &win_w,  NULL);
+		SDL_GL_GetDrawableSize(native, &draw_w, NULL);
+		if (win_w <= 0 || draw_w <= 0)
 			return 1;
 
-		return dpi / 96.f;
+		return (float) draw_w / (float) win_w;
 	}
 
 	Window*
@@ -318,32 +320,111 @@ namespace Reflex
 	bool
 	Window_dispatch_event (Window* win, const SDL_Event& event)
 	{
-		if (event.type != SDL_WINDOWEVENT) return true;
-
 		WindowData* self = get_data(win);
 
-		switch (event.window.event)
+		switch (event.type)
 		{
-			case SDL_WINDOWEVENT_CLOSE:
-				Window_close(win);
+			case SDL_WINDOWEVENT:
+			{
+				switch (event.window.event)
+				{
+					case SDL_WINDOWEVENT_CLOSE:
+						Window_close(win);
+						break;
+
+					case SDL_WINDOWEVENT_EXPOSED:
+						self->context.make_current();
+						draw(win);
+						self->context.swap_buffers();
+						break;
+
+					case SDL_WINDOWEVENT_MOVED:
+					case SDL_WINDOWEVENT_RESIZED:
+					case SDL_WINDOWEVENT_SIZE_CHANGED:
+					case SDL_WINDOWEVENT_RESTORED:
+					case SDL_WINDOWEVENT_MAXIMIZED:
+					case SDL_WINDOWEVENT_MINIMIZED:
+						frame_changed(win);
+						break;
+
+					case SDL_WINDOWEVENT_FOCUS_GAINED:
+						Window_call_activate_event(win);
+						break;
+
+					case SDL_WINDOWEVENT_FOCUS_LOST:
+						Window_call_deactivate_event(win);
+						break;
+				}
 				break;
+			}
+
+			case SDL_KEYDOWN:
+			{
+				NativeKeyEvent e(event.key, KeyEvent::DOWN);
+				Window_call_key_event(win, &e);
+				break;
+			}
 
-			case SDL_WINDOWEVENT_EXPOSED:
+			case SDL_KEYUP:
 			{
-				self->context.make_current();
-				draw(win);
-				self->context.swap_buffers();
+				NativeKeyEvent e(event.key, KeyEvent::UP);
+				Window_call_key_event(win, &e);
 				break;
 			}
 
-			case SDL_WINDOWEVENT_MOVED:
-			case SDL_WINDOWEVENT_RESIZED:
-			case SDL_WINDOWEVENT_SIZE_CHANGED:
-			case SDL_WINDOWEVENT_RESTORED:
-			case SDL_WINDOWEVENT_MAXIMIZED:
-			case SDL_WINDOWEVENT_MINIMIZED:
-				frame_changed(win);
+			case SDL_MOUSEBUTTONDOWN:
+			{
+				NativePointerEvent e(
+					event.button, self->native, Pointer::DOWN);
+				Window_call_pointer_event(win, &e);
+				break;
+			}
+
+			case SDL_MOUSEBUTTONUP:
+			{
+				NativePointerEvent e(
+					event.button, self->native, Pointer::UP);
+				Window_call_pointer_event(win, &e);
+				break;
+			}
+
+			case SDL_MOUSEMOTION:
+			{
+				NativePointerEvent e(event.motion, self->native);
+				Window_call_pointer_event(win, &e);
 				break;
+			}
+
+			case SDL_MOUSEWHEEL:
+			{
+				NativeWheelEvent e(event.wheel, self->native);
+				Window_call_wheel_event(win, &e);
+				break;
+			}
+
+			case SDL_FINGERDOWN:
+			{
+				NativePointerEvent e(event.tfinger, self->native, Pointer::DOWN);
+				Window_call_pointer_event(win, &e);
+				break;
+			}
+
+			case SDL_FINGERUP:
+			{
+				NativePointerEvent e(event.tfinger, self->native, Pointer::UP);
+				Window_call_pointer_event(win, &e);
+				break;
+			}
+
+			case SDL_FINGERMOTION:
+			{
+				NativePointerEvent e(event.tfinger, self->native, Pointer::MOVE);
+				Window_call_pointer_event(win, &e);
+				break;
+			}
+
+			default:
+				return false;
 		}
 
 		return true;

data/src/shape.cpp

@@ -852,7 +852,7 @@ namespace Reflex
 				b2points[i] = to_b2vec2(polyline[i], ppm);
 
 			b2PolygonShape b2shape;
-			b2shape.Set(&b2points[0], polyline.size());
+			b2shape.Set(&b2points[0], (int32) polyline.size());
 
 			return FixtureBuilder(shape, &b2shape).fixtures();
 		}
@@ -1213,12 +1213,6 @@ namespace Reflex
 		return (WallShapeData&) *shape.self;
 	}
 
-	static const WallShapeData&
-	get_data (const WallShape& shape)
-	{
-		return get_data(const_cast<WallShape&>(shape));
-	}
-
 
 	WallShape::WallShape (uint positions, coord thickness)
 	:	Super(new WallShapeData)

data/src/style.cpp

@@ -321,7 +321,7 @@ namespace Reflex
 
 		bool set_flow (Flow main, Flow sub)
 		{
-			return flow.set((main & FLOW_MASK) | ((sub & FLOW_MASK) << FLOW_SHIFT));
+			return flow.set(((int) main & FLOW_MASK) | (((int) sub & FLOW_MASK) << FLOW_SHIFT));
 		}
 
 		Flow flow_main () const

data/src/timer.cpp

@@ -268,6 +268,8 @@ namespace Reflex
 			timers.pop_front();
 	}
 
+	#pragma GCC diagnostic push
+	#pragma GCC diagnostic ignored "-Wmissing-noreturn"
 	void
 	Timers::find_timers (
 		TimerList* result, const Selector& selector, bool recursive) const
@@ -277,6 +279,7 @@ namespace Reflex
 
 		not_implemented_error(__FILE__, __LINE__);
 	}
+	#pragma GCC diagnostic pop
 
 
 }// Reflex

data/src/win32/event.cpp

@@ -42,7 +42,6 @@ namespace Reflex
 	}
 
 
-
 	static uint
 	get_mouse_type (UINT msg, WPARAM wp)
 	{

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reflexion
 version: !ruby/object:Gem::Version
-  version: 0.3.14
+  version: 0.3.15
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-17 00:00:00.000000000 Z
+date: 2026-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
 - !ruby/object:Gem::Dependency
   name: rays
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
 description: This library helps you to develop interactive graphical user interface.
 email: xordog@gmail.com
 executables: []
@@ -383,6 +383,8 @@ files:
 - src/reflex.cpp
 - src/sdl/application.cpp
 - src/sdl/device.cpp
+- src/sdl/event.cpp
+- src/sdl/event.h
 - src/sdl/gamepad.cpp
 - src/sdl/opengl.cpp
 - src/sdl/opengl.h