reflexion 0.3.6 → 0.3.8

data/src/osx/gamepad_gc.mm

@@ -65,7 +65,7 @@ namespace Reflex
 		if (!win) return;
 
 		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
-		KeyEvent e(action, NULL, key_code, get_key_modifiers(), 0);
+		KeyEvent e(action, NULL, key_code, KeyEvent_get_modifiers(), 0);
 		Window_call_key_event(win, &e);
 	}
 

data/src/osx/gamepad_hid.mm

@@ -308,7 +308,7 @@ namespace Reflex
 		if (!win) return;
 
 		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
-		KeyEvent e(action, NULL, key_code, get_key_modifiers(), 0);
+		KeyEvent e(action, NULL, key_code, KeyEvent_get_modifiers(), 0);
 		Window_call_key_event(win, &e);
 	}
 

data/src/queue.h

@@ -0,0 +1,71 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_QUEUE_H__
+#define __REFLEX_SRC_QUEUE_H__
+
+
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+
+
+namespace Reflex
+{
+
+
+	template <typename T>
+	class Queue
+	{
+
+		public:
+
+			void push (const T& value)
+			{
+				{
+					std::lock_guard<std::mutex> lock(mutex);
+					queue.push(value);
+				}
+				condvar.notify_one();
+			}
+
+			T pop ()
+			{
+				std::unique_lock<std::mutex> lock(mutex);
+				condvar.wait(lock, [this] {return !queue.empty();});
+
+				T value = queue.front();
+				queue.pop();
+				return value;
+			}
+
+			bool try_pop (T* value)
+			{
+				std::lock_guard<std::mutex> lock(mutex);
+				if (queue.empty()) return false;
+
+				*value = queue.front();
+				queue.pop();
+				return true;
+			}
+
+			bool empty () const
+			{
+				std::lock_guard<std::mutex> lock(mutex);
+				return queue.empty();
+			}
+
+		private:
+
+			std::queue<T> queue;
+
+			std::mutex mutex;
+
+			std::condition_variable condvar;
+
+	};// Queue
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/reflex.cpp

@@ -0,0 +1,18 @@
+#include "reflex/reflex.h"
+
+
+#include "midi.h"
+
+
+namespace Reflex
+{
+
+
+	void
+	process_events ()
+	{
+		MIDI_process_events();
+	}
+
+
+}// Reflex

data/src/timer.cpp

@@ -40,25 +40,18 @@ namespace Reflex
 	};// Data
 
 
-	namespace global
-	{
-
-		static Timer_CreateFun create_fun = NULL;
-
-	}// global
+	static Timer_CreateFun timer_create_fun = NULL;
 
 	void
 	Timer_set_create_fun (Timer_CreateFun fun)
 	{
-		global::create_fun = fun;
+		timer_create_fun = fun;
 	}
 
 	static Timer*
 	Timer_create ()
 	{
-		return global::create_fun
-			?	global::create_fun()
-			:	new Timer();
+		return timer_create_fun ? timer_create_fun() : new Timer();
 	}
 
 

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/event.cpp

@@ -12,7 +12,7 @@ namespace Reflex
 
 
 	uint
-	get_key_modifiers ()
+	KeyEvent_get_modifiers ()
 	{
 		return
 			(GetKeyState(VK_SHIFT)   & 0x8000 ? MOD_SHIFT   : 0) |
@@ -37,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_key_modifiers(), lp & 0xFF)
+	:	KeyEvent(get_key_action(msg), chars, (int) wp, KeyEvent_get_modifiers(), lp & 0xFF)
 	{
 	}
 
@@ -135,7 +135,7 @@ namespace Reflex
 			get_mouse_type(msg, wp),
 			get_mouse_action(msg),
 			Point(GET_X_LPARAM(lp), GET_Y_LPARAM(lp)),
-			get_key_modifiers(),
+			KeyEvent_get_modifiers(),
 			get_mouse_click_count(msg),
 			is_mouse_dragging(msg, wp),
 			Xot::time()));
@@ -196,7 +196,7 @@ namespace Reflex
 				get_touch_type(touch),
 				action,
 				get_touch_position(hwnd, touch),
-				get_key_modifiers(),
+				KeyEvent_get_modifiers(),
 				action == Pointer::DOWN ? 1 : 0,
 				action == Pointer::MOVE,
 				get_touch_time(touch));
@@ -212,7 +212,7 @@ 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_key_modifiers())
+			KeyEvent_get_modifiers())
 	{
 	}
 

data/src/win32/event.h

@@ -44,8 +44,6 @@ namespace Reflex
 	};// NativeWheelEvent
 
 
-	uint get_key_modifiers ();
-
 	void Gamepad_poll ();
 
 

data/src/win32/gamepad.cpp

@@ -18,7 +18,7 @@ namespace Reflex
 	call_gamepad_event (Window* win, int code, bool pressed)
 	{
 		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
-		KeyEvent e(action, NULL, code, get_key_modifiers(), 0);
+		KeyEvent e(action, NULL, code, KeyEvent_get_modifiers(), 0);
 		Window_call_key_event(win, &e);
 	}
 

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

data/test/test_view.rb

@@ -378,21 +378,22 @@ class TestView < Test::Unit::TestCase
     w.add v
     assert_equal [], v.capture
 
-    v.capture  = :key;             assert_equal [:key],           v.capture
-    v.capture  = :pointer;         assert_equal [:pointer],       v.capture
-    v.capture  = :all;             assert_equal [:key, :pointer], v.capture
+    v.capture  = :key;                    assert_equal [:key],                  v.capture
+    v.capture  = :pointer;                assert_equal [:pointer],              v.capture
+    v.capture  = :note;                   assert_equal [:note],                 v.capture
+    v.capture  = :all;                    assert_equal [:key, :pointer, :note], v.capture
 
-    v.capture -= [:key];           assert_equal [:pointer],       v.capture
-    v.capture += [:key];           assert_equal [:key, :pointer], v.capture
+    v.capture -= [:key];                  assert_equal [:pointer, :note],       v.capture
+    v.capture += [:key];                  assert_equal [:key, :pointer, :note], v.capture
 
-    v.capture  = [];               assert_equal [],               v.capture
-    v.capture += [:key, :pointer]; assert_equal [:key, :pointer], v.capture
-    v.capture  = [];               assert_equal [],               v.capture
-    v.capture += [:all];           assert_equal [:key, :pointer], v.capture
+    v.capture  = [];                      assert_equal [],                      v.capture
+    v.capture += [:key, :pointer, :note]; assert_equal [:key, :pointer, :note], v.capture
+    v.capture  = [];                      assert_equal [],                      v.capture
+    v.capture += [:all];                  assert_equal [:key, :pointer, :note], v.capture
 
-    v.capture -= [];               assert_equal [:key, :pointer], v.capture
-    v.capture  = [];               assert_equal [],               v.capture
-    v.capture += [];               assert_equal [],               v.capture
+    v.capture -= [];                      assert_equal [:key, :pointer, :note], v.capture
+    v.capture  = [];                      assert_equal [],                      v.capture
+    v.capture += [];                      assert_equal [],                      v.capture
   end
 
   def test_capturing()
@@ -403,24 +404,35 @@ class TestView < Test::Unit::TestCase
     assert_false v.capturing?
     assert_false v.capturing? :key
     assert_false v.capturing? :pointer
+    assert_false v.capturing? :note
     assert_false v.capturing? :all
 
     v.capture = :key
     assert_true  v.capturing?
     assert_true  v.capturing? :key
     assert_false v.capturing? :pointer
+    assert_false v.capturing? :note
     assert_false v.capturing? :all
 
     v.capture = :pointer
     assert_true  v.capturing?
     assert_false v.capturing? :key
     assert_true  v.capturing? :pointer
+    assert_false v.capturing? :note
+    assert_false v.capturing? :all
+
+    v.capture = :note
+    assert_true  v.capturing?
+    assert_false v.capturing? :key
+    assert_false v.capturing? :pointer
+    assert_true  v.capturing? :note
     assert_false v.capturing? :all
 
     v.capture = :all
     assert_true  v.capturing?
     assert_true  v.capturing? :key
     assert_true  v.capturing? :pointer
+    assert_true  v.capturing? :note
     assert_true  v.capturing? :all
   end