reflexion 0.3.6 → 0.3.7

data/src/event.cpp

@@ -17,14 +17,14 @@ namespace Reflex
 	struct Event::Data
 	{
 
-		bool blocked;
-
 		double time;
 
+		bool blocked;
+
 		Data* parent = NULL;
 
-		Data (bool blocked = false, double time = Xot::time())
-		:	blocked(blocked), time(time)
+		Data (double time = -1, bool blocked = false)
+		:	time(time >= 0 ? time : Xot::time()), blocked(blocked)
 		{
 		}
 
@@ -37,7 +37,8 @@ namespace Reflex
 	};// Event::Data
 
 
-	Event::Event ()
+	Event::Event (double time)
+	:	self(new Data(time))
 	{
 	}
 
@@ -562,8 +563,9 @@ namespace Reflex
 	}
 
 	KeyEvent::KeyEvent (
-		Action action, const char* chars, int code, uint modifiers, int repeat)
-	:	self(new Data(action, chars, code, modifiers, repeat))
+		Action action, const char* chars, int code, uint modifiers, int repeat,
+		double time)
+	:	Event(time), self(new Data(action, chars, code, modifiers, repeat))
 	{
 	}
 
@@ -866,6 +868,92 @@ namespace Reflex
 	}
 
 
+	struct NoteEvent::Data
+	{
+
+		Action action  = ACTION_NONE;
+
+		int channel    = 0;
+
+		int note       = 0;
+
+		float velocity = 0;
+
+		bool captured  = false;
+
+	};// NoteEvent::Data
+
+
+	void
+	NoteEvent_set_captured (NoteEvent* pthis, bool captured)
+	{
+		pthis->self->captured = captured;
+	}
+
+
+	NoteEvent::NoteEvent ()
+	{
+	}
+
+	NoteEvent::NoteEvent (
+		Action action, int channel, int note, float velocity, double time)
+	:	Event(time)
+	{
+		self->action   = action;
+		self->channel  = channel;
+		self->note     = note;
+		self->velocity = velocity;
+	}
+
+	NoteEvent::NoteEvent (const NoteEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
+	}
+
+	NoteEvent
+	NoteEvent::dup () const
+	{
+		return NoteEvent(this);
+	}
+
+	NoteEvent::Action
+	NoteEvent::action () const
+	{
+		return self->action;
+	}
+
+	int
+	NoteEvent::channel () const
+	{
+		return self->channel;
+	}
+
+	int
+	NoteEvent::note () const
+	{
+		return self->note;
+	}
+
+	float
+	NoteEvent::frequency () const
+	{
+		static const int A4 = 69;
+		return 440 * std::pow(2.0, (note() - A4) / 12.0);
+	}
+
+	float
+	NoteEvent::velocity () const
+	{
+		return self->velocity;
+	}
+
+	bool
+	NoteEvent::is_captured () const
+	{
+		return self->captured;
+	}
+
+
 	struct CaptureEvent::Data
 	{
 

data/src/event.h

@@ -19,6 +19,8 @@ namespace Reflex
 	void DrawEvent_set_bounds  (DrawEvent* pthis, const Bounds& bounds);
 
 
+	uint KeyEvent_get_modifiers ();
+
 	void KeyEvent_set_chars (KeyEvent* pthis, const char* chars);
 
 	void KeyEvent_set_captured (KeyEvent* pthis, bool captured);
@@ -47,6 +49,9 @@ namespace Reflex
 	void WheelEvent_set_position (WheelEvent* pthis, const Point& position);
 
 
+	void NoteEvent_set_captured (NoteEvent* pthis, bool captured);
+
+
 }// Reflex
 
 

data/src/gamepad.cpp

@@ -39,20 +39,6 @@ namespace Reflex
 	}
 
 
-	static Gamepad_CreateFun gamepad_create_fun = NULL;
-
-	void
-	Gamepad_set_create_fun (Gamepad_CreateFun fun)
-	{
-		gamepad_create_fun = fun;
-	}
-
-	Gamepad*
-	Gamepad_create ()
-	{
-		return gamepad_create_fun ? gamepad_create_fun() : new Gamepad();
-	}
-
 	static Gamepad::List gamepads;
 
 	void
@@ -107,6 +93,20 @@ namespace Reflex
 		return 0.35;
 	}
 
+	static Gamepad_CreateFun gamepad_create_fun = NULL;
+
+	void
+	Gamepad_set_create_fun (Gamepad_CreateFun fun)
+	{
+		gamepad_create_fun = fun;
+	}
+
+	Gamepad*
+	Gamepad_create ()
+	{
+		return gamepad_create_fun ? gamepad_create_fun() : new Gamepad();
+	}
+
 
 	Gamepad::Gamepad ()
 	{

data/src/gamepad.h

@@ -1,7 +1,7 @@
 // -*- c++ -*-
 #pragma once
-#ifndef __REFLEX_SRC_DEVICE_H__
-#define __REFLEX_SRC_DEVICE_H__
+#ifndef __REFLEX_SRC_GAMEPAD_H__
+#define __REFLEX_SRC_GAMEPAD_H__
 
 
 #include <memory>
@@ -46,17 +46,10 @@ namespace Reflex
 	};// Gamepad
 
 
-	typedef Gamepad* (*Gamepad_CreateFun) ();
-
-
 	void Gamepad_init (Application* app);
 
 	void Gamepad_fin  (Application* app);
 
-	void Gamepad_set_create_fun (Gamepad_CreateFun fun);
-
-	Gamepad* Gamepad_create ();
-
 	void Gamepad_add    (Application* app, Gamepad* gamepad);
 
 	void Gamepad_remove (Application* app, Gamepad* gamepad);
@@ -68,6 +61,13 @@ namespace Reflex
 	float Gamepad_get_button_press_threshold ();
 
 
+	typedef Gamepad* (*Gamepad_CreateFun) ();
+
+	void Gamepad_set_create_fun (Gamepad_CreateFun fun);
+
+	Gamepad* Gamepad_create ();
+
+
 }// Reflex
 
 

data/src/ios/event.mm

@@ -54,10 +54,11 @@ namespace Reflex
 	static uint
 	get_modifiers (const UIEvent* event)
 	{
-		assert(event);
+		if (!event) return 0;
 
 		NSInteger flags = 0;
-		if (@available(iOS 13.4, *)) flags = event.modifierFlags;
+		if (@available(iOS 13.4, *))
+			flags = event.modifierFlags;
 
 		return
 			(flags & UIKeyModifierAlphaShift) ? MOD_CAPS    : 0 |
@@ -68,6 +69,13 @@ namespace Reflex
 			(flags & UIKeyModifierNumericPad) ? MOD_NUMPAD  : 0;
 	}
 
+	uint
+	KeyEvent_get_modifiers ()
+	{
+		return get_modifiers(nil);
+	}
+
+
 	NativePointerEvent::NativePointerEvent (
 		NSSet* touches, UIEvent* event, UIView* view)
 	{

data/src/ios/gamepad.mm

@@ -4,6 +4,7 @@
 
 #import <GameController/GameController.h>
 #include "reflex/exception.h"
+#include "../event.h"
 #include "window.h"
 
 
@@ -63,7 +64,7 @@ namespace Reflex
 		if (!win) return;
 
 		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
-		KeyEvent e(action, NULL, key_code, 0, 0);
+		KeyEvent e(action, NULL, key_code, KeyEvent_get_modifiers(), 0);
 		Window_call_key_event(win, &e);
 	}
 

data/src/midi.cpp

@@ -0,0 +1,379 @@
+#include "midi.h"
+
+
+#include <algorithm>
+#include <RtMidi.h>
+#include <xot/time.h>
+#include "reflex/exception.h"
+#include "reflex/debug.h"
+#include "queue.h"
+#include "event.h"
+#include "application.h"
+#include "window.h"
+
+
+namespace Reflex
+{
+
+
+	struct MIDI::Data
+	{
+
+		RtMidiIn input;
+
+		String name;
+
+		double time = 0;
+
+		~Data ()
+		{
+			input.closePort();
+		}
+
+	};// 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
+	{
+
+		typedef std::vector<unsigned char> Message;
+
+		enum Type {UNKNOWN, MESSAGE, ERROR};
+
+		Type type = UNKNOWN;
+
+		MIDI::Ref midi;
+
+		Message message;
+
+		RtMidiError error;
+
+		double time = 0;
+
+		MIDIEvent ()
+		:	error("")
+		{
+		}
+
+		MIDIEvent (MIDI* midi, const Message& message, double time)
+		:	type(MESSAGE), midi(midi), message(message), error(""), time(time)
+		{
+		}
+
+		MIDIEvent (MIDI* midi, const RtMidiError& error)
+		:	type(ERROR), midi(midi), error(error)
+		{
+		}
+
+	};// MIDIEvent
+
+
+	static Queue<MIDIEvent> queue;
+
+	static void
+	dispatch_midi_event (MIDIEvent* 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;
+				}
+				break;
+			}
+
+			case MIDIEvent::ERROR:
+			{
+				system_error(
+					__FILE__, __LINE__,
+					Xot::stringf("MIDI: %s", event->error.what()).c_str());
+				break;
+			}
+
+			case MIDIEvent::UNKNOWN:
+				invalid_state_error(__FILE__, __LINE__);
+		}
+	}
+
+	static void
+	process_midi_events ()
+	{
+		MIDIEvent event;
+		while (queue.try_pop(&event))
+			dispatch_midi_event(&event);
+	}
+
+	static void
+	midi_callback (double dt, MIDIEvent::Message* message, void* data)
+	{
+		MIDI* midi       = (MIDI*) data;
+		MIDI::Data* self = midi->self.get();
+
+		if (self->time == 0)
+			self->time = Xot::time();
+		else
+			self->time += dt;
+
+		queue.push(MIDIEvent(midi, *message, self->time));
+	}
+
+	static void
+	error_callback (RtMidiError::Type type, const std::string& message, void* data)
+	{
+		MIDI* midi = (MIDI*) data;
+
+		queue.push(MIDIEvent(midi, RtMidiError(message, type)));
+	}
+
+	static MIDI_CreateFun midi_create_fun = NULL;
+
+	void
+	MIDI_set_create_fun (MIDI_CreateFun fun)
+	{
+		midi_create_fun = fun;
+	}
+
+	static MIDI*
+	create_midi ()
+	{
+		return midi_create_fun ? midi_create_fun() : new MIDI();
+	}
+
+	static void
+	open_midi (MIDI* midi, uint port)
+	{
+		MIDI::Data* self = midi->self.get();
+
+		if (port >= self->input.getPortCount())
+			argument_error(__FILE__, __LINE__);
+
+		self->name = self->input.getPortName(port);
+		self->input.setCallback(midi_callback, midi);
+		self->input.setErrorCallback(error_callback, midi);
+		self->input.openPort(port);
+		self->input.ignoreTypes(false, false, false);
+	}
+
+	static MIDI::List midis;
+
+	static void
+	add_midi (MIDI* midi)
+	{
+		midis.emplace_back(midi);
+		Application_call_device_connect(app(), midi);
+	}
+
+	static void
+	remove_midi (MIDI* midi)
+	{
+		MIDI::Ref ref = midi;
+		auto it = std::find(midis.begin(), midis.end(), ref);
+		if (it == midis.end()) return;
+
+		midis.erase(it);
+		Application_call_device_disconnect(app(), ref);
+	}
+
+
+	struct MIDIDeviceManager
+	{
+
+		RtMidiIn manager;
+
+		uint duplicated_port_name_count = 0;
+
+		MIDIDeviceManager ()
+		{
+			update();
+		}
+
+		~MIDIDeviceManager ()
+		{
+			for (auto& midi : midis)
+				Application_call_device_disconnect(app(), midi);
+		}
+
+		void update ()
+		{
+			uint count = manager.getPortCount() - duplicated_port_name_count;
+			if (count > midis.size())
+				on_connect();
+			else if (count < midis.size())
+				on_disconnect();
+		}
+
+		void on_connect ()
+		{
+			std::set<String> names;
+			for (auto& midi : midis)
+				names.emplace(midi->self->name);
+
+			each_port([&](int port, auto& name)
+			{
+				if (names.contains(name)) return;
+
+				MIDI* midi = create_midi();
+				open_midi(midi, port);
+				add_midi(midi);
+			});
+
+			update_duplicated_port_name_count();
+		}
+
+		void on_disconnect ()
+		{
+			std::set<String> port_names;
+			get_port_names(&port_names);
+
+			while (true)
+			{
+				auto it = std::find_if(
+					midis.begin(), midis.end(),
+					[&](auto& midi) {return !port_names.contains(midi->self->name);});
+				if (it == midis.end()) break;
+
+				remove_midi(*it);
+			}
+
+			update_duplicated_port_name_count();
+		}
+
+		void update_duplicated_port_name_count ()
+		{
+			std::set<String> port_names;
+			get_port_names(&port_names);
+
+			duplicated_port_name_count =
+				manager.getPortCount() - (uint) port_names.size();
+		}
+
+		void get_port_names (std::set<String>* names)
+		{
+			each_port([&](int, auto& name) {names->emplace(name);});
+		}
+
+		void each_port (std::function<void(int, const std::string&)> fun)
+		{
+			uint size = manager.getPortCount();
+			for (uint i = 0; i < size; ++i)
+				fun(i, manager.getPortName(i));
+		}
+
+	};// MIDIDeviceManager
+
+
+	static std::unique_ptr<MIDIDeviceManager> manager;
+
+	void
+	MIDI_init (Application* app)
+	{
+		if (manager)
+			invalid_state_error(__FILE__, __LINE__);
+
+		manager.reset(new MIDIDeviceManager());
+	}
+
+	void
+	MIDI_fin (Application* app)
+	{
+		if (!manager)
+			invalid_state_error(__FILE__, __LINE__);
+
+		manager.reset();
+	}
+
+	void
+	MIDI_process_events ()
+	{
+		process_midi_events();
+
+		static double prev_time = 0;
+		if (manager && Xot::time() - prev_time > 0.5)
+		{
+			manager->update();
+			prev_time = Xot::time();
+		}
+	}
+
+
+	MIDI::MIDI ()
+	{
+	}
+
+	MIDI::~MIDI ()
+	{
+	}
+
+	const char*
+	MIDI::name () const
+	{
+		return self->name;
+	}
+
+	void
+	MIDI::on_note (NoteEvent* e)
+	{
+	}
+
+	void
+	MIDI::on_note_on (NoteEvent* e)
+	{
+	}
+
+	void
+	MIDI::on_note_off (NoteEvent* e)
+	{
+	}
+
+	MIDI::operator bool () const
+	{
+		return self->input.isPortOpen();
+	}
+
+	const MIDI::List&
+	MIDI::all ()
+	{
+		return midis;
+	}
+
+
+}// Reflex

data/src/midi.h

@@ -0,0 +1,32 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_MIDI_H__
+#define __REFLEX_SRC_MIDI_H__
+
+
+#include "reflex/midi.h"
+
+
+namespace Reflex
+{
+
+
+	class Application;
+
+
+	void MIDI_init (Application* app);
+
+	void MIDI_fin  (Application* app);
+
+	void MIDI_process_events ();
+
+
+	typedef MIDI* (*MIDI_CreateFun) ();
+
+	void MIDI_set_create_fun (MIDI_CreateFun fun);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/osx/event.h

@@ -53,9 +53,6 @@ namespace Reflex
 	};// NativeWheelEvent
 
 
-	uint get_key_modifiers ();
-
-
 }// Reflex
 
 

data/src/osx/event.mm

@@ -28,12 +28,6 @@ namespace Reflex
 			(flags & NSFunctionKeyMask)   ? MOD_FUNCTION : 0;
 	}
 
-	uint
-	get_key_modifiers ()
-	{
-		return get_modifiers(nil);
-	}
-
 	static Point
 	get_pointer_position (NSEvent* e, NSView* view)
 	{
@@ -44,6 +38,12 @@ namespace Reflex
 		return Point(p.x, p.y);
 	}
 
+	uint
+	KeyEvent_get_modifiers ()
+	{
+		return get_modifiers(nil);
+	}
+
 
 	static const char*
 	get_chars (NSEvent* e)