reflexion 0.3.5 → 0.3.7

data/src/view.cpp

@@ -1373,6 +1373,7 @@ namespace Reflex
 
 		KeyEvent e = event->dup();
 		view->on_key(&e);
+		if (e.is_blocked()) return;
 
 		switch (e.action())
 		{
@@ -1413,6 +1414,7 @@ namespace Reflex
 			view->self->pbody->awake();
 
 		view->on_pointer(event);
+		if (event->is_blocked()) return;
 
 		switch ((*event)[0].action())
 		{
@@ -1506,6 +1508,28 @@ namespace Reflex
 		view->on_wheel(&e);
 	}
 
+	void
+	View_call_note_event (View* view, NoteEvent* event)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		if (view->hidden()) return;
+
+		NoteEvent e = event->dup();
+		view->on_note(&e);
+		if (e.is_blocked()) return;
+
+		switch (e.action())
+		{
+			case NoteEvent::ON:  view->on_note_on(&e);  break;
+			case NoteEvent::OFF: view->on_note_off(&e); break;
+			default: break;
+		}
+	}
+
 	void
 	View_call_contact_event (View* view, ContactEvent* event)
 	{
@@ -2781,6 +2805,21 @@ namespace Reflex
 		//scroll_by(e->dx, e->dy, e->dz);
 	}
 
+	void
+	View::on_note (NoteEvent* e)
+	{
+	}
+
+	void
+	View::on_note_on (NoteEvent* e)
+	{
+	}
+
+	void
+	View::on_note_off (NoteEvent* e)
+	{
+	}
+
 	void
 	View::on_capture (CaptureEvent* e)
 	{

data/src/view.h

@@ -42,6 +42,8 @@ namespace Reflex
 
 	void View_call_wheel_event   (View* view, WheelEvent* event);
 
+	void View_call_note_event    (View* view, NoteEvent* event);
+
 	void View_call_contact_event (View* view, ContactEvent* event);
 
 

data/src/win32/application.cpp

@@ -42,7 +42,7 @@ namespace Reflex
 	Application::start ()
 	{
 		Event e;
-		on_start(&e);
+		Application_call_start(this, &e);
 
 		timeBeginPeriod(1);
 
@@ -84,27 +84,11 @@ namespace Reflex
 	void
 	Application::quit ()
 	{
-		PostQuitMessage(0);
-	}
-
-	void
-	Application::on_start (Event* e)
-	{
-	}
-
-	void
-	Application::on_quit (Event* e)
-	{
-	}
-
-	void
-	Application::on_motion (MotionEvent* e)
-	{
-	}
+		Event e;
+		Application_call_quit(this, &e);
+		if (e.is_blocked()) return;
 
-	void
-	Application::on_preference (Event* e)
-	{
+		PostQuitMessage(0);
 	}
 
 	void
@@ -112,10 +96,5 @@ namespace Reflex
 	{
 	}
 
-	Application::operator bool () const
-	{
-		return true;
-	}
-
 
 }// Reflex

data/src/win32/event.cpp

@@ -1,7 +1,6 @@
 #include "event.h"
 
 
-#include <xinput.h>
 #include <xot/time.h>
 #include "reflex/exception.h"
 #include "reflex/debug.h"
@@ -12,8 +11,8 @@ namespace Reflex
 {
 
 
-	static uint
-	get_modifiers ()
+	uint
+	KeyEvent_get_modifiers ()
 	{
 		return
 			(GetKeyState(VK_SHIFT)   & 0x8000 ? MOD_SHIFT   : 0) |
@@ -38,7 +37,7 @@ namespace Reflex
 	}
 
 	NativeKeyEvent::NativeKeyEvent (UINT msg, WPARAM wp, LPARAM lp, const char* chars)
-	:	KeyEvent(get_key_action(msg), chars, (int) wp, get_modifiers(), lp & 0xFF)
+	:	KeyEvent(get_key_action(msg), chars, (int) wp, KeyEvent_get_modifiers(), lp & 0xFF)
 	{
 	}
 
@@ -136,7 +135,7 @@ namespace Reflex
 			get_mouse_type(msg, wp),
 			get_mouse_action(msg),
 			Point(GET_X_LPARAM(lp), GET_Y_LPARAM(lp)),
-			get_modifiers(),
+			KeyEvent_get_modifiers(),
 			get_mouse_click_count(msg),
 			is_mouse_dragging(msg, wp),
 			Xot::time()));
@@ -197,7 +196,7 @@ namespace Reflex
 				get_touch_type(touch),
 				action,
 				get_touch_position(hwnd, touch),
-				get_modifiers(),
+				KeyEvent_get_modifiers(),
 				action == Pointer::DOWN ? 1 : 0,
 				action == Pointer::MOVE,
 				get_touch_time(touch));
@@ -213,90 +212,8 @@ namespace Reflex
 	:	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())
-	{
-	}
-
-
-	static void
-	call_gamepad_event (Window* win, int code, bool pressed)
-	{
-		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
-		KeyEvent e(action, NULL, code, get_modifiers(), 0);
-		Window_call_key_event(win, &e);
-	}
-
-	static void
-	handle_gamepad_button_event (
-		Window* win, const XINPUT_STATE& state, const XINPUT_STATE& prev_state,
-		WORD mask, int code)
-	{
-		WORD pressed =      state.Gamepad.wButtons & mask;
-		WORD prev    = prev_state.Gamepad.wButtons & mask;
-		if (pressed == prev) return;
-
-		call_gamepad_event(win, code, pressed);
-	}
-
-	static void
-	handle_gamepad_trigger_event (Window* win, BYTE value, BYTE prev_value, int code)
-	{
-		WORD pressed =      value > XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
-		WORD prev    = prev_value > XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
-		if (pressed == prev) return;
-
-		call_gamepad_event(win, code, pressed);
-	}
-
-	static void
-	handle_gamepad_events (const XINPUT_STATE& state, const XINPUT_STATE& prev_state)
+			KeyEvent_get_modifiers())
 	{
-		Window* win = Window_get_active();
-		if (!win) return;
-
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_LEFT,  KEY_GAMEPAD_LEFT);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_RIGHT, KEY_GAMEPAD_RIGHT);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_UP,    KEY_GAMEPAD_UP);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_DOWN,  KEY_GAMEPAD_DOWN);
-
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_A, KEY_GAMEPAD_A);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_B, KEY_GAMEPAD_B);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_X, KEY_GAMEPAD_X);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_Y, KEY_GAMEPAD_Y);
-
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_LEFT_SHOULDER,  KEY_GAMEPAD_SHOULDER_LEFT);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_RIGHT_SHOULDER, KEY_GAMEPAD_SHOULDER_RIGHT);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_LEFT_THUMB,     KEY_GAMEPAD_THUMB_LEFT);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_RIGHT_THUMB,    KEY_GAMEPAD_THUMB_RIGHT);
-
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_START, KEY_GAMEPAD_START);
-		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_BACK,  KEY_GAMEPAD_SELECT);
-
-		handle_gamepad_trigger_event(win, state.Gamepad.bLeftTrigger,  prev_state.Gamepad.bLeftTrigger,  KEY_GAMEPAD_TRIGGER_LEFT);
-		handle_gamepad_trigger_event(win, state.Gamepad.bRightTrigger, prev_state.Gamepad.bRightTrigger, KEY_GAMEPAD_TRIGGER_RIGHT);
-	}
-
-	void
-	poll_gamepads ()
-	{
-		static XINPUT_STATE prev_state;
-		static bool prev_detected = false;
-
-		XINPUT_STATE state = {0};
-		bool detected      = XInputGetState(0, &state) == ERROR_SUCCESS;
-
-		if (detected != prev_detected)
-		{
-			prev_detected = detected;
-			if (detected) prev_state = {0};
-		}
-
-		if (!detected) return;
-
-		if (state.dwPacketNumber != prev_state.dwPacketNumber)
-			handle_gamepad_events(state, prev_state);
-
-		prev_state = state;
 	}
 
 

data/src/win32/event.h

@@ -44,7 +44,7 @@ namespace Reflex
 	};// NativeWheelEvent
 
 
-	void poll_gamepads ();
+	void Gamepad_poll ();
 
 
 }// Reflex

data/src/win32/gamepad.cpp

@@ -0,0 +1,110 @@
+#include "gamepad.h"
+
+
+#include <xot/windows.h>
+#include <xinput.h>
+
+#include "reflex/exception.h"
+#include "reflex/debug.h"
+#include "window.h"
+#include "event.h"
+
+
+namespace Reflex
+{
+
+
+	static void
+	call_gamepad_event (Window* win, int code, bool pressed)
+	{
+		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
+		KeyEvent e(action, NULL, code, KeyEvent_get_modifiers(), 0);
+		Window_call_key_event(win, &e);
+	}
+
+	static void
+	handle_gamepad_button_event (
+		Window* win, const XINPUT_STATE& state, const XINPUT_STATE& prev_state,
+		WORD mask, int code)
+	{
+		WORD pressed =      state.Gamepad.wButtons & mask;
+		WORD prev    = prev_state.Gamepad.wButtons & mask;
+		if (pressed == prev) return;
+
+		call_gamepad_event(win, code, pressed);
+	}
+
+	static void
+	handle_gamepad_trigger_event (Window* win, BYTE value, BYTE prev_value, int code)
+	{
+		WORD pressed =      value > XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
+		WORD prev    = prev_value > XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
+		if (pressed == prev) return;
+
+		call_gamepad_event(win, code, pressed);
+	}
+
+	static void
+	handle_gamepad_events (const XINPUT_STATE& state, const XINPUT_STATE& prev_state)
+	{
+		Window* win = Window_get_active();
+		if (!win) return;
+
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_LEFT,  KEY_GAMEPAD_LEFT);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_RIGHT, KEY_GAMEPAD_RIGHT);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_UP,    KEY_GAMEPAD_UP);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_DOWN,  KEY_GAMEPAD_DOWN);
+
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_A, KEY_GAMEPAD_A);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_B, KEY_GAMEPAD_B);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_X, KEY_GAMEPAD_X);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_Y, KEY_GAMEPAD_Y);
+
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_LEFT_SHOULDER,  KEY_GAMEPAD_LSHOULDER);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_RIGHT_SHOULDER, KEY_GAMEPAD_RSHOULDER);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_LEFT_THUMB,     KEY_GAMEPAD_LTHUMB);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_RIGHT_THUMB,    KEY_GAMEPAD_RTHUMB);
+
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_START, KEY_GAMEPAD_START);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_BACK,  KEY_GAMEPAD_SELECT);
+
+		handle_gamepad_trigger_event(win, state.Gamepad.bLeftTrigger,  prev_state.Gamepad.bLeftTrigger,  KEY_GAMEPAD_LTRIGGER);
+		handle_gamepad_trigger_event(win, state.Gamepad.bRightTrigger, prev_state.Gamepad.bRightTrigger, KEY_GAMEPAD_RTRIGGER);
+	}
+
+	void
+	Gamepad_init (Application* app)
+	{
+	}
+
+	void
+	Gamepad_fin (Application* app)
+	{
+		Gamepad_remove_all(app);
+	}
+
+	void
+	Gamepad_poll ()
+	{
+		static XINPUT_STATE prev_state;
+		static bool prev_detected = false;
+
+		XINPUT_STATE state = {0};
+		bool detected      = XInputGetState(0, &state) == ERROR_SUCCESS;
+
+		if (detected != prev_detected)
+		{
+			prev_detected = detected;
+			if (detected) prev_state = {0};
+		}
+
+		if (!detected) return;
+
+		if (state.dwPacketNumber != prev_state.dwPacketNumber)
+			handle_gamepad_events(state, prev_state);
+
+		prev_state = state;
+	}
+
+
+}// Reflex

data/src/win32/gamepad.h

@@ -0,0 +1,20 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_WIN32_GAMEPAD_H__
+#define __REFLEX_SRC_WIN32_GAMEPAD_H__
+
+
+#include "../gamepad.h"
+
+
+namespace Reflex
+{
+
+
+	void Gamepad_poll ();
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/win32/window.cpp

@@ -12,6 +12,7 @@
 #include "reflex/debug.h"
 #include "../view.h"
 #include "event.h"
+#include "gamepad.h"
 #include "screen.h"
 #include "opengl.h"
 
@@ -154,7 +155,7 @@ namespace Reflex
 	{
 		WindowData* self = get_data(win);
 
-		poll_gamepads();
+		Gamepad_poll();
 
 		Window_call_update_event(win);
 

data/src/window.cpp

@@ -103,25 +103,18 @@ namespace Reflex
 		}
 	}
 
-	namespace global
-	{
-
-		static Window_CreateRootViewFun create_root_view_fun = NULL;
-
-	}// global
+	static Window_CreateRootViewFun create_root_view_fun = NULL;
 
 	void
 	Window_set_create_root_view_fun (Window_CreateRootViewFun fun)
 	{
-		global::create_root_view_fun = fun;
+		create_root_view_fun = fun;
 	}
 
 	static View*
 	create_root_view ()
 	{
-		return global::create_root_view_fun
-			?	global::create_root_view_fun()
-			:	new View();
+		return create_root_view_fun ? create_root_view_fun() : new View();
 	}
 
 	void
@@ -614,6 +607,49 @@ namespace Reflex
 		View_call_wheel_event(window->root(), event);
 	}
 
+	void
+	Window_call_note_event (Window* window, NoteEvent* event)
+	{
+		assert(window);
+
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		for (auto& [view, targets] : window->self->captures)
+		{
+			if (
+				!view->window() ||
+				!is_capturing(view.get(), targets, View::CAPTURE_NOTE))
+			{
+				continue;
+			}
+
+			NoteEvent e = event->dup();
+			NoteEvent_set_captured(&e, true);
+			View_call_note_event(const_cast<View*>(view.get()), &e);
+
+			if (e.is_blocked()) event->block();
+		}
+
+		if (!event->is_blocked())
+			window->on_note(event);
+
+		if (!event->is_blocked())
+		{
+			switch (event->action())
+			{
+				case NoteEvent::ON:  window->on_note_on(event);  break;
+				case NoteEvent::OFF: window->on_note_off(event); break;
+				default: break;
+			}
+		}
+
+		if (!event->is_blocked() && window->self->focus)
+			View_call_note_event(window->self->focus.get(), event);
+
+		cleanup_captures(window);
+	}
+
 
 	Window::Window ()
 	:	self(Window_create_data())
@@ -905,6 +941,21 @@ namespace Reflex
 	{
 	}
 
+	void
+	Window::on_note (NoteEvent* e)
+	{
+	}
+
+	void
+	Window::on_note_on (NoteEvent* e)
+	{
+	}
+
+	void
+	Window::on_note_off (NoteEvent* e)
+	{
+	}
+
 	Window::operator bool () const
 	{
 		return self && *self;

data/src/window.h

@@ -139,6 +139,8 @@ namespace Reflex
 
 	void Window_call_wheel_event      (Window* window, WheelEvent*   event);
 
+	void Window_call_note_event       (Window* window, NoteEvent*    event);
+
 
 	typedef View* (*Window_CreateRootViewFun) ();
 

data/test/test_capture_event.rb

@@ -26,31 +26,35 @@ class TestCaptureEvent < Test::Unit::TestCase
   end
 
   def test_begin()
-    c = event [:key, :pointer], []
-    assert_equal [:key, :pointer], c.begin
-    assert_equal true, c.begin?(:key)
-    assert_equal true, c.begin?(:pointer)
-    assert_equal true, c.begin?(:all)
+    c = event [:key, :pointer, :note], []
+    assert_equal [:key, :pointer, :note], c.begin
+    assert_equal true,                    c.begin?(:key)
+    assert_equal true,                    c.begin?(:pointer)
+    assert_equal true,                    c.begin?(:note)
+    assert_equal true,                    c.begin?(:all)
 
     c = event [:key], []
     assert_equal [:key], c.begin
-    assert_equal true,  c.begin?(:key)
-    assert_equal false, c.begin?(:pointer)
-    assert_equal false, c.begin?(:all)
+    assert_equal true,   c.begin?(:key)
+    assert_equal false,  c.begin?(:pointer)
+    assert_equal false,  c.begin?(:note)
+    assert_equal false,  c.begin?(:all)
   end
 
   def test_end()
-    c = event [], [:key, :pointer]
-    assert_equal [:key, :pointer], c.end
-    assert_equal true, c.end?(:key)
-    assert_equal true, c.end?(:pointer)
-    assert_equal true, c.end?(:all)
+    c = event [], [:key, :pointer, :note]
+    assert_equal [:key, :pointer, :note], c.end
+    assert_equal true,                    c.end?(:key)
+    assert_equal true,                    c.end?(:pointer)
+    assert_equal true,                    c.end?(:note)
+    assert_equal true,                    c.end?(:all)
 
     c = event [], [:key]
     assert_equal [:key], c.end
-    assert_equal true,  c.end?(:key)
-    assert_equal false, c.end?(:pointer)
-    assert_equal false, c.end?(:all)
+    assert_equal true,   c.end?(:key)
+    assert_equal false,  c.end?(:pointer)
+    assert_equal false,  c.end?(:note)
+    assert_equal false,  c.end?(:all)
   end
 
 end# TestCaptureEvent

data/test/test_key_event.rb

@@ -3,7 +3,7 @@ require_relative 'helper'
 
 class TestKeyEvent < Test::Unit::TestCase
 
-  DOWN = Reflex::KeyEvent::DOWN
+  DOWN, UP = Reflex::KeyEvent::DOWN, Reflex::KeyEvent::UP
 
   def event(*args)
     Reflex::KeyEvent.new(*args)
@@ -29,6 +29,13 @@ class TestKeyEvent < Test::Unit::TestCase
     assert_true  e3.blocked?
   end
 
+  def test_down_up()
+    assert_true  event(DOWN, 'a', 1, 2, 3).down?
+    assert_false event(DOWN, 'a', 1, 2, 3).up?
+    assert_false event(UP,   'a', 1, 2, 3).down?
+    assert_true  event(UP,   'a', 1, 2, 3).up?
+  end
+
   def test_chars()
     assert_equal 'foo', event(DOWN, 'foo', 1, 2, 3).chars
 

data/test/test_note_event.rb

@@ -0,0 +1,43 @@
+require_relative 'helper'
+
+
+class TestNoteEvent < Test::Unit::TestCase
+
+  ON, OFF = Reflex::NoteEvent::ON, Reflex::NoteEvent::OFF
+
+  def event(*args)
+    Reflex::NoteEvent.new(*args)
+  end
+
+  def test_initialize()
+    e = event ON, 1, 2, 0.5, 3
+    assert_equal :on, e.action
+    assert_equal 1,   e.channel
+    assert_equal 2,   e.note
+    assert_equal 0.5, e.velocity
+    assert_equal 3,   e.time
+    assert_false      e.captured?
+  end
+
+  def test_dup()
+    e1 = event ON, 1, 2, 0.5, 3
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+  def test_on_off()
+    assert_true  event(ON,  1, 2, 0.5, 3).on?
+    assert_false event(ON,  1, 2, 0.5, 3).off?
+    assert_false event(OFF, 1, 2, 0.5, 3).on?
+    assert_true  event(OFF, 1, 2, 0.5, 3).off?
+  end
+
+  def test_frequency()
+    assert_equal 440, event(ON, 1, 69, 0.5, 3).frequency
+  end
+
+end# TestNoteEvent