reflexion 0.5.3 → 0.7.0

data/src/window.h

@@ -9,9 +9,11 @@
 #include <map>
 #include <xot/time.h>
 #include <rays/point.h>
+#include <rays/image.h>
 #include <rays/painter.h>
 #include "reflex/window.h"
 #include "reflex/view.h"
+#include "reflex/menu.h"
 #include "application.h"
 #include "pointer.h"
 
@@ -33,34 +35,54 @@ namespace Reflex
 
 		typedef std::map<View::Ref, CaptureTargetIDList> CaptureMap;
 
+		typedef std::vector<Xot::WeakRef<View>>          WeakViewList;
+
+		typedef std::map<Pointer::ID, WeakViewList>      HoveredViewMap;
+
 		enum Flag
 		{
 
-			ACTIVE = Xot::bit(1, FLAG_LAST),
+			ACTIVE                  = Xot::bit(1, FLAG_LAST),
+
+			REDRAW                  = Xot::bit(2, FLAG_LAST),
+
+			POINTER_THROUGH_PAUSED  = Xot::bit(3, FLAG_LAST),
+
+			POINTER_THROUGH_ENTERED = Xot::bit(4, FLAG_LAST),
 
 		};// Flag
 
 		int hide_count = 1;
 
-		bool redraw    = true;
+		uint flags;
 
 		Painter painter;
 
+		Image draw_cache;
+
+		Painter draw_cache_painter;
+
 		View::Ref root, focus;
 
+		Menu::Ref menu;
+
 		Point prev_position, prev_size;
 
 		double prev_time_update, prev_time_draw, prev_fps = 0;
 
-		CaptureMap captures;
+		int next_pointer_id         = 1;
+
+		uint pointer_cancels        = 0;
 
-		int next_pointer_id = 1;
+		float pointer_through_alpha = 1;
 
 		Pointer prev_mouse_pointer;
 
 		PointerList prev_pointers;
 
-		uint flags;
+		CaptureMap captures;
+
+		HoveredViewMap hovered_views;
 
 		Data ();
 
@@ -81,7 +103,9 @@ namespace Reflex
 	};// Window::Data
 
 
-	Window::Data* Window_create_data ();
+	typedef View* (*Window_CreateRootViewFun) ();
+
+	void Window_set_create_root_view_fun (Window_CreateRootViewFun fun);
 
 	void Window_register   (Window* win);
 
@@ -91,6 +115,49 @@ namespace Reflex
 
 	Window* Window_get_active ();
 
+	void Window_skip_update_time_of_all (double seconds);
+
+
+	void Window_set_focus (Window* window, View* view);
+
+	void Window_register_capture (
+		Window* window, View* view, Pointer::ID target);
+
+	void Window_unregister_capture (
+		Window* window, View* view, Pointer::ID target);
+
+	void Window_cancel_active_pointers (Window* window);
+
+	uint Window_get_pointer_cancels (const Window& window);
+
+	void Window_call_close (Window* window);
+
+	void Window_call_activate_event   (Window* window);
+
+	void Window_call_deactivate_event (Window* window);
+
+	void Window_call_update_event     (Window* window);
+
+	void Window_call_draw_event       (Window* window, DrawEvent* event);
+
+	void Window_call_frame_event      (Window* window);
+
+	void Window_call_key_event        (
+		Window* window, KeyEvent* event, bool capture = true);
+
+	void Window_call_text_event       (
+		Window* window, TextEvent* event, bool synthesize_key_events = false);
+
+	void Window_call_pointer_event    (Window* window, PointerEvent* event);
+
+	void Window_call_wheel_event      (Window* window, WheelEvent* event);
+
+	void Window_call_file_event       (Window* window, FileEvent* event);
+
+	void Window_call_midi_event       (Window* window, MIDIEvent* event);
+
+
+	Window::Data* Window_create_data ();
 
 	uint Window_default_flags ();
 
@@ -111,40 +178,17 @@ namespace Reflex
 
 	Bounds Window_get_frame (const Window& window);
 
+	void Window_set_menu (Window* window, Menu* menu);
+
 	Screen Window_get_screen (const Window& window);
 
 	void Window_set_flags (Window* window, uint flags);
 
 	float Window_get_pixel_density (const Window& window);
 
-	void Window_set_focus (Window* window, View* view);
-
-	void Window_register_capture (
-		Window* window, View* view, Pointer::ID target);
-
-	void Window_unregister_capture (
-		Window* window, View* view, Pointer::ID target);
-
-	void Window_call_activate_event   (Window* window);
-
-	void Window_call_deactivate_event (Window* window);
-
-	void Window_call_update_event     (Window* window);
-
-	void Window_call_draw_event       (Window* window, DrawEvent*    event);
+	void Window_set_pointer_through (Window* window, bool through);
 
-	void Window_call_key_event        (Window* window, KeyEvent*     event);
-
-	void Window_call_pointer_event    (Window* window, PointerEvent* event);
-
-	void Window_call_wheel_event      (Window* window, WheelEvent*   event);
-
-	void Window_call_midi_event       (Window* window, MIDIEvent*    event);
-
-
-	typedef View* (*Window_CreateRootViewFun) ();
-
-	void Window_set_create_root_view_fun (Window_CreateRootViewFun fun);
+	bool Window_is_pointer_over_and_uncovered (Point* position, const Window& window);
 
 
 }// Reflex

data/src/world.cpp

@@ -2,6 +2,7 @@
 
 
 #include <assert.h>
+#include <algorithm>
 #include <memory>
 #include <vector>
 #include <map>
@@ -9,8 +10,9 @@
 #include <box2d/box2d.h>
 #include "reflex/event.h"
 #include "reflex/exception.h"
-#include "shape.h"
 #include "view.h"
+#include "shape.h"
+#include "constraint.h"
 #include "body.h"
 #include "fixture.h"
 
@@ -218,7 +220,7 @@ namespace Reflex
 	static Shape*
 	get_shape (b2ShapeId b2shape)
 	{
-		if (B2_IS_NULL(b2shape)) return NULL;
+		if (!b2Shape_IsValid(b2shape)) return NULL;
 		return (Shape*) b2Shape_GetUserData(b2shape);
 	}
 
@@ -257,6 +259,11 @@ namespace Reflex
 		if (!v1 || !v2 || !View_is_active(*v1) || !View_is_active(*v2))
 			return;
 
+		// the first handler is free to remove either view, so hold everything
+		// the second one needs until both have run
+		Shape::Ref sref1 = s1, sref2 = s2;
+		View::Ref  vref1 = v1, vref2 = v2;
+
 		ContactEvent e1(action, s2), e2(action, s1);
 		Shape_call_contact_event(s1, &e1);
 		Shape_call_contact_event(s2, &e2);
@@ -274,12 +281,24 @@ namespace Reflex
 
 		bool stepping     = false;
 
-		std::unique_ptr<DebugDraw> debug_draw;
-
 		// tracked to deliver contact-end events for shapes that Box2D has already
 		// forgotten on destruction
 		ShapePairMap touching_pairs;
 
+		std::vector<Xot::WeakRef<Constraint>> constraints;
+
+		// fixture-less static body for constraints that anchor to the world
+		// (e.g. chasing a target point) without affecting any collision
+		std::unique_ptr<Body>      pground;
+
+		std::unique_ptr<DebugDraw> pdebug_draw;
+
+		Body* ground (World* world)
+		{
+			if (!pground) pground.reset(new Body(world));
+			return pground.get();
+		}
+
 		void begin_contact (b2ShapeId b2shape1, b2ShapeId b2shape2, bool is_sensor_event)
 		{
 			Shape* s1 = get_shape(b2shape1);
@@ -308,6 +327,9 @@ namespace Reflex
 			ShapePair pair = it->second;
 			touching_pairs.erase(it);
 
+			if (!b2Shape_IsValid(id1) || !b2Shape_IsValid(id2))
+				return;
+
 			call_contact_events(pair.first, pair.second, ContactEvent::END);
 		}
 
@@ -338,6 +360,25 @@ namespace Reflex
 			}
 		}
 
+		void update_constraints ()
+		{
+			for (auto& constraint : constraints)
+			{
+				if (constraint)
+					Constraint_on_world_update(constraint);
+			}
+		}
+
+		void clear_constraints ()
+		{
+			for (auto& constraint : constraints)
+			{
+				if (constraint)
+					Constraint_on_world_destroyed(constraint);
+			}
+			constraints.clear();
+		}
+
 	};// World::Data
 
 
@@ -361,6 +402,8 @@ namespace Reflex
 	World::~World ()
 	{
 		self->touching_pairs.clear();
+		self->clear_constraints();
+		self->pground.reset();
 
 		b2DestroyWorld(self->b2world);
 		self->b2world = b2_nullWorldId;
@@ -377,6 +420,8 @@ namespace Reflex
 
 		for (int i = 0; i < count; ++i)
 		{
+			self->update_constraints();
+
 			self->stepping = true;
 			b2World_Step(self->b2world, dt, 4);
 			self->stepping = false;
@@ -426,19 +471,19 @@ namespace Reflex
 		if (state == debug()) return;
 
 		if (state)
-			self->debug_draw.reset(new DebugDraw(self->ppm));
+			self->pdebug_draw.reset(new DebugDraw(self->ppm));
 		else
-			self->debug_draw.reset();
+			self->pdebug_draw.reset();
 	}
 
 	bool
 	World::debug () const
 	{
-		return !!self->debug_draw;
+		return !!self->pdebug_draw;
 	}
 
 	void
-	World::on_update (float dt)
+	World::on_update ()
 	{
 		update(DELTA_TIME);
 	}
@@ -446,11 +491,11 @@ namespace Reflex
 	void
 	World::on_draw (Painter* painter)
 	{
-		if (!self->debug_draw) return;
+		if (!self->pdebug_draw) return;
 
-		self->debug_draw->begin(painter);
-		b2World_Draw(self->b2world, self->debug_draw->b2ptr());
-		self->debug_draw->end();
+		self->pdebug_draw->begin(painter);
+		b2World_Draw(self->b2world, self->pdebug_draw->b2ptr());
+		self->pdebug_draw->end();
 	}
 
 
@@ -460,10 +505,24 @@ namespace Reflex
 		return world ? world->self->b2world : b2_nullWorldId;
 	}
 
-	bool
-	World_is_stepping (const World* world)
+	void
+	World_add_constraint (World* world, Constraint* constraint)
 	{
-		return world ? world->self->stepping : false;
+		if (!world || !constraint)
+			argument_error(__FILE__, __LINE__);
+
+		world->self->constraints.emplace_back(constraint);
+	}
+
+	void
+	World_remove_constraint (World* world, Constraint* constraint)
+	{
+		if (!world || !constraint)
+			argument_error(__FILE__, __LINE__);
+
+		std::erase_if(
+			world->self->constraints,
+			[=](auto& c) {return !c || c == constraint;});
 	}
 
 	void
@@ -490,6 +549,18 @@ namespace Reflex
 			call_contact_events(pair.first, pair.second, ContactEvent::END);
 	}
 
+	bool
+	World_is_stepping (const World* world)
+	{
+		return world ? world->self->stepping : false;
+	}
+
+	const Body*
+	World_get_ground (World* world)
+	{
+		return world ? world->self->ground(world) : NULL;
+	}
+
 	World*
 	World_get_temporary ()
 	{

data/src/world.h

@@ -19,6 +19,7 @@ namespace Reflex
 
 	class View;
 	class Body;
+	class Constraint;
 
 
 	class World : public Xot::NonCopyable
@@ -51,7 +52,7 @@ namespace Reflex
 
 			bool     debug () const;
 
-			virtual void on_update (float dt);
+			virtual void on_update ();
 
 			virtual void on_draw (Painter* painter);
 
@@ -104,10 +105,16 @@ namespace Reflex
 
 	b2WorldId World_get_id (const World* world);
 
-	bool World_is_stepping (const World* world);
+	void World_add_constraint    (World* world, Constraint* constraint);
+
+	void World_remove_constraint (World* world, Constraint* constraint);
 
 	void World_end_contacts_for (World* world, b2ShapeId b2shape);
 
+	bool World_is_stepping (const World* world);
+
+	const Body* World_get_ground (World* world);
+
 	World* World_get_temporary ();
 
 

data/test/helper.rb

@@ -8,3 +8,27 @@ require 'reflex'
 require 'test/unit'
 
 include Xot::Test
+
+
+module HasWindow
+
+  def window(*args, **kwargs, &block)
+    win = Reflex::Window.new(*args, **kwargs, &block)
+    (@windows_for_test__ ||= []).push win
+    win
+  end
+
+  def teardown()
+    super
+    @windows_for_test__&.each(&:close)
+    @windows_for_test__ = nil
+  end
+
+end# HasWindow
+
+
+def assert_equal_point(expected, actual, delta = 0.01, *args)
+  assert_in_delta expected.x, actual.x, delta, *args
+  assert_in_delta expected.y, actual.y, delta, *args
+  assert_in_delta expected.z, actual.z, delta, *args
+end

data/test/test_application.rb

@@ -5,12 +5,112 @@ class TestApplication < Test::Unit::TestCase
 
   @@app = Reflex::Application.new
 
+  def start(&block)
+    @@app.on(:start) {|e| block.call}
+    @@app.start
+  ensure
+    @@app.singleton_class.remove_method :on_start
+  end
+
+  def omit_on_macos_ci()
+    omit 'the macos runner aborts in CoreAnimation on an event loop' if ci? && osx?
+  end
+
+  def test_start_returns_on_quit()
+    omit_on_macos_ci
+
+    started = false
+    start {started = true; @@app.quit}
+    assert_true started
+  end
+
+  def test_start_returns_when_last_window_closed()
+    omit_on_macos_ci
+
+    quit = false
+    @@app.on(:quit) {|e| quit = true}
+    start {w = Reflex.window; w.on(:update) {|e| w.close}}
+    assert_true quit
+  end
+
+  def test_start_raises_on_start_block()
+    omit_on_macos_ci
+
+    e = assert_raise(RuntimeError) {start {raise 'boom'}}
+    assert_equal 'boom', e.message
+    assert_match(/#{__FILE__}/, e.backtrace.first)
+  end
+
+  def test_start_raises_from_window_event()
+    omit_on_macos_ci
+
+    w = nil
+    e = assert_raise(RuntimeError) do
+      start {w = Reflex::Window.new; w.on(:update) {|e| raise 'in update'}}
+    end
+    assert_equal 'in update', e.message
+  ensure
+    w&.close
+  end
+
+  def test_start_passes_exit()
+    omit_on_macos_ci
+
+    e = assert_raise(SystemExit) {start {exit 3}}
+    assert_equal 3, e.status
+  end
+
+  def test_start_passes_throw()
+    omit_on_macos_ci
+
+    assert_throw(:tag) {start {throw :tag}}
+  end
+
+  def test_start_twice()
+    omit_on_macos_ci
+
+    count = 0
+    2.times {start {count += 1; @@app.quit}}
+    assert_equal 2, count
+  end
+
   def test_name()
-    assert_equal '', @@app.name
+    assert_not_empty @@app.name
+
     @@app.name = 'AppName'
     assert_equal 'AppName', @@app.name
   end
 
+  def test_menu()
+    m          = Reflex::Menu.new
+    assert_nil      @@app.menu
+    @@app.menu = m
+    assert_equal m, @@app.menu
+    @@app.menu = nil
+    assert_nil      @@app.menu
+
+    assert_raise(TypeError) {@@app.menu = 1}
+  end
+
+  def test_background()
+    assert_false @@app.background?
+    @@app.background = true
+    assert_true  @@app.background?
+    @@app.background = false
+    assert_false @@app.background?
+  end
+
+  def test_background_menu()
+    m                     = Reflex::Menu.new
+    assert_nil      @@app.background_menu
+    @@app.background_menu = m
+    assert_equal m, @@app.background_menu
+    @@app.background_menu = nil
+    assert_nil      @@app.background_menu
+
+    assert_raise(TypeError) {@@app.background_menu = 1}
+  end
+
   def test_inspect()
     assert_match %r|#<Reflex::Application:0x\w{16}>|, @@app.inspect
   end

data/test/test_chase_constraint.rb

@@ -0,0 +1,122 @@
+require_relative 'helper'
+
+
+class TestChaseConstraint < Test::Unit::TestCase
+
+  include HasWindow
+
+  def view(x = 0, y = 0, w = 50, h = 50, **options, &block)
+    Reflex::View.new(
+      frame: [x, y, w, h],
+      shape: Reflex::RectShape.new(density: 1),
+      **options, &block)
+  end
+
+  def point(...)
+    Reflex::Point.new(...)
+  end
+
+  def setup_views(win = window)
+    v1 = view 100, 100, dynamic: true
+    v2 = view 200, 100, static:  true
+    win&.add v1
+    win&.add v2
+    [v1, v2, win, win&.root]
+  end
+
+  def test_initial_state()
+    v1, v2, = setup_views
+
+    assert_equal v1,     v1.chase(v2)              .pins[0].view
+    assert_nil           v1.chase(v2)              .pins[1].view
+    assert_equal v2,     v1.chase(v2)              .target.view
+    assert_nil           v1.chase(v2)              .force
+    assert_equal 1,      v1.chase(v2, force: 1)    .force
+    assert_equal 5,      v1.chase(v2)              .spring
+    assert_equal 2,      v1.chase(v2, spring: 2)   .spring
+    assert_in_delta 0.7, v1.chase(v2)              .damping
+    assert_in_delta 0.1, v1.chase(v2, damping: 0.1).damping
+    assert_false         v1.chase(v2)              .collide?
+    assert_true          v1.chase(v2)              .active?
+    assert_false         v1.chase(v2)              .removed?
+  end
+
+  def test_chase_view()
+    v1, v2, _, root = setup_views
+
+    c = v1.chase v2
+    assert_equal v2, c.target.view
+
+    root.update_world
+    assert_operator v1.linear_velocity.x, :>, 0
+  end
+
+  def test_chase_world_point()
+    v1, _, _, root = setup_views
+
+    c = v1.chase            [300, 300]
+    assert_nil                          c.target.view
+    assert_equal_point point(300, 300), c.target.pos
+
+    root.update_world
+    assert_operator v1.linear_velocity.x, :>, 0
+    assert_operator v1.linear_velocity.y, :>, 0
+  end
+
+  def test_grabbing_corner_creates_torque()
+    v1, _, _, root = setup_views
+
+    c = v1.pin(0, 0).chase [300, 100], spring: 8
+    assert_equal_point point(0, 0), c.pins[0].pos
+
+    3.times {root.update_world}
+    assert_operator v1.angular_velocity.abs, :>, 1
+  end
+
+  def test_chase_to_itself_error()
+    v1, v2, = setup_views
+
+    assert_raise(ArgumentError) {v1.chase v1}
+    assert_raise(ArgumentError) {v1.chase(v2).target = v1}
+  end
+
+  def test_target()
+    v1, v2, = setup_views
+
+    c = v1.chase [300, 300]
+    assert_nil                          c.target.view
+    assert_equal_point point(300, 300), c.target.pos
+
+    c.target =   v2
+    assert_equal v2,                    c.target.view
+    assert_nil                          c.target.pos
+
+    c.target = v2.pin(0, 0)
+    assert_equal v2,                    c.target.view
+    assert_equal_point point(0, 0),     c.target.pos
+
+    c.target = [v2, 5, 5]
+    assert_equal v2,                    c.target.view
+    assert_equal_point point(5, 5),     c.target.pos
+
+    c.target = nil
+    assert_nil                          c.target.view
+    assert_nil                          c.target.pos
+  end
+
+  def test_force()
+    v1, = setup_views
+
+    c = v1.chase [300, 100], force: 500
+    assert_equal 500, c.force
+
+    c.force = nil
+    assert_nil        c.force
+
+    c.force = 100
+    assert_equal 100, c.force
+
+    assert_raise(ArgumentError) {c.force = -1}
+  end
+
+end# TestChaseConstraint