reflexion 0.3.3 → 0.3.5

data/src/osx/event.mm

@@ -5,6 +5,9 @@
 #include <assert.h>
 #include <Carbon/Carbon.h>
 #import <Cocoa/Cocoa.h>
+#import <GameController/GameController.h>
+#include "reflex/debug.h"
+#include "window.h"
 
 
 namespace Reflex
@@ -12,9 +15,9 @@ namespace Reflex
 
 
 	static uint
-	get_modifiers (const NSEvent* e)
+	get_modifiers (const NSEvent* event = nil)
 	{
-		NSUInteger flags = e.modifierFlags;
+		NSUInteger flags = event ? event.modifierFlags : NSEvent.modifierFlags;
 		return
 			(flags & NSAlphaShiftKeyMask) ? MOD_CAPS     : 0 |
 			(flags & NSShiftKeyMask)      ? MOD_SHIFT    : 0 |
@@ -161,4 +164,86 @@ namespace Reflex
 	}
 
 
+	static void
+	call_gamepad_event (int code, bool pressed)
+	{
+		Window* win = Window_get_active();
+		if (!win) return;
+
+		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
+		KeyEvent e(action, NULL, code, get_modifiers(), 0);
+		Window_call_key_event(win, &e);
+	}
+
+	static void
+	handle_gamepad_event (GCControllerButtonInput* input, int code)
+	{
+		[input setPressedChangedHandler:
+			^(GCControllerButtonInput* button, float value, BOOL pressed) {
+				call_gamepad_event(code, pressed);
+			}];
+	}
+
+	static void
+	handle_gamepad_events (GCController* controller)
+	{
+		GCExtendedGamepad* gamepad = controller.extendedGamepad;
+		if (!gamepad) return;
+
+		handle_gamepad_event(gamepad.dpad.left,  KEY_GAMEPAD_LEFT);
+		handle_gamepad_event(gamepad.dpad.right, KEY_GAMEPAD_RIGHT);
+		handle_gamepad_event(gamepad.dpad.up,    KEY_GAMEPAD_UP);
+		handle_gamepad_event(gamepad.dpad.down,  KEY_GAMEPAD_DOWN);
+
+		handle_gamepad_event(gamepad.buttonA, KEY_GAMEPAD_A);
+		handle_gamepad_event(gamepad.buttonB, KEY_GAMEPAD_B);
+		handle_gamepad_event(gamepad.buttonX, KEY_GAMEPAD_X);
+		handle_gamepad_event(gamepad.buttonY, KEY_GAMEPAD_Y);
+
+		handle_gamepad_event(gamepad. leftShoulder, KEY_GAMEPAD_SHOULDER_LEFT);
+		handle_gamepad_event(gamepad.rightShoulder, KEY_GAMEPAD_SHOULDER_RIGHT);
+		handle_gamepad_event(gamepad. leftTrigger,  KEY_GAMEPAD_TRIGGER_LEFT);
+		handle_gamepad_event(gamepad.rightTrigger,  KEY_GAMEPAD_TRIGGER_RIGHT);
+
+		if (@available(macOS 10.14.1, *))
+		{
+			handle_gamepad_event(gamepad. leftThumbstickButton, KEY_GAMEPAD_THUMB_LEFT);
+			handle_gamepad_event(gamepad.rightThumbstickButton, KEY_GAMEPAD_THUMB_RIGHT);
+		}
+
+		if (@available(macOS 10.15, *))
+		{
+			handle_gamepad_event(gamepad.buttonMenu,    KEY_GAMEPAD_MENU);
+			handle_gamepad_event(gamepad.buttonOptions, KEY_GAMEPAD_OPTION);
+		}
+
+		if (@available(macOS 11.0, *))
+			handle_gamepad_event(gamepad.buttonHome, KEY_GAMEPAD_HOME);
+	}
+
+	static id game_controllers_observer = nil;
+
+	void
+	init_game_controllers ()
+	{
+		for (GCController* c in GCController.controllers)
+			handle_gamepad_events(c);
+
+		game_controllers_observer = [NSNotificationCenter.defaultCenter
+			addObserverForName: GCControllerDidConnectNotification
+			object: nil
+			queue: NSOperationQueue.mainQueue
+			usingBlock: ^(NSNotification* n) {handle_gamepad_events(n.object);}];
+	}
+
+	void
+	fin_game_controllers ()
+	{
+		if (!game_controllers_observer) return;
+
+		[NSNotificationCenter.defaultCenter
+			removeObserver: game_controllers_observer];
+	}
+
+
 };// Reflex

data/src/osx/native_window.mm

@@ -201,13 +201,7 @@ move_to_main_screen_origin (NativeWindow* window)
 
 		++update_count;
 
-		double now = Xot::time();
-		Reflex::UpdateEvent e(now, now - win->self->prev_time_update);
-		win->self->prev_time_update = now;
-
-		win->on_update(&e);
-		if (!e.is_blocked())
-			Reflex::View_update_tree(win->root(), e);
+		Window_call_update_event(win);
 
 		if (win->self->redraw)
 		{

data/src/osx/reflex.mm

@@ -4,6 +4,7 @@
 
 #import <Cocoa/Cocoa.h>
 #include "reflex/exception.h"
+#include "event.h"
 
 
 namespace Reflex
@@ -25,6 +26,8 @@ namespace Reflex
 			reflex_error(__FILE__, __LINE__, "already initialized.");
 
 		global::pool = [[NSAutoreleasePool alloc] init];
+
+		init_game_controllers();
 	}
 
 	void
@@ -33,6 +36,8 @@ namespace Reflex
 		if (!global::pool)
 			reflex_error(__FILE__, __LINE__, "not initialized.");
 
+		fin_game_controllers();
+
 		[global::pool release];
 		global::pool = nil;
 	}

data/src/view.cpp

@@ -39,23 +39,29 @@ namespace Reflex
 		enum Flag
 		{
 
-			REDRAW               = Xot::bit(1, FLAG_LAST),
+			UPDATING               = Xot::bit(1, FLAG_LAST),
 
-			APPLY_STYLE          = Xot::bit(2, FLAG_LAST),
+			NO_SHAPE               = Xot::bit(2, FLAG_LAST),
 
-			UPDATE_STYLE         = Xot::bit(3, FLAG_LAST),
+			HAS_VARIABLE_LENGTHS   = Xot::bit(3, FLAG_LAST),
 
-			UPDATE_SHAPES        = Xot::bit(4, FLAG_LAST),
+			HAS_CHILDREN_TO_REMOVE = Xot::bit(4, FLAG_LAST),
 
-			UPDATE_LAYOUT        = Xot::bit(5, FLAG_LAST),
+			REMOVE_FROM_PARENT     = Xot::bit(5, FLAG_LAST),
 
-			SORT_CHILDREN        = Xot::bit(6, FLAG_LAST),
+			REDRAW                 = Xot::bit(6, FLAG_LAST),
 
-			FIT_TO_CONTENT       = Xot::bit(7, FLAG_LAST),
+			APPLY_STYLE            = Xot::bit(7, FLAG_LAST),
 
-			HAS_VARIABLE_LENGTHS = Xot::bit(8, FLAG_LAST),
+			UPDATE_STYLE           = Xot::bit(8, FLAG_LAST),
 
-			NO_SHAPE             = Xot::bit(9, FLAG_LAST),
+			UPDATE_SHAPES          = Xot::bit(9, FLAG_LAST),
+
+			UPDATE_LAYOUT          = Xot::bit(10, FLAG_LAST),
+
+			SORT_CHILDREN          = Xot::bit(11, FLAG_LAST),
+
+			FIT_TO_CONTENT         = Xot::bit(12, FLAG_LAST),
 
 		};// Flag
 
@@ -235,6 +241,8 @@ namespace Reflex
 			}
 			else
 				pbody->set_transform(frame.x, frame.y, angle);
+
+			pbody->awake();
 		}
 
 		void update_body_states ()
@@ -1043,6 +1051,20 @@ namespace Reflex
 		}
 	}
 
+	static void
+	remove_children (View* view, View::ChildList* children)
+	{
+		assert(children);
+
+		int size = (int) children->size();
+		for (int i = size - 1; i >= 0; --i)
+		{
+			View* child = (*children)[i].get();
+			if (child->self->check_and_remove_flag(View::Data::REMOVE_FROM_PARENT))
+				view->remove_child(child);
+		}
+	}
+
 	void
 	View_update_tree (View* view, const UpdateEvent& event)
 	{
@@ -1051,13 +1073,16 @@ namespace Reflex
 
 		View::Data* self = view->self.get();
 
+		self->add_flag(View::Data::UPDATING);
+
 		fire_timers(view, event.now());
 
 		View::ChildList* children = self->children();
 		if (children)
 		{
-			for (auto& child : *children)
-				View_update_tree(child.get(), event);
+			size_t size = children->size();
+			for (size_t i = 0; i < size; ++i)
+				View_update_tree((*children)[i].get(), event);
 		}
 
 		update_view_shapes(view);
@@ -1079,6 +1104,11 @@ namespace Reflex
 
 		if (self->check_and_remove_flag(View::Data::FIT_TO_CONTENT))
 			fit_view_to_content(view);
+
+		self->remove_flag(View::Data::UPDATING);
+
+		if (self->check_and_remove_flag(View::Data::HAS_CHILDREN_TO_REMOVE))
+			remove_children(view, children);
 	}
 
 	static bool
@@ -1790,13 +1820,19 @@ namespace Reflex
 		else if (found != belong)
 			invalid_state_error(__FILE__, __LINE__);
 
-		set_parent(child, NULL);
-
-		erase_child_from_children(this, child);
-
-		self->sort_children();
-
-		update_view_layout(this);
+		if (self->has_flag(Data::UPDATING))
+		{
+			// delay removing child to avoid breaking child list looped on View_update_tree()
+			self->add_flag(Data::HAS_CHILDREN_TO_REMOVE);
+			child->self->add_flag(Data::REMOVE_FROM_PARENT);
+		}
+		else
+		{
+			set_parent(child, NULL);
+			erase_child_from_children(this, child);
+			self->sort_children();
+			update_view_layout(this);
+		}
 	}
 
 	void
@@ -2295,9 +2331,9 @@ namespace Reflex
 		bool capture    = types != CAPTURE_NONE;
 
 		if (capture && !registered)
-			Window_register_capture(w, this, CAPTURE_ALL);
+			Window_register_capture(w, this, CAPTURE_ALL_EVENTS);
 		else if (!capture && registered)
-			Window_unregister_capture(w, this, CAPTURE_ALL);
+			Window_unregister_capture(w, this, CAPTURE_ALL_EVENTS);
 
 		CaptureEvent e(~old & types, old & ~types);
 		on_capture(&e);

data/src/win32/event.cpp

@@ -1,9 +1,11 @@
 #include "event.h"
 
 
+#include <xinput.h>
 #include <xot/time.h>
 #include "reflex/exception.h"
-#include "../pointer.h"
+#include "reflex/debug.h"
+#include "window.h"
 
 
 namespace Reflex
@@ -216,4 +218,86 @@ namespace Reflex
 	}
 
 
+	static void
+	call_gamepad_event (Window* win, int code, bool pressed)
+	{
+		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
+		KeyEvent e(action, NULL, code, get_modifiers(), 0);
+		Window_call_key_event(win, &e);
+	}
+
+	static void
+	handle_gamepad_button_event (
+		Window* win, const XINPUT_STATE& state, const XINPUT_STATE& prev_state,
+		WORD mask, int code)
+	{
+		WORD pressed =      state.Gamepad.wButtons & mask;
+		WORD prev    = prev_state.Gamepad.wButtons & mask;
+		if (pressed == prev) return;
+
+		call_gamepad_event(win, code, pressed);
+	}
+
+	static void
+	handle_gamepad_trigger_event (Window* win, BYTE value, BYTE prev_value, int code)
+	{
+		WORD pressed =      value > XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
+		WORD prev    = prev_value > XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
+		if (pressed == prev) return;
+
+		call_gamepad_event(win, code, pressed);
+	}
+
+	static void
+	handle_gamepad_events (const XINPUT_STATE& state, const XINPUT_STATE& prev_state)
+	{
+		Window* win = Window_get_active();
+		if (!win) return;
+
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_LEFT,  KEY_GAMEPAD_LEFT);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_RIGHT, KEY_GAMEPAD_RIGHT);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_UP,    KEY_GAMEPAD_UP);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_DPAD_DOWN,  KEY_GAMEPAD_DOWN);
+
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_A, KEY_GAMEPAD_A);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_B, KEY_GAMEPAD_B);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_X, KEY_GAMEPAD_X);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_Y, KEY_GAMEPAD_Y);
+
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_LEFT_SHOULDER,  KEY_GAMEPAD_SHOULDER_LEFT);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_RIGHT_SHOULDER, KEY_GAMEPAD_SHOULDER_RIGHT);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_LEFT_THUMB,     KEY_GAMEPAD_THUMB_LEFT);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_RIGHT_THUMB,    KEY_GAMEPAD_THUMB_RIGHT);
+
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_START, KEY_GAMEPAD_START);
+		handle_gamepad_button_event(win, state, prev_state, XINPUT_GAMEPAD_BACK,  KEY_GAMEPAD_SELECT);
+
+		handle_gamepad_trigger_event(win, state.Gamepad.bLeftTrigger,  prev_state.Gamepad.bLeftTrigger,  KEY_GAMEPAD_TRIGGER_LEFT);
+		handle_gamepad_trigger_event(win, state.Gamepad.bRightTrigger, prev_state.Gamepad.bRightTrigger, KEY_GAMEPAD_TRIGGER_RIGHT);
+	}
+
+	void
+	poll_gamepads ()
+	{
+		static XINPUT_STATE prev_state;
+		static bool prev_detected = false;
+
+		XINPUT_STATE state = {0};
+		bool detected      = XInputGetState(0, &state) == ERROR_SUCCESS;
+
+		if (detected != prev_detected)
+		{
+			prev_detected = detected;
+			if (detected) prev_state = {0};
+		}
+
+		if (!detected) return;
+
+		if (state.dwPacketNumber != prev_state.dwPacketNumber)
+			handle_gamepad_events(state, prev_state);
+
+		prev_state = state;
+	}
+
+
 }// Reflex

data/src/win32/event.h

@@ -44,6 +44,9 @@ namespace Reflex
 	};// NativeWheelEvent
 
 
+	void poll_gamepads ();
+
+
 }// Reflex
 
 

data/src/win32/window.cpp

@@ -154,13 +154,9 @@ namespace Reflex
 	{
 		WindowData* self = get_data(win);
 
-		double now = Xot::time();
-		Reflex::UpdateEvent e(now, now - self->prev_time_update);
-		self->prev_time_update = now;
+		poll_gamepads();
 
-		win->on_update(&e);
-		if (!e.is_blocked())
-			Reflex::View_update_tree(win->root(), e);
+		Window_call_update_event(win);
 
 		if (self->redraw)
 		{
@@ -347,8 +343,13 @@ namespace Reflex
 		{
 			case WM_ACTIVATE:
 			{
-				if ((wp & 0xFFFF) == WA_INACTIVE)
+				if (LOWORD(wp) == WA_INACTIVE)
+				{
+					Window_call_deactivate_event(win);
 					self->pressing_keys.clear();
+				}
+				else
+					Window_call_activate_event(win);
 				break;
 			}
 

data/src/window.cpp

@@ -52,6 +52,17 @@ namespace Reflex
 		return windows;
 	}
 
+	Window*
+	Window_get_active ()
+	{
+		for (auto& w : Window_all())
+		{
+			if (Xot::has_flag(w->self->flags, Window::Data::ACTIVE))
+				return w;
+		}
+		return NULL;
+	}
+
 
 	Window::Data::Data ()
 	:	flags(Window_default_flags())
@@ -129,7 +140,7 @@ namespace Reflex
 			return;
 
 		targets.insert(
-			target == CAPTURE_ALL ? targets.begin() : targets.end(),
+			target == CAPTURE_ALL_EVENTS ? targets.begin() : targets.end(),
 			target);
 	}
 
@@ -163,21 +174,40 @@ namespace Reflex
 	}
 
 	void
-	Window_call_activate_event (Reflex::Window* window)
+	Window_call_activate_event (Window* window)
 	{
 		if (!window) return;
 
-		Reflex::Event e;
+		Xot::add_flag(&window->self->flags, Window::Data::ACTIVE);
+
+		Event e;
 		window->on_activate(&e);
 	}
 
 	void
-	Window_call_deactivate_event (Reflex::Window* window)
+	Window_call_deactivate_event (Window* window)
 	{
 		if (!window) return;
 
-		Reflex::Event e;
+		Event e;
 		window->on_deactivate(&e);
+
+		Xot::remove_flag(&window->self->flags, Window::Data::ACTIVE);
+	}
+
+	void
+	Window_call_update_event (Window* window)
+	{
+		Window::Data* self = window->self.get();
+
+		double now = Xot::time();
+		UpdateEvent e(now, now - self->prev_time_update);
+		self->prev_time_update = now;
+
+		window->on_update(&e);
+		if (e.is_blocked()) return;
+
+		View_update_tree(window->root(), e);
 	}
 
 	void
@@ -203,19 +233,19 @@ namespace Reflex
 
 		window->on_draw(event);
 		if (!event->is_blocked())
-			Reflex::View_draw_tree(window->root(), event, 0, frame.move_to(0));
+			View_draw_tree(window->root(), event, 0, frame.move_to(0));
 
 		painter->pop_state();
 		painter->end();
 	}
 
 	static bool
-	is_capturing_all (
+	is_capturing (
 		const View* view, const CaptureTargetIDList& targets, View::Capture type)
 	{
 		return
 			!targets.empty() &&
-			targets[0] == CAPTURE_ALL &&
+			targets[0] == CAPTURE_ALL_EVENTS &&
 			(view->capture() & type) == type;
 	}
 
@@ -227,20 +257,11 @@ namespace Reflex
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		window->on_key(event);
-
-		switch (event->action())
-		{
-			case KeyEvent::DOWN: window->on_key_down(event); break;
-			case KeyEvent::UP:   window->on_key_up(event);   break;
-			default: break;
-		}
-
 		for (auto& [view, targets] : window->self->captures)
 		{
 			if (
 				!view->window() ||
-				!is_capturing_all(view.get(), targets, View::CAPTURE_KEY))
+				!is_capturing(view.get(), targets, View::CAPTURE_KEY))
 			{
 				continue;
 			}
@@ -248,9 +269,24 @@ namespace Reflex
 			KeyEvent e = event->dup();
 			KeyEvent_set_captured(&e, true);
 			View_call_key_event(const_cast<View*>(view.get()), &e);
+
+			if (e.is_blocked()) event->block();
+		}
+
+		if (!event->is_blocked())
+			window->on_key(event);
+
+		if (!event->is_blocked())
+		{
+			switch (event->action())
+			{
+				case KeyEvent::DOWN: window->on_key_down(event); break;
+				case KeyEvent::UP:   window->on_key_up(event);   break;
+				default: break;
+			}
 		}
 
-		if (window->self->focus)
+		if (!event->is_blocked() && window->self->focus)
 			View_call_key_event(window->self->focus.get(), event);
 
 		cleanup_captures(window);
@@ -367,7 +403,7 @@ namespace Reflex
 		result->clear();
 		for (const auto& [view, targets] : window->self->captures)
 		{
-			if (is_capturing_all(view.get(), targets, View::CAPTURE_POINTER))
+			if (is_capturing(view.get(), targets, View::CAPTURE_POINTER))
 				result->emplace_back(view);
 		}
 	}
@@ -416,7 +452,7 @@ namespace Reflex
 
 	static void
 	capture_targeted_pointers_and_call_events (
-		ExtractedPointerIDSet* extracteds,
+		ExtractedPointerIDSet* extracteds, bool* blocked,
 		Window* window, const PointerMap& pointers)
 	{
 		for (auto& [view, targets] : window->self->captures)
@@ -430,6 +466,8 @@ namespace Reflex
 
 			PointerEvent_update_for_capturing_view(&event, view);
 			View_call_pointer_event(const_cast<View*>(view.get()), &event);
+
+			if (event.is_blocked()) *blocked = true;
 		}
 	}
 
@@ -451,7 +489,7 @@ namespace Reflex
 
 	static void
 	capture_hovering_pointers_and_call_events (
-		ExtractedPointerIDSet* extracteds,
+		ExtractedPointerIDSet* extracteds, bool* blocked,
 		const ViewList& views_capturing_all, const PointerMap& pointers)
 	{
 		assert(extracteds);
@@ -470,6 +508,8 @@ namespace Reflex
 			PointerEvent e = event.dup();
 			PointerEvent_update_for_capturing_view(&e, view);
 			View_call_pointer_event(const_cast<View*>(view.get()), &e);
+
+			if (e.is_blocked()) *blocked = true;
 		}
 	}
 
@@ -512,11 +552,17 @@ namespace Reflex
 		});
 
 		ExtractedPointerIDSet extracteds;
-		capture_targeted_pointers_and_call_events(&extracteds, window, pointers);
+		bool blocked = false;
+
+		capture_targeted_pointers_and_call_events(
+			&extracteds, &blocked, window, pointers);
 		erase_extracted_pointers(&pointers, extracteds);
 
-		capture_hovering_pointers_and_call_events(&extracteds, views_capturing_all, pointers);
+		capture_hovering_pointers_and_call_events(
+			&extracteds, &blocked, views_capturing_all, pointers);
 		erase_extracted_pointers(event, extracteds);
+
+		if (blocked) event->block();
 	}
 
 	void
@@ -529,20 +575,24 @@ namespace Reflex
 
 		setup_pointer_event(window, event);
 
-		window->on_pointer(event);
+		call_captured_pointer_events(window, event);
+
+		if (!event->is_blocked() && !event->empty())
+			window->on_pointer(event);
 
-		switch ((*event)[0].action())
+		if (!event->is_blocked() && !event->empty())
 		{
-			case Pointer::DOWN:   window->on_pointer_down(event);   break;
-			case Pointer::UP:     window->on_pointer_up(event);     break;
-			case Pointer::MOVE:   window->on_pointer_move(event);   break;
-			case Pointer::CANCEL: window->on_pointer_cancel(event); break;
-			default: break;
+			switch ((*event)[0].action())
+			{
+				case Pointer::DOWN:   window->on_pointer_down(event);   break;
+				case Pointer::UP:     window->on_pointer_up(event);     break;
+				case Pointer::MOVE:   window->on_pointer_move(event);   break;
+				case Pointer::CANCEL: window->on_pointer_cancel(event); break;
+				default: break;
+			}
 		}
 
-		call_captured_pointer_events(window, event);
-
-		if (!event->empty())
+		if (!event->is_blocked() && !event->empty())
 		{
 			PointerEvent_update_for_child_view(event, window->root());
 			View_call_pointer_event(window->root(), event);