reflexion 0.3.8.1 → 0.3.9

data/src/event.cpp

@@ -5,6 +5,7 @@
 #include "reflex/device.h"
 #include "reflex/timer.h"
 #include "reflex/shape.h"
+#include "reflex/midi.h"
 #include "reflex/exception.h"
 #include "view.h"
 #include "pointer.h"
@@ -868,6 +869,124 @@ namespace Reflex
 	}
 
 
+	struct MIDIEvent::Data
+	{
+
+		MIDI::Ref midi;
+
+		uchar bytes[3] = {0};
+
+		bool captured  = false;
+
+	};// MIDIEvent
+
+
+	bool
+	MIDIEvent_to_note_event (NoteEvent* result, const MIDIEvent& event)
+	{
+		auto a = event.action();
+		if (a != MIDIEvent::NOTE_ON && a != MIDIEvent::NOTE_OFF)
+			return false;
+
+		*result = NoteEvent(
+			a == MIDIEvent::NOTE_ON ? NoteEvent::ON : NoteEvent::OFF,
+			event.channel(), event.data1(), event.data2() / 127.f, event.time());
+		return true;
+	}
+
+	bool
+	MIDIEvent_to_control_change_event (
+		ControlChangeEvent* result, const MIDIEvent& event)
+	{
+		if (event.action() != MIDIEvent::CONTROL_CHANGE)
+			return false;
+
+		*result = ControlChangeEvent(
+			event.channel(), event.data1(), event.data2() / 127.f, event.time());
+		return true;
+	}
+
+	void
+	MIDIEvent_set_captured (MIDIEvent* pthis, bool captured)
+	{
+		pthis->self->captured = captured;
+	}
+
+
+	MIDIEvent::MIDIEvent ()
+	{
+	}
+
+	MIDIEvent::MIDIEvent (MIDI* midi, const uchar* bytes, double time)
+	:	Event(time)
+	{
+		self->midi = midi;
+		memcpy(self->bytes, bytes, sizeof(uchar) * 3);
+	}
+
+	MIDIEvent::MIDIEvent (const MIDIEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
+	}
+
+	MIDIEvent
+	MIDIEvent::dup () const
+	{
+		return MIDIEvent(this);
+	}
+
+	MIDI*
+	MIDIEvent::midi () const
+	{
+		return self->midi;
+	}
+
+	MIDIEvent::Action
+	MIDIEvent::action () const
+	{
+		switch (self->bytes[0] >> 4)
+		{
+			case 0x9: return NOTE_ON;
+			case 0x8: return NOTE_OFF;
+			case 0xA: return KEY_PRESSURE;
+			case 0xB: return CONTROL_CHANGE;
+			case 0xC: return PROGRAM_CHANGE;
+			case 0xD: return CHANNEL_PRESSURE;
+			case 0xE: return PITCH_BEND_CHANGE;
+			case 0xF: return SYSTEM;
+			default:  return ACTION_NONE;
+		}
+	}
+
+	int
+	MIDIEvent::channel () const
+	{
+		auto a = action();
+		if (a == ACTION_NONE || a == SYSTEM)
+			return -1;
+
+		return self->bytes[0] & 0xF;
+	}
+
+	uchar
+	MIDIEvent::data1 () const
+	{
+		return self->bytes[1];
+	}
+
+	uchar
+	MIDIEvent::data2 () const
+	{
+		return self->bytes[2];
+	}
+
+	bool
+	MIDIEvent::is_captured () const
+	{
+		return self->captured;
+	}
+
+
 	struct NoteEvent::Data
 	{
 
@@ -954,6 +1073,76 @@ namespace Reflex
 	}
 
 
+	struct ControlChangeEvent::Data
+	{
+
+		int channel    = 0;
+
+		int controller = 0;
+
+		float value    = 0;
+
+		bool captured  = false;
+
+	};// ControlChangeEvent::Data
+
+
+	void
+	ControlChangeEvent_set_captured (ControlChangeEvent* pthis, bool captured)
+	{
+		pthis->self->captured = captured;
+	}
+
+
+	ControlChangeEvent::ControlChangeEvent ()
+	{
+	}
+
+	ControlChangeEvent::ControlChangeEvent (
+		int channel, int controller, float value, double time)
+	:	Event(time)
+	{
+		self->channel    = channel;
+		self->controller = controller;
+		self->value      = value;
+	}
+
+	ControlChangeEvent::ControlChangeEvent (const ControlChangeEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
+	}
+
+	ControlChangeEvent
+	ControlChangeEvent::dup () const
+	{
+		return ControlChangeEvent(this);
+	}
+
+	int
+	ControlChangeEvent::channel () const
+	{
+		return self->channel;
+	}
+
+	int
+	ControlChangeEvent::controller () const
+	{
+		return self->controller;
+	}
+
+	float
+	ControlChangeEvent::value () const
+	{
+		return self->value;
+	}
+
+	bool
+	ControlChangeEvent::is_captured () const
+	{
+		return self->captured;
+	}
+
+
 	struct CaptureEvent::Data
 	{
 

data/src/event.h

@@ -49,9 +49,20 @@ namespace Reflex
 	void WheelEvent_set_position (WheelEvent* pthis, const Point& position);
 
 
+	bool MIDIEvent_to_note_event (NoteEvent* result, const MIDIEvent& event);
+
+	bool MIDIEvent_to_control_change_event (
+		ControlChangeEvent* result, const MIDIEvent& event);
+
+	void MIDIEvent_set_captured (MIDIEvent* pthis, bool captured);
+
+
 	void NoteEvent_set_captured (NoteEvent* pthis, bool captured);
 
 
+	void ControlChangeEvent_set_captured (ControlChangeEvent* pthis, bool captured);
+
+
 }// Reflex
 
 

data/src/midi.cpp

@@ -33,33 +33,7 @@ namespace Reflex
 	};// MIDI::Data
 
 
-	static void
-	call_note_event (
-		MIDI* midi, bool on,
-		int channel, int note, float velocity, double time)
-	{
-		NoteEvent e(
-			on ? NoteEvent::ON : NoteEvent::OFF,
-			channel, note, velocity, time);
-
-		midi->on_note(&e);
-		if (e.is_blocked()) return;
-
-		switch ((int) e.action())
-		{
-			case NoteEvent::ON:  midi->on_note_on(&e);  break;
-			case NoteEvent::OFF: midi->on_note_off(&e); break;
-		}
-		if (e.is_blocked()) return;
-
-		Window* win = Window_get_active();
-		if (!win) return;
-
-		Window_call_note_event(win, &e);
-	}
-
-
-	struct MIDIEvent
+	struct RtMidiEvent
 	{
 
 		typedef std::vector<unsigned char> Message;
@@ -76,60 +50,84 @@ namespace Reflex
 
 		double time = 0;
 
-		MIDIEvent ()
+		RtMidiEvent ()
 		:	error("")
 		{
 		}
 
-		MIDIEvent (MIDI* midi, const Message& message, double time)
+		RtMidiEvent (MIDI* midi, const Message& message, double time)
 		:	type(MESSAGE), midi(midi), message(message), error(""), time(time)
 		{
 		}
 
-		MIDIEvent (MIDI* midi, const RtMidiError& error)
+		RtMidiEvent (MIDI* midi, const RtMidiError& error)
 		:	type(ERROR), midi(midi), error(error)
 		{
 		}
 
-	};// MIDIEvent
+	};// RtMidiEvent
+
+
+	static void
+	call_midi_note_event (MIDI* midi, NoteEvent* event)
+	{
+		midi->on_note(event);
+		if (event->is_blocked())
+			return;
+
+		switch ((int) event->action())
+		{
+			case NoteEvent::ON:  midi->on_note_on(event);  break;
+			case NoteEvent::OFF: midi->on_note_off(event); break;
+		}
+	}
 
+	static void
+	call_midi_event (MIDI* midi, const MIDIEvent& event)
+	{
+		NoteEvent note_e;
+		if (MIDIEvent_to_note_event(&note_e, event))
+			call_midi_note_event(midi, &note_e);
 
-	static Queue<MIDIEvent> queue;
+		ControlChangeEvent cc_e;
+		if (MIDIEvent_to_control_change_event(&cc_e, event))
+			midi->on_control_change(&cc_e);
+	}
 
 	static void
-	dispatch_midi_event (MIDIEvent* event)
+	call_events (MIDI* midi, const uchar* bytes, double time)
+	{
+		MIDIEvent event(midi, bytes, time);
+
+		midi->on_midi(&event);
+		if (event.is_blocked()) return;
+
+		call_midi_event(midi, event);
+
+		Window* win = Window_get_active();
+		if (!win) return;
+
+		Window_call_midi_event(win, &event);
+	}
+
+	static Queue<RtMidiEvent> queue;
+
+	static void
+	dispatch_midi_event (RtMidiEvent* event)
 	{
 		switch (event->type)
 		{
-			case MIDIEvent::MESSAGE:
-			{
-				auto& bytes = event->message;
-				switch (bytes[0] >> 4)
-				{
-					case 0x9:
-						call_note_event(
-							event->midi, true,
-							bytes[0] & 0xf, bytes[1], bytes[2] / 127.f, event->time);
-						break;
-
-					case 0x8:
-						call_note_event(
-							event->midi, false,
-							bytes[0] & 0xf, bytes[1], bytes[2] / 127.f, event->time);
-						break;
-				}
+			case RtMidiEvent::MESSAGE:
+				call_events(event->midi, &event->message[0], event->time);
 				break;
-			}
 
-			case MIDIEvent::ERROR:
-			{
+			case RtMidiEvent::ERROR:
 				system_error(
 					__FILE__, __LINE__,
 					Xot::stringf("MIDI: %s", event->error.what()).c_str());
 				break;
-			}
 
-			case MIDIEvent::UNKNOWN:
+			case RtMidiEvent::UNKNOWN:
 				invalid_state_error(__FILE__, __LINE__);
 		}
 	}
@@ -137,13 +135,13 @@ namespace Reflex
 	static void
 	process_midi_events ()
 	{
-		MIDIEvent event;
+		RtMidiEvent event;
 		while (queue.try_pop(&event))
 			dispatch_midi_event(&event);
 	}
 
 	static void
-	event_callback (double dt, MIDIEvent::Message* message, void* data)
+	event_callback (double dt, RtMidiEvent::Message* message, void* data)
 	{
 		MIDI* midi       = (MIDI*) data;
 		MIDI::Data* self = midi->self.get();
@@ -153,7 +151,7 @@ namespace Reflex
 		else
 			self->time += dt;
 
-		queue.push(MIDIEvent(midi, *message, self->time));
+		queue.push(RtMidiEvent(midi, *message, self->time));
 	}
 
 	static void
@@ -161,7 +159,7 @@ namespace Reflex
 	{
 		MIDI* midi = (MIDI*) data;
 
-		queue.push(MIDIEvent(midi, RtMidiError(message, type)));
+		queue.push(RtMidiEvent(midi, RtMidiError(message, type)));
 	}
 
 	static MIDI_CreateFun midi_create_fun = NULL;
@@ -349,6 +347,11 @@ namespace Reflex
 		return self->name;
 	}
 
+	void
+	MIDI::on_midi (MIDIEvent* e)
+	{
+	}
+
 	void
 	MIDI::on_note (NoteEvent* e)
 	{
@@ -364,6 +367,11 @@ namespace Reflex
 	{
 	}
 
+	void
+	MIDI::on_control_change (ControlChangeEvent* e)
+	{
+	}
+
 	MIDI::operator bool () const
 	{
 		return self->input.isPortOpen();

data/src/view.cpp

@@ -1508,6 +1508,20 @@ namespace Reflex
 		view->on_wheel(&e);
 	}
 
+	void
+	View_call_midi_event (View* view, MIDIEvent* event)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		if (view->hidden()) return;
+
+		MIDIEvent e = event->dup();
+		view->on_midi(&e);
+	}
+
 	void
 	View_call_note_event (View* view, NoteEvent* event)
 	{
@@ -1530,6 +1544,20 @@ namespace Reflex
 		}
 	}
 
+	void
+	View_call_control_change_event (View* view, ControlChangeEvent* event)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		if (view->hidden()) return;
+
+		ControlChangeEvent e = event->dup();
+		view->on_control_change(&e);
+	}
+
 	void
 	View_call_contact_event (View* view, ContactEvent* event)
 	{
@@ -2805,6 +2833,11 @@ namespace Reflex
 		//scroll_by(e->dx, e->dy, e->dz);
 	}
 
+	void
+	View::on_midi (MIDIEvent* e)
+	{
+	}
+
 	void
 	View::on_note (NoteEvent* e)
 	{
@@ -2820,6 +2853,11 @@ namespace Reflex
 	{
 	}
 
+	void
+	View::on_control_change (ControlChangeEvent* e)
+	{
+	}
+
 	void
 	View::on_capture (CaptureEvent* e)
 	{

data/src/view.h

@@ -36,15 +36,19 @@ namespace Reflex
 
 	void View_update_shapes (View* view);
 
-	void View_call_key_event     (View* view, KeyEvent* event);
+	void View_call_key_event            (View* view, KeyEvent* event);
 
-	void View_call_pointer_event (View* view, PointerEvent* event);
+	void View_call_pointer_event        (View* view, PointerEvent* event);
 
-	void View_call_wheel_event   (View* view, WheelEvent* event);
+	void View_call_wheel_event          (View* view, WheelEvent* event);
 
-	void View_call_note_event    (View* view, NoteEvent* event);
+	void View_call_midi_event           (View* view, MIDIEvent* event);
 
-	void View_call_contact_event (View* view, ContactEvent* event);
+	void View_call_note_event           (View* view, NoteEvent* event);
+
+	void View_call_control_change_event (View* view, ControlChangeEvent* event);
+
+	void View_call_contact_event        (View* view, ContactEvent* event);
 
 
 }// Reflex

data/src/window.cpp

@@ -262,8 +262,6 @@ namespace Reflex
 			KeyEvent e = event->dup();
 			KeyEvent_set_captured(&e, true);
 			View_call_key_event(const_cast<View*>(view.get()), &e);
-
-			if (e.is_blocked()) event->block();
 		}
 
 		if (!event->is_blocked())
@@ -607,7 +605,7 @@ namespace Reflex
 		View_call_wheel_event(window->root(), event);
 	}
 
-	void
+	static void
 	Window_call_note_event (Window* window, NoteEvent* event)
 	{
 		assert(window);
@@ -619,7 +617,7 @@ namespace Reflex
 		{
 			if (
 				!view->window() ||
-				!is_capturing(view.get(), targets, View::CAPTURE_NOTE))
+				!is_capturing(view.get(), targets, View::CAPTURE_MIDI))
 			{
 				continue;
 			}
@@ -627,8 +625,6 @@ namespace Reflex
 			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())
@@ -646,6 +642,75 @@ namespace Reflex
 
 		if (!event->is_blocked() && window->self->focus)
 			View_call_note_event(window->self->focus.get(), event);
+	}
+
+	static void
+	Window_call_control_change_event (Window* window, ControlChangeEvent* 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_MIDI))
+			{
+				continue;
+			}
+
+			ControlChangeEvent e = event->dup();
+			ControlChangeEvent_set_captured(&e, true);
+			View_call_control_change_event(const_cast<View*>(view.get()), &e);
+		}
+
+		if (!event->is_blocked())
+			window->on_control_change(event);
+
+		if (!event->is_blocked() && window->self->focus)
+			View_call_control_change_event(window->self->focus.get(), event);
+	}
+
+	void
+	Window_call_midi_event (Window* window, MIDIEvent* event)
+	{
+		if (!window) return;
+
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		for (auto& [view, targets] : window->self->captures)
+		{
+			if (
+				!view->window() ||
+				!is_capturing(view.get(), targets, View::CAPTURE_MIDI))
+			{
+				continue;
+			}
+
+			MIDIEvent e = event->dup();
+			MIDIEvent_set_captured(&e, true);
+			View_call_midi_event(const_cast<View*>(view.get()), &e);
+		}
+
+		if (!event->is_blocked())
+			window->on_midi(event);
+
+		if (!event->is_blocked() && window->self->focus)
+			View_call_midi_event(window->self->focus.get(), event);
+
+		if (!event->is_blocked())
+		{
+			NoteEvent note_e;
+			if (MIDIEvent_to_note_event(&note_e, *event))
+				Window_call_note_event(window, &note_e);
+
+			ControlChangeEvent cc_e;
+			if (MIDIEvent_to_control_change_event(&cc_e, *event))
+				Window_call_control_change_event(window, &cc_e);
+		}
 
 		cleanup_captures(window);
 	}
@@ -941,6 +1006,11 @@ namespace Reflex
 	{
 	}
 
+	void
+	Window::on_midi (MIDIEvent* e)
+	{
+	}
+
 	void
 	Window::on_note (NoteEvent* e)
 	{
@@ -956,6 +1026,11 @@ namespace Reflex
 	{
 	}
 
+	void
+	Window::on_control_change (ControlChangeEvent* e)
+	{
+	}
+
 	Window::operator bool () const
 	{
 		return self && *self;

data/src/window.h

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

data/test/test_capture_event.rb

@@ -26,34 +26,34 @@ class TestCaptureEvent < Test::Unit::TestCase
   end
 
   def test_begin()
-    c = event [:key, :pointer, :note], []
-    assert_equal [:key, :pointer, :note], c.begin
+    c = event [:key, :pointer, :midi], []
+    assert_equal [:key, :pointer, :midi], 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?(:midi)
     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?(:note)
+    assert_equal false,  c.begin?(:midi)
     assert_equal false,  c.begin?(:all)
   end
 
   def test_end()
-    c = event [], [:key, :pointer, :note]
-    assert_equal [:key, :pointer, :note], c.end
+    c = event [], [:key, :pointer, :midi]
+    assert_equal [:key, :pointer, :midi], 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?(:midi)
     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?(:note)
+    assert_equal false,  c.end?(:midi)
     assert_equal false,  c.end?(:all)
   end