reflexion 0.5.3 → 0.7.0

data/src/sdl/window.cpp

@@ -24,6 +24,10 @@ namespace Reflex
 
 		bool need_rebind   = false;
 
+		// whether the input method is composing, which is what tells the text
+		// it commits apart from the text a key produces on its own
+		bool composing     = false;
+
 		OpenGLContext context;
 
 		mutable String title_tmp;
@@ -87,13 +91,16 @@ namespace Reflex
 			if (win) win->release();
 
 			if (Window_all().empty())
-				Reflex::app()->quit();
+				Reflex::Application_call_quit(Reflex::app());
 		}
 
 		Uint32 to_sdl_flags (uint flags)
 		{
 			Uint32 sdl_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI;
 
+			if (!Xot::has_flag(flags, Window::FLAG_TITLEBAR_BACKGROUND))
+				sdl_flags |= SDL_WINDOW_BORDERLESS;
+
 			if (Xot::has_flag(flags, Window::FLAG_RESIZABLE))
 				sdl_flags |= SDL_WINDOW_RESIZABLE;
 
@@ -157,32 +164,60 @@ namespace Reflex
 		Window_call_draw_event(win, &e);
 	}
 
+	static bool
+	accepts_text_input (Window* win)
+	{
+		const View* focus = win->focus();
+		return focus && focus->accepts_text_input();
+	}
+
 	static void
-	frame_changed (Window* win)
+	update_text_input_rect (Window* win)
 	{
-		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();
+		const View* focus = win->focus();
+		if (!focus) return;
 
-		if (dpos == 0 && dsize == 0) return;
+		Bounds b = focus->text_input_bounds();
+		Point p1 = focus->to_window(b.position());
+		Point p2 = focus->to_window(b.position() + b.size());
 
-		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);
+		SDL_Rect rect = {(int) p1.x, (int) p1.y, (int) (p2.x - p1.x), (int) (p2.y - p1.y)};
+		SDL_SetTextInputRect(&rect);
+	}
 
-			if (win->painter())
-				win->painter()->canvas(b, win->painter()->pixel_density());
+	static void
+	preedit (Window* win, const char* text, int offset, int size)
+	{
+		WindowData* self = get_data(win);
 
-			if (win->root())
-				View_set_frame(win->root(), b);
+		// the input method reports an empty composition before anything is typed
+		bool empty = !text || *text == '\0';
+		if (empty && !self->composing)
+			return;
 
-			win->on_resize(&e);
-		}
+		self->composing = !empty;
+
+		if (!accepts_text_input(win))
+			return;
+
+		NativeTextEvent e(text ? text : "", offset, size);
+		Window_call_text_event(win, &e);
+
+		update_text_input_rect(win);
+	}
+
+	static void
+	commit (Window* win, const SDL_TextInputEvent& event)
+	{
+		WindowData* self = get_data(win);
+
+		bool composed = self->composing;
+
+		if (!accepts_text_input(win))
+			return;
+
+		NativeTextEvent e(event);
+		Window_call_text_event(win, &e, composed);
 	}
 
 
@@ -196,9 +231,12 @@ namespace Reflex
 	Window_default_flags ()
 	{
 		return
-			Window::FLAG_CLOSABLE  |
-			Window::FLAG_RESIZABLE |
-			Window::FLAG_MINIMIZABLE;
+			Window::FLAG_CLOSABLE            |
+			Window::FLAG_MINIMIZABLE         |
+			Window::FLAG_RESIZABLE           |
+			Window::FLAG_TITLEBAR_BUTTONS    |
+			Window::FLAG_TITLEBAR_BACKGROUND |
+			Window::FLAG_SHADOW;
 	}
 
 	void
@@ -283,6 +321,12 @@ namespace Reflex
 		return Bounds(x, y, w, h);
 	}
 
+	void
+	Window_set_menu (Window* window, Menu* menu)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
 	Screen
 	Window_get_screen (const Window& win)
 	{
@@ -305,13 +349,48 @@ namespace Reflex
 		if (!*win)
 			invalid_state_error(__FILE__, __LINE__);
 
+		bool buttons    = Xot::has_flag(flags, Window::FLAG_TITLEBAR_BUTTONS);
+		bool background = Xot::has_flag(flags, Window::FLAG_TITLEBAR_BACKGROUND);
+		if (buttons != background)
+		{
+			argument_error(
+				__FILE__, __LINE__,
+				"FLAG_TITLEBAR_BUTTONS and FLAG_TITLEBAR_BACKGROUND must match");
+		}
+
+		if (Xot::has_flag(flags, Window::FLAG_UNLISTED))
+			not_implemented_error(__FILE__, __LINE__, "FLAG_UNLISTED");
+
+		if (!Xot::has_flag(flags, Window::FLAG_SHADOW))
+			not_implemented_error(__FILE__, __LINE__, "missing FLAG_SHADOW");
+
+		if (Xot::has_flag(flags, Window::FLAG_TRANSPARENT))
+			not_implemented_error(__FILE__, __LINE__, "FLAG_TRANSPARENT");
+
+		if (Xot::has_flag(flags, Window::FLAG_ALWAYS_ON_BOTTOM))
+			not_implemented_error(__FILE__, __LINE__, "FLAG_ALWAYS_ON_BOTTOM");
+
+		if (Xot::has_flag(flags, Window::FLAG_POINTER_THROUGH))
+			not_implemented_error(__FILE__, __LINE__, "FLAG_POINTER_THROUGH");
+
 		WindowData* self = get_data(win);
 		Uint32 sdl_flags = self->to_sdl_flags(flags);
 
+#if SDL_VERSION_ATLEAST(2, 0, 16)
+		SDL_SetWindowAlwaysOnTop(
+			self->native,
+			Xot::has_flag(flags, Window::FLAG_ALWAYS_ON_TOP) ? SDL_TRUE : SDL_FALSE);
+#else
+		if (Xot::has_flag(flags, Window::FLAG_ALWAYS_ON_TOP))
+			not_implemented_error(__FILE__, __LINE__, "FLAG_ALWAYS_ON_TOP");
+#endif
+
 		SDL_SetWindowResizable(
 			self->native,
 			sdl_flags & SDL_WINDOW_RESIZABLE ? SDL_TRUE : SDL_FALSE);
 
+		SDL_SetWindowBordered(self->native, background ? SDL_TRUE : SDL_FALSE);
+
 		int result = SDL_SetWindowFullscreen(
 			self->native,
 			sdl_flags & SDL_WINDOW_FULLSCREEN_DESKTOP ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
@@ -338,6 +417,17 @@ namespace Reflex
 		return (float) draw_w / (float) win_w;
 	}
 
+	void
+	Window_set_pointer_through (Window* window, bool through)
+	{
+	}
+
+	bool
+	Window_is_pointer_over_and_uncovered (Point* position, const Window& window)
+	{
+		return false;
+	}
+
 	Window*
 	Window_from (SDL_Window* native)
 	{
@@ -358,7 +448,7 @@ namespace Reflex
 				switch (event.window.event)
 				{
 					case SDL_WINDOWEVENT_CLOSE:
-						win->close();
+						Window_call_close(win);
 						break;
 
 					case SDL_WINDOWEVENT_EXPOSED:
@@ -373,7 +463,7 @@ namespace Reflex
 					case SDL_WINDOWEVENT_RESTORED:
 					case SDL_WINDOWEVENT_MAXIMIZED:
 					case SDL_WINDOWEVENT_MINIMIZED:
-						frame_changed(win);
+						Window_call_frame_event(win);
 						break;
 
 					case SDL_WINDOWEVENT_FOCUS_GAINED:
@@ -381,8 +471,23 @@ namespace Reflex
 						break;
 
 					case SDL_WINDOWEVENT_FOCUS_LOST:
+						Window_cancel_active_pointers(win);
 						Window_call_deactivate_event(win);
 						break;
+
+					case SDL_WINDOWEVENT_ENTER:
+					{
+						NativePointerEvent e(self->native, Pointer::ENTER);
+						Window_call_pointer_event(win, &e);
+						break;
+					}
+
+					case SDL_WINDOWEVENT_LEAVE:
+					{
+						NativePointerEvent e(self->native, Pointer::LEAVE);
+						Window_call_pointer_event(win, &e);
+						break;
+					}
 				}
 				break;
 			}
@@ -401,25 +506,54 @@ namespace Reflex
 				break;
 			}
 
+			case SDL_TEXTEDITING:
+			{
+				preedit(win, event.edit.text, event.edit.start, event.edit.length);
+				break;
+			}
+
+#if SDL_VERSION_ATLEAST(2, 0, 22)
+			case SDL_TEXTEDITING_EXT:
+			{
+				preedit(win, event.editExt.text, event.editExt.start, event.editExt.length);
+				break;
+			}
+#endif
+
+			case SDL_TEXTINPUT:
+			{
+				commit(win, event.text);
+				break;
+			}
+
 			case SDL_MOUSEBUTTONDOWN:
 			{
-				NativePointerEvent e(
-					event.button, self->native, Pointer::DOWN);
+				NativePointerEvent e(self->native, event.button, Pointer::DOWN);
 				Window_call_pointer_event(win, &e);
+
+				#if SDL_VERSION_ATLEAST(2, 0, 4)
+					SDL_CaptureMouse(SDL_TRUE);
+				#endif
 				break;
 			}
 
 			case SDL_MOUSEBUTTONUP:
 			{
-				NativePointerEvent e(
-					event.button, self->native, Pointer::UP);
+				NativePointerEvent e(self->native, event.button, Pointer::UP);
 				Window_call_pointer_event(win, &e);
+
+				#if SDL_VERSION_ATLEAST(2, 0, 4)
+					static const uint32_t BUTTONS =
+						SDL_BUTTON_LMASK | SDL_BUTTON_RMASK | SDL_BUTTON_MMASK;
+					if ((SDL_GetMouseState(NULL, NULL) & BUTTONS) == 0)
+						SDL_CaptureMouse(SDL_FALSE);
+				#endif
 				break;
 			}
 
 			case SDL_MOUSEMOTION:
 			{
-				NativePointerEvent e(event.motion, self->native);
+				NativePointerEvent e(self->native, event.motion);
 				Window_call_pointer_event(win, &e);
 				break;
 			}
@@ -433,21 +567,21 @@ namespace Reflex
 
 			case SDL_FINGERDOWN:
 			{
-				NativePointerEvent e(event.tfinger, self->native, Pointer::DOWN);
+				NativePointerEvent e(self->native, event.tfinger, Pointer::DOWN);
 				Window_call_pointer_event(win, &e);
 				break;
 			}
 
 			case SDL_FINGERUP:
 			{
-				NativePointerEvent e(event.tfinger, self->native, Pointer::UP);
+				NativePointerEvent e(self->native, event.tfinger, Pointer::UP);
 				Window_call_pointer_event(win, &e);
 				break;
 			}
 
 			case SDL_FINGERMOTION:
 			{
-				NativePointerEvent e(event.tfinger, self->native, Pointer::MOVE);
+				NativePointerEvent e(self->native, event.tfinger, Pointer::MOVE);
 				Window_call_pointer_event(win, &e);
 				break;
 			}
@@ -476,11 +610,8 @@ namespace Reflex
 
 		Window_call_update_event(win);
 
-		if (self->redraw)
-		{
+		if (Xot::check_and_remove_flag(&self->flags, Window::Data::REDRAW))
 			redraw_window(self->native);
-			self->redraw = false;
-		}
 	}
 
 

data/src/shape.cpp

@@ -7,6 +7,7 @@
 #include <rays/polygon.h>
 #include "reflex/exception.h"
 #include "reflex/debug.h"
+#include "application.h"
 #include "selector.h"
 #include "view.h"
 #include "world.h"
@@ -449,18 +450,22 @@ namespace Reflex
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		shape->on_contact(event);
-
-		switch (event->action())
+		// called back from box2d, which can not let an exception through
+		Application_guard([&]()
 		{
-			case ContactEvent::BEGIN: shape->on_contact_begin(event); break;
-			case ContactEvent::END:   shape->on_contact_end(event);   break;
-			default: break;
-		}
+			shape->on_contact(event);
+
+			switch (event->action())
+			{
+				case ContactEvent::BEGIN: shape->on_contact_begin(event); break;
+				case ContactEvent::END:   shape->on_contact_end(event);   break;
+				default: break;
+			}
 
-		if (event->is_blocked()) return;
+			if (event->is_blocked()) return;
 
-		View_call_contact_event(shape->owner(), event);
+			View_call_contact_event(shape->owner(), event);
+		});
 	}
 
 
@@ -705,7 +710,7 @@ namespace Reflex
 			if (points.empty())
 				return Polygon();
 
-			return Rays::create_line(&points[0], points.size(), loop);
+			return Rays::create_line(points.data(), points.size(), loop);
 		}
 
 		Bounds get_fixed_frame () const override