reflexion 0.6.0 → 0.7.0

data/src/pointer.h

@@ -16,8 +16,12 @@ namespace Reflex
 
 	void Pointer_set_id (Pointer* it, Pointer::ID id);
 
+	void Pointer_set_types (Pointer* it, uint types);
+
 	void Pointer_set_action (Pointer* it, Pointer::Action action);
 
+	void Pointer_set_time (Pointer* it, double time);
+
 	void Pointer_set_floatable (Pointer* it, bool floatable);
 
 	bool Pointer_is_floatable (const Pointer& it);

data/src/rays.h

@@ -0,0 +1,46 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_RAYS_H__
+#define __REFLEX_SRC_RAYS_H__
+
+
+#include <rays/color.h>
+#include <rays/bitmap.h>
+#include <rays/painter.h>
+
+#if defined(OSX) && defined(__OBJC__)
+	@class NSImage;
+#elif defined(WIN32)
+	#include <xot/windows.h>
+#endif
+
+
+namespace Rays
+{
+
+
+	bool Painter_get_pixel (Color* color, Painter* painter, coord x, coord y);
+
+
+#if defined(OSX) && defined(__OBJC__)
+
+	NSImage* Bitmap_get_nsimage (const Bitmap& bitmap);
+
+#endif
+
+
+#ifdef WIN32
+
+	void Rays_set_pre_init_fun (void (*)());
+
+	HBITMAP Bitmap_get_hbitmap (const Bitmap& bitmap);
+
+	const PIXELFORMATDESCRIPTOR* OpenGL_get_pixel_format_descriptor ();
+
+#endif
+
+
+}// Rays
+
+
+#endif//EOH

data/src/sdl/application.cpp

@@ -5,6 +5,11 @@
 #ifdef WASM
 	#include <emscripten.h>
 #endif
+#ifdef LINUX
+	#include <limits.h>
+	#include <string.h>
+	#include <unistd.h>
+#endif
 #include <xot/time.h>
 #include "reflex/exception.h"
 #include "reflex/debug.h"
@@ -41,11 +46,43 @@ namespace Reflex
 		return new ApplicationData();
 	}
 
+	String
+	Application_get_default_name ()
+	{
+#ifdef LINUX
+		char path[PATH_MAX];
+		ssize_t len = readlink("/proc/self/exe", path, sizeof(path) - 1);
+		if (len > 0)
+		{
+			path[len]   = '\0';
+			char* slash = strrchr(path, '/');
+			return slash ? slash + 1 : path;
+		}
+#endif
+		return "";
+	}
+
+	void
+	Application_stop (Application* app)
+	{
+		get_data(app)->quit = true;
+	}
+
 	void
 	Application_set_menu (Application* app, Menu* menu)
 	{
 	}
 
+	void
+	Application_set_background (Application* app, bool state)
+	{
+	}
+
+	void
+	Application_set_background_menu (Application* app, Menu* menu)
+	{
+	}
+
 
 	static bool
 	dispatch_window_event (const SDL_Event& event)
@@ -65,11 +102,18 @@ namespace Reflex
 		SDL_Event event;
 		while (SDL_PollEvent(&event))
 		{
-			if (dispatch_window_event(event))
-				continue;
+			bool dispatched = dispatch_window_event(event);
+
+#if SDL_VERSION_ATLEAST(2, 0, 22)
+			// the text of an extended composition event is handed over to
+			// whoever takes the event, so it is freed here rather than in the
+			// window that may or may not have been found for it
+			if (event.type == SDL_TEXTEDITING_EXT)
+				SDL_free(event.editExt.text);
+#endif
 
-			if (event.type == SDL_QUIT)
-				app->quit();
+			if (!dispatched && event.type == SDL_QUIT)
+				Application_call_quit(app);
 		}
 	}
 
@@ -115,7 +159,10 @@ namespace Reflex
 		dispatch_events(app);
 
 		if (get_data(app)->quit)
+		{
 			emscripten_cancel_main_loop();
+			Application_cleanup(app);
+		}
 		else
 			update_all_windows(app);
 	}
@@ -124,13 +171,26 @@ namespace Reflex
 	void
 	Application::start ()
 	{
+		get_data(this)->quit = false;
+		self->started        = false;
+		self->quitting       = false;
+		self->running        = true;
+
 		Event e;
-		Application_call_start(this, &e);
+		Application_call_start_event(this, &e);
 
 #ifdef WASM
 		emscripten_set_main_loop_arg(emscripten_main_loop, this, 0, true);
 #else
-		main_loop(this);
+		// guarded here too, since rays can throw while drawing
+		Application_guard([&]()
+		{
+			main_loop(this);
+		});
+		self->running = false;
+
+		Application_cleanup(this);
+		Application_throw_exception(this);
 #endif
 	}
 
@@ -138,10 +198,10 @@ namespace Reflex
 	Application::quit ()
 	{
 		Event e;
-		Application_call_quit(this, &e);
+		Application_call_quit_event(this, &e);
 		if (e.is_blocked()) return;
 
-		get_data(this)->quit = true;
+		Application_stop(this);
 	}
 
 	void

data/src/sdl/color_picker.cpp

@@ -0,0 +1,18 @@
+#include "../color_picker.h"
+
+
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	void
+	ColorPicker_show (ColorPicker* picker, const Color* initial)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+
+}// Reflex

data/src/sdl/event.cpp

@@ -70,6 +70,21 @@ namespace Reflex
 	}
 
 
+	NativeTextEvent::NativeTextEvent (
+		const char* text, int selection_offset, int selection_size)
+	:	TextEvent(
+			PREEDIT, text, selection_offset,
+			// a size below zero is how sdl says nothing is selected
+			selection_size < 0 ? 0 : selection_size)
+	{
+	}
+
+	NativeTextEvent::NativeTextEvent (const SDL_TextInputEvent& e)
+	:	TextEvent(COMMIT, e.text)
+	{
+	}
+
+
 	static uint
 	get_pointer_type (Uint8 button)
 	{
@@ -175,13 +190,19 @@ namespace Reflex
 	}
 
 
+	static coord
+	to_wheel_pixels (const SDL_MouseWheelEvent& e, float delta)
+	{
+		float scale = WHEEL_PIXELS_PER_NOTCH;
+		if (e.direction == SDL_MOUSEWHEEL_FLIPPED) scale = -scale;
+		return delta * scale;
+	}
+
 	NativeWheelEvent::NativeWheelEvent (
 		const SDL_MouseWheelEvent& e, SDL_Window* window)
 	:	WheelEvent(
 			0, 0, 0,
-			e.direction == SDL_MOUSEWHEEL_FLIPPED ? -e.preciseX : e.preciseX,
-			e.direction == SDL_MOUSEWHEEL_FLIPPED ? -e.preciseY : e.preciseY,
-			0,
+			to_wheel_pixels(e, e.preciseX), to_wheel_pixels(e, -e.preciseY), 0,
 			get_modifiers(SDL_GetModState()))
 	{
 		int mx, my;

data/src/sdl/event.h

@@ -22,6 +22,18 @@ namespace Reflex
 	};// NativeKeyEvent
 
 
+	class NativeTextEvent : public TextEvent
+	{
+
+		public:
+
+			NativeTextEvent (const char* text, int selection_offset, int selection_size);
+
+			NativeTextEvent (const SDL_TextInputEvent& event);
+
+	};// NativeTextEvent
+
+
 	class NativePointerEvent : public PointerEvent
 	{
 

data/src/sdl/file_dialog.cpp

@@ -0,0 +1,20 @@
+#include "../file_dialog.h"
+
+
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	void
+	FileDialog_show (
+		FileDialog* dialog, FileDialog::Data::Mode mode,
+		const char* dir, const char* name)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+
+}// Reflex

data/src/sdl/gamepad.cpp

@@ -9,17 +9,13 @@ namespace Reflex
 
 
 	void
-	Gamepad_init (Application* app)
+	Gamepad_init_native (Application* app)
 	{
+		not_implemented_error(__FILE__, __LINE__);
 	}
 
 	void
-	Gamepad_fin (Application* app)
-	{
-	}
-
-	void
-	Gamepad_poll ()
+	Gamepad_fin_native (Application* app)
 	{
 	}
 

data/src/sdl/menu.cpp

@@ -11,6 +11,11 @@ namespace Reflex
 		return new Menu::Data();
 	}
 
+	void
+	Menu_validate_shortcut_modifiers (uint modifiers)
+	{
+	}
+
 	void
 	Menu_update (Menu* menu)
 	{

data/src/sdl/reflex.cpp

@@ -3,6 +3,7 @@
 
 #include <SDL.h>
 #include "reflex/exception.h"
+#include "../vk.h"
 
 
 namespace Reflex
@@ -23,6 +24,13 @@ namespace Reflex
 		if (global::initialized)
 			reflex_error(__FILE__, __LINE__, "already initialized.");
 
+#if SDL_VERSION_ATLEAST(2, 0, 22)
+		// without this, sdl cuts a composition longer than 32 bytes into
+		// pieces and reuses the offset field to say where each piece goes,
+		// which leaves no way to tell a composition from its selection
+		SDL_SetHint(SDL_HINT_IME_SUPPORT_EXTENDED_TEXT, "1");
+#endif
+
 		global::initialized = true;
 	}
 
@@ -35,5 +43,17 @@ namespace Reflex
 		global::initialized = false;
 	}
 
+	void
+	alert (const char* message, const char* title)
+	{
+		if (!message)
+			argument_error(__FILE__, __LINE__);
+
+		int ret = SDL_ShowSimpleMessageBox(
+			SDL_MESSAGEBOX_INFORMATION, title ? title : "", message, NULL);
+		if (ret < 0)
+			reflex_error(__FILE__, __LINE__, SDL_GetError());
+	}
+
 
 }// Reflex

data/src/sdl/screen.cpp

@@ -35,6 +35,16 @@ namespace Reflex
 	{
 	}
 
+	String
+	Screen::name () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		const char* name = SDL_GetDisplayName(self->display_index);
+		return name ? name : "";
+	}
+
 	Bounds
 	Screen::frame () const
 	{
@@ -48,6 +58,15 @@ namespace Reflex
 		return Bounds(rect.x, rect.y, rect.w, rect.h);
 	}
 
+	float
+	Screen::pixel_density () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return 1;
+	}
+
 	Screen::operator bool () const
 	{
 		return self->display_index >= 0;
@@ -59,5 +78,22 @@ namespace Reflex
 		return !operator bool();
 	}
 
+	Screen::List
+	Screen::all ()
+	{
+		int count = SDL_GetNumVideoDisplays();
+		if (count < 0)
+			reflex_error(__FILE__, __LINE__, SDL_GetError());
+
+		List list;
+		for (int i = 0; i < count; ++i)
+		{
+			Screen s;
+			Screen_initialize(&s, i);
+			list.emplace_back(s);
+		}
+		return list;
+	}
+
 
 }// Reflex

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
@@ -311,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);
@@ -344,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)
 	{
@@ -364,7 +448,7 @@ namespace Reflex
 				switch (event.window.event)
 				{
 					case SDL_WINDOWEVENT_CLOSE:
-						win->close();
+						Window_call_close(win);
 						break;
 
 					case SDL_WINDOWEVENT_EXPOSED:
@@ -379,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:
@@ -387,6 +471,7 @@ namespace Reflex
 						break;
 
 					case SDL_WINDOWEVENT_FOCUS_LOST:
+						Window_cancel_active_pointers(win);
 						Window_call_deactivate_event(win);
 						break;
 
@@ -421,10 +506,34 @@ 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(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;
 			}
 
@@ -432,6 +541,13 @@ namespace Reflex
 			{
 				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;
 			}
 
@@ -494,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;
-		}
 	}