reflexion 0.5.3 → 0.7.0

data/src/osx/application.mm

@@ -2,9 +2,12 @@
 #include "application.h"
 
 
-#import <AppKit/NSApplication.h>
+#import <AppKit/AppKit.h>
 #include "reflex/exception.h"
 #include "reflex/debug.h"
+#include "window.h"
+#include "menu.h"
+#import "native_window.h"
 #import "app_delegate.h"
 
 
@@ -18,6 +21,16 @@ namespace Reflex
 		return new ApplicationData();
 	}
 
+	String
+	Application_get_default_name ()
+	{
+		NSBundle* bundle = NSBundle.mainBundle;
+		NSString* name   = [bundle objectForInfoDictionaryKey: @"CFBundleDisplayName"];
+		if (!name) name  = [bundle objectForInfoDictionaryKey: @"CFBundleName"];
+		if (!name) name  = NSProcessInfo.processInfo.processName;
+		return name ? name.UTF8String : "";
+	}
+
 	ApplicationData&
 	Application_get_data (Application* app)
 	{
@@ -34,6 +47,60 @@ namespace Reflex
 	}
 
 
+	static void
+	update_status_item (Application* app)
+	{
+		[Application_get_data(app).delegate updateStatusItem];
+	}
+
+	void
+	Application_stop (Application* app)
+	{
+		[NSApp stop: nil];
+
+		// stop: takes effect only after an event is handled, so post one
+		NSEvent* e = [NSEvent
+			otherEventWithType: NSEventTypeApplicationDefined
+			location: NSZeroPoint modifierFlags: 0 timestamp: 0
+			windowNumber: 0 context: nil subtype: 0 data1: 0 data2: 0];
+		[NSApp postEvent: e atStart: YES];
+	}
+
+	void
+	Application_set_menu (Application* app, Menu* menu)
+	{
+		update_status_item(app);
+
+		for (auto it = app->window_begin(), end = app->window_end(); it != end; ++it)
+		{
+			Window* win = it->get();
+			if (win->menu() && Window_get_data(win).native.isMainWindow)
+				return;
+		}
+
+		Menu_apply_to_main_menu(menu);
+	}
+
+	void
+	Application_set_background (Application* app, bool state)
+	{
+		[NSApp setActivationPolicy: state
+			?	NSApplicationActivationPolicyAccessory
+			:	NSApplicationActivationPolicyRegular];
+
+		if (!state)
+			[NSApp activateIgnoringOtherApps: YES];
+
+		update_status_item(app);
+	}
+
+	void
+	Application_set_background_menu (Application* app, Menu* menu)
+	{
+		update_status_item(app);
+	}
+
+
 	ApplicationData::ApplicationData ()
 	:	delegate(nil)
 	{
@@ -63,16 +130,47 @@ namespace Reflex
 		ReflexAppDelegate* delegate = setup_app_delegate(app);
 		[delegate bind: this];
 
-		if (!app.isRunning)
-			[app run];
-		else
+		if (app.isRunning)
+		{
+			// the host app runs the event loop
 			[delegate callOnStart];
+			return;
+		}
+
+		if (delegate.isLaunched)
+		{
+			// the app is launched only once, so the later runs start by themselves
+			[delegate performSelector: @selector(callOnStart) withObject: nil afterDelay: 0];
+		}
+
+		self->started  = false;
+		self->quitting = false;
+		self->running  = true;
+		[app run];
+		self->running  = false;
+
+		Application_cleanup(this);
+		[delegate unbind];
+
+		Application_throw_exception(this);
 	}
 
 	void
 	Application::quit ()
 	{
-		[NSApp terminate: nil];
+		// terminate exits the process even before run, which would take down
+		// irb or a test process
+		if (!NSApp.isRunning)
+			invalid_state_error(__FILE__, __LINE__, "the application is not running.");
+
+		Event e;
+		Application_call_quit_event(this, &e);
+		if (e.is_blocked()) return;
+
+		if (self->running)
+			Application_stop(this);
+		else
+			[NSApp terminate: nil];
 	}
 
 	void

data/src/osx/clipboard.mm

@@ -0,0 +1,45 @@
+// -*- objc -*-
+#include "reflex/clipboard.h"
+
+
+#import <AppKit/NSPasteboard.h>
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	void
+	set_clipboard (const Clipboard& clipboard)
+	{
+		const char* text = clipboard.text();
+		NSString* nstext = nil;
+		if (text)
+		{
+			nstext = [NSString stringWithUTF8String: text];
+			if (!nstext)
+				argument_error(__FILE__, __LINE__);
+		}
+
+		NSPasteboard* pasteboard = NSPasteboard.generalPasteboard;
+		[pasteboard clearContents];
+
+		if (nstext)
+			[pasteboard setString: nstext forType: NSPasteboardTypeString];
+	}
+
+	Clipboard
+	get_clipboard ()
+	{
+		Clipboard clipboard;
+
+		NSString* nstext = [NSPasteboard.generalPasteboard stringForType: NSPasteboardTypeString];
+		const char* text = nstext ? nstext.UTF8String : NULL;
+		if (text) clipboard.set_text(text);
+
+		return clipboard;
+	}
+
+
+}// Reflex

data/src/osx/color_picker.mm

@@ -0,0 +1,112 @@
+// -*- objc -*-
+#include "../color_picker.h"
+
+
+#import <AppKit/AppKit.h>
+#include "reflex/exception.h"
+
+
+@interface ReflexColorPanelTarget : NSObject
+
+	- (void) setCurrentPicker: (Reflex::ColorPicker*) picker;
+
+@end
+
+
+@implementation ReflexColorPanelTarget
+
+	{
+		// not a static, that would be released at exit after the ruby vm is gone
+		Reflex::ColorPicker::Ref current;
+	}
+
+	- (void) setCurrentPicker: (Reflex::ColorPicker*) picker
+	{
+		if (current && current != picker)
+			[self closeCurrent];
+
+		current = picker;
+	}
+
+	- (void) closeCurrent
+	{
+		if (!current) return;
+
+		Reflex::ColorPicker::Ref picker = current;
+		current                         = NULL;
+
+		Reflex::Event e;
+		Reflex::ColorPicker_call_close_event(picker, &e);
+	}
+
+	- (void) colorChanged: (NSColorPanel*) panel
+	{
+		if (!current) return;
+
+		NSColor* color = [panel.color colorUsingColorSpace: NSColorSpace.sRGBColorSpace];
+		if (!color) return;
+
+		Reflex::ColorEvent e(Reflex::Color(
+			color.redComponent,
+			color.greenComponent,
+			color.blueComponent,
+			color.alphaComponent));
+		Reflex::ColorPicker_call_color_event(current, &e);
+	}
+
+	- (void) panelWillClose: (NSNotification*) notification
+	{
+		[self closeCurrent];
+	}
+
+@end
+
+
+namespace Reflex
+{
+
+
+	static ReflexColorPanelTarget*
+	get_target (NSColorPanel* panel)
+	{
+		static ReflexColorPanelTarget* target = nil;
+		if (!target)
+		{
+			target = [[ReflexColorPanelTarget alloc] init];
+			[NSNotificationCenter.defaultCenter
+				addObserver: target
+				selector: @selector(panelWillClose:)
+				name: NSWindowWillCloseNotification
+				object: panel];
+		}
+		return target;
+	}
+
+	void
+	ColorPicker_show (ColorPicker* picker, const Color* initial)
+	{
+		if (!picker)
+			argument_error(__FILE__, __LINE__);
+
+		NSColorPanel* panel            = NSColorPanel.sharedColorPanel;
+		ReflexColorPanelTarget* target = get_target(panel);
+		[target setCurrentPicker: picker];
+
+		panel.showsAlpha = picker->alpha();
+		panel.continuous = YES;
+		panel.target     = target;
+		panel.action     = @selector(colorChanged:);
+		if (initial)
+		{
+			panel.color = [NSColor
+				colorWithSRGBRed: initial->red
+				green:            initial->green
+				blue:             initial->blue
+				alpha:            initial->alpha];
+		}
+
+		[panel makeKeyAndOrderFront: nil];
+	}
+
+
+}// Reflex

data/src/osx/event.h

@@ -32,6 +32,16 @@ namespace Reflex
 	};// NativeFlagKeyEvent
 
 
+	class NativeTextEvent : public TextEvent
+	{
+
+		public:
+
+			NativeTextEvent (Action action, NSString* text, NSRange selection);
+
+	};// NativeTextEvent
+
+
 	class NativePointerEvent : public PointerEvent
 	{
 

data/src/osx/event.mm

@@ -18,14 +18,14 @@ namespace Reflex
 	{
 		NSUInteger flags = event ? event.modifierFlags : NSEvent.modifierFlags;
 		return
-			(flags & NSAlphaShiftKeyMask) ? MOD_CAPS     : 0 |
-			(flags & NSShiftKeyMask)      ? MOD_SHIFT    : 0 |
-			(flags & NSControlKeyMask)    ? MOD_CONTROL  : 0 |
-			(flags & NSAlternateKeyMask)  ? MOD_OPTION   : 0 |
-			(flags & NSCommandKeyMask)    ? MOD_COMMAND  : 0 |
-			(flags & NSNumericPadKeyMask) ? MOD_NUMPAD   : 0 |
-			(flags & NSHelpKeyMask)       ? MOD_HELP     : 0 |
-			(flags & NSFunctionKeyMask)   ? MOD_FUNCTION : 0;
+			(flags & NSEventModifierFlagCapsLock   ? MOD_CAPS     : 0) |
+			(flags & NSEventModifierFlagShift      ? MOD_SHIFT    : 0) |
+			(flags & NSEventModifierFlagControl    ? MOD_CONTROL  : 0) |
+			(flags & NSEventModifierFlagOption     ? MOD_OPTION   : 0) |
+			(flags & NSEventModifierFlagCommand    ? MOD_COMMAND  : 0) |
+			(flags & NSEventModifierFlagNumericPad ? MOD_NUMPAD   : 0) |
+			(flags & NSEventModifierFlagHelp       ? MOD_HELP     : 0) |
+			(flags & NSEventModifierFlagFunction   ? MOD_FUNCTION : 0);
 	}
 
 	static Point
@@ -52,8 +52,17 @@ namespace Reflex
 		return [chars UTF8String];
 	}
 
+	static int
+	get_key_code (NSEvent* e)
+	{
+		// fn+return on a laptop keyboard reports a code of its own, which
+		// has no kVK_* name; it is the same key as the enter on the keypad
+		// of an external keyboard
+		return e.keyCode == 0x34 ? kVK_ANSI_KeypadEnter : e.keyCode;
+	}
+
 	NativeKeyEvent::NativeKeyEvent (NSEvent* e, Action action, int repeat)
-	:	KeyEvent(action, get_chars(e), [e keyCode], get_modifiers(e), repeat)
+	:	KeyEvent(action, get_chars(e), get_key_code(e), get_modifiers(e), repeat)
 	{
 	}
 
@@ -64,15 +73,15 @@ namespace Reflex
 		switch ([e keyCode])
 		{
 			case kVK_Shift:
-			case kVK_RightShift:   return NSShiftKeyMask;
+			case kVK_RightShift:   return NSEventModifierFlagShift;
 			case kVK_Control:
-			case kVK_RightControl: return NSControlKeyMask;
+			case kVK_RightControl: return NSEventModifierFlagControl;
 			case kVK_Option:
-			case kVK_RightOption:  return NSAlternateKeyMask;
+			case kVK_RightOption:  return NSEventModifierFlagOption;
 			case kVK_Command:
-			case kVK_RightCommand: return NSCommandKeyMask;
-			case kVK_CapsLock:     return NSAlphaShiftKeyMask;
-			case kVK_Function:     return NSFunctionKeyMask;
+			case kVK_RightCommand: return NSEventModifierFlagCommand;
+			case kVK_CapsLock:     return NSEventModifierFlagCapsLock;
+			case kVK_Function:     return NSEventModifierFlagFunction;
 		}
 		return 0;
 	}
@@ -96,13 +105,56 @@ namespace Reflex
 	}
 
 
+	static int
+	to_char_index (NSString* str, NSUInteger utf16_index)
+	{
+		if (utf16_index > str.length) utf16_index = str.length;
+
+		int index = 0;
+		for (NSUInteger i = 0; i < utf16_index; ++i, ++index)
+		{
+			unichar c = [str characterAtIndex: i];
+			if (!CFStringIsSurrogateHighCharacter(c) || i + 1 >= str.length)
+				continue;
+
+			if (CFStringIsSurrogateLowCharacter([str characterAtIndex: i + 1]))
+				++i;
+		}
+		return index;
+	}
+
+	static int
+	get_selection_offset (NSString* str, NSRange selection)
+	{
+		if (selection.location == NSNotFound) return -1;
+		return to_char_index(str, selection.location);
+	}
+
+	static int
+	get_selection_size (NSString* str, NSRange selection)
+	{
+		if (selection.location == NSNotFound) return 0;
+		return
+			to_char_index(str, selection.location + selection.length) -
+			to_char_index(str, selection.location);
+	}
+
+	NativeTextEvent::NativeTextEvent (
+		Action action, NSString* text, NSRange selection)
+	:	TextEvent(
+			action, text.UTF8String,
+			get_selection_offset(text, selection), get_selection_size(text, selection))
+	{
+	}
+
+
 	static bool
 	is_pointer_dragging (NSEvent* e)
 	{
 		return
-			[e type] == NSLeftMouseDragged  ||
-			[e type] == NSRightMouseDragged ||
-			[e type] == NSOtherMouseDragged;
+			[e type] == NSEventTypeLeftMouseDragged  ||
+			[e type] == NSEventTypeRightMouseDragged ||
+			[e type] == NSEventTypeOtherMouseDragged;
 	}
 
 	static uint
@@ -121,22 +173,24 @@ namespace Reflex
 	{
 		switch ([e type])
 		{
-			case NSLeftMouseDown:
-			case NSLeftMouseUp:
-			case NSLeftMouseDragged:
+			case NSEventTypeLeftMouseDown:
+			case NSEventTypeLeftMouseUp:
+			case NSEventTypeLeftMouseDragged:
 				return Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_LEFT;
 
-			case NSRightMouseDown:
-			case NSRightMouseUp:
-			case NSRightMouseDragged:
+			case NSEventTypeRightMouseDown:
+			case NSEventTypeRightMouseUp:
+			case NSEventTypeRightMouseDragged:
 				return Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_RIGHT;
 
-			case NSOtherMouseDown:
-			case NSOtherMouseUp:
-			case NSOtherMouseDragged:
+			case NSEventTypeOtherMouseDown:
+			case NSEventTypeOtherMouseUp:
+			case NSEventTypeOtherMouseDragged:
 				return Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_MIDDLE;
 
-			case NSMouseMoved:
+			case NSEventTypeMouseMoved:
+			case NSEventTypeMouseEntered:
+			case NSEventTypeMouseExited:
 				return Reflex::Pointer::MOUSE | get_current_pointer_type();
 
 			default:
@@ -144,6 +198,25 @@ namespace Reflex
 		}
 	}
 
+	static uint
+	get_click_count (NSEvent* e, Pointer::Action action, bool dragging)
+	{
+		switch (action)
+		{
+			case Pointer::DOWN:
+			case Pointer::UP:
+				return (uint) e.clickCount;
+
+			case Pointer::MOVE:
+				return dragging ? (uint) e.clickCount : 0;
+
+			default:
+				// asking clickCount raises NSInternalInconsistencyException for
+				// tracking (enter/exit) events.
+				return 0;
+		}
+	}
+
 	NativePointerEvent::NativePointerEvent (
 		NSEvent* event, NSView* view, Pointer::Action action)
 	{
@@ -154,14 +227,25 @@ namespace Reflex
 			action,
 			get_pointer_position(event, view),
 			get_modifiers(event),
-			action == Pointer::MOVE && !dragging ? 0 : (uint) event.clickCount,
+			get_click_count(event, action, dragging),
 			dragging,
 			time()));
 	}
 
 
+	static coord
+	to_wheel_pixels (NSEvent* e, CGFloat delta)
+	{
+		return delta * (e.hasPreciseScrollingDeltas ? 1 : WHEEL_PIXELS_PER_LINE);
+	}
+
 	NativeWheelEvent::NativeWheelEvent (NSEvent* e, NSView* view)
-	:	WheelEvent(0, 0, 0, [e deltaX], -[e deltaY], [e deltaZ], get_modifiers(e))
+	:	WheelEvent(
+			0, 0, 0,
+			to_wheel_pixels(e,  e.scrollingDeltaX),
+			to_wheel_pixels(e, -e.scrollingDeltaY),
+			0,
+			get_modifiers(e))
 	{
 		WheelEvent_set_position(this, get_pointer_position(e, view));
 	}

data/src/osx/file_dialog.mm

@@ -0,0 +1,168 @@
+// -*- objc -*-
+#include "../file_dialog.h"
+
+
+#import <AppKit/AppKit.h>
+#include "reflex/exception.h"
+#include "window.h"
+
+
+@interface ReflexOpenSavePanelDelegate : NSObject <NSOpenSavePanelDelegate>
+@end
+
+
+@implementation ReflexOpenSavePanelDelegate
+
+	{
+		NSArray<NSString*>* suffixes;
+	}
+
+	- (id) initWithExtensions: (const Reflex::StringList&) extensions
+	{
+		self = [super init];
+		if (!self) return nil;
+
+		NSMutableArray* array = [NSMutableArray arrayWithCapacity: extensions.size()];
+		for (const auto& extension : extensions)
+		{
+			NSString* str = [NSString stringWithUTF8String: ("." + extension).c_str()];
+			if (!str)
+				Reflex::argument_error(__FILE__, __LINE__);
+
+			[array addObject: str];
+		}
+		suffixes = [array retain];
+
+		return self;
+	}
+
+	- (void) dealloc
+	{
+		[suffixes release];
+
+		[super dealloc];
+	}
+
+	- (BOOL) panel: (id) sender shouldEnableURL: (NSURL*) url
+	{
+		NSNumber* directory = nil;
+		if (![url getResourceValue: &directory forKey: NSURLIsDirectoryKey error: NULL])
+			return YES;// what cannot be classified is better shown than hidden
+
+		if (directory.boolValue)
+			return YES;
+
+		NSString* name = url.lastPathComponent.lowercaseString;
+		for (NSString* suffix in suffixes)
+		{
+			if ([name hasSuffix: suffix.lowercaseString])
+				return YES;
+		}
+		return NO;
+	}
+
+@end
+
+
+namespace Reflex
+{
+
+
+	static NSOpenPanel*
+	create_open_panel (FileDialog* dialog, FileDialog::Data::Mode mode)
+	{
+		NSOpenPanel* panel            = [NSOpenPanel openPanel];
+		panel.canChooseFiles          = mode != FileDialog::Data::OPEN_DIRECTORY;
+		panel.canChooseDirectories    = mode == FileDialog::Data::OPEN_DIRECTORY;
+		panel.allowsMultipleSelection = mode == FileDialog::Data::OPEN_FILES;
+
+		const StringList& extensions = dialog->extensions();
+		if (mode != FileDialog::Data::OPEN_DIRECTORY && !extensions.empty())
+		{
+			panel.delegate = [[[ReflexOpenSavePanelDelegate alloc]
+				initWithExtensions: extensions]
+				autorelease];
+		}
+
+		return panel;
+	}
+
+	static NSSavePanel*
+	create_save_panel (const char* name)
+	{
+		NSSavePanel* panel = [NSSavePanel savePanel];
+
+		if (name && *name)
+			panel.nameFieldStringValue = [NSString stringWithUTF8String: name];
+
+		return panel;
+	}
+
+	void
+	FileDialog_show (
+		FileDialog* dialog, FileDialog::Data::Mode mode,
+		const char* dir, const char* name)
+	{
+		if (!dialog)
+			argument_error(__FILE__, __LINE__);
+
+		bool save          = mode == FileDialog::Data::SAVE_FILE;
+		NSSavePanel* panel = save
+			?	create_save_panel(name)
+			:	create_open_panel(dialog, mode);
+
+		const char* title = dialog->title();
+		if (*title)
+			panel.message = [NSString stringWithUTF8String: title];
+
+		if (dir && *dir)
+		{
+			NSString* nsdir    = [NSString stringWithUTF8String: dir];
+			panel.directoryURL = [NSURL fileURLWithPath: nsdir isDirectory: YES];
+		}
+
+		FileDialog::Ref dialog_ref          = dialog;
+		id delegate                         = panel.delegate;
+		void (^completion)(NSModalResponse) = ^(NSModalResponse result)
+		{
+			(void) delegate;// panel.delegate is weak ref, so capture it here
+
+			FileDialog* pdialog = const_cast<FileDialog*>(dialog_ref.get());
+
+			if (result == NSModalResponseOK)
+			{
+				StringList paths;
+				if (save)
+				{
+					const char* path = panel.URL.path.UTF8String;
+					if (path) paths.emplace_back(path);
+				}
+				else
+				{
+					for (NSURL* url in ((NSOpenPanel*) panel).URLs)
+					{
+						const char* path = url.path.UTF8String;
+						if (path) paths.emplace_back(path);
+					}
+				}
+
+				FileEvent e(save ? FileEvent::SAVE : FileEvent::OPEN, paths);
+				FileDialog_call_file_event(pdialog, &e);
+			}
+			else
+			{
+				Event e;
+				FileDialog_call_cancel_event(pdialog, &e);
+			}
+		};
+
+		Window* owner      = dialog->owner();
+		NSWindow* nswindow = owner ? (NSWindow*) Window_get_data(owner).native : nil;
+		if (nswindow)
+			[panel beginSheetModalForWindow: nswindow completionHandler: completion];
+		else
+			[panel beginWithCompletionHandler: completion];
+	}
+
+
+}// Reflex

data/src/osx/gamepad.mm

@@ -21,14 +21,14 @@ namespace Reflex
 
 
 	void
-	Gamepad_init (Application* app)
+	Gamepad_init_native (Application* app)
 	{
 		init_gc_gamepads(app);
 		init_hid_gamepads(app);
 	}
 
 	void
-	Gamepad_fin (Application* app)
+	Gamepad_fin_native (Application* app)
 	{
 		fin_gc_gamepads(app);
 		fin_hid_gamepads(app);