reflexion 0.5.3 → 0.7.0

data/src/ios/screen.mm

@@ -37,6 +37,15 @@ namespace Reflex
 	{
 	}
 
+	String
+	Screen::name () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return "";
+	}
+
 	Bounds
 	Screen::frame () const
 	{
@@ -47,6 +56,15 @@ namespace Reflex
 		return Bounds(b.origin.x, b.origin.y, b.size.width, b.size.height);
 	}
 
+	float
+	Screen::pixel_density () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return self->screen.nativeScale;
+	}
+
 	Screen::operator bool () const
 	{
 		return self->screen;
@@ -58,5 +76,13 @@ namespace Reflex
 		return !operator bool();
 	}
 
+	Screen::List
+	Screen::all ()
+	{
+		Screen s;
+		Screen_initialize(&s, UIScreen.mainScreen);
+		return {s};
+	}
+
 
 }// Reflex

data/src/ios/view_controller.mm

@@ -151,6 +151,7 @@ ReflexViewController_get_show_fun ()
 		int update_count;
 		int touching_count;
 		int repeating_key_count;
+		bool pen;
 	}
 
 	- (id) init
@@ -163,6 +164,7 @@ ReflexViewController_get_show_fun ()
 		update_count        = 0;
 		touching_count      = 0;
 		repeating_key_count = 0;
+		pen                 = false;
 
 		return self;
 	}
@@ -426,11 +428,8 @@ ReflexViewController_get_show_fun ()
 
 		Window_call_update_event(win);
 
-		if (win->self->redraw)
-		{
+		if (Xot::check_and_remove_flag(&win->self->flags, Reflex::Window::Data::REDRAW))
 			[self.reflexView setNeedsDisplay];
-			win->self->redraw = false;
-		}
 	}
 
 	- (void) glkView: (GLKView*) view drawInRect: (CGRect) rect
@@ -461,32 +460,7 @@ ReflexViewController_get_show_fun ()
 
 	- (void) viewDidResize
 	{
-		Reflex::Window* win = self.window;
-		if (!win) return;
-
-		Rays::Bounds b           = win->frame();
-		Rays::Point dpos         = b.position() - win->self->prev_position;
-		Rays::Point dsize        = b.size()     - win->self->prev_size;
-		win->self->prev_position = b.position();
-		win->self->prev_size     = b.size();
-
-		if (dpos == 0 && dsize == 0) return;
-
-		Reflex::FrameEvent e(b, dpos.x, dpos.y, 0, dsize.x, dsize.y, 0);
-		if (dpos  != 0) win->on_move(&e);
-		if (dsize != 0)
-		{
-			Rays::Bounds b = win->frame();
-			b.move_to(0, 0);
-
-			if (win->painter())
-				win->painter()->canvas(b, win->painter()->pixel_density());
-
-			if (win->root())
-				View_set_frame(win->root(), b);
-
-			win->on_resize(&e);
-		}
+		Window_call_frame_event(self.window);
 	}
 
 #if 0
@@ -529,10 +503,12 @@ ReflexViewController_get_show_fun ()
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(touches, event, self.reflexView);
+		Reflex::NativePointerEvent e(self.reflexView, self.hoverRecognizer, touches, event);
+
+		int count = (int) e.size();
 		Window_call_pointer_event(win, &e);
 
-		touching_count += e.size();
+		touching_count += count;
 	}
 
 	- (void) touchesEnded: (NSSet*) touches withEvent: (UIEvent*) event
@@ -540,12 +516,19 @@ ReflexViewController_get_show_fun ()
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(touches, event, self.reflexView);
+		Reflex::NativePointerEvent e(self.reflexView, self.hoverRecognizer, touches, event);
+
+		int count = (int) e.size();
 		Window_call_pointer_event(win, &e);
 
-		touching_count -= e.size();
+		touching_count -= count;
 		if (touching_count == 0)
-			win->self->prev_pointers.clear();
+		{
+			win->self->prev_pointers.remove_if([](const Reflex::Pointer& p)
+			{
+				return !Reflex::Pointer_is_floatable(p);
+			});
+		}
 		else if (touching_count < 0)
 			Reflex::invalid_state_error(__FILE__, __LINE__);
 	}
@@ -560,7 +543,7 @@ ReflexViewController_get_show_fun ()
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		Reflex::NativePointerEvent e(touches, event, self.reflexView);
+		Reflex::NativePointerEvent e(self.reflexView, self.hoverRecognizer, touches, event);
 		Window_call_pointer_event(win, &e);
 	}
 
@@ -570,16 +553,38 @@ ReflexViewController_get_show_fun ()
 		Reflex::Window* win = self.window;
 		if (!win) return;
 
-		if (touching_count > 0) return;
+		if (recognizer.state == UIGestureRecognizerStateBegan)
+			pen = false;
 
-		if (
-			recognizer.state != UIGestureRecognizerStateBegan &&
-			recognizer.state != UIGestureRecognizerStateChanged)
+		Reflex::Pointer::Action action;
+		switch (recognizer.state)
 		{
-			return;
+			case UIGestureRecognizerStateBegan:
+			case UIGestureRecognizerStateChanged:
+				// suppress hover moves while a touch is active
+				if (touching_count > 0) return;
+				action = recognizer.state == UIGestureRecognizerStateBegan
+					?	Reflex::Pointer::ENTER
+					:	Reflex::Pointer::MOVE;
+				if (@available(iOS 16.1, *))
+				{
+					// zOffset drops to 0 on the Ended state, so latch the pen-ness
+					// here and reuse it until the leave.
+					if (recognizer.zOffset > 0) pen = true;
+				}
+				break;
+
+			case UIGestureRecognizerStateEnded:
+			case UIGestureRecognizerStateCancelled:
+			case UIGestureRecognizerStateFailed:
+				action = Reflex::Pointer::LEAVE;
+				break;
+
+			default:
+				return;
 		}
 
-		Reflex::NativePointerEvent e(recognizer, self.reflexView);
+		Reflex::NativePointerEvent e(self.reflexView, recognizer, action, pen);
 		if (e.size() > 0)
 			Window_call_pointer_event(win, &e);
 	}

data/src/ios/window.mm

@@ -142,6 +142,12 @@ namespace Reflex
 		return Bounds(b.origin.x, b.origin.y, b.size.width, b.size.height);
 	}
 
+	void
+	Window_set_menu (Window* window, Menu* menu)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
 	static UIScreen*
 	get_screen (const Window& window)
 	{
@@ -218,8 +224,8 @@ namespace Reflex
 		}
 	}
 
-	void
-	Window_set_orientation_mask (UIViewController* vc, UIInterfaceOrientationMask mask)
+	static void
+	set_orientation_mask (UIViewController* vc, UIInterfaceOrientationMask mask)
 	{
 		if (mask == g_orientation_mask) return;
 
@@ -227,12 +233,6 @@ namespace Reflex
 		update_orientation_mask(vc, mask);
 	}
 
-	UIInterfaceOrientationMask
-	Window_get_orientation_mask ()
-	{
-		return g_orientation_mask;
-	}
-
 	static UIInterfaceOrientationMask
 	flags_to_orientation_mask (uint flags)
 	{
@@ -260,7 +260,31 @@ namespace Reflex
 		if (Xot::has_flag(flags, Window::FLAG_MINIMIZABLE))
 			argument_error(__FILE__, __LINE__, "FLAG_MINIMIZABLE is not supported");
 
-		Window_set_orientation_mask(
+		if (Xot::has_flag(flags, Window::FLAG_TITLEBAR_BUTTONS))
+			argument_error(__FILE__, __LINE__, "FLAG_TITLEBAR_BUTTONS is not supported");
+
+		if (Xot::has_flag(flags, Window::FLAG_TITLEBAR_BACKGROUND))
+			argument_error(__FILE__, __LINE__, "FLAG_TITLEBAR_BACKGROUND is not supported");
+
+		if (Xot::has_flag(flags, Window::FLAG_UNLISTED))
+			argument_error(__FILE__, __LINE__, "FLAG_UNLISTED is not supported");
+
+		if (Xot::has_flag(flags, Window::FLAG_SHADOW))
+			argument_error(__FILE__, __LINE__, "FLAG_SHADOW is not supported");
+
+		if (Xot::has_flag(flags, Window::FLAG_TRANSPARENT))
+			argument_error(__FILE__, __LINE__, "FLAG_TRANSPARENT is not supported");
+
+		if (Xot::has_flag(flags, Window::FLAG_ALWAYS_ON_TOP))
+			argument_error(__FILE__, __LINE__, "FLAG_ALWAYS_ON_TOP is not supported");
+
+		if (Xot::has_flag(flags, Window::FLAG_ALWAYS_ON_BOTTOM))
+			argument_error(__FILE__, __LINE__, "FLAG_ALWAYS_ON_BOTTOM is not supported");
+
+		if (Xot::has_flag(flags, Window::FLAG_POINTER_THROUGH))
+			argument_error(__FILE__, __LINE__, "FLAG_POINTER_THROUGH is not supported");
+
+		set_orientation_mask(
 			get_vc(window),
 			flags_to_orientation_mask(flags & (Window::FLAG_PORTRAIT | Window::FLAG_LANDSCAPE)));
 	}
@@ -271,5 +295,16 @@ namespace Reflex
 		return UIScreen.mainScreen.nativeScale;
 	}
 
+	void
+	Window_set_pointer_through (Window* window, bool through)
+	{
+	}
+
+	bool
+	Window_is_pointer_over_and_uncovered (Point* position, const Window& window)
+	{
+		return false;
+	}
+
 
 }// Reflex

data/src/menu.cpp

@@ -0,0 +1,387 @@
+#include "menu.h"
+
+
+#include <algorithm>
+#include <rays/point.h>
+#include "reflex/exception.h"
+#include "application.h"
+#include "view.h"
+#include "window.h"
+
+
+namespace Reflex
+{
+
+
+	void
+	Menu_cancel_active_pointers_for_popup (View* view)
+	{
+		Window* window = view ? view->window() : Window_get_active();
+		if (!window) return;
+
+		// popup runs a modal event loop that swallows every event until the
+		// menu is dismissed, so pointers being pressed would never see their
+		// up; canceling them first keeps every pointer stream closed.
+		Window_cancel_active_pointers(window);
+	}
+
+	void
+	Menu_call_click_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_click(event);
+		});
+	}
+
+	void
+	Menu_call_show_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_show(event);
+		});
+	}
+
+	void
+	Menu_call_hide_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_hide(event);
+		});
+	}
+
+	void
+	Menu_call_open_submenu_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_open_submenu(event);
+		});
+	}
+
+	void
+	Menu_call_close_submenu_event (Menu* menu, Event* event)
+	{
+		Application_guard([&]()
+		{
+			menu->on_close_submenu(event);
+		});
+	}
+
+
+	Menu::Data::Data ()
+	{
+	}
+
+	Menu::Data::~Data ()
+	{
+	}
+
+
+	Menu::Menu (const char* label)
+	:	self(Menu_create_data())
+	{
+		if (label) set_label(label);
+	}
+
+	Menu::~Menu ()
+	{
+	}
+
+	void
+	Menu::popup (coord x, coord y)
+	{
+		Menu_popup(this, NULL, x, y);
+	}
+
+	void
+	Menu::popup (const Point& position)
+	{
+		Menu_popup(this, NULL, position.x, position.y);
+	}
+
+	void
+	Menu::popup (View* view, coord x, coord y)
+	{
+		Menu_popup(this, view, x, y);
+	}
+
+	void
+	Menu::popup (View* view, const Point& position)
+	{
+		Menu_popup(this, view, position.x, position.y);
+	}
+
+	void
+	Menu::add_child (Menu* child, int index)
+	{
+		if (!child)
+			argument_error(__FILE__, __LINE__);
+
+		if (child->parent() == this)
+			return;
+
+		if (child->parent())
+			argument_error(__FILE__, __LINE__);
+
+		ChildList* children = self->children();
+		if (index < 0 || (int) children->size() < index)
+			index = (int) children->size();
+
+		children->insert(children->begin() + (size_t) index, child);
+
+		child->self->parent.reset(this);
+
+		Menu_child_added(this, child, index);
+	}
+
+	void
+	Menu::remove_child (Menu* child)
+	{
+		if (!child || child->parent() != this)
+			return;
+
+		auto* children = self->pchildren.get();
+		if (!children) return;
+
+		auto it = std::find(children->begin(), children->end(), child);
+		if (it == children->end()) return;
+
+		children->erase(it);
+		if (children->empty())
+			self->pchildren.reset();
+
+		child->self->parent.reset();
+
+		Menu_child_removed(this, child);
+	}
+
+	void
+	Menu::clear_children ()
+	{
+		while (self->pchildren && !self->pchildren->empty())
+			remove_child(self->pchildren->back().get());
+	}
+
+	static void
+	find_all_children (
+		Menu::ChildList* result, const Menu* menu, const Selector& selector,
+		bool recursive)
+	{
+		auto* children = menu->self->pchildren.get();
+		if (!children) return;
+
+		for (auto& child : *children)
+		{
+			if (!child)
+				invalid_state_error(__FILE__, __LINE__);
+
+			if (child->selector().contains(selector))
+				result->push_back(child);
+
+			if (recursive)
+				find_all_children(result, child.get(), selector, true);
+		}
+	}
+
+	Menu::ChildList
+	Menu::find_children (const Selector& selector, bool recursive) const
+	{
+		ChildList result;
+		find_all_children(&result, this, selector, recursive);
+		return result;
+	}
+
+	static bool
+	is_separator_label (const char* s)
+	{
+		if (!s || !*s) return false;
+		for (const char* p = s; *p; ++p)
+			if (*p != '-') return false;
+		return true;
+	}
+
+	void
+	Menu::set_label (const char* label)
+	{
+		if (!label) label = "";
+		if (label == self->label)
+			return;
+
+		self->label     = label;
+		self->separator = is_separator_label(label);
+
+		Menu_update(this);
+	}
+
+	const char*
+	Menu::label () const
+	{
+		return self->label.c_str();
+	}
+
+	void
+	Menu::enable (bool state)
+	{
+		if (state == self->enabled)
+			return;
+
+		self->enabled = state;
+		Menu_update(this);
+	}
+
+	bool
+	Menu::is_enabled () const
+	{
+		return self->enabled;
+	}
+
+	void
+	Menu::check (bool state)
+	{
+		if (state == self->checked)
+			return;
+
+		self->checked = state;
+		Menu_update(this);
+	}
+
+	bool
+	Menu::is_checked () const
+	{
+		return self->checked;
+	}
+
+	void
+	Menu::set_shortcut (KeyCode key, uint modifiers)
+	{
+		Menu_validate_shortcut_modifiers(modifiers);
+
+		if (key == self->key && modifiers == self->modifiers)
+			return;
+
+		self->key       = key;
+		self->modifiers = modifiers;
+		Menu_update(this);
+	}
+
+	KeyCode
+	Menu::shortcut_key () const
+	{
+		return self->key;
+	}
+
+	uint
+	Menu::shortcut_modifiers () const
+	{
+		return self->modifiers;
+	}
+
+	void
+	Menu::set_image (const Image& image)
+	{
+		self->image = image;
+		Menu_update(this);
+	}
+
+	const Image&
+	Menu::image () const
+	{
+		return self->image;
+	}
+
+	bool
+	Menu::is_separator () const
+	{
+		return self->separator;
+	}
+
+	Menu*
+	Menu::parent ()
+	{
+		return self->parent;
+	}
+
+	const Menu*
+	Menu::parent () const
+	{
+		return const_cast<Menu*>(this)->parent();
+	}
+
+	size_t
+	Menu::size () const
+	{
+		return self->pchildren ? self->pchildren->size() : 0;
+	}
+
+	bool
+	Menu::empty () const
+	{
+		return self->pchildren ? self->pchildren->empty() : true;
+	}
+
+	static Menu::ChildList empty_children;
+
+	Menu::iterator
+	Menu::begin ()
+	{
+		if (!self->pchildren) return empty_children.begin();
+		return self->pchildren->begin();
+	}
+
+	Menu::const_iterator
+	Menu::begin () const
+	{
+		if (!self->pchildren) return empty_children.begin();
+		return self->pchildren->begin();
+	}
+
+	Menu::iterator
+	Menu::end ()
+	{
+		if (!self->pchildren) return empty_children.end();
+		return self->pchildren->end();
+	}
+
+	Menu::const_iterator
+	Menu::end () const
+	{
+		if (!self->pchildren) return empty_children.end();
+		return self->pchildren->end();
+	}
+
+	void
+	Menu::on_show (Event* e)
+	{
+	}
+
+	void
+	Menu::on_hide (Event* e)
+	{
+	}
+
+	void
+	Menu::on_open_submenu (Event* e)
+	{
+	}
+
+	void
+	Menu::on_close_submenu (Event* e)
+	{
+	}
+
+	void
+	Menu::on_click (Event* e)
+	{
+	}
+
+	SelectorPtr*
+	Menu::get_selector_ptr ()
+	{
+		return &self->pselector;
+	}
+
+
+}// Reflex