reflexion 0.5.2 → 0.6.0

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 & 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);
 	}
 
 	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)
 	{
 	}
 
@@ -137,6 +146,8 @@ namespace Reflex
 				return Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_MIDDLE;
 
 			case NSMouseMoved:
+			case NSMouseEntered:
+			case NSMouseExited:
 				return Reflex::Pointer::MOUSE | get_current_pointer_type();
 
 			default:
@@ -144,6 +155,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,7 +184,7 @@ 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()));
 	}

data/src/osx/menu.h

@@ -0,0 +1,25 @@
+// -*- objc -*-
+#pragma once
+#ifndef __REFLEX_SRC_OSX_MENU_H__
+#define __REFLEX_SRC_OSX_MENU_H__
+
+
+#import <AppKit/NSMenu.h>
+#include "../menu.h"
+
+
+namespace Reflex
+{
+
+
+	NSMenu* Menu_get_nssubmenu (Menu* menu);
+
+	void Menu_set_native_action (Menu* menu, SEL action);
+
+	void Menu_apply_to_main_menu (Menu* menu);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/osx/menu.mm

@@ -0,0 +1,372 @@
+// -*- objc -*-
+#include "menu.h"
+
+
+#import <Cocoa/Cocoa.h>
+#import <AppKit/AppKit.h>
+#import <objc/runtime.h>
+#include "reflex/exception.h"
+#include "reflex/event.h"
+#include "reflex/view.h"
+#include "window.h"
+#include "screen.h"
+#import "native_window.h"
+
+
+namespace Rays
+{
+	NSImage* Bitmap_get_nsimage (const Bitmap& bmp);
+}
+
+
+@interface ReflexMenuTarget : NSObject <NSMenuDelegate>
+	- (void) handleMenuItem: (NSMenuItem*) sender;
+@end
+
+
+static NSValue*
+menu2value (Reflex::Menu* menu)
+{
+	return [NSValue valueWithPointer: menu];
+}
+
+static Reflex::Menu*
+value2menu (NSValue* value)
+{
+	return value ? (Reflex::Menu*) value.pointerValue : NULL;
+}
+
+static void
+set_owner (NSMenuItem* nsitem, Reflex::Menu* owner)
+{
+	[nsitem setRepresentedObject: menu2value(owner)];
+}
+
+static Reflex::Menu*
+get_owner (NSMenuItem* nsitem)
+{
+	return value2menu(nsitem.representedObject);
+}
+
+static void*
+associated_object_key ()
+{
+	static char key;
+	return &key;
+}
+
+static void
+set_owner (NSMenu* nsmenu, Reflex::Menu* owner)
+{
+	objc_setAssociatedObject(
+		nsmenu, associated_object_key(), menu2value(owner),
+		OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+static Reflex::Menu*
+get_owner (NSMenu* nsmenu)
+{
+	return value2menu(objc_getAssociatedObject(nsmenu, associated_object_key()));
+}
+
+static ReflexMenuTarget*
+menu_target ()
+{
+	static ReflexMenuTarget* target = [[ReflexMenuTarget alloc] init];
+	return target;
+}
+
+
+namespace Reflex
+{
+
+
+	struct MenuData : public Menu::Data
+	{
+
+		NSMenuItem* nsitem = nil;
+
+		NSMenu* nssubmenu  = nil;
+
+		SEL native_action  = NULL;
+
+		MenuData ()
+		{
+			nsitem = [[NSMenuItem alloc]
+				initWithTitle: @"" action: @selector(handleMenuItem:) keyEquivalent: @""];
+		}
+
+		virtual ~MenuData ()
+		{
+			[nsitem release];
+			[nssubmenu release];
+		}
+
+		NSMenu* get_nssubmenu (Menu* menu)
+		{
+			if (!nssubmenu)
+			{
+				nssubmenu = [[NSMenu alloc] initWithTitle: @""];
+				set_owner(nssubmenu, menu);
+				[nssubmenu setAutoenablesItems: NO];
+				[nssubmenu setDelegate: menu_target()];
+				[nsitem setSubmenu: nssubmenu];
+			}
+			return nssubmenu;
+		}
+
+	};// MenuData
+
+
+	static MenuData&
+	get_data (Menu* menu)
+	{
+		if (!menu)
+			argument_error(__FILE__, __LINE__);
+
+		return (MenuData&) *menu->self;
+	}
+
+	static void
+	Menu_validate_items (NSMenu* nsmenu)
+	{
+		for (NSMenuItem* nsitem in nsmenu.itemArray)
+		{
+			Menu* menu = get_owner(nsitem);
+			if (!menu) continue;
+
+			MenuData& self = get_data(menu);
+			if (!self.native_action) continue;
+
+			[nsitem setEnabled:
+				menu->is_enabled() && [NSApp targetForAction: self.native_action] != nil];
+		}
+	}
+
+	Menu::Data*
+	Menu_create_data ()
+	{
+		return new MenuData();
+	}
+
+	static NSEventModifierFlags
+	modifiers2mask (uint mods)
+	{
+		NSEventModifierFlags mask = 0;
+		if (mods &  MOD_SHIFT)             mask |= NSEventModifierFlagShift;
+		if (mods &  MOD_CONTROL)           mask |= NSEventModifierFlagControl;
+		if (mods &  MOD_COMMAND)           mask |= NSEventModifierFlagCommand;
+		if (mods & (MOD_OPTION | MOD_ALT)) mask |= NSEventModifierFlagOption;
+		return mask;
+	}
+
+	void
+	Menu_update (Menu* menu)
+	{
+		auto& self   = get_data(menu);
+		bool old_sep = self.nsitem && self.nsitem.isSeparatorItem;
+		bool  is_sep = menu->is_separator();
+
+		if (!self.nsitem || is_sep != old_sep)
+		{
+			NSMenu* parent  = self.nsitem.menu;
+			NSInteger index = parent ? [parent indexOfItem: self.nsitem] : -1;
+
+			NSMenuItem* nsitem = is_sep
+				?	[[NSMenuItem separatorItem] retain]
+				:	[[NSMenuItem alloc]
+						initWithTitle: @""
+						action:        @selector(handleMenuItem:)
+						keyEquivalent: @""];
+
+			if (parent)
+			{
+				[parent removeItem: self.nsitem];
+				[parent insertItem: nsitem atIndex: index];
+			}
+
+			[self.nsitem release];
+			self.nsitem = nsitem;
+		}
+
+		if (is_sep) return;
+
+		set_owner(self.nsitem, menu);
+		[self.nsitem setTarget: self.native_action ? nil : menu_target()];
+		[self.nsitem setAction: self.native_action ? self.native_action : @selector(handleMenuItem:)];
+		[self.nsitem setTitle: [NSString stringWithUTF8String: menu->label()]];
+		[self.nsitem setEnabled: menu->is_enabled() ? YES : NO];
+		[self.nsitem setState: menu->is_checked() ? NSControlStateValueOn : NSControlStateValueOff];
+		[self.nsitem setKeyEquivalent: [NSString stringWithUTF8String: menu->shortcut_key()]];
+		[self.nsitem setKeyEquivalentModifierMask: modifiers2mask(menu->shortcut_modifiers())];
+		[self.nsitem setImage: menu->image() ? Rays::Bitmap_get_nsimage(menu->image().bitmap()) : nil];
+		[self.nsitem setSubmenu: menu->empty() ? nil : self.nssubmenu];
+	}
+
+	void
+	Menu_popup (Menu* menu, View* view, coord x, coord y)
+	{
+		MenuData& self = get_data(menu);
+
+		if (!self.nssubmenu)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (view)
+		{
+			Window* win     = view->window();
+			if (!win)
+				invalid_state_error(__FILE__, __LINE__);
+
+			NSWindow* nswin = Window_get_data(win).native;
+			if (!nswin)
+				invalid_state_error(__FILE__, __LINE__);
+
+			NSView* nsview  = nswin.contentView;
+			if (!nsview)
+				invalid_state_error(__FILE__, __LINE__);
+
+			Point win_pos   = view->to_window(Point(x, y));
+			CGFloat win_h   = nsview.frame.size.height;
+			[self.nssubmenu popUpMenuPositioningItem: nil
+				atLocation: NSMakePoint(win_pos.x, win_h - win_pos.y)
+				inView: nsview];
+		}
+		else
+		{
+			[self.nssubmenu popUpMenuPositioningItem: nil
+				atLocation: NSMakePoint(x, primary_screen_height() - y)
+				inView: nil];
+		}
+	}
+
+	void
+	Menu_child_added (Menu* parent, Menu* child, int index)
+	{
+		auto& p = get_data(parent);
+		auto& c = get_data(child);
+
+		[p.get_nssubmenu(parent) insertItem: c.nsitem atIndex: index];
+		Menu_update(child);
+	}
+
+	void
+	Menu_child_removed (Menu* parent, Menu* child)
+	{
+		auto& p = get_data(parent);
+		auto& c = get_data(child);
+
+		if (p.nssubmenu && c.nsitem.menu == p.nssubmenu)
+			[p.nssubmenu removeItem: c.nsitem];
+	}
+
+	NSMenu*
+	Menu_get_nssubmenu (Menu* menu)
+	{
+		return get_data(menu).get_nssubmenu(menu);
+	}
+
+	void
+	Menu_set_native_action (Menu* menu, SEL action)
+	{
+		MenuData& self = get_data(menu);
+
+		self.native_action = action;
+		Menu_update(menu);
+	}
+
+	void
+	Menu_apply_to_main_menu (Menu* menu)
+	{
+		if (!menu && app())
+			menu = app()->menu();
+
+		if (!menu) return;
+
+		[NSApp setMainMenu: get_data(menu).get_nssubmenu(menu)];
+	}
+
+
+}// Reflex
+
+
+@implementation ReflexMenuTarget
+
+	- (void) handleMenuItem: (NSMenuItem*) nsitem
+	{
+		Reflex::Menu* menu = get_owner(nsitem);
+		if (!menu) return;
+
+		Reflex::Event e;
+		menu->on_click(&e);
+	}
+
+	- (void) menuWillOpen: (NSMenu*) nsmenu
+	{
+		Reflex::Menu_validate_items(nsmenu);
+
+		Reflex::Menu* menu = get_owner(nsmenu);
+		if (!menu) return;
+
+		Reflex::Event e;
+		menu->on_open_submenu(&e);
+
+		for (NSMenuItem* nsitem in nsmenu.itemArray)
+		{
+			Reflex::Menu* child = get_owner(nsitem);
+			if (!child) continue;
+
+			Reflex::Event ce;
+			child->on_show(&ce);
+		}
+	}
+
+	- (void) menuDidClose: (NSMenu*) nsmenu
+	{
+		Reflex::Menu* menu = get_owner(nsmenu);
+		if (!menu) return;
+
+		for (NSMenuItem* nsitem in nsmenu.itemArray)
+		{
+			Reflex::Menu* child = get_owner(nsitem);
+			if (!child) continue;
+
+			Reflex::Event ce;
+			child->on_hide(&ce);
+		}
+
+		Reflex::Event e;
+		menu->on_close_submenu(&e);
+	}
+
+	- (BOOL) menuHasKeyEquivalent: (NSMenu*) nsmenu
+		forEvent: (NSEvent*) event
+		target: (id*) target
+		action: (SEL*) action
+	{
+		// answer key equivalent matching ourselves: AppKit's own scanning of
+		// delegate-backed menus caches stale results across setMainMenu calls,
+		// leaving every shortcut dead until the menu bar is clicked once
+		static const NSEventModifierFlags MODIFIER_MASK =
+			NSEventModifierFlagCommand |
+			NSEventModifierFlagShift   |
+			NSEventModifierFlagOption  |
+			NSEventModifierFlagControl;
+
+		NSEventModifierFlags mods = event.modifierFlags & MODIFIER_MASK;
+		NSString* chars           = event.charactersIgnoringModifiers;
+
+		for (NSMenuItem* nsitem in nsmenu.itemArray)
+		{
+			if (nsitem.hasSubmenu || !nsitem.enabled)           continue;
+			if (nsitem.keyEquivalent.length == 0)               continue;
+			if (nsitem.keyEquivalentModifierMask != mods)       continue;
+			if (![nsitem.keyEquivalent isEqualToString: chars]) continue;
+
+			*target = nsitem.target;
+			*action = nsitem.action;
+			return YES;
+		}
+		return NO;
+	}
+
+@end// ReflexMenuTarget

data/src/osx/native_window.mm

@@ -10,6 +10,7 @@
 #include "../pointer.h"
 #include "event.h"
 #include "window.h"
+#include "menu.h"
 #import "opengl_view.h"
 
 
@@ -261,6 +262,14 @@ move_to_main_screen_origin (NativeWindow* window)
 		[self setDelegate: nil];
 	}
 
+	- (void) windowDidBecomeMain: (NSNotification*) notification
+	{
+		Reflex::Window* win = self.window;
+		if (!win) return;
+
+		Menu_apply_to_main_menu(win->menu());
+	}
+
 	- (void) windowWillMove: (NSNotification*) notification
 	{
 		Reflex::Window* win = self.window;
@@ -444,6 +453,24 @@ move_to_main_screen_origin (NativeWindow* window)
 		Window_call_pointer_event(win, &e);
 	}
 
+	- (void) mouseEntered: (NSEvent*) event
+	{
+		Reflex::Window* win = self.window;
+		if (!win) return;
+
+		Reflex::NativePointerEvent e(event, view, Reflex::Pointer::ENTER);
+		Window_call_pointer_event(win, &e);
+	}
+
+	- (void) mouseExited: (NSEvent*) event
+	{
+		Reflex::Window* win = self.window;
+		if (!win) return;
+
+		Reflex::NativePointerEvent e(event, view, Reflex::Pointer::LEAVE);
+		Window_call_pointer_event(win, &e);
+	}
+
 	- (void) scrollWheel: (NSEvent*) event
 	{
 		Reflex::Window* win = self.window;

data/src/osx/opengl_view.mm

@@ -15,6 +15,7 @@
 
 	{
 		bool setup_context_done;
+		NSTrackingArea* tracking_area;
 	}
 
 	- (id) initWithFrame: (NSRect) frame
@@ -30,6 +31,7 @@
 		if (!self) return nil;
 
 		setup_context_done = false;
+		tracking_area      = nil;
 
 		return self;
 	}
@@ -100,6 +102,39 @@
 #endif
 	}
 
+	- (void) updateTrackingAreas
+	{
+		[super updateTrackingAreas];
+
+		if (tracking_area)
+		{
+			[self removeTrackingArea: tracking_area];
+			[tracking_area release];
+		}
+
+		// to track pointer enter/leave event of the window bounds
+		tracking_area = [[NSTrackingArea alloc]
+			initWithRect: NSZeroRect
+			options:
+				NSTrackingMouseEnteredAndExited |
+				NSTrackingActiveAlways |
+				NSTrackingInVisibleRect
+			owner: self
+			userInfo: nil];
+		[self addTrackingArea: tracking_area];
+	}
+
+	- (void) dealloc
+	{
+		if (tracking_area)
+		{
+			[self removeTrackingArea: tracking_area];
+			[tracking_area release];
+			tracking_area = nil;
+		}
+		[super dealloc];
+	}
+
 	- (void) insertText: (id) str
 	{
 		//NSLog(@"interText: %@", str);
@@ -211,4 +246,20 @@
 		[win mouseMoved: event];
 	}
 
+	- (void) mouseEntered: (NSEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) [self window];
+		if (!win) return;
+
+		[win mouseEntered: event];
+	}
+
+	- (void) mouseExited: (NSEvent*) event
+	{
+		NativeWindow* win = (NativeWindow*) [self window];
+		if (!win) return;
+
+		[win mouseExited: event];
+	}
+
 @end// OpenGLView

data/src/osx/window.mm

@@ -4,6 +4,7 @@
 
 #import <Cocoa/Cocoa.h>
 #include "reflex/exception.h"
+#include "menu.h"
 #include "screen.h"
 #import "native_window.h"
 
@@ -143,6 +144,16 @@ namespace Reflex
 		return Bounds(f.origin.x, f.origin.y, f.size.width, f.size.height);
 	}
 
+	void
+	Window_set_menu (Window* window, Menu* menu)
+	{
+		NativeWindow* native = get_native(window);
+		if (!native) return;
+
+		if (native.isMainWindow)
+			Menu_apply_to_main_menu(menu);
+	}
+
 	Screen
 	Window_get_screen (const Window& window)
 	{