reflexion 0.6.0 → 0.7.0

data/src/window.h

@@ -9,6 +9,7 @@
 #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"
@@ -41,16 +42,26 @@ namespace Reflex
 		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;
@@ -59,14 +70,16 @@ namespace Reflex
 
 		double prev_time_update, prev_time_draw, prev_fps = 0;
 
-		int next_pointer_id = 1;
+		int next_pointer_id         = 1;
+
+		uint pointer_cancels        = 0;
+
+		float pointer_through_alpha = 1;
 
 		Pointer prev_mouse_pointer;
 
 		PointerList prev_pointers;
 
-		uint flags;
-
 		CaptureMap captures;
 
 		HoveredViewMap hovered_views;
@@ -90,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);
 
@@ -100,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 ();
 
@@ -128,34 +186,9 @@ namespace Reflex
 
 	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_set_pointer_through (Window* window, bool through);
 
-	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_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

@@ -220,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);
 	}
 
@@ -259,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);
@@ -322,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);
 		}
 

data/test/helper.rb

@@ -10,6 +10,23 @@ 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

data/test/test_application.rb

@@ -5,8 +5,78 @@ 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
@@ -22,6 +92,25 @@ class TestApplication < Test::Unit::TestCase
     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

@@ -3,9 +3,7 @@ require_relative 'helper'
 
 class TestChaseConstraint < Test::Unit::TestCase
 
-  def window()
-    Reflex::Window.new
-  end
+  include HasWindow
 
   def view(x = 0, y = 0, w = 50, h = 50, **options, &block)
     Reflex::View.new(

data/test/test_color_event.rb

@@ -0,0 +1,36 @@
+require_relative 'helper'
+
+
+class TestColorEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::ColorEvent.new(*args)
+  end
+
+  def color(*args)
+    Reflex::Color.new(*args)
+  end
+
+  def test_initialize()
+    assert_equal color(1, 0, 0),      event(color(1, 0, 0)).color
+    assert_equal color(0, 1, 0, 0.5), event([0, 1, 0, 0.5]).color
+
+    assert_raise(ArgumentError) {event}
+    assert_raise(ArgumentError) {event(nil)}
+  end
+
+  def test_dup()
+    e1 = event color(1, 0, 0)
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+  def test_inspect()
+    assert_equal "#<Reflex::ColorEvent color:[1.0, 0.0, 0.0, 1.0]>", event(color(1, 0, 0)).inspect
+  end
+
+end# TestColorEvent

data/test/test_color_picker.rb

@@ -0,0 +1,62 @@
+require_relative 'helper'
+
+
+class TestColorPicker < Test::Unit::TestCase
+
+  include HasWindow
+
+  def picker(*args, &block)
+    Reflex::ColorPicker.new(*args, &block)
+  end
+
+  def event(color)
+    Reflex::ColorEvent.new color
+  end
+
+  def color(*args)
+    Reflex::Color.new(*args)
+  end
+
+  def test_initialize()
+    assert_nil   picker                     .owner
+    assert_false picker                     .alpha?
+    assert_true  picker(      alpha:  true) .alpha?
+    assert_true  picker      {alpha   true} .alpha?
+    assert_true  picker {self.alpha = true} .alpha?
+  end
+
+  def test_owner()
+    w = window
+    picker.tap do |p|
+      p.owner = w
+      assert_equal w, p.owner
+      p.owner = nil
+      assert_nil      p.owner
+    end
+
+    assert_raise(TypeError) {picker.owner = 1}
+  end
+
+  def test_alpha()
+    picker.tap do |p|
+      p.alpha = true
+      assert_true  p.alpha?
+      p.alpha = false
+      assert_false p.alpha?
+    end
+  end
+
+  def test_color_block_stays_until_close()
+    # the native side calls call_color_block and clear_color_block
+    p, got = picker, []
+    p.instance_variable_set :@color_block, -> e {got << e.color}
+    p.send :call_color_block, event(color(1, 0, 0))
+    p.send :call_color_block, event(color(0, 1, 0))
+    assert_equal [color(1, 0, 0), color(0, 1, 0)], got
+
+    p.send :clear_color_block
+    p.send :call_color_block, event(color(0, 0, 1))
+    assert_equal [color(1, 0, 0), color(0, 1, 0)], got
+  end
+
+end# TestColorPicker

data/test/test_constraint.rb

@@ -3,11 +3,9 @@ require_relative 'helper'
 
 class TestConstraint < Test::Unit::TestCase
 
-  R = Reflex
+  include HasWindow
 
-  def window()
-    R::Window.new
-  end
+  R = Reflex
 
   def view(x = 0, y = 0, w = 50, h = 50, **options, &block)
     R::View.new(

data/test/test_event.rb

@@ -46,7 +46,7 @@ class TestEvent < Test::Unit::TestCase
   end
 
   def test_time()
-    assert_in_delta Time.now.to_f, event.time, 0.001
+    assert_in_delta Time.now.to_f, event.time, 0.1
   end
 
 end# TestEvent

data/test/test_file_dialog.rb

@@ -0,0 +1,48 @@
+require_relative 'helper'
+
+
+class TestFileDialog < Test::Unit::TestCase
+
+  def dialog(*args, &block)
+    Reflex::FileDialog.new(*args, &block)
+  end
+
+  def test_initialize()
+    assert_nil            dialog                            .owner
+    assert_equal '',      dialog                            .title
+    assert_equal 'hoge',  dialog(      title:  'hoge')      .title
+    assert_equal 'hoge',  dialog      {title   'hoge'}      .title
+    assert_equal 'hoge',  dialog {self.title = 'hoge'}      .title
+    assert_equal [],      dialog                            .extensions
+    assert_equal ['png'], dialog(      extensions:  ['png']).extensions
+    assert_equal ['png'], dialog      {extensions   ['png']}.extensions
+    assert_equal ['png'], dialog {self.extensions = ['png']}.extensions
+  end
+
+  def test_extensions()
+    dialog.tap do |d|
+      d.extensions = %w[png jpg]
+      assert_equal   %w[png jpg], d.extensions
+      d.extensions = ['txt']
+      assert_equal   ['txt'],     d.extensions
+    end
+
+    assert_equal %w[png],    dialog(extensions: 'png')      .extensions
+    assert_equal %w[png],    dialog(extensions: ['png'])    .extensions
+    assert_equal %w[png],    dialog(extensions: [:png])     .extensions
+    assert_equal %w[jpg],    dialog(extensions: ['.jpg'])   .extensions
+    assert_equal %w[gif],    dialog(extensions: ['..gif'])  .extensions
+    assert_equal %w[tar.gz], dialog(extensions: ['.tar.gz']).extensions
+
+    assert_raise(ArgumentError) {dialog.extensions = ['']}
+    assert_raise(ArgumentError) {dialog.extensions = ['.']}
+    assert_raise(ArgumentError) {dialog.extensions = ['png', '']}
+    assert_raise(ArgumentError) {dialog.extensions = ['*.png']}
+    assert_raise(ArgumentError) {dialog.extensions = ['p?g']}
+    assert_raise(ArgumentError) {dialog.extensions = ['png;jpg']}
+    assert_raise(ArgumentError) {dialog.extensions = ['a/b']}
+    assert_raise(ArgumentError) {dialog.extensions = [/png/]}
+    assert_raise(ArgumentError) {dialog.extensions = [1]}
+  end
+
+end# TestFileDialog

data/test/test_file_event.rb

@@ -0,0 +1,43 @@
+require_relative 'helper'
+
+
+class TestFileEvent < Test::Unit::TestCase
+
+  Event            = Reflex::FileEvent
+
+  NONE, OPEN, SAVE = Event::ACTION_NONE, Event::OPEN, Event::SAVE
+
+  def event(*args)
+    Event.new(*args)
+  end
+
+  def test_initialize()
+    assert_equal :open,        event(OPEN, ['/a', '/b']).action
+    assert_equal ['/a', '/b'], event(OPEN, ['/a', '/b']).paths
+    assert_equal '/a',         event(OPEN, ['/a', '/b']).path
+  end
+
+  def test_dup()
+    e1 = event OPEN, ['/a']
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+  def test_action()
+    assert_equal :none, event(NONE, []).action
+    assert_equal :open, event(OPEN, []).action
+    assert_equal :save, event(SAVE, []).action
+  end
+
+  def test_open_save?()
+    assert_true  event(OPEN, ['/a']).open?
+    assert_false event(OPEN, ['/a']).save?
+    assert_false event(SAVE, ['/a']).open?
+    assert_true  event(SAVE, ['/a']).save?
+  end
+
+end# TestFileEvent

data/test/test_has_text_preedit.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+require_relative 'helper'
+
+
+class TestHasTextPreedit < Test::Unit::TestCase
+
+  PREEDIT, COMMIT = Reflex::TextEvent::PREEDIT, Reflex::TextEvent::COMMIT
+
+  def view(*args)
+    Class.new(Reflex::View) {include Reflex::HasTextPreedit}.new(*args)
+  end
+
+  def event(*args)
+    Reflex::TextEvent.new(*args)
+  end
+
+  def test_initial_state()
+    v = view
+    assert_equal '', v.preedit
+    assert_nil       v.preedit_selection
+    assert_false     v.preedit?
+  end
+
+  def test_preedit()
+    v = view
+    v.on_text_preedit event(PREEDIT, 'こんにちは', 1, 2)
+    assert_equal 'こんにちは', v.preedit
+    assert_equal 1...3,        v.preedit_selection
+    assert_true                v.preedit?
+  end
+
+  def test_cancel()
+    v = view
+    v.on_text_preedit event(PREEDIT, 'こんにちは', 1, 2)
+    v.on_text_preedit event(PREEDIT, '', -1, 0)
+    assert_equal '', v.preedit
+    assert_nil       v.preedit_selection
+    assert_false     v.preedit?
+  end
+
+  def test_commit_clears_preedit()
+    v = view
+    v.on_text_preedit event(PREEDIT, 'こんにちは', 1, 2)
+    v.on_text_commit  event(COMMIT,  '今日は',    -1, 0)
+    assert_equal '', v.preedit
+    assert_nil       v.preedit_selection
+    assert_false     v.preedit?
+  end
+
+  def test_include_accepts_text_input()
+    assert_true view.accepts_text_input?
+  end
+
+end# TestHasTextPreedit

data/test/test_key_event.rb

@@ -3,10 +3,12 @@ require_relative 'helper'
 
 class TestKeyEvent < Test::Unit::TestCase
 
-  DOWN, UP = Reflex::KeyEvent::DOWN, Reflex::KeyEvent::UP
+  R = Reflex
+
+  DOWN, UP = R::KeyEvent::DOWN, R::KeyEvent::UP
 
   def event(*args)
-    Reflex::KeyEvent.new(*args)
+    R::KeyEvent.new(*args)
   end
 
   def test_initialize()
@@ -43,10 +45,23 @@ class TestKeyEvent < Test::Unit::TestCase
     assert_nil event(DOWN, nil, 1, 2, 3).chars
   end
 
+  def test_key()
+    assert_equal :a,    event(DOWN, 'a', R::KEY_A,    0, 0).key
+    assert_equal :f1,   event(DOWN, '',  R::KEY_F1,   0, 0).key
+    assert_equal :left, event(DOWN, '',  R::KEY_LEFT, 0, 0).key
+  end
+
   def test_modifiers()
-    e = event DOWN, 'a', 1, Reflex::MOD_CONTROL | Reflex::MOD_CAPS, 0
-    assert_equal [:control, :caps], e.modifiers
-    assert_equal [:control],        e.modifiers(locks: false)
+    e = event DOWN, 'a', 1, R::MOD_CONTROL | R::MOD_CAPS, 0
+    assert_equal [:control],        e.modifiers
+    assert_equal [:control, :caps], e.modifiers(all: true)
+  end
+
+  def test_inspect()
+    hex_z = R::KEY_Z.to_s(16).upcase
+    assert_equal(
+      "#<Reflex::KeyEvent :down chars:'z' key:z code:0x#{hex_z} mod:[:control, :caps] repeat:2 captured?:false>",
+      event(DOWN, 'z', R::KEY_Z, R::MOD_CONTROL | R::MOD_CAPS, 2).inspect)
   end
 
 end# TestKeyEvent

data/test/test_link_constraint.rb

@@ -3,9 +3,7 @@ require_relative 'helper'
 
 class TestLinkConstraint < Test::Unit::TestCase
 
-  def window()
-    Reflex::Window.new
-  end
+  include HasWindow
 
   def view(x = 0, y = 0, w = 50, h = 50, **options, &block)
     Reflex::View.new(