reflexion 0.6.0 → 0.7.0

data/src/menu.cpp

@@ -4,12 +4,73 @@
 #include <algorithm>
 #include <rays/point.h>
 #include "reflex/exception.h"
+#include "application.h"
+#include "view.h"
+#include "window.h"
 
 
 namespace Reflex
 {
 
 
+	void
+	Menu_cancel_active_pointers_for_popup (View* view)
+	{
+		Window* window = view ? view->window() : Window_get_active();
+		if (!window) return;
+
+		// popup runs a modal event loop that swallows every event until the
+		// menu is dismissed, so pointers being pressed would never see their
+		// up; canceling them first keeps every pointer stream closed.
+		Window_cancel_active_pointers(window);
+	}
+
+	void
+	Menu_call_click_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_click(event);
+		});
+	}
+
+	void
+	Menu_call_show_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_show(event);
+		});
+	}
+
+	void
+	Menu_call_hide_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_hide(event);
+		});
+	}
+
+	void
+	Menu_call_open_submenu_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_open_submenu(event);
+		});
+	}
+
+	void
+	Menu_call_close_submenu_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_close_submenu(event);
+		});
+	}
+
+
 	Menu::Data::Data ()
 	{
 	}
@@ -194,9 +255,10 @@ namespace Reflex
 	}
 
 	void
-	Menu::set_shortcut (const char* key, uint modifiers)
+	Menu::set_shortcut (KeyCode key, uint modifiers)
 	{
-		if (!key) key = "";
+		Menu_validate_shortcut_modifiers(modifiers);
+
 		if (key == self->key && modifiers == self->modifiers)
 			return;
 
@@ -205,10 +267,10 @@ namespace Reflex
 		Menu_update(this);
 	}
 
-	const char*
+	KeyCode
 	Menu::shortcut_key () const
 	{
-		return self->key.c_str();
+		return self->key;
 	}
 
 	uint

data/src/menu.h

@@ -19,10 +19,12 @@ namespace Reflex
 
 		Xot::WeakRef<Menu> parent;
 
-		String label, key;
+		String label;
 
 		Image image;
 
+		KeyCode key    = KEY_NONE;
+
 		uint modifiers = MOD_NONE;
 
 		bool enabled   = true;
@@ -50,6 +52,8 @@ namespace Reflex
 
 	Menu::Data* Menu_create_data ();
 
+	void Menu_validate_shortcut_modifiers (uint modifiers);
+
 	void Menu_update (Menu* menu);
 
 	void Menu_popup (Menu* menu, View* view, coord x, coord y);
@@ -58,6 +62,18 @@ namespace Reflex
 
 	void Menu_child_removed (Menu* parent, Menu* child);
 
+	void Menu_cancel_active_pointers_for_popup (View* view);
+
+	void Menu_call_click_event         (Menu* menu, Event* event);
+
+	void Menu_call_show_event          (Menu* menu, Event* event);
+
+	void Menu_call_hide_event          (Menu* menu, Event* event);
+
+	void Menu_call_open_submenu_event  (Menu* menu, Event* event);
+
+	void Menu_call_close_submenu_event (Menu* menu, Event* event);
+
 
 }// Reflex
 

data/src/midi.cpp

@@ -40,23 +40,24 @@ namespace Reflex
 
 		enum Type {UNKNOWN, MESSAGE, ERROR};
 
-		Type type = UNKNOWN;
+		Type type  = UNKNOWN;
 
-		MIDI::Ref midi;
+		MIDI* midi = NULL;
 
 		Message message;
 
 		RtMidiError error;
 
-		double time = 0;
+		double time = 0, delta_time = 0;
 
 		RtMidiEvent ()
 		:	error("")
 		{
 		}
 
-		RtMidiEvent (MIDI* midi, const Message& message, double time)
-		:	type(MESSAGE), midi(midi), message(message), error(""), time(time)
+		RtMidiEvent (MIDI* midi, const Message& message, double time, double delta_time)
+		:	type(MESSAGE), midi(midi), message(message), error(""),
+			time(time), delta_time(delta_time)
 		{
 		}
 
@@ -104,13 +105,34 @@ namespace Reflex
 
 		call_midi_event(midi, event);
 
-		Window* win = Window_get_active();
-		if (!win) return;
+		for (auto& win : Window_all())
+		{
+			MIDIEvent e = event.dup();
+			Window_call_midi_event(win, &e);
+		}
+	}
+
+	static MIDI::List midis;
 
-		Window_call_midi_event(win, &event);
+	static MIDI::Ref
+	find_midi (MIDI* midi)
+	{
+		auto it = std::find_if(
+			midis.begin(), midis.end(),
+			[=](const MIDI::Ref& ref) {return ref.get() == midi;});
+		return it == midis.end() ? MIDI::Ref() : *it;
 	}
 
-	static Queue<RtMidiEvent> queue;
+	static double
+	apply_time (MIDI* midi, const RtMidiEvent& event)
+	{
+		MIDI::Data* self = midi->self.get();
+		if (self->time == 0)
+			self->time  = event.time;
+		else
+			self->time += event.delta_time;
+		return self->time;
+	}
 
 	static void
 	dispatch_midi_event (RtMidiEvent* event)
@@ -118,8 +140,12 @@ namespace Reflex
 		switch (event->type)
 		{
 			case RtMidiEvent::MESSAGE:
-				call_events(event->midi, &event->message[0], event->time);
+			{
+				MIDI::Ref midi = find_midi(event->midi);
+				if (midi)
+					call_events(midi, event->message.data(), apply_time(midi, *event));
 				break;
+			}
 
 			case RtMidiEvent::ERROR:
 				system_error(
@@ -132,6 +158,8 @@ namespace Reflex
 		}
 	}
 
+	static Queue<RtMidiEvent> queue;
+
 	static void
 	process_midi_events ()
 	{
@@ -143,23 +171,13 @@ namespace Reflex
 	static void
 	event_callback (double dt, RtMidiEvent::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(RtMidiEvent(midi, *message, self->time));
+		queue.push(RtMidiEvent((MIDI*) data, *message, Xot::time(), dt));
 	}
 
 	static void
 	error_callback (RtMidiError::Type type, const std::string& message, void* data)
 	{
-		MIDI* midi = (MIDI*) data;
-
-		queue.push(RtMidiEvent(midi, RtMidiError(message, type)));
+		queue.push(RtMidiEvent((MIDI*) data, RtMidiError(message, type)));
 	}
 
 	static MIDI_CreateFun midi_create_fun = NULL;
@@ -191,13 +209,11 @@ namespace Reflex
 		self->name = name;
 	}
 
-	static MIDI::List midis;
-
 	static void
 	add_midi (MIDI* midi)
 	{
 		midis.emplace_back(midi);
-		Application_call_device_connect(app(), midi);
+		Application_call_device_connect_event(app(), midi);
 	}
 
 	static void
@@ -208,7 +224,7 @@ namespace Reflex
 		if (it == midis.end()) return;
 
 		midis.erase(it);
-		Application_call_device_disconnect(app(), ref);
+		Application_call_device_disconnect_event(app(), ref);
 	}
 
 
@@ -227,7 +243,7 @@ namespace Reflex
 		~MIDIDeviceManager ()
 		{
 			for (auto& midi : midis)
-				Application_call_device_disconnect(app(), midi);
+				Application_call_device_disconnect_event(app(), midi);
 		}
 
 		void update ()
@@ -308,8 +324,10 @@ namespace Reflex
 		return;
 #endif
 
-		if (manager)
-			invalid_state_error(__FILE__, __LINE__);
+		if (!app)
+			argument_error(__FILE__, __LINE__);
+
+		if (manager) return;
 
 		manager.reset(new MIDIDeviceManager());
 	}
@@ -317,8 +335,10 @@ namespace Reflex
 	void
 	MIDI_fin (Application* app)
 	{
-		if (!manager)
-			invalid_state_error(__FILE__, __LINE__);
+		if (!app)
+			argument_error(__FILE__, __LINE__);
+
+		if (!manager) return;
 
 		midis.clear();
 		manager.reset();
@@ -337,6 +357,16 @@ namespace Reflex
 		}
 	}
 
+	void
+	enable_midi ()
+	{
+		Application* app_ = app();
+		if (!app_)
+			invalid_state_error(__FILE__, __LINE__);
+
+		MIDI_init(app_);
+	}
+
 
 	MIDI::MIDI ()
 	{

data/src/osx/app_delegate.h

@@ -9,4 +9,8 @@
 
 	- (BOOL) callOnStart;
 
+	- (BOOL) isLaunched;
+
+	- (void) updateStatusItem;
+
 @end// ReflexAppDelegate

data/src/osx/app_delegate.mm

@@ -6,17 +6,19 @@
 #import <Cocoa/Cocoa.h>
 #include "reflex/event.h"
 #include "reflex/exception.h"
+#include "../application.h"
+#include "../rays.h"
 #include "menu.h"
 
 
 static Reflex::Menu::Ref
 create_menu (
 	const char* label, const char* name, SEL action = NULL,
-	const char* key = NULL, uint modifiers = Reflex::MOD_COMMAND)
+	Reflex::KeyCode key = Reflex::KEY_NONE, uint modifiers = Reflex::MOD_COMMAND)
 {
 	Reflex::Menu* item = new Reflex::Menu(label);
 	item->set_name(name);
-	if (key) item->set_shortcut(key, modifiers);
+	if (key != Reflex::KEY_NONE) item->set_shortcut(key, modifiers);
 	Reflex::Menu_set_native_action(item, action);
 	return item;
 }
@@ -40,17 +42,17 @@ create_application_menu (Reflex::Application* application)
 
 	app->add_child(create_menu(("About" + name).c_str(), "about", @selector(showAbout)));
 	app->add_child(create_sep());
-	app->add_child(create_menu("Preferences", "preferences", @selector(showPreference), ","));
+	app->add_child(create_menu("Preferences", "preferences", @selector(showPreference), KEY_COMMA));
 	app->add_child(create_sep());
 	app->add_child(services.get());
 	app->add_child(create_sep());
-	app->add_child(create_menu(("Hide" + name).c_str(), "hide", @selector(hide:), "h"));
+	app->add_child(create_menu(("Hide" + name).c_str(), "hide", @selector(hide:), KEY_H));
 	app->add_child(create_menu(
 		"Hide Others", "hide_others", @selector(hideOtherApplications:),
-		"h", MOD_OPTION | MOD_COMMAND));
+		KEY_H, MOD_OPTION | MOD_COMMAND));
 	app->add_child(create_menu("ShowAll", "show_all", @selector(unhideAllApplications:)));
 	app->add_child(create_sep());
-	app->add_child(create_menu(("Quit" + name).c_str(), "quit", @selector(quit), "q"));
+	app->add_child(create_menu(("Quit" + name).c_str(), "quit", @selector(quit), KEY_Q));
 
 	[NSApp setServicesMenu: Menu_get_nssubmenu(services)];
 	if ([NSApp respondsToSelector: @selector(setAppleMenu:)])
@@ -62,9 +64,11 @@ create_application_menu (Reflex::Application* application)
 static Reflex::Menu::Ref
 create_window_menu ()
 {
+	using namespace Reflex;
+
 	Reflex::Menu::Ref win = create_menu("Window", "window");
 
-	win->add_child(create_menu("Minimize", "minimize", @selector(performMiniaturize:), "m"));
+	win->add_child(create_menu("Minimize", "minimize", @selector(performMiniaturize:), KEY_M));
 	win->add_child(create_menu("Zoom", "zoom", @selector(performZoom:)));
 	win->add_child(create_sep());
 	win->add_child(create_menu(
@@ -80,7 +84,8 @@ create_window_menu ()
 
 	{
 		Reflex::Application* application;
-		bool started;
+		NSStatusItem* status_item;
+		bool launched;
 	}
 
 	- (id) init
@@ -89,7 +94,8 @@ create_window_menu ()
 		if (!self) return nil;
 
 		application = NULL;
-		started     = false;
+		status_item = nil;
+		launched    = false;
 
 		return self;
 	}
@@ -98,9 +104,20 @@ create_window_menu ()
 	{
 		assert(!application);
 
+		[self clearStatusItem];
+
 		[super dealloc];
 	}
 
+	- (void) clearStatusItem
+	{
+		if (!status_item) return;
+
+		[NSStatusBar.systemStatusBar removeStatusItem: status_item];
+		[status_item release];
+		status_item = nil;
+	}
+
 	- (void) bind: (Reflex::Application*) app
 	{
 		if (!app)
@@ -133,21 +150,59 @@ create_window_menu ()
 
 	- (BOOL) callOnStart
 	{
-		if (!application || started)
+		if (!application)
 			return YES;
 
 		Reflex::Event e;
-		Application_call_start(application, &e);
-		started = true;
+		Application_call_start_event(application, &e);
 
 		if (e.is_blocked()) [self quit];
 		return !e.is_blocked();
 	}
 
+	- (BOOL) isLaunched
+	{
+		return launched;
+	}
+
+	- (void) updateStatusItem
+	{
+		Reflex::Menu* menu = application ? application->background_menu() : NULL;
+		if (!menu && application && application->background())
+			menu = application->menu();
+		if (!menu)
+			return [self clearStatusItem];
+
+		if (!status_item)
+		{
+			status_item =
+				[[NSStatusBar.systemStatusBar statusItemWithLength: NSVariableStatusItemLength]
+					retain];
+		}
+
+		NSImage* image =
+			menu->image() ? Rays::Bitmap_get_nsimage(menu->image().bitmap()) : nil;
+		[image setTemplate: YES];
+
+		NSString* title = @"";
+		if (!image)
+		{
+			Reflex::String label     = menu->label();
+			if (label.empty()) label = application->name();
+			title = !label.empty()
+				?	[NSString stringWithUTF8String: label]
+				:	NSProcessInfo.processInfo.processName;
+		}
+
+		status_item.button.image = image;
+		status_item.button.title = title;
+		status_item.menu         = Reflex::Menu_get_nssubmenu(menu);
+	}
+
 	- (void) quit
 	{
 		if (application)
-			application->quit();
+			Application_call_quit(application);
 		else
 			[NSApp terminate: nil];
 	}
@@ -157,7 +212,7 @@ create_window_menu ()
 		if (!application) return;
 
 		Reflex::Event e;
-		application->on_preference(&e);
+		Application_call_preference_event(application, &e);
 	}
 
 	- (void) showAbout
@@ -165,7 +220,7 @@ create_window_menu ()
 		if (application)
 		{
 			Reflex::Event e;
-			application->on_about(&e);
+			Application_call_about_event(application, &e);
 		}
 		else
 			[NSApp orderFrontStandardAboutPanel: nil];
@@ -183,31 +238,56 @@ create_window_menu ()
 
 	- (void) applicationDidFinishLaunching: (NSNotification*) notification
 	{
-		[NSApp setActivationPolicy: NSApplicationActivationPolicyRegular];
-		[NSApp activateIgnoringOtherApps: YES];
+		if (application)
+			Application_set_background(application, application->background());
 
+		launched = true;
 		[self callOnStart];
 	}
 
 	- (NSApplicationTerminateReply) applicationShouldTerminate: (NSApplication*) application
 	{
-		if (self->application)
+		Reflex::Application* app = self->application;
+		if (!app) return NSTerminateNow;
+
+		if (app->self->running && !self.isQuitBySystem)
 		{
-			Reflex::Event e;
-			Application_call_quit(self->application, &e);
-			if (e.is_blocked()) return NSTerminateCancel;
+			Application_call_quit(app);
+			return NSTerminateCancel;
 		}
 
+		Reflex::Event e;
+		Application_call_quit_event(app, &e);
+		if (e.is_blocked()) return NSTerminateCancel;
+
 		return NSTerminateNow;
 	}
 
+	- (BOOL) isQuitBySystem
+	{
+		// log out, shut down and restart put a reason on the quit event,
+		// while a quit from the dock or a script comes without one
+		NSAppleEventDescriptor* event =
+			NSAppleEventManager.sharedAppleEventManager.currentAppleEvent;
+		return
+			event &&
+			event.eventClass == kCoreEventClass &&
+			event.eventID    == kAEQuitApplication &&
+			[event attributeDescriptorForKeyword: kAEQuitReason];
+	}
+
 	- (BOOL) applicationShouldTerminateAfterLastWindowClosed: (NSApplication*) application
 	{
-		return YES;
+		if (Application_should_quit(self->application))
+			[self quit];
+		return NO;
 	}
 
 	- (void) applicationWillTerminate: (NSNotification*) notification
 	{
+		if (application)
+			Application_cleanup(application);
+
 		[self unbind];
 	}