reflexion 0.5.3 → 0.7.0

data/samples/window_style.rb

@@ -0,0 +1,156 @@
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflex'
+
+
+# How a window can look and behave: which parts of the titlebar it shows,
+# whether it draws a shadow, whether the alpha you draw with lets the desktop
+# show through, and whether it can be closed, minimized or resized.
+#
+# Hiding a part of the titlebar takes its function away too. With the
+# background hidden the window can no longer be dragged or zoomed by the strip
+# the titlebar sat on, since the window itself draws there and gets the mouse
+# events.
+#
+# The two windows differ only in what they draw behind the circles, so a
+# see-through background and a translucent one can be compared. On macOS the
+# shadow of a see-through window is made from what was drawn, so it follows
+# the circles. Windows draws it around the frame instead.
+#
+# A window that lets the pointer through gets no pointer events at all. It
+# cannot be clicked, dragged or activated, and the click reaches whatever sits
+# behind it. Drag the two windows over each other to see where a click lands,
+# the counter says which one got it. Only one window at a time can do it, so
+# there is always another one left to click on.
+#
+# Pressing 9 again keeps the pointer going through only where the window
+# drew little: with pointer_through_alpha at 0.5, the see-through window takes
+# a click on its circles and passes one on its empty background, and the
+# translucent window passes clicks through its 0.3 background too. The
+# titlebar always takes the pointer. A third press turns it off.
+#
+# An unlisted window is still there on screen, but it leaves the window
+# overviews: Mission Control on macOS, the taskbar and alt-tab on Windows.
+# Toggle it and open the overview to watch the window drop out of the list
+# while staying right where it is.
+#
+# Not every platform can do all of this, and the ones that cannot say so.
+#
+#   1: titlebar buttons, 2: titlebar background, 3: both
+#   4: shadow, 5: transparent
+#   6: closable, 7: minimizable, 8: resizable
+#   9: pointer through, 0: unlisted
+#   ESC: quit
+class StyledWindow < Reflex::Window
+
+  PARTS = [:buttons, :background]
+
+  @@message = nil
+
+  def initialize (title, x, alpha)
+    super title: title, frame: [x, 100, 360, 360], transparent: true
+    @alpha  = alpha
+    @t      = 0.0
+    @clicks = 0
+    painter.font = Reflex::Font.new nil, 16
+  end
+
+  def on_draw (e)
+    @t += 0.03
+    p   = e.painter
+
+    # the alpha here is what lets the desktop show through
+    p.background 0, 0, 0, @alpha
+
+    8.times do |i|
+      a = @t + i * Math::PI / 4
+      x = 180 + Math.cos(a) * 100
+      y = 180 + Math.sin(a) * 100
+      p.fill((Math.sin(@t + i) + 1) / 2, 0.6, 1)
+      p.ellipse x - 20, y - 20, 40, 40
+    end
+
+    # something that stays put, to aim a click at
+    p.fill 1, 0.8, 0.2
+    p.ellipse 150, 150, 60, 60
+
+    p.fill 1
+    p.text "titlebar: #{titlebar.inspect}", 10, 10
+    p.text "shadow: #{shadow?}, transparent: #{transparent?}, " \
+           "unlisted: #{unlisted?}", 10, 30
+    p.text "closable: #{closable?}, minimizable: #{minimizable?}, " \
+           "resizable: #{resizable?}", 10, 50
+    p.text "pointer through: #{pointer_through_state}, clicks: #{@clicks}", 10, 70
+    p.text "#{e.fps.to_i} FPS", 10, 90
+    p.text '1: buttons, 2: background, 3: both', 10, 110
+    p.text '4: shadow, 5: transparent', 10, 130
+    p.text '6: closable, 7: minimizable, 8: resizable', 10, 150
+    p.text '9: pointer through, 0: unlisted, ESC: quit', 10, 170
+
+    if @@message
+      p.fill 1, 0.4, 0.4
+      p.text @@message, 10, 190
+    end
+  end
+
+  def on_update (e) = redraw
+
+  def on_pointer_down (e)
+    @clicks += 1
+  end
+
+  def on_key_down (e)
+    case e.chars
+    when '1' then change {|w| w.toggle_titlebar :buttons}
+    when '2' then change {|w| w.toggle_titlebar :background}
+    when '3' then change {|w| w.titlebar = w.titlebar.empty? ? PARTS : []}
+    when '4' then change {|w| w.shadow      = !w.shadow?}
+    when '5' then change {|w| w.transparent = !w.transparent?}
+    when '6' then change {|w| w.closable    = !w.closable?}
+    when '7' then change {|w| w.minimizable = !w.minimizable?}
+    when '8' then change {|w| w.resizable   = !w.resizable?}
+    when '9' then change {|w| w.cycle_pointer_through w.equal?(self)}
+    when '0' then change {|w| w.unlisted    = !w.unlisted?}
+    end
+    Reflex.quit if e.key == :escape
+  end
+
+  def toggle_titlebar (part)
+    parts         = titlebar
+    self.titlebar = parts.include?(part) ? parts - [part] : parts + [part]
+  end
+
+  # off -> everything through -> only the pixels at alpha 0.5 or less -> off
+  def cycle_pointer_through (mine)
+    if !mine || (pointer_through? && pointer_through_alpha < 1)
+      self.pointer_through = false
+    elsif !pointer_through?
+      self.pointer_through       = true
+      self.pointer_through_alpha = 1
+    else
+      self.pointer_through_alpha = 0.5
+    end
+  end
+
+  def pointer_through_state ()
+    return 'false'                                if !pointer_through?
+    return 'all'                                  if pointer_through_alpha >= 1
+    return "alpha <= #{pointer_through_alpha}"
+  end
+
+  def change (&block)
+    @@message = nil
+    Reflex::Application.instance.windows.each(&block)
+  rescue ArgumentError, NotImplementedError => e
+    @@message = e.message
+  end
+
+end# StyledWindow
+
+
+Reflex.start do
+  StyledWindow.new('see-through', 100, 0.0).show
+  StyledWindow.new('translucent', 500, 0.3).show
+end

data/src/application.cpp

@@ -4,8 +4,8 @@
 #include "reflex/exception.h"
 #include "reflex/debug.h"
 #include "window.h"
-#include "gamepad.h"
 #include "midi.h"
+#include "gamepad.h"
 
 
 namespace Reflex
@@ -20,49 +20,149 @@ namespace Reflex
 	}// global
 
 
+	bool
+	Application_should_quit (Application* app)
+	{
+		if (!app || !app->self->started)
+			return false;
+
+		if (app->background_menu())
+			return false;
+
+		if (app->background() && app->menu())
+			return false;
+
+		return Reflex::Window_all().empty();
+	}
+
 	void
-	Application_call_start (Application* app, Event* e)
+	Application_cleanup (Application* app)
 	{
-		app->on_start(e);
+		MIDI_fin(app);
+		Gamepad_fin(app);
+	}
+
+	void
+	Application_call_quit (Application* app)
+	{
+		Application_guard([&]()
+		{
+			app->quit();
+		});
+	}
 
-		Gamepad_init(app);
-		MIDI_init(app);
+	void
+	Application_call_start_event (Application* app, Event* e)
+	{
+		if (app->self->started) return;
+
+		Application_guard([&]()
+		{
+			app->on_start(e);
+			app->self->started = true;
+		});
 	}
 
 	static void
 	close_all_windows (Application* app)
 	{
-		for (auto it = app->window_begin(), end = app->window_end(); it != end; ++it)
-			(*it)->close(true);
+		for (auto& window : Application::WindowList(app->window_begin(), app->window_end()))
+			window->close(true);
 	}
 
 	void
-	Application_call_quit (Application* app, Event* e)
+	Application_call_quit_event (Application* app, Event* e)
 	{
 		if (app->self->quitting) return;
 
-		app->on_quit(e);
-		if (e->is_blocked()) return;
+		Application_guard([&]()
+		{
+			app->on_quit(e);
+			if (e->is_blocked()) return;
 
-		app->self->quitting = true;
+			app->self->quitting = true;
 
-		close_all_windows(app);
-		MIDI_fin(app);
-		Gamepad_fin(app);
+			close_all_windows(app);
+		});
 	}
 
 	void
-	Application_call_device_connect (Application* app, Device* device)
+	Application_call_device_connect_event (Application* app, Device* device)
+	{
+		Application_guard([&]()
+		{
+			DeviceEvent e(device);
+			app->on_device_connect(&e);
+		});
+	}
+
+	void
+	Application_call_device_disconnect_event (Application* app, Device* device)
+	{
+		Application_guard([&]()
+		{
+			DeviceEvent e(device);
+			app->on_device_disconnect(&e);
+		});
+	}
+
+	void
+	Application_call_motion_event (Application* app, MotionEvent* e)
+	{
+		Application_guard([&]()
+		{
+			app->on_motion(e);
+		});
+	}
+
+	void
+	Application_call_preference_event (Application* app, Event* e)
+	{
+		Application_guard([&]()
+		{
+			app->on_preference(e);
+		});
+	}
+
+	void
+	Application_call_about_event (Application* app, Event* e)
+	{
+		Application_guard([&]()
+		{
+			app->on_about(e);
+		});
+	}
+
+	bool
+	Application_has_exception ()
 	{
-		DeviceEvent e(device);
-		app->on_device_connect(&e);
+		Application* app = global::instance;
+		return app && app->self->exception;
+	}
+
+	bool
+	Application_keep_exception (std::exception_ptr exception)
+	{
+		Application* app = global::instance;
+		if (!app || !app->self->running)
+			return false;
+
+		// the first one is the cause, so keep it and drop the rest
+		if (!app->self->exception)
+			app->self->exception = exception;
+
+		Application_stop(app);
+		return true;
 	}
 
 	void
-	Application_call_device_disconnect (Application* app, Device* device)
+	Application_throw_exception (Application* app)
 	{
-		DeviceEvent e(device);
-		app->on_device_disconnect(&e);
+		std::exception_ptr exception = app->self->exception;
+		if (!exception) return;
+
+		app->self->exception = NULL;
+		std::rethrow_exception(exception);
 	}
 
 	Application*
@@ -72,6 +172,12 @@ namespace Reflex
 	}
 
 
+	Application::Data::Data ()
+	:	name(Application_get_default_name())
+	{
+	}
+
+
 	Application::Application ()
 	:	self(Application_create_data())
 	{
@@ -101,6 +207,60 @@ namespace Reflex
 		return self->name.c_str();
 	}
 
+	void
+	Application::set_menu (Menu* menu)
+	{
+		self->menu = menu;
+		Application_set_menu(this, menu);
+	}
+
+	Menu*
+	Application::menu ()
+	{
+		return self->menu.get();
+	}
+
+	const Menu*
+	Application::menu () const
+	{
+		return const_cast<Application*>(this)->menu();
+	}
+
+	void
+	Application::set_background (bool state)
+	{
+		if (state == self->background)
+			return;
+
+		self->background = state;
+		Application_set_background(this, state);
+	}
+
+	bool
+	Application::background () const
+	{
+		return self->background;
+	}
+
+	void
+	Application::set_background_menu (Menu* menu)
+	{
+		self->background_menu = menu;
+		Application_set_background_menu(this, menu);
+	}
+
+	Menu*
+	Application::background_menu ()
+	{
+		return self->background_menu.get();
+	}
+
+	const Menu*
+	Application::background_menu () const
+	{
+		return const_cast<Application*>(this)->background_menu();
+	}
+
 	Application::window_iterator
 	Application::window_begin ()
 	{

data/src/application.h

@@ -4,7 +4,11 @@
 #define __REFLEX_SRC_APPLICATION_H__
 
 
+#include <exception>
+#include <type_traits>
+#include <utility>
 #include "reflex/application.h"
+#include "reflex/menu.h"
 
 
 namespace Reflex
@@ -16,21 +20,107 @@ namespace Reflex
 
 		String name;
 
-		bool quitting = false;
+		Menu::Ref menu, background_menu;
+
+		bool background = false;
+
+		bool started    = false;
+
+		bool running    = false;
+
+		bool quitting   = false;
+
+		std::exception_ptr exception;
+
+		Data ();
 
 	};// Application::Data
 
 
+	bool Application_should_quit (Application* app);
+
+	void Application_cleanup (Application* app);
+
+	void Application_call_quit (Application* app);
+
+	void Application_call_start_event             (Application* app, Event* e);
+
+	void Application_call_quit_event              (Application* app, Event* e);
+
+	void Application_call_device_connect_event    (Application* app, Device* device);
+
+	void Application_call_device_disconnect_event (Application* app, Device* device);
+
+	void Application_call_motion_event            (Application* app, MotionEvent* e);
+
+	void Application_call_preference_event        (Application* app, Event* e);
+
+	void Application_call_about_event             (Application* app, Event* e);
+
+	bool Application_has_exception ();
+
+	bool Application_keep_exception (std::exception_ptr exception);
+
+	void Application_throw_exception (Application* app);
+
+
 	Application::Data* Application_create_data ();
 
+	String Application_get_default_name ();
+
+	void Application_stop (Application* app);
 
-	void Application_call_start (Application* app, Event* e);
+	void Application_set_menu (Application* app, Menu* menu);
 
-	void Application_call_quit  (Application* app, Event* e);
+	void Application_set_background (Application* app, bool state);
 
-	void Application_call_device_connect    (Application* app, Device* device);
+	void Application_set_background_menu (Application* app, Menu* menu);
 
-	void Application_call_device_disconnect (Application* app, Device* device);
+
+	template <typename FUN, typename RET>
+	inline RET
+	Application_guard (FUN&& fun, RET fallback)
+	{
+		// Runs 'fun' so that no C++ exception gets out of it while start()
+		// runs the event loop. The exception is kept, the loop is stopped,
+		// and start() throws it again after the loop returns. Once one is
+		// kept, later calls return 'fallback' without running 'fun'.
+		//
+		// Where to use it:
+		// 1. Platform code never calls anything that reaches on_* by itself,
+		//    not even close() or quit(). It goes through a Foo_call_* function
+		//    in src/, and those are the places to guard.
+		// 2. Guard the body of Foo_call_*. The argument checks stay outside,
+		//    a bug inside reflex should fail right there.
+		// 3. Two exceptions: the window procedures on windows, since an
+		//    exception can not cross the kernel callback boundary, and the
+		//    drawing calls of each platform loop, since rays can throw there.
+
+		if (Application_has_exception())
+			return fallback;
+
+		try
+		{
+			return fun();
+		}
+		catch (...)
+		{
+			if (!Application_keep_exception(std::current_exception()))
+				throw;
+		}
+		return fallback;
+	}
+
+	template <typename FUN>
+	inline auto
+	Application_guard (FUN&& fun) -> decltype(fun())
+	{
+		typedef decltype(fun()) RET;
+		if constexpr (std::is_void<RET>::value)
+			Application_guard([&]() {fun(); return 0;}, 0);
+		else
+			return Application_guard(std::forward<FUN>(fun), RET());
+	}
 
 
 }// Reflex

data/src/clipboard.cpp

@@ -0,0 +1,81 @@
+#include "reflex/clipboard.h"
+
+
+#include <map>
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	static const char* TEXT_TYPE = "text/plain";
+
+
+	struct Clipboard::Data
+	{
+
+		std::map<String, String> types;
+
+	};// Clipboard::Data
+
+
+	Clipboard::Clipboard (const char* text)
+	{
+		if (text) set_text(text);
+	}
+
+	Clipboard::~Clipboard ()
+	{
+	}
+
+	void
+	Clipboard::set_text (const char* text)
+	{
+		if (!text)
+			argument_error(__FILE__, __LINE__);
+
+		self->types[TEXT_TYPE] = text;
+	}
+
+	const char*
+	Clipboard::text () const
+	{
+		auto it = self->types.find(TEXT_TYPE);
+		if (it == self->types.end())
+			return NULL;
+
+		return it->second.c_str();
+	}
+
+	void
+	Clipboard::set_image (const Image& image)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	const Image*
+	Clipboard::image () const
+	{
+		return NULL;
+	}
+
+	void
+	Clipboard::clear ()
+	{
+		self->types.clear();
+	}
+
+	Clipboard::operator bool () const
+	{
+		return true;
+	}
+
+	bool
+	Clipboard::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex