reflexion 0.1.20 → 0.1.24

data/src/osx/event.mm

@@ -3,6 +3,7 @@
 
 
 #include <assert.h>
+#include <Carbon/Carbon.h>
 #import <Cocoa/Cocoa.h>
 
 
@@ -17,14 +18,176 @@ namespace Reflex
 		return [chars UTF8String];
 	}
 
+	static KeyCode
+	get_code (UInt16 code)
+	{
+		switch (code)
+		{
+			case kVK_ANSI_A:              return KEY_A;
+			case kVK_ANSI_S:              return KEY_S;
+			case kVK_ANSI_D:              return KEY_D;
+			case kVK_ANSI_F:              return KEY_F;
+			case kVK_ANSI_H:              return KEY_H;
+			case kVK_ANSI_G:              return KEY_G;
+			case kVK_ANSI_Z:              return KEY_Z;
+			case kVK_ANSI_X:              return KEY_X;
+			case kVK_ANSI_C:              return KEY_C;
+			case kVK_ANSI_V:              return KEY_V;
+			case kVK_ANSI_B:              return KEY_B;
+			case kVK_ANSI_Q:              return KEY_Q;
+			case kVK_ANSI_W:              return KEY_W;
+			case kVK_ANSI_E:              return KEY_E;
+			case kVK_ANSI_R:              return KEY_R;
+			case kVK_ANSI_Y:              return KEY_Y;
+			case kVK_ANSI_T:              return KEY_T;
+			case kVK_ANSI_1:              return KEY_1;
+			case kVK_ANSI_2:              return KEY_2;
+			case kVK_ANSI_3:              return KEY_3;
+			case kVK_ANSI_4:              return KEY_4;
+			case kVK_ANSI_6:              return KEY_6;
+			case kVK_ANSI_5:              return KEY_5;
+			case kVK_ANSI_Equal:          return KEY_EQUAL;
+			case kVK_ANSI_9:              return KEY_9;
+			case kVK_ANSI_7:              return KEY_7;
+			case kVK_ANSI_Minus:          return KEY_MINUS;
+			case kVK_ANSI_8:              return KEY_8;
+			case kVK_ANSI_0:              return KEY_0;
+			case kVK_ANSI_RightBracket:   return KEY_RBRACKET;
+			case kVK_ANSI_O:              return KEY_O;
+			case kVK_ANSI_U:              return KEY_U;
+			case kVK_ANSI_LeftBracket:    return KEY_LBRACKET;
+			case kVK_ANSI_I:              return KEY_I;
+			case kVK_ANSI_P:              return KEY_P;
+			case kVK_ANSI_L:              return KEY_L;
+			case kVK_ANSI_J:              return KEY_J;
+			case kVK_ANSI_Quote:          return KEY_QUOTE;
+			case kVK_ANSI_K:              return KEY_K;
+			case kVK_ANSI_Semicolon:      return KEY_SEMICOLON;
+			case kVK_ANSI_Backslash:      return KEY_BACKSLASH;
+			case kVK_ANSI_Comma:          return KEY_COMMA;
+			case kVK_ANSI_Slash:          return KEY_SLASH;
+			case kVK_ANSI_N:              return KEY_N;
+			case kVK_ANSI_M:              return KEY_M;
+			case kVK_ANSI_Period:         return KEY_PERIOD;
+			case kVK_ANSI_Grave:          return KEY_GRAVE;
+			case kVK_ANSI_KeypadDecimal:  return KEY_NUM_DECIMAL;
+			case kVK_ANSI_KeypadMultiply: return KEY_NUM_MULTIPLY;
+			case kVK_ANSI_KeypadPlus:     return KEY_NUM_PLUS;
+			case kVK_ANSI_KeypadClear:    return KEY_NUM_CLEAR;
+			case kVK_ANSI_KeypadDivide:   return KEY_NUM_DIVIDE;
+			case kVK_ANSI_KeypadEnter:    return KEY_ENTER;
+			case kVK_ANSI_KeypadMinus:    return KEY_NUM_MINUS;
+			case kVK_ANSI_KeypadEquals:   return KEY_NUM_EQUAL;
+			case kVK_ANSI_Keypad0:        return KEY_NUM_0;
+			case kVK_ANSI_Keypad1:        return KEY_NUM_1;
+			case kVK_ANSI_Keypad2:        return KEY_NUM_2;
+			case kVK_ANSI_Keypad3:        return KEY_NUM_3;
+			case kVK_ANSI_Keypad4:        return KEY_NUM_4;
+			case kVK_ANSI_Keypad5:        return KEY_NUM_5;
+			case kVK_ANSI_Keypad6:        return KEY_NUM_6;
+			case kVK_ANSI_Keypad7:        return KEY_NUM_7;
+			case kVK_ANSI_Keypad8:        return KEY_NUM_8;
+			case kVK_ANSI_Keypad9:        return KEY_NUM_9;
+
+			case kVK_Return:        return KEY_RETURN;
+			case kVK_Tab:           return KEY_TAB;
+			case kVK_Space:         return KEY_SPACE;
+			case kVK_Delete:        return KEY_BACKSPACE;
+			case kVK_Escape:        return KEY_ESCAPE;
+			case kVK_Command:       return KEY_LCOMMAND;
+			case kVK_Shift:         return KEY_LSHIFT;
+			case kVK_CapsLock:      return KEY_CAPSLOCK;
+			case kVK_Option:        return KEY_LOPTION;
+			case kVK_Control:       return KEY_LCONTROL;
+			case kVK_RightCommand:  return KEY_RCOMMAND;
+			case kVK_RightShift:    return KEY_RSHIFT;
+			case kVK_RightOption:   return KEY_ROPTION;
+			case kVK_RightControl:  return KEY_RCONTROL;
+			case kVK_Function:      return KEY_FUNCTION;
+			case kVK_F17:           return KEY_F17;
+			case kVK_VolumeUp:      return KEY_VOLUME_UP;
+			case kVK_VolumeDown:    return KEY_VOLUME_DOWN;
+			case kVK_Mute:          return KEY_MUTE;
+			case kVK_F18:           return KEY_F18;
+			case kVK_F19:           return KEY_F19;
+			case kVK_F20:           return KEY_F20;
+			case kVK_F5:            return KEY_F5;
+			case kVK_F6:            return KEY_F6;
+			case kVK_F7:            return KEY_F7;
+			case kVK_F3:            return KEY_F3;
+			case kVK_F8:            return KEY_F8;
+			case kVK_F9:            return KEY_F9;
+			case kVK_F11:           return KEY_F11;
+			case kVK_F13:           return KEY_F13;
+			case kVK_F16:           return KEY_F16;
+			case kVK_F14:           return KEY_F14;
+			case kVK_F10:           return KEY_F10;
+			case kVK_F12:           return KEY_F12;
+			case kVK_F15:           return KEY_F15;
+			case kVK_Help:          return KEY_HELP;
+			case kVK_Home:          return KEY_HOME;
+			case kVK_PageUp:        return KEY_PAGEUP;
+			case kVK_ForwardDelete: return KEY_DELETE;
+			case kVK_F4:            return KEY_F4;
+			case kVK_End:           return KEY_END;
+			case kVK_F2:            return KEY_F2;
+			case kVK_PageDown:      return KEY_PAGEDOWN;
+			case kVK_F1:            return KEY_F1;
+			case kVK_LeftArrow:     return KEY_LEFT;
+			case kVK_RightArrow:    return KEY_RIGHT;
+			case kVK_DownArrow:     return KEY_DOWN;
+			case kVK_UpArrow:       return KEY_UP;
+
+			case kVK_ISO_Section: return KEY_SECTION;
+
+			case kVK_JIS_Yen:         return KEY_YEN;
+			case kVK_JIS_Underscore:  return KEY_UNDERSCORE;
+			case kVK_JIS_KeypadComma: return KEY_NUM_COMMA;
+			case kVK_JIS_Eisu:        return KEY_IME_EISU;
+			case kVK_JIS_Kana:        return KEY_IME_KANA;
+		}
+
+		return KEY_NONE;
+	}
+
+	static uint
+	get_modifier_flag_mask (const NSEvent* e)
+	{
+		switch ([e keyCode])
+		{
+			case kVK_Shift:
+			case kVK_RightShift:   return NSShiftKeyMask;
+			case kVK_Control:
+			case kVK_RightControl: return NSControlKeyMask;
+			case kVK_Option:
+			case kVK_RightOption:  return NSAlternateKeyMask;
+			case kVK_Command:
+			case kVK_RightCommand: return NSCommandKeyMask;
+			case kVK_CapsLock:     return NSAlphaShiftKeyMask;
+			case kVK_Function:     return NSFunctionKeyMask;
+		}
+		return 0;
+	}
+
+	static KeyEvent::Action
+	get_flag_key_event_action (const NSEvent* e)
+	{
+		uint mask = get_modifier_flag_mask(e);
+		if (mask == 0) return Reflex::KeyEvent::ACTION_NONE;
+
+		return [e modifierFlags] & mask
+			?	Reflex::KeyEvent::DOWN
+			:	Reflex::KeyEvent::UP;
+	}
+
 	static uint
 	get_current_pointer_type ()
 	{
 		NSUInteger buttons = [NSEvent pressedMouseButtons];
 		uint ret = 0;
-		if (buttons &  (1 << 0)) ret |= POINTER_MOUSE_LEFT;
-		if (buttons &  (1 << 1)) ret |= POINTER_MOUSE_RIGHT;
-		if (buttons >= (1 << 2)) ret |= POINTER_MOUSE_MIDDLE;
+		if (buttons &  Xot::bit(0)) ret |= Reflex::Pointer::MOUSE_LEFT;
+		if (buttons &  Xot::bit(1)) ret |= Reflex::Pointer::MOUSE_RIGHT;
+		if (buttons >= Xot::bit(2)) ret |= Reflex::Pointer::MOUSE_MIDDLE;
 		return ret;
 	}
 
@@ -36,22 +199,24 @@ namespace Reflex
 			case NSLeftMouseDown:
 			case NSLeftMouseUp:
 			case NSLeftMouseDragged:
-				return POINTER_MOUSE_LEFT;
+				return Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_LEFT;
 
 			case NSRightMouseDown:
 			case NSRightMouseUp:
 			case NSRightMouseDragged:
-				return POINTER_MOUSE_RIGHT;
+				return Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_RIGHT;
 
 			case NSOtherMouseDown:
 			case NSOtherMouseUp:
 			case NSOtherMouseDragged:
-				return POINTER_MOUSE_MIDDLE;
+				return Reflex::Pointer::MOUSE | Reflex::Pointer::MOUSE_MIDDLE;
 
 			case NSMouseMoved:
-				return get_current_pointer_type();
+				return Reflex::Pointer::MOUSE | get_current_pointer_type();
+
+			default:
+				return Reflex::Pointer::TYPE_NONE;
 		}
-		return 0;
 	}
 
 	static uint
@@ -78,34 +243,59 @@ namespace Reflex
 		return p;
 	}
 
+	static Point
+	get_pointer_position (NSEvent* e, NSView* view)
+	{
+		NSPoint p = correct_point(view, [e locationInWindow]);
+		return Point(p.x, p.y);
+	}
+
 
-	NativeKeyEvent::NativeKeyEvent (NSEvent* e, Type type)
+	NativeKeyEvent::NativeKeyEvent (NSEvent* e, Action action)
 	:	KeyEvent(
-			type, get_chars(e), [e keyCode], get_modifiers(e), [e isARepeat] ? 1 : 0)
+			action, get_chars(e), get_code([e keyCode]),
+			get_modifiers(e), [e isARepeat] ? 1 : 0)
 	{
 	}
 
 
-	NativePointerEvent::NativePointerEvent (NSEvent* e, NSView* view, Type type)
-	:	PointerEvent(
-			type, get_pointer_type(e), (coord) 0, (coord) 0,
-			get_modifiers(e), (uint) [e clickCount],
-			[e type] == NSLeftMouseDragged || [e type] == NSRightMouseDragged || [e type] == NSOtherMouseDragged)
+	NativeFlagKeyEvent::NativeFlagKeyEvent (NSEvent* e)
+	:	KeyEvent(
+			get_flag_key_event_action(e), "", get_code([e keyCode]),
+			get_modifiers(e), 0)
 	{
-		NSPoint p = correct_point(view, [e locationInWindow]);
-		x = p.x;
-		y = p.y;
+	}
+
+
+	static bool
+	is_pointer_dragging (NSEvent* e)
+	{
+		return
+			[e type] == NSLeftMouseDragged  ||
+			[e type] == NSRightMouseDragged ||
+			[e type] == NSOtherMouseDragged;
+	}
+
+	NativePointerEvent::NativePointerEvent (
+		NSEvent* event, NSView* view, Pointer::ID id, Pointer::Action action)
+	{
+		bool dragging = is_pointer_dragging(event);
+		PointerEvent_add_pointer(this, Pointer(
+			id,
+			get_pointer_type(event),
+			action,
+			get_pointer_position(event, view),
+			get_modifiers(event),
+			action == Pointer::MOVE && !dragging ? 0 : (uint) [event clickCount],
+			dragging,
+			time()));
 	}
 
 
 	NativeWheelEvent::NativeWheelEvent (NSEvent* e, NSView* view)
-	:	WheelEvent([e deltaX], [e deltaY], [e deltaZ])
+	:	WheelEvent(0, 0, 0, [e deltaX], [e deltaY], [e deltaZ], get_modifiers(e))
 	{
-		NSPoint p = correct_point(view, [e locationInWindow]);
-		x         = p.x;
-		y         = p.y;
-		z         = 0;
-		modifiers = get_modifiers(e);
+		WheelEvent_set_position(this, get_pointer_position(e, view));
 	}
 
 

data/src/osx/native_window.mm

@@ -4,9 +4,9 @@
 
 #include <assert.h>
 #import <Cocoa/Cocoa.h>
-#include "rays/bounds.h"
 #include "reflex/exception.h"
 #include "../view.h"
+#include "../pointer.h"
 #include "event.h"
 #include "window.h"
 #import "opengl_view.h"
@@ -20,12 +20,30 @@ static const NSUInteger WINDOW_STYLE_MASK =
 	0;//NSTexturedBackgroundWindowMask
 
 
+static int
+count_mouse_buttons (const Reflex::PointerEvent& e)
+{
+	uint nbuttons = 0;
+	PointerEvent_each_pointer(&e, [&](const auto& pointer) {
+		uint t = pointer.type();
+		nbuttons +=
+			(t & Reflex::Pointer::MOUSE_LEFT   ? 1 : 0) +
+			(t & Reflex::Pointer::MOUSE_RIGHT  ? 1 : 0) +
+			(t & Reflex::Pointer::MOUSE_MIDDLE ? 1 : 0);
+	});
+	return nbuttons;
+}
+
 @implementation NativeWindow
 
 	{
 		Reflex::Window *pwindow, *ptr_for_rebind;
 		OpenGLView* view;
 		NSTimer* timer;
+		int update_count;
+		int clicking_count;
+		Reflex::Pointer::ID pointer_id;
+		Reflex::Pointer prevPointer;
 	}
 
 	- (id) init
@@ -37,9 +55,13 @@ static const NSUInteger WINDOW_STYLE_MASK =
 			defer: NO];
 		if (!self) return nil;
 
-		pwindow = ptr_for_rebind = NULL;
-		view    = nil;
-		timer   = nil;
+		pwindow         =
+		ptr_for_rebind  = NULL;
+		view            = nil;
+		timer           = nil;
+		update_count    = 0;
+		clicking_count  = 0;
+		pointer_id      = 0;
 
 		[self setDelegate: self];
 		[self setupContentView];
@@ -152,6 +174,8 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
+		++update_count;
+
 		double now = Xot::time();
 		Reflex::UpdateEvent e(now, now - win->self->prev_time_update);
 		win->self->prev_time_update = now;
@@ -172,6 +196,9 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
+		if (update_count == 0)
+			[self update];
+
 		double now = Xot::time();
 		double dt  = now - win->self->prev_time_draw;
 		double fps = 1. / dt;
@@ -242,7 +269,7 @@ static const NSUInteger WINDOW_STYLE_MASK =
 
 		if (dpos != 0 || dsize != 0)
 		{
-			Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y);
+			Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y, 0, 0);
 			if (dpos  != 0) win->on_move(&e);
 			if (dsize != 0)
 			{
@@ -250,7 +277,7 @@ static const NSUInteger WINDOW_STYLE_MASK =
 				b.move_to(0, 0);
 
 				if (win->painter())
-					win->painter()->canvas(b, self.backingScaleFactor);
+					win->painter()->canvas(b, win->painter()->pixel_density());
 
 				if (win->root())
 					View_set_frame(win->root(), b);
@@ -266,7 +293,7 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		if (!win) return;
 
 		Reflex::NativeKeyEvent e(event, Reflex::KeyEvent::DOWN);
-		win->on_key(&e);
+		Window_call_key_event(win, &e);
 	}
 
 	- (void) keyUp: (NSEvent*) event
@@ -275,12 +302,16 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		if (!win) return;
 
 		Reflex::NativeKeyEvent e(event, Reflex::KeyEvent::UP);
-		win->on_key(&e);
+		Window_call_key_event(win, &e);
 	}
 
 	- (void) flagsChanged: (NSEvent*) event
 	{
-		// TODO: implement later.
+		Reflex::Window* win = self.window;
+		if (!win) return;
+
+		Reflex::NativeFlagKeyEvent e(event);
+		Window_call_key_event(win, &e);
 	}
 
 	- (void) mouseDown: (NSEvent*) event
@@ -288,8 +319,22 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::DOWN);
-		win->on_pointer(&e);
+		if (clicking_count == 0) ++pointer_id;
+
+		Reflex::NativePointerEvent e(event, view, pointer_id, Reflex::Pointer::DOWN);
+
+		if (e[0].position().y < 0)
+		{
+			// ignore mouseDown event since the mouseUp event to the window title bar
+			// will not come and will break clicking_count.
+			return;
+		}
+
+		[self attachAndUpdatePrevPointer: &e];
+
+		clicking_count += count_mouse_buttons(e);
+
+		Window_call_pointer_event(win, &e);
 	}
 
 	- (void) mouseUp: (NSEvent*) event
@@ -297,8 +342,16 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::UP);
-		win->on_pointer(&e);
+		Reflex::NativePointerEvent e(event, view, pointer_id, Reflex::Pointer::UP);
+		[self attachAndUpdatePrevPointer: &e];
+
+		clicking_count -= count_mouse_buttons(e);
+		if (clicking_count == 0)
+			++pointer_id;
+		else if (clicking_count < 0)
+			Reflex::invalid_state_error(__FILE__, __LINE__);
+
+		Window_call_pointer_event(win, &e);
 	}
 
 	- (void) mouseDragged: (NSEvent*) event
@@ -306,8 +359,10 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::MOVE);
-		win->on_pointer(&e);
+		Reflex::NativePointerEvent e(event, view, pointer_id, Reflex::Pointer::MOVE);
+		[self attachAndUpdatePrevPointer: &e];
+
+		Window_call_pointer_event(win, &e);
 	}
 
 	- (void) mouseMoved: (NSEvent*) event
@@ -315,8 +370,20 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(event, view, Reflex::PointerEvent::MOVE);
-		win->on_pointer(&e);
+		Reflex::NativePointerEvent e(event, view, pointer_id, Reflex::Pointer::MOVE);
+		[self attachAndUpdatePrevPointer: &e];
+
+		Window_call_pointer_event(win, &e);
+	}
+
+	- (void) attachAndUpdatePrevPointer: (Reflex::PointerEvent*) e
+	{
+		assert(e->size() == 1);
+
+		Reflex::Pointer& pointer = Reflex::PointerEvent_pointer_at(e, 0);
+		if (prevPointer)
+			Reflex::Pointer_set_prev(&pointer, &prevPointer);
+		prevPointer = pointer;
 	}
 
 	- (void) scrollWheel: (NSEvent*) event
@@ -325,7 +392,7 @@ static const NSUInteger WINDOW_STYLE_MASK =
 		if (!win) return;
 
 		Reflex::NativeWheelEvent e(event, view);
-		win->on_wheel(&e);
+		Window_call_wheel_event(win, &e);
 	}
 
 	+ (NSRect) frameRectForContentRect: (NSRect) contentRect

data/src/osx/window.mm

@@ -112,6 +112,28 @@ namespace Reflex
 			rect.size.height);
 	}
 
+	void
+	Window_set_resizable (Window* window, bool state)
+	{
+		NativeWindow* native = get_native(window);
+		if (state)
+			native.styleMask |= NSResizableWindowMask;
+		else
+			native.styleMask &= ~NSResizableWindowMask;
+	}
+
+	bool
+	Window_is_resizable (const Window& window)
+	{
+		return get_native(&window).styleMask & NSResizableWindowMask;
+	}
+
+	float
+	Window_get_pixel_density (const Window& window)
+	{
+		return get_native(&window).backingScaleFactor;
+	}
+
 
 	WindowData::WindowData ()
 	{