reflexion 0.2.1 → 0.3

data/include/reflex/ruby/reflex.h

@@ -13,7 +13,7 @@ namespace Reflex
 {
 
 
-	Rucy::Module reflex_module ();
+	REFLEX_EXPORT Rucy::Module reflex_module ();
 	// module Reflex
 
 

data/include/reflex/ruby/screen.h

@@ -9,14 +9,14 @@
 #include <reflex/screen.h>
 
 
-RUCY_DECLARE_VALUE_FROM_TO(Reflex::Screen)
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Screen)
 
 
 namespace Reflex
 {
 
 
-	Rucy::Class screen_class ();
+	REFLEX_EXPORT Rucy::Class screen_class ();
 	// class Reflex::Screen
 
 

data/include/reflex/ruby/selector.h

@@ -9,14 +9,14 @@
 #include <reflex/selector.h>
 
 
-RUCY_DECLARE_VALUE_OR_ARRAY_FROM_TO(Reflex::Selector)
+RUCY_DECLARE_VALUE_OR_ARRAY_FROM_TO(REFLEX_EXPORT, Reflex::Selector)
 
 
 namespace Reflex
 {
 
 
-	Rucy::Class selector_class ();
+	REFLEX_EXPORT Rucy::Class selector_class ();
 	// class Reflex::Selector
 
 

data/include/reflex/ruby/shape.h

@@ -10,34 +10,34 @@
 #include <reflex/ruby/event.h>
 
 
-RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::Shape)
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Shape)
 
-RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::PolygonShape)
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::PolygonShape)
 
-RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::LineShape)
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::LineShape)
 
-RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::RectShape)
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::RectShape)
 
-RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::EllipseShape)
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::EllipseShape)
 
 
 namespace Reflex
 {
 
 
-	Rucy::Class shape_class ();
+	REFLEX_EXPORT Rucy::Class shape_class ();
 	// class Reflex::Shape
 
-	Rucy::Class polygon_shape_class ();
+	REFLEX_EXPORT Rucy::Class polygon_shape_class ();
 	// class Reflex::PolygonShape
 
-	Rucy::Class line_shape_class ();
+	REFLEX_EXPORT Rucy::Class line_shape_class ();
 	// class Reflex::LineShape
 
-	Rucy::Class rect_shape_class ();
+	REFLEX_EXPORT Rucy::Class rect_shape_class ();
 	// class Reflex::RectShape
 
-	Rucy::Class ellipse_shape_class ();
+	REFLEX_EXPORT Rucy::Class ellipse_shape_class ();
 	// class Reflex::EllipseShape
 
 

data/include/reflex/ruby/style.h

@@ -9,19 +9,19 @@
 #include <reflex/style.h>
 
 
-RUCY_DECLARE_VALUE_OR_ARRAY_FROM_TO(Reflex::StyleLength)
+RUCY_DECLARE_VALUE_OR_ARRAY_FROM_TO(REFLEX_EXPORT, Reflex::StyleLength)
 
-RUCY_DECLARE_VALUE_FROM_TO(Reflex::Style)
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Style)
 
 
 namespace Reflex
 {
 
 
-	Rucy::Class style_length_class ();
+	REFLEX_EXPORT Rucy::Class style_length_class ();
 	// class Reflex::StyleLength
 
-	Rucy::Class style_class ();
+	REFLEX_EXPORT Rucy::Class style_class ();
 	// class Reflex::Style
 
 

data/include/reflex/ruby/timer.h

@@ -9,14 +9,14 @@
 #include <reflex/timer.h>
 
 
-RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::Timer)
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Timer)
 
 
 namespace Reflex
 {
 
 
-	Rucy::Class timer_class ();
+	REFLEX_EXPORT Rucy::Class timer_class ();
 	// class Reflex::Timer
 
 

data/include/reflex/ruby/view.h

@@ -10,14 +10,14 @@
 #include <reflex/ruby/event.h>
 
 
-RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::View)
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::View)
 
 
 namespace Reflex
 {
 
 
-	Rucy::Class view_class ();
+	REFLEX_EXPORT Rucy::Class view_class ();
 	// class Reflex::View
 
 

data/include/reflex/ruby/window.h

@@ -10,14 +10,14 @@
 #include <reflex/ruby/event.h>
 
 
-RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::Window)
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Window)
 
 
 namespace Reflex
 {
 
 
-	Rucy::Class window_class ();
+	REFLEX_EXPORT Rucy::Class window_class ();
 	// class Reflex::Window
 
 

data/lib/reflex/extension.rb

@@ -25,6 +25,10 @@ module Reflex
       root_dir 'lib'
     end
 
+    def ext_dir()
+      root_dir 'ext'
+    end
+
   end# Extension
 
 

data/reflex.gemspec

@@ -25,10 +25,10 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_runtime_dependency 'xot',   '~> 0.2.1'
-  s.add_runtime_dependency 'rucy',  '~> 0.2.1'
-  s.add_runtime_dependency 'beeps', '~> 0.2.1'
-  s.add_runtime_dependency 'rays',  '~> 0.2.1'
+  s.add_runtime_dependency 'xot',   '~> 0.3'
+  s.add_runtime_dependency 'rucy',  '~> 0.3'
+  s.add_runtime_dependency 'beeps', '~> 0.3'
+  s.add_runtime_dependency 'rays',  '~> 0.3'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/event.cpp

@@ -1,6 +1,7 @@
 #include "event.h"
 
 
+#include <algorithm>
 #include "reflex/timer.h"
 #include "reflex/shape.h"
 #include "reflex/exception.h"
@@ -506,11 +507,14 @@ namespace Reflex
 
 
 	void
-	KeyEvent_set_captured (KeyEvent* pthis, bool captured)
+	KeyEvent_set_chars (KeyEvent* pthis, const char* chars)
 	{
-		if (!pthis)
-			argument_error(__FILE__, __LINE__);
+		pthis->self->chars = chars ? chars : "";
+	}
 
+	void
+	KeyEvent_set_captured (KeyEvent* pthis, bool captured)
+	{
 		pthis->self->captured = captured;
 	}
 

data/src/event.h

@@ -19,6 +19,8 @@ namespace Reflex
 	void DrawEvent_set_bounds  (DrawEvent* pthis, const Bounds& bounds);
 
 
+	void KeyEvent_set_chars (KeyEvent* pthis, const char* chars);
+
 	void KeyEvent_set_captured (KeyEvent* pthis, bool captured);
 
 

data/src/ios/event.mm

@@ -69,38 +69,32 @@ namespace Reflex
 			(flags & UIKeyModifierNumericPad) ? MOD_NUMPAD  : 0;
 	}
 
-	static Pointer
-	create_pointer (UITouch* touch, UIEvent* event, UIView* view)
-	{
-		Pointer::Action action = get_action(touch);
-
-		Pointer pointer(
-			0,
-			get_type(touch),
-			action,
-			to_point([touch locationInView: view]),
-			get_modifiers(event),
-			action == Pointer::MOVE,
-			(uint) touch.tapCount,
-			0,
-			touch.timestamp);
-
-		if (touch.phase != UITouchPhaseBegan)
-		{
-			Pointer_set_prev_position(
-				&pointer, to_point([touch previousLocationInView: view]));
-		}
-
-		return pointer;
-	}
-
 	NativePointerEvent::NativePointerEvent (
 		NSSet* touches, UIEvent* event, UIView* view)
 	{
 		for (UITouch* touch in touches)
 		{
-			Pointer pointer = create_pointer(touch, event, view);
-			if (pointer) PointerEvent_add_pointer(this, pointer);
+			Pointer::Action action = get_action(touch);
+
+			Pointer pointer(
+				0,
+				get_type(touch),
+				action,
+				to_point([touch locationInView: view]),
+				get_modifiers(event),
+				action == Pointer::MOVE,
+				(uint) touch.tapCount,
+				0,
+				touch.timestamp);
+
+			if (pointer.action() != Pointer::DOWN)
+			{
+				Pointer_set_prev_position(
+					&pointer, to_point([touch previousLocationInView: view]));
+			}
+
+			if (pointer)
+				PointerEvent_add_pointer(this, pointer);
 		}
 	}
 

data/src/shape.cpp

@@ -1024,8 +1024,8 @@ namespace Reflex
 		bool has_angle () const
 		{
 			return
-				angle_from != DEFAULT_ANGLE_FROM ||
-				angle_to   != DEFAULT_ANGLE_TO;
+				angle_from != (float) DEFAULT_ANGLE_FROM ||
+				angle_to   != (float) DEFAULT_ANGLE_TO;
 		}
 
 		Fixture* create_fixtures (Shape* shape) override

data/src/view.cpp

@@ -2,6 +2,7 @@
 
 
 #include <limits.h>
+#include <string.h>
 #include <assert.h>
 #include <memory>
 #include <algorithm>

data/src/win32/application.cpp

@@ -1,7 +1,7 @@
 #include "reflex/application.h"
 
 
-#include <windows.h>
+#include <xot/windows.h>
 #include "reflex/exception.h"
 
 
@@ -9,13 +9,18 @@ namespace Reflex
 {
 
 
-	static Application* instance = NULL;
+	namespace global
+	{
+
+		static Application* instance = NULL;
+
+	}// global
 
 
 	Application*
 	app ()
 	{
-		return instance;
+		return global::instance;
 	}
 
 
@@ -24,30 +29,27 @@ namespace Reflex
 
 		String name;
 
-		operator bool () const
-		{
-			return true;
-		}
-
 	};// Application::Data
 
 
 	Application::Application ()
 	{
-		if (instance) reflex_error("multiple application instance.");
+		if (global::instance)
+			reflex_error(__FILE__, __LINE__, "multiple application instances.");
 
-		instance = this;
+		global::instance = this;
 	}
 
 	Application::~Application ()
 	{
-		instance = NULL;
+		global::instance = NULL;
 	}
 
-	bool
-	Application::run ()
+	void
+	Application::start ()
 	{
-		if (!*this) return false;
+		Event e;
+		on_start(&e);
 
 		MSG msg;
 		while (GetMessage(&msg, NULL, 0, 0))
@@ -56,48 +58,59 @@ namespace Reflex
 			DispatchMessage(&msg);
 		}
 
-		return msg.wParam == 0;
+		if (msg.wParam != 0)
+			reflex_error(__FILE__, __LINE__, "WM_QUIT with wParam %d.", msg.wParam);
 	}
 
-	bool
+	void
 	Application::quit ()
 	{
-		if (!*this) return false;
-
 		PostQuitMessage(0);
-		return true;
 	}
 
-	bool
-	Application::preference ()
+	void
+	Application::set_name (const char* name)
 	{
-		return *this;
+		if (!name)
+			argument_error(__FILE__, __LINE__);
+
+		self->name = name;
 	}
 
-	bool
-	Application::about ()
+	const char*
+	Application::name () const
 	{
-		return *this;
+		return self->name.c_str();
 	}
 
-	bool
-	Application::set_name (const char* name)
+	void
+	Application::on_start (Event* e)
 	{
-		if (!*this || !name) return false;
-		self->name = name;
-		return true;
 	}
 
-	const char*
-	Application::name () const
+	void
+	Application::on_quit (Event* e)
+	{
+	}
+
+	void
+	Application::on_motion (MotionEvent* e)
+	{
+	}
+
+	void
+	Application::on_preference (Event* e)
+	{
+	}
+
+	void
+	Application::on_about (Event* e)
 	{
-		if (!*this) return "";
-		return self->name.c_str();
 	}
 
 	Application::operator bool () const
 	{
-		return self && *self;
+		return true;
 	}
 
 	bool

data/src/win32/device.cpp

@@ -0,0 +1,18 @@
+#include "reflex/device.h"
+
+
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	void
+	vibrate ()
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+
+}// Reflex

data/src/win32/event.cpp

@@ -0,0 +1,221 @@
+#include "event.h"
+
+
+#include <xot/time.h>
+#include "reflex/exception.h"
+#include "../pointer.h"
+
+
+namespace Reflex
+{
+
+
+	static uint
+	get_modifiers ()
+	{
+		return
+			(GetKeyState(VK_SHIFT)   & 0x8000 ? MOD_SHIFT   : 0) |
+			(GetKeyState(VK_CONTROL) & 0x8000 ? MOD_CONTROL : 0) |
+			(GetKeyState(VK_MENU)    & 0x8000 ? MOD_ALT     : 0) |
+			(GetKeyState(VK_LWIN)    & 0x8000 ? MOD_WIN     : 0) |
+			(GetKeyState(VK_RWIN)    & 0x8000 ? MOD_WIN     : 0);
+	}
+
+
+	static KeyEvent::Action
+	get_key_action (UINT msg)
+	{
+		switch (msg)
+		{
+			case WM_KEYDOWN:
+			case WM_SYSKEYDOWN: return KeyEvent::DOWN;
+			case WM_KEYUP:
+			case WM_SYSKEYUP:   return KeyEvent::UP;
+			default:            argument_error(__FILE__, __LINE__);
+		}
+	}
+
+	NativeKeyEvent::NativeKeyEvent (UINT msg, WPARAM wp, LPARAM lp, const char* chars)
+	:	KeyEvent(get_key_action(msg), chars, (int) wp, get_modifiers(), lp & 0xFF)
+	{
+	}
+
+
+
+	static uint
+	get_mouse_type (UINT msg, WPARAM wp)
+	{
+		uint type = Reflex::Pointer::TYPE_NONE;
+
+		switch (msg)
+		{
+			case WM_LBUTTONDOWN:
+			case WM_LBUTTONDBLCLK:
+			case WM_LBUTTONUP:
+				type |= Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_LEFT;
+				break;
+
+			case WM_RBUTTONDOWN:
+			case WM_RBUTTONDBLCLK:
+			case WM_RBUTTONUP:
+				type |= Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_RIGHT;
+				break;
+
+			case WM_MBUTTONDOWN:
+			case WM_MBUTTONDBLCLK:
+			case WM_MBUTTONUP:
+				type |= Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_MIDDLE;
+				break;
+
+			case WM_MOUSEMOVE:
+				type |= Reflex::Pointer::MOUSE;
+				break;
+		}
+
+		return type;
+	}
+
+	static Reflex::Pointer::Action
+	get_mouse_action (UINT msg)
+	{
+		switch (msg)
+		{
+			case WM_LBUTTONDOWN:
+			case WM_RBUTTONDOWN:
+			case WM_MBUTTONDOWN:
+			case WM_LBUTTONDBLCLK:
+			case WM_RBUTTONDBLCLK:
+			case WM_MBUTTONDBLCLK:
+				return Reflex::Pointer::DOWN;
+
+			case WM_LBUTTONUP:
+			case WM_RBUTTONUP:
+			case WM_MBUTTONUP:
+				return Reflex::Pointer::UP;
+
+			case WM_MOUSEMOVE:
+				return Reflex::Pointer::MOVE;
+
+			default:
+				return Reflex::Pointer::ACTION_NONE;
+		}
+	}
+
+	static bool
+	is_mouse_dragging (UINT msg, WPARAM wp)
+	{
+		return msg == WM_MOUSEMOVE && wp & (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON);
+	}
+
+	static int
+	get_mouse_click_count (UINT msg)
+	{
+		switch (msg)
+		{
+			case WM_LBUTTONDOWN:
+			case WM_RBUTTONDOWN:
+			case WM_MBUTTONDOWN:
+				return 1;
+
+			case WM_LBUTTONDBLCLK:
+			case WM_RBUTTONDBLCLK:
+			case WM_MBUTTONDBLCLK:
+				return 2;
+
+			default:
+				return 0;
+		}
+	}
+
+	NativePointerEvent::NativePointerEvent (UINT msg, WPARAM wp, LPARAM lp)
+	{
+		PointerEvent_add_pointer(this, Pointer(
+			0,
+			get_mouse_type(msg, wp),
+			get_mouse_action(msg),
+			Point(GET_X_LPARAM(lp), GET_Y_LPARAM(lp)),
+			get_modifiers(),
+			is_mouse_dragging(msg, wp),
+			get_mouse_click_count(msg),
+			0,
+			Xot::time()));
+	}
+
+	static uint
+	get_touch_type (const TOUCHINPUT& touch)
+	{
+		if (touch.dwFlags & TOUCHEVENTF_PEN)  return Pointer::PEN;
+		if (touch.dwFlags & TOUCHEVENTF_PALM) return Pointer::TYPE_NONE;
+		else                                  return Pointer::TOUCH;
+	}
+
+	static Pointer::Action
+	get_touch_action (const TOUCHINPUT& touch)
+	{
+		if (touch.dwFlags & TOUCHEVENTF_DOWN) return Pointer::DOWN;
+		if (touch.dwFlags & TOUCHEVENTF_UP)   return Pointer::UP;
+		if (touch.dwFlags & TOUCHEVENTF_MOVE) return Pointer::MOVE;
+		else                                  return Pointer::ACTION_NONE;
+	}
+
+	static Point
+	get_touch_position (HWND hwnd, const TOUCHINPUT& touch)
+	{
+		coord x = (coord) touch.x / 100;
+		coord y = (coord) touch.y / 100;
+
+		POINT point = {0, 0};
+		if (ClientToScreen(hwnd, &point))
+		{
+			x -= point.x;
+			y -= point.y;
+		}
+
+		return Point(x, y);
+	}
+
+	static double
+	get_touch_time (const TOUCHINPUT& touch)
+	{
+		//if (touch.dwFlags & TOUCHINPUTMASKF_TIMEFROMSYSTEM)
+		//	return (double) touch.dwTime / 1000.0;
+
+		return Xot::time();
+	}
+
+	NativePointerEvent::NativePointerEvent (
+		HWND hwnd, const TOUCHINPUT* touches, size_t size)
+	{
+		for (size_t i = 0; i < size; ++i)
+		{
+			const TOUCHINPUT& touch = touches[i];
+			Pointer::Action action  = get_touch_action(touch);
+
+			Pointer pointer(
+				0,
+				get_touch_type(touch),
+				action,
+				get_touch_position(hwnd, touch),
+				get_modifiers(),
+				action == Pointer::MOVE,
+				action == Pointer::DOWN ? 1 : 0,
+				0,
+				get_touch_time(touch));
+			Pointer_set_system_id(&pointer, touch.dwID);
+
+			if (pointer)
+				PointerEvent_add_pointer(this, pointer);
+		}
+	}
+
+
+	NativeWheelEvent::NativeWheelEvent (WPARAM wp_x, WPARAM wp_y, LPARAM lp)
+	:	WheelEvent(
+			GET_X_LPARAM(lp),              GET_Y_LPARAM(lp),             0,
+			GET_WHEEL_DELTA_WPARAM(wp_x), -GET_WHEEL_DELTA_WPARAM(wp_y), 0,
+			get_modifiers())
+	{
+	}
+
+
+}// Reflex