reflexion 0.5.3 → 0.7.0

data/src/menu.h

@@ -0,0 +1,81 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_MENU_H__
+#define __REFLEX_SRC_MENU_H__
+
+
+#include <memory>
+#include <rays/image.h>
+#include "reflex/menu.h"
+#include "selector.h"
+
+
+namespace Reflex
+{
+
+
+	struct Menu::Data
+	{
+
+		Xot::WeakRef<Menu> parent;
+
+		String label;
+
+		Image image;
+
+		KeyCode key    = KEY_NONE;
+
+		uint modifiers = MOD_NONE;
+
+		bool enabled   = true;
+
+		bool checked   = false;
+
+		bool separator = false;
+
+		std::unique_ptr<ChildList> pchildren;
+
+		SelectorPtr pselector;
+
+		Data ();
+
+		virtual ~Data ();
+
+		ChildList* children ()
+		{
+			if (!pchildren) pchildren.reset(new ChildList);
+			return pchildren.get();
+		}
+
+	};// Menu::Data
+
+
+	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);
+
+	void Menu_child_added   (Menu* parent, Menu* child, int index);
+
+	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
+
+
+#endif//EOH

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,13 +6,86 @@
 #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,
+	Reflex::KeyCode key = Reflex::KEY_NONE, uint modifiers = Reflex::MOD_COMMAND)
+{
+	Reflex::Menu* item = new Reflex::Menu(label);
+	item->set_name(name);
+	if (key != Reflex::KEY_NONE) item->set_shortcut(key, modifiers);
+	Reflex::Menu_set_native_action(item, action);
+	return item;
+}
+
+static Reflex::Menu::Ref
+create_sep ()
+{
+	return new Reflex::Menu("-");
+}
+
+static Reflex::Menu::Ref
+create_application_menu (Reflex::Application* application)
+{
+	using namespace Reflex;
+
+	String name = application->name();
+	if (!name.empty()) name = " " + name;
+
+	Menu::Ref app      = create_menu("Application", "application");
+	Menu::Ref services = create_menu("Services",    "services");
+
+	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), 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:), KEY_H));
+	app->add_child(create_menu(
+		"Hide Others", "hide_others", @selector(hideOtherApplications:),
+		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), KEY_Q));
+
+	[NSApp setServicesMenu: Menu_get_nssubmenu(services)];
+	if ([NSApp respondsToSelector: @selector(setAppleMenu:)])
+		[NSApp performSelector: @selector(setAppleMenu:) withObject: Menu_get_nssubmenu(app)];
+
+	return app;
+}
+
+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:), KEY_M));
+	win->add_child(create_menu("Zoom", "zoom", @selector(performZoom:)));
+	win->add_child(create_sep());
+	win->add_child(create_menu(
+		"Bring All to Front", "bring_all_to_front", @selector(arrangeInFront:)));
+
+	[NSApp setWindowsMenu: Menu_get_nssubmenu(win)];
+
+	return win;
+}
 
 
 @implementation ReflexAppDelegate
 
 	{
 		Reflex::Application* application;
-		bool started;
+		NSStatusItem* status_item;
+		bool launched;
 	}
 
 	- (id) init
@@ -21,7 +94,8 @@
 		if (!self) return nil;
 
 		application = NULL;
-		started     = false;
+		status_item = nil;
+		launched    = false;
 
 		return self;
 	}
@@ -30,9 +104,20 @@
 	{
 		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)
@@ -65,21 +150,59 @@
 
 	- (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];
 	}
@@ -89,7 +212,7 @@
 		if (!application) return;
 
 		Reflex::Event e;
-		application->on_preference(&e);
+		Application_call_preference_event(application, &e);
 	}
 
 	- (void) showAbout
@@ -97,7 +220,7 @@
 		if (application)
 		{
 			Reflex::Event e;
-			application->on_about(&e);
+			Application_call_about_event(application, &e);
 		}
 		else
 			[NSApp orderFrontStandardAboutPanel: nil];
@@ -105,161 +228,67 @@
 
 	- (void) applicationWillFinishLaunching: (NSNotification*) notification
 	{
-		[self setupMenu];
+		if (!application || [NSApp mainMenu]) return;
+
+		Reflex::Menu::Ref menu = new Reflex::Menu();
+		menu->add_child(create_application_menu(application));
+		menu->add_child(create_window_menu());
+		application->set_menu(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;
 		}
 
-		return NSTerminateNow;
-	}
-
-	- (BOOL) applicationShouldTerminateAfterLastWindowClosed: (NSApplication*) application
-	{
-		return YES;
-	}
+		Reflex::Event e;
+		Application_call_quit_event(app, &e);
+		if (e.is_blocked()) return NSTerminateCancel;
 
-	- (void) applicationWillTerminate: (NSNotification*) notification
-	{
-		[self unbind];
+		return NSTerminateNow;
 	}
 
-	- (BOOL) setupApplicationMenu: (NSMenu*) parent
+	- (BOOL) isQuitBySystem
 	{
-		if (!application || !parent) return NO;
-
-		NSMenu* menu = [[[NSMenu alloc]
-			initWithTitle: @"Application"]
-			autorelease];
-		if ([NSApp respondsToSelector: @selector(setAppleMenu:)])
-			[NSApp performSelector: @selector(setAppleMenu:) withObject: menu];
-
-		NSString* name = !application->self->name.empty() ?
-			[NSString stringWithUTF8String: application->self->name.c_str()] : @"";
-		if ([name length] > 0)
-			name = [@" " stringByAppendingString: name];
-
-		NSMenu* submenu = nil;
-		NSMenuItem* item = nil;
-
-		[menu
-			addItemWithTitle: [@"About" stringByAppendingString: name]
-			action: @selector(showAbout)
-			keyEquivalent: @""];
-
-		[menu addItem: [NSMenuItem separatorItem]];
-
-		[menu
-			addItemWithTitle: @"Preferences"
-			action: @selector(showPreference)
-			keyEquivalent: @","];
-
-		[menu addItem: [NSMenuItem separatorItem]];
-
-		item = [menu
-			addItemWithTitle: @"Services"
-			action: nil
-			keyEquivalent: @""];
-		submenu = [[[NSMenu alloc] initWithTitle: @"Services"] autorelease];
-		[item setSubmenu: submenu];
-		[NSApp setServicesMenu: submenu];
-
-		[menu addItem: [NSMenuItem separatorItem]];
-
-		[menu
-			addItemWithTitle: [@"Hide" stringByAppendingString: name]
-			action: @selector(hide:)
-			keyEquivalent: @"h"];
-
-		item = [menu
-			addItemWithTitle: @"Hide Others"
-			action: @selector(hideOtherApplications:)
-			keyEquivalent: @"h"];
-		[item setKeyEquivalentModifierMask: NSAlternateKeyMask | NSCommandKeyMask];
-
-		[menu
-			addItemWithTitle: @"ShowAll"
-			action: @selector(unhideAllApplications:)
-			keyEquivalent: @""];
-
-		[menu addItem: [NSMenuItem separatorItem]];
-
-		[menu
-			addItemWithTitle: [@"Quit" stringByAppendingString: name]
-			action: @selector(quit)
-			keyEquivalent: @"q"];
-
-		item =
-			[parent addItemWithTitle: @"Application" action: nil keyEquivalent: @""];
-		[parent setSubmenu: menu forItem: item];
-
-		return YES;
+		// 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) setupWindowMenu: (NSMenu*) parent
+	- (BOOL) applicationShouldTerminateAfterLastWindowClosed: (NSApplication*) application
 	{
-		if (!parent) return NO;
-
-		NSMenu* menu = [[[NSMenu alloc]
-			initWithTitle: @"Window"]
-			autorelease];
-
-		[menu
-			addItemWithTitle: @"Minimize"
-			action: @selector(performMiniaturize:)
-			keyEquivalent: @"m"];
-
-		[menu
-			addItemWithTitle: @"Zoom"
-			action: @selector(performZoom:)
-			keyEquivalent: @""];
-
-		[menu addItem: [NSMenuItem separatorItem]];
-
-		[menu
-			addItemWithTitle: @"Bring All to Front"
-			action: @selector(arrangeInFront:)
-			keyEquivalent: @""];
-
-		NSMenuItem* item =
-			[parent addItemWithTitle: @"Window" action: nil keyEquivalent: @""];
-		[parent setSubmenu: menu forItem: item];
-
-		[NSApp setWindowsMenu: menu];
-
-		return YES;
+		if (Application_should_quit(self->application))
+			[self quit];
+		return NO;
 	}
 
-	- (BOOL) setupMenu
+	- (void) applicationWillTerminate: (NSNotification*) notification
 	{
-		if ([NSApp mainMenu]) return NO;
-
-		NSMenu* menu = [[[NSMenu alloc] initWithTitle: @"MainMenu"] autorelease];
-
-		if (
-			![self setupApplicationMenu: menu] ||
-			![self setupWindowMenu: menu])
-		{
-			return NO;
-		}
-
-		[NSApp setMainMenu: menu];
+		if (application)
+			Application_cleanup(application);
 
-		return YES;
+		[self unbind];
 	}
 
 @end// ReflexAppDelegate