reflexion 0.3.14 → 0.4.0

data/src/application.cpp

@@ -29,12 +29,24 @@ namespace Reflex
 		MIDI_init(app);
 	}
 
+	static void
+	close_all_windows (Application* app)
+	{
+		for (auto it = app->window_begin(), end = app->window_end(); it != end; ++it)
+			(*it)->close(true);
+	}
+
 	void
 	Application_call_quit (Application* app, Event* e)
 	{
+		if (app->self->quitting) return;
+
 		app->on_quit(e);
 		if (e->is_blocked()) return;
 
+		app->self->quitting = true;
+
+		close_all_windows(app);
 		MIDI_fin(app);
 		Gamepad_fin(app);
 	}

data/src/application.h

@@ -16,6 +16,8 @@ namespace Reflex
 
 		String name;
 
+		bool quitting = false;
+
 	};// Application::Data
 
 

data/src/ios/event.h

@@ -4,7 +4,7 @@
 #define __REFLEX_SRC_IOS_EVENT_H__
 
 
-#import <UIKit/UIEvent.h>
+#import <UIKit/UIKit.h>
 #include "../event.h"
 
 
@@ -12,6 +12,17 @@ namespace Reflex
 {
 
 
+	class NativeKeyEvent : public KeyEvent
+	{
+
+		public:
+
+			NativeKeyEvent (UIPress* press, Action action)
+				API_AVAILABLE(ios(13.4));
+
+	};// NativeKeyEvent
+
+
 	class NativePointerEvent : public PointerEvent
 	{
 
@@ -19,9 +30,22 @@ namespace Reflex
 
 			NativePointerEvent (NSSet* touches, UIEvent* event, UIView* view);
 
+			NativePointerEvent (UIHoverGestureRecognizer* recognizer, UIView* view);
+
 	};// NativePointerEvent
 
 
+	class NativeWheelEvent : public WheelEvent
+	{
+
+		public:
+
+			NativeWheelEvent (
+				UIPanGestureRecognizer* recognizer, UIView* view, CGPoint position);
+
+	};// NativeWheelEvent
+
+
 }// Reflex
 
 

data/src/ios/event.mm

@@ -3,6 +3,7 @@
 
 
 #include <assert.h>
+#include <xot/util.h>
 #include "window.h"
 
 
@@ -11,7 +12,23 @@ namespace Reflex
 
 
 	static uint
-	get_type (UITouch* touch)
+	get_mouse_button_types (UIEvent* event)
+	{
+		if (!event) return 0;
+
+		uint ret = 0;
+		if (@available(iOS 13.4, *))
+		{
+			UIEventButtonMask mask = event.buttonMask;
+			if (mask & UIEventButtonMaskPrimary)            ret |= Pointer::MOUSE_LEFT;
+			if (mask & UIEventButtonMaskSecondary)          ret |= Pointer::MOUSE_RIGHT;
+			if (mask & UIEventButtonMaskForButtonNumber(3)) ret |= Pointer::MOUSE_MIDDLE;
+		}
+		return ret;
+	}
+
+	static uint
+	get_type (UITouch* touch, UIEvent* event)
 	{
 		assert(touch);
 
@@ -22,8 +39,15 @@ namespace Reflex
 		{
 			case UITouchTypeDirect: return Pointer::TOUCH;
 			case UITouchTypePencil: return Pointer::PEN;
-			default:                return Pointer::TYPE_NONE;
 		}
+
+		if (@available(iOS 13.4, *))
+		{
+			if (type == UITouchTypeIndirectPointer)
+				return Pointer::MOUSE | get_mouse_button_types(event);
+		}
+
+		return Pointer::TYPE_NONE;
 	}
 
 	static Pointer::Action
@@ -52,14 +76,8 @@ namespace Reflex
 	}
 
 	static uint
-	get_modifiers (const UIEvent* event)
+	to_modifiers (NSInteger flags)
 	{
-		if (!event) return 0;
-
-		NSInteger flags = 0;
-		if (@available(iOS 13.4, *))
-			flags = event.modifierFlags;
-
 		return
 			(flags & UIKeyModifierAlphaShift) ? MOD_CAPS    : 0 |
 			(flags & UIKeyModifierShift)      ? MOD_SHIFT   : 0 |
@@ -69,6 +87,18 @@ namespace Reflex
 			(flags & UIKeyModifierNumericPad) ? MOD_NUMPAD  : 0;
 	}
 
+	static uint
+	get_modifiers (const UIEvent* event)
+	{
+		if (!event) return 0;
+
+		NSInteger flags = 0;
+		if (@available(iOS 13.4, *))
+			flags = event.modifierFlags;
+
+		return to_modifiers(flags);
+	}
+
 	uint
 	KeyEvent_get_modifiers ()
 	{
@@ -76,25 +106,45 @@ namespace Reflex
 	}
 
 
+	static const char*
+	get_chars (UIKey* key) API_AVAILABLE(ios(13.4))
+	{
+		NSString* s = key.characters;
+		if (!s || [s hasPrefix: @"UIKeyInput"])
+			return NULL;
+		return s.UTF8String;
+	}
+
+	NativeKeyEvent::NativeKeyEvent (UIPress* press, Action action)
+	:	KeyEvent(
+			action, get_chars(press.key), (int) press.key.keyCode,
+			to_modifiers(press.key.modifierFlags), 0)
+	{
+	}
+
+
 	NativePointerEvent::NativePointerEvent (
 		NSSet* touches, UIEvent* event, UIView* view)
 	{
 		for (UITouch* touch in touches)
 		{
 			Pointer::Action action = get_action(touch);
+			uint type              = get_type(touch, event);
 
 			Pointer pointer(
 				0,
-				get_type(touch),
+				type,
 				action,
 				to_point([touch locationInView: view]),
 				get_modifiers(event),
 				(uint) touch.tapCount,
 				action == Pointer::MOVE,
 				touch.timestamp);
-			Pointer_set_system_id(&pointer, (Pointer::ID) touch);
 
-			if (pointer.action() != Pointer::DOWN)
+			if (!(type & Pointer::MOUSE))
+				Pointer_set_system_id(&pointer, (Pointer::ID) touch);
+
+			if (action != Pointer::DOWN)
 			{
 				Pointer_set_prev_position(
 					&pointer, to_point([touch previousLocationInView: view]));
@@ -105,5 +155,38 @@ namespace Reflex
 		}
 	}
 
+	NativePointerEvent::NativePointerEvent (
+		UIHoverGestureRecognizer* recognizer, UIView* view)
+	{
+		assert(recognizer && view);
+
+		Pointer pointer(
+			0,
+			Pointer::MOUSE,
+			Pointer::MOVE,
+			to_point([recognizer locationInView: view]),
+			get_modifiers(nil),
+			0,
+			false,
+			Xot::time());
+
+		if (pointer)
+			PointerEvent_add_pointer(this, pointer);
+	}
+
+
+	NativeWheelEvent::NativeWheelEvent (
+		UIPanGestureRecognizer* recognizer, UIView* view, CGPoint position)
+	:	WheelEvent(0, 0, 0, 0, 0, 0, get_modifiers(nil))
+	{
+		assert(recognizer && view);
+
+		WheelEvent_set_position(this, to_point(position));
+
+		CGPoint delta       = [recognizer translationInView: view];
+		this->dposition().x = delta.x;
+		this->dposition().y = delta.y;
+	}
+
 
 }// Reflex

data/src/ios/view_controller.mm

@@ -121,12 +121,14 @@ ReflexViewController_get_show_fun ()
 @end
 
 
-@interface ReflexViewController () <GLKViewDelegate>
+@interface ReflexViewController () <GLKViewDelegate, UIGestureRecognizerDelegate>
 
 	@property(nonatomic, strong) ReflexView* reflexView;
 
 	@property(nonatomic, strong) CADisplayLink* displayLink;
 
+	@property(nonatomic, strong) UIHoverGestureRecognizer* hoverRecognizer;
+
 @end
 
 
@@ -264,10 +266,36 @@ ReflexViewController_get_show_fun ()
 		//view.drawableMultisample   = GLKViewDrawableMultisample4X;
 
 		[self.view addSubview: view];
+		[self setupMouseRecognizers: view];
 
 		self.reflexView = view;
 	}
 
+	- (void) setupMouseRecognizers: (UIView*) view
+	{
+		if (@available(iOS 13.4, *))
+		{
+			UIHoverGestureRecognizer* hover = [[[UIHoverGestureRecognizer alloc]
+				initWithTarget: self action: @selector(hoverChanged:)]
+				autorelease];
+			hover.delegate       = self;
+			[view addGestureRecognizer: hover];
+			self.hoverRecognizer = hover;
+
+			UIPanGestureRecognizer* pan = [[[UIPanGestureRecognizer alloc]
+				initWithTarget: self action: @selector(scrollChanged:)]
+				autorelease];
+			pan.allowedScrollTypesMask = UIScrollTypeMaskAll;
+			// 0/0 touches means the recognizer only fires from indirect scroll
+			// (mouse wheel / trackpad scroll) — touch-based panning is left to
+			// the touchesBegan/etc. path so this won't intercept finger pans.
+			pan.minimumNumberOfTouches = 0;
+			pan.maximumNumberOfTouches = 0;
+			pan.delegate               = self;
+			[view addGestureRecognizer: pan];
+		}
+	}
+
 	- (void) cleanupReflexView
 	{
 		ReflexView* view = self.reflexView;
@@ -299,10 +327,14 @@ ReflexViewController_get_show_fun ()
 			selector: @selector(willResignActive)
 			name: UIApplicationWillResignActiveNotification
 			object: nil];
+
+		[self becomeFirstResponder];
 	}
 
 	- (void) viewDidDisappear: (BOOL) animated
 	{
+		[self resignFirstResponder];
+
 		[NSNotificationCenter.defaultCenter
 			removeObserver: self
 			name: UIApplicationDidBecomeActiveNotification
@@ -334,6 +366,11 @@ ReflexViewController_get_show_fun ()
 		self.reflexView.frame = self.view.bounds;
 	}
 
+	- (BOOL) canBecomeFirstResponder
+	{
+		return YES;
+	}
+
 	- (void) startTimer
 	{
 		[self startTimer: 60];
@@ -509,4 +546,99 @@ ReflexViewController_get_show_fun ()
 		Window_call_pointer_event(win, &e);
 	}
 
+	- (void) hoverChanged: (UIHoverGestureRecognizer*) recognizer
+		API_AVAILABLE(ios(13.4))
+	{
+		Reflex::Window* win = self.window;
+		if (!win) return;
+
+		if (touching_count > 0) return;
+
+		if (
+			recognizer.state != UIGestureRecognizerStateBegan &&
+			recognizer.state != UIGestureRecognizerStateChanged)
+		{
+			return;
+		}
+
+		Reflex::NativePointerEvent e(recognizer, self.reflexView);
+		if (e.size() > 0)
+			Window_call_pointer_event(win, &e);
+	}
+
+	- (void) scrollChanged: (UIPanGestureRecognizer*) recognizer
+		API_AVAILABLE(ios(13.4))
+	{
+		Reflex::Window* win = self.window;
+		if (!win) return;
+
+		if (
+			recognizer.state != UIGestureRecognizerStateBegan &&
+			recognizer.state != UIGestureRecognizerStateChanged)
+		{
+			return;
+		}
+
+		// The pan recognizer's locationInView drifts with the synthetic scroll
+		// touch, so use the hover recognizer's location — it tracks the actual
+		// cursor and exposes the last known position regardless of its state.
+		CGPoint pos = [self.hoverRecognizer locationInView: self.reflexView];
+
+		Reflex::NativeWheelEvent e(recognizer, self.reflexView, pos);
+		Window_call_wheel_event(win, &e);
+
+		// reset translation so subsequent deltas are incremental
+		[recognizer setTranslation: CGPointZero inView: self.reflexView];
+	}
+
+	- (BOOL) gestureRecognizer: (UIGestureRecognizer*) recognizer
+		shouldRecognizeSimultaneouslyWithGestureRecognizer: (UIGestureRecognizer*) other
+	{
+		// UIKit only calls this delegate method when at least one of the two
+		// recognizers has us set as its delegate, and we only set ourselves as
+		// the delegate for our mouse recognizers (hover / indirect scroll). So
+		// every call here already involves one of ours, and we want it to run
+		// alongside whatever else is on the view (touches, app-added gestures).
+		return YES;
+	}
+
+	- (void) pressesBegan: (NSSet<UIPress*>*) presses
+		withEvent: (UIPressesEvent*) event
+	{
+		if (@available(iOS 13.4, *))
+			[self handlePresses: presses action: Reflex::KeyEvent::DOWN];
+		[super pressesBegan: presses withEvent: event];
+	}
+
+	- (void) pressesEnded: (NSSet<UIPress*>*) presses
+		withEvent: (UIPressesEvent*) event
+	{
+		if (@available(iOS 13.4, *))
+			[self handlePresses: presses action: Reflex::KeyEvent::UP];
+		[super pressesEnded: presses withEvent: event];
+	}
+
+	- (void) pressesCancelled: (NSSet<UIPress*>*) presses
+		withEvent: (UIPressesEvent*) event
+	{
+		if (@available(iOS 13.4, *))
+			[self handlePresses: presses action: Reflex::KeyEvent::UP];
+		[super pressesCancelled: presses withEvent: event];
+	}
+
+	- (void) handlePresses: (NSSet<UIPress*>*) presses
+		action: (Reflex::KeyEvent::Action) action
+		API_AVAILABLE(ios(13.4))
+	{
+		Reflex::Window* win = self.window;
+		if (!win) return;
+
+		for (UIPress* press in presses)
+		{
+			if (!press.key) continue;
+			Reflex::NativeKeyEvent e(press, action);
+			Window_call_key_event(win, &e);
+		}
+	}
+
 @end// ReflexViewController

data/src/midi.cpp

@@ -304,6 +304,10 @@ namespace Reflex
 	void
 	MIDI_init (Application* app)
 	{
+#ifdef WASM
+		return;
+#endif
+
 		if (manager)
 			invalid_state_error(__FILE__, __LINE__);
 

data/src/osx/device.mm

@@ -9,11 +9,14 @@ namespace Reflex
 {
 
 
+	#pragma GCC diagnostic push
+	#pragma GCC diagnostic ignored "-Wmissing-noreturn"
 	void
 	vibrate ()
 	{
 		not_implemented_error(__FILE__, __LINE__);
 	}
+	#pragma GCC diagnostic pop
 
 
 }// Reflex

data/src/osx/event.mm

@@ -163,7 +163,7 @@ namespace Reflex
 
 
 	NativeWheelEvent::NativeWheelEvent (NSEvent* e, NSView* view)
-	:	WheelEvent(0, 0, 0, [e deltaX], [e deltaY], [e deltaZ], get_modifiers(e))
+	:	WheelEvent(0, 0, 0, [e deltaX], -[e deltaY], [e deltaZ], get_modifiers(e))
 	{
 		WheelEvent_set_position(this, get_pointer_position(e, view));
 	}

data/src/sdl/application.cpp

@@ -2,6 +2,9 @@
 
 
 #include <SDL.h>
+#ifdef WASM
+	#include <emscripten.h>
+#endif
 #include <xot/time.h>
 #include "reflex/exception.h"
 #include "reflex/debug.h"
@@ -51,8 +54,8 @@ namespace Reflex
 		return Window_dispatch_event(win, event);
 	}
 
-	static bool
-	dispatch_events ()
+	static void
+	dispatch_events (Application* app)
 	{
 		SDL_Event event;
 		while (SDL_PollEvent(&event))
@@ -60,13 +63,9 @@ namespace Reflex
 			if (dispatch_window_event(event))
 				continue;
 
-			switch (event.type)
-			{
-				case SDL_QUIT: return false;
-			}
+			if (event.type == SDL_QUIT)
+				app->quit();
 		}
-
-		return true;
 	}
 
 	static void
@@ -76,18 +75,15 @@ namespace Reflex
 			Window_update(it->get());
 	}
 
-	void
-	Application::start ()
+	static void
+	main_loop (Application* app)
 	{
-		Event e;
-		Application_call_start(this, &e);
-
-		ApplicationData* self = get_data(this);
+		ApplicationData* self = get_data(app);
 
 		double prev = Xot::time();
 		while (!self->quit)
 		{
-			if (!dispatch_events()) break;
+			dispatch_events(app);
 
 			static const double INTERVAL  = 1.0 / 60.0;
 			static const double SLEEPABLE = INTERVAL * 0.9;
@@ -100,11 +96,39 @@ namespace Reflex
 				continue;
 			}
 
-			update_all_windows(this);
+			update_all_windows(app);
 			prev = now;
 		}
 	}
 
+#ifdef WASM
+	static void
+	emscripten_main_loop (void* arg)
+	{
+		Application* app = (Application*) arg;
+
+		dispatch_events(app);
+
+		if (get_data(app)->quit)
+			emscripten_cancel_main_loop();
+		else
+			update_all_windows(app);
+	}
+#endif
+
+	void
+	Application::start ()
+	{
+		Event e;
+		Application_call_start(this, &e);
+
+#ifdef WASM
+		emscripten_set_main_loop_arg(emscripten_main_loop, this, 0, true);
+#else
+		main_loop(this);
+#endif
+	}
+
 	void
 	Application::quit ()
 	{