reflexion 0.2.1 → 0.3.1

data/src/view.cpp

@@ -2,6 +2,7 @@
 
 
 #include <limits.h>
+#include <string.h>
 #include <assert.h>
 #include <memory>
 #include <algorithm>
@@ -288,15 +289,22 @@ namespace Reflex
 
 		World* child_world (View* view, bool create = true)
 		{
-			if (!pchild_world && create)
-			{
-				pchild_world.reset(new World());
-				create_walls(view);
-			}
-
+			if (!pchild_world && create) create_world(view);
 			return pchild_world.get();
 		}
 
+		void create_world (View* view, float pixels_per_meter = 0)
+		{
+			if (pchild_world)
+				invalid_state_error(__FILE__, __LINE__);
+
+			if (pixels_per_meter == 0)
+				pixels_per_meter = World::DEFAULT_PIXELS_PER_METER;
+
+			pchild_world.reset(new World(pixels_per_meter));
+			create_walls(view);
+		}
+
 		void create_walls (View* view)
 		{
 			clear_walls(view);
@@ -1326,7 +1334,9 @@ namespace Reflex
 	void
 	View_call_key_event (View* view, KeyEvent* event)
 	{
-		if (!view || !event)
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
 			argument_error(__FILE__, __LINE__);
 
 		if (view->hidden()) return;
@@ -1382,9 +1392,6 @@ namespace Reflex
 			case Pointer::CANCEL: view->on_pointer_cancel(event); break;
 			default: break;
 		}
-
-		if (!event->is_captured())
-			PointerEvent_increment_view_indices(event);
 	}
 
 	static void
@@ -1397,34 +1404,36 @@ namespace Reflex
 		PointerEvent_each_pointer(&event, [&](const auto& pointer)
 		{
 			if (pointer.action() == Pointer::DOWN)
-				Window_register_capture(win, view, pointer.id(), pointer.view_index());
+				Window_register_capture(win, view, pointer.id());
 		});
 	}
 
 	static void
-	unregister_captures (View* view, const PointerEvent& event)
+	unregister_captures (Window* window, View* view, const PointerEvent& event)
 	{
-		Window* win = view->window();
-		if (!win)
-			invalid_state_error(__FILE__, __LINE__);
-
 		PointerEvent_each_pointer(&event, [&](const auto& pointer)
 		{
 			auto action = pointer.action();
 			if (action == Pointer::UP || action == Pointer::CANCEL)
-				Window_unregister_capture(win, view, pointer.id());
+				Window_unregister_capture(window, view, pointer.id());
 		});
 	}
 
 	void
 	View_call_pointer_event (View* view, PointerEvent* event)
 	{
-		if (!view || !event)
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
 			argument_error(__FILE__, __LINE__);
 
 		if (view->hidden() || event->empty())
 			return;
 
+		Window* win = view->window();
+		if (!win)
+			invalid_state_error(__FILE__, __LINE__);
+
 		PointerEvent e = event->dup();
 
 		if (!e.is_captured())
@@ -1436,13 +1445,15 @@ namespace Reflex
 			call_pointer_events(view, &e);
 		}
 
-		unregister_captures(view, e);
+		unregister_captures(win, view, e);
 	}
 
 	void
 	View_call_wheel_event (View* view, WheelEvent* event)
 	{
-		if (!view || !event)
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
 			argument_error(__FILE__, __LINE__);
 
 		if (view->hidden()) return;
@@ -1468,7 +1479,9 @@ namespace Reflex
 	void
 	View_call_contact_event (View* view, ContactEvent* event)
 	{
-		if (!view || !event)
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
 			argument_error(__FILE__, __LINE__);
 
 		ContactEvent e = event->dup();
@@ -1737,7 +1750,9 @@ namespace Reflex
 	void
 	View::add_child (View* child)
 	{
-		if (!child || child == this)
+		if (!child)
+			argument_error(__FILE__, __LINE__);
+		if (child == this)
 			argument_error(__FILE__, __LINE__);
 
 		bool found  = std::find(child_begin(), child_end(), child) != child_end();
@@ -1763,7 +1778,9 @@ namespace Reflex
 	void
 	View::remove_child (View* child)
 	{
-		if (!child || child == this)
+		if (!child)
+			argument_error(__FILE__, __LINE__);
+		if (child == this)
 			argument_error(__FILE__, __LINE__);
 
 		bool found  = std::find(child_begin(), child_end(), child) != child_end();
@@ -2516,7 +2533,13 @@ namespace Reflex
 	}
 
 	void
-	View::update_physics (float duration)
+	View::create_world (float pixels_per_meter)
+	{
+		self->create_world(this, pixels_per_meter);
+	}
+
+	void
+	View::update_world (float duration)
 	{
 		World* w = self->pchild_world.get();
 		if (w) w->update(duration);

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,219 @@
+#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(),
+			get_mouse_click_count(msg),
+			is_mouse_dragging(msg, wp),
+			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::DOWN ? 1 : 0,
+				action == Pointer::MOVE,
+				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

data/src/win32/event.h

@@ -0,0 +1,50 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_WIN32_EVENT_H__
+#define __REFLEX_SRC_WIN32_EVENT_H__
+
+
+#include <xot/windows.h>
+#include "../event.h"
+
+
+namespace Reflex
+{
+
+
+	class NativeKeyEvent : public KeyEvent
+	{
+
+		public:
+
+			NativeKeyEvent (UINT msg, WPARAM wp, LPARAM lp, const char* chars = NULL);
+
+	};// NativeKeyEvent
+
+
+	class NativePointerEvent : public PointerEvent
+	{
+
+		public:
+
+			NativePointerEvent (UINT msg, WPARAM wp, LPARAM lp);
+
+			NativePointerEvent (HWND hwnd, const TOUCHINPUT* touches, size_t size);
+
+	};// NativePointerEvent
+
+
+	class NativeWheelEvent : public WheelEvent
+	{
+
+		public:
+
+			NativeWheelEvent (WPARAM wp_x, WPARAM wp_y, LPARAM lp);
+
+	};// NativeWheelEvent
+
+
+}// Reflex
+
+
+#endif//EOH