reflexion 0.1.6 → 0.1.7

data/src/win32/application.cpp

@@ -2,7 +2,7 @@
 
 
 #include <windows.h>
-#include <reflex/exception.h>
+#include "reflex/exception.h"
 
 
 namespace Reflex

data/src/window.cpp

@@ -3,16 +3,17 @@
 
 #include <rays/bounds.h>
 #include <rays/painter.h>
-#include <reflex/view.h>
+#include "reflex/view.h"
+#include "reflex/exception.h"
 
 
 namespace Reflex
 {
 
 
-	void update_view_tree (View* v, float dt);
+	void update_view_tree (View* v, const UpdateEvent& e);
 
-	void draw_view_tree (View* v, Painter* p, coord left, coord top);
+	void draw_view_tree (View* v, const DrawEvent& e, const Point& offset, const Bounds& clip);
 
 
 	const View*
@@ -21,70 +22,97 @@ namespace Reflex
 		return const_cast<Window*>(this)->root();
 	}
 
+	const View*
+	Window::focus () const
+	{
+		return const_cast<Window*>(this)->focus();
+	}
+
 	const Painter*
 	Window::painter () const
 	{
 		return const_cast<Window*>(this)->painter();
 	}
 
-	void
-	Window::update (float dt)
+	Rays::Point
+	Window::from_screen (const Rays::Point& point) const
 	{
-		update_view_tree(root(), dt);
+		not_implemented_error(__FILE__, __LINE__);
+		return 0;
 	}
 
-	void
-	Window::draw ()
+	Rays::Point
+	Window::to_screen (const Rays::Point& point) const
 	{
-		Painter* p = painter();
-		if (!p) return;
+		not_implemented_error(__FILE__, __LINE__);
+		return 0;
+	}
 
-		View* v = root();
-		if (!v) return;
+	void
+	Window::on_update (UpdateEvent* e)
+	{
+		if (!e)
+			argument_error(__FILE__, __LINE__);
 
-		if (!p->begin()) return;
-		draw_view_tree(v, p, 0, 0);
-		p->end();
+		update_view_tree(root(), *e);
 	}
 
 	void
-	Window::moved (coord x, coord y)
+	Window::on_draw (DrawEvent* e)
 	{
+		if (!e)
+			argument_error(__FILE__, __LINE__);
+
+		draw_view_tree(root(), *e, 0, frame().dup().move_to(0));
 	}
 
 	void
-	Window::resized (coord width, coord height)
+	Window::on_move (FrameEvent* e)
 	{
-		Painter* p = painter();
-		if (p) p->canvas(0, 0, width, height);
+		if (!e)
+			argument_error(__FILE__, __LINE__);
+	}
 
-		View* v = root();
-		if (v) v->set_bounds(0, 0, width, height);
+	void
+	Window::on_resize (FrameEvent* e)
+	{
+		if (!e)
+			argument_error(__FILE__, __LINE__);
 	}
 
 	void
-	Window::key_down (const Key& key)
+	Window::on_key_down (KeyEvent* e)
 	{
+		if (!e)
+			argument_error(__FILE__, __LINE__);
 	}
 
 	void
-	Window::key_up (const Key& key)
+	Window::on_key_up (KeyEvent* e)
 	{
+		if (!e)
+			argument_error(__FILE__, __LINE__);
 	}
 
 	void
-	Window::points_down (const Points& points)
+	Window::on_pointer_down (PointerEvent* e)
 	{
+		if (!e)
+			argument_error(__FILE__, __LINE__);
 	}
 
 	void
-	Window::points_up (const Points& points)
+	Window::on_pointer_up (PointerEvent* e)
 	{
+		if (!e)
+			argument_error(__FILE__, __LINE__);
 	}
 
 	void
-	Window::points_moved (const Points& points)
+	Window::on_pointer_move (PointerEvent* e)
 	{
+		if (!e)
+			argument_error(__FILE__, __LINE__);
 	}
 
 	bool

data/test/helper.rb

@@ -1,14 +1,18 @@
 # -*- coding: utf-8 -*-
 
 
-require 'xot/load_path'
-Xot::LoadPath.unshift File.expand_path('../../lib', __FILE__)
+%w[../xot ../rucy ../rays .]
+  .map  {|s| File.expand_path "../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'test/unit'
+require 'xot/test'
 require 'reflex'
 
+include Xot::Test
+
 
 unless $REFLEX_NOAUTOINIT
-  def Rays.fin! (); end
-  def Reflex.fin! (); end
+  def Rays.fin! () end
+  def Reflex.fin! () end
 end

data/test/test_capture_event.rb

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestCaptureEvent < Test::Unit::TestCase
+
+  def cap (*args)
+    Reflex::CaptureEvent.new *args.map {|arg| Reflex::CAPTURE_FLAG.symbols2bits *arg}
+  end
+
+  def test_begin ()
+    c = cap [:key, :pointer], []
+    assert_equal [:key, :pointer], c.begin
+    assert_equal true, c.begin?(:key)
+    assert_equal true, c.begin?(:pointer)
+    assert_equal true, c.begin?(:all)
+
+    c = cap [:key], []
+    assert_equal [:key], c.begin
+    assert_equal true,  c.begin?(:key)
+    assert_equal false, c.begin?(:pointer)
+    assert_equal false, c.begin?(:all)
+  end
+
+  def test_end ()
+    c = cap [], [:key, :pointer]
+    assert_equal [:key, :pointer], c.end
+    assert_equal true, c.end?(:key)
+    assert_equal true, c.end?(:pointer)
+    assert_equal true, c.end?(:all)
+
+    c = cap [], [:key]
+    assert_equal [:key], c.end
+    assert_equal true,  c.end?(:key)
+    assert_equal false, c.end?(:pointer)
+    assert_equal false, c.end?(:all)
+  end
+
+end# TestCaptureEvent

data/test/test_event.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestEvent < Test::Unit::TestCase
+
+  def event ()
+    Reflex::Event.new
+  end
+
+  def test_block ()
+    e = event
+    assert_equal false, e.block?
+    e.block
+    assert_equal true, e.block?
+  end
+
+end# TestEvent

data/test/test_has_frame.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestHasFrame < Test::Unit::TestCase
+
+  def view (*args)
+    Reflex::View.new *args
+  end
+
+  def test_accessors ()
+    v = view
+    b = v.frame.dup
+    assert_equal b, v.frame
+
+    v.x = 10; assert_equal 10, v.x
+    v.y = 20; assert_equal 20, v.y
+    v.z = 30; assert_equal 30, v.z
+
+    v.width  = 100; assert_equal 100, v.width
+    v.height = 200; assert_equal 200, v.height
+    v.depth  = 300; assert_equal 300, v.depth
+
+    v.inset_by 5, 5
+    assert_equal [15, 25,     90, 190],      v.frame.to_a
+    assert_equal [15, 25, 30, 90, 190, 300], v.frame.to_a(3)
+  end
+
+  def test_move ()
+    v = view
+    v.move_to  10,  10; assert_equal [10, 10], v.pos.to_a
+    v.move_by  40,  40; assert_equal [50, 50], v.pos.to_a
+    v.move_by -10, -10; assert_equal [40, 40], v.pos.to_a
+  end
+
+  def test_resize ()
+    v = view
+    v.resize_to  100,  100; assert_equal [100, 100], v.size.to_a
+    v.resize_by  400,  400; assert_equal [500, 500], v.size.to_a
+    v.resize_by -100, -100; assert_equal [400, 400], v.size.to_a
+  end
+
+end# TestHasFrame

data/test/test_model.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestModel < Test::Unit::TestCase
+
+end# TestModel

data/test/test_model_owner.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestModelOwner < Test::Unit::TestCase
+
+end# TestModelOwnerData

data/test/test_selector.rb

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestSelector < Test::Unit::TestCase
+
+  def sel (*args, &block)
+    Reflex::Selector.new *args, &block
+  end
+
+  def test_initialize ()
+    assert_equal 'A', sel(name: :A).name
+    assert_equal 'B', sel(name: :A){set name: :B}.name
+    assert_equal %w[T1],    sel(tag:    :T1      ).tags.to_a
+    assert_equal %w[T1 T2], sel(tag:   [:T1, :T2]).tags.to_a
+    assert_equal %w[T1],    sel(tags:   :T1      ).tags.to_a
+    assert_equal %w[T1 T2], sel(tags:  [:T1, :T2]).tags.to_a
+  end
+
+  def test_name ()
+    s = sel
+    assert_equal nil, s.name
+    s.name = 'Test'
+    assert_equal 'Test', s.name
+  end
+
+  def test_tags ()
+    s = sel
+    assert_equal [], s.tags.to_a
+    s.tag 'A'
+    assert_equal %w[A], s.tags.to_a
+    s.tag :B
+    assert_equal %w[A B], s.tags.to_a
+    s.tag :C, :D
+    assert_equal %w[A B C D], s.tags.to_a
+    s.untag :B, :C
+    assert_equal %w[A D], s.tags.to_a
+    assert_equal %w[a d], s.tags.map(&:downcase).to_a
+  end
+
+  def test_clear_tags ()
+    s = sel tag: [:T1, :T2]
+    s.clear_tags
+    assert_equal [], s.tags.to_a
+  end
+
+  def test_match ()
+    assert_not sel.match(sel name: :A, tag: :T)
+    assert     sel(name: :A).match(sel name: :A)
+    assert_not sel(name: :A).match(sel name: :B)
+    assert     sel(tag: :T1).match(sel tag: :T1)
+    assert_not sel(tag: :T1).match(sel tag: :T2)
+    assert     sel(tag: :T1).match(sel tag: [:T1, :T2])
+    assert_not sel(tag: [:T1, :T2]).match(sel tag: :T1)
+    assert     sel(name: :A, tag: :T1).match(sel name: :A, tag: :T1)
+    assert_not sel(name: :A, tag: :T1).match(sel name: :A)
+    assert_not sel(name: :A, tag: :T1).match(sel tag: :T1)
+  end
+
+  def test_compare ()
+    assert_equal     sel(name: :A), sel(name: :A)
+    assert_not_equal sel(name: :A), sel(name: :X)
+    assert_equal     sel(tag: [:A, :B]), sel(tag: [:A, :B])
+    assert_not_equal sel(tag: [:A, :B]), sel(tag: [:A, :X])
+    assert_equal     sel(name: :A, tag: :B), sel(name: :A, tag: :B)
+    assert_not_equal sel(name: :A, tag: :B), sel(name: :X, tag: :B)
+    assert_not_equal sel(name: :A, tag: :B), sel(name: :A, tag: :X)
+    assert_equal     sel(name: :A, tag: [:B, :C]), sel(name: :A, tag: [:B, :C])
+    assert_not_equal sel(name: :A, tag: :B),       sel(name: :A, tag: [:B, :C])
+    assert_not_equal sel(name: :A, tag: [:B, :C]), sel(name: :A, tag: :B)
+  end
+
+end# TestSelector

data/test/test_style.rb

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestStyle < Test::Unit::TestCase
+
+  def style (*args, &block)
+    Reflex::Style.new *args, &block
+  end
+
+  def test_initialize ()
+    assert_equal nil, style.name
+    assert_equal 'A', style(name: :A).name
+    assert_equal 'A', style{self.name = :A}.name
+  end
+
+  def test_selector ()
+    assert_equal 'A', style(name: :A).selector.name
+    assert_equal %w[T], style(tag: :T).selector.tags.to_a
+  end
+
+  def test_flow ()
+    s = style
+
+    assert_equal [:down, :none], s.flow
+    s.flow = :up
+    assert_equal [:up, :none],   s.flow
+    s.flow = [:left, :down]
+    assert_equal [:left, :down], s.flow
+    s.flow = :none
+    assert_equal [:none, :none], s.flow
+    assert_raise(ArgumentError) {s.flow = []}
+    assert_raise(ArgumentError) {s.flow = [:down, :right, :none]}
+  end
+
+  def test_margin_padding ()
+    s = style
+
+    assert_equal [0, 0, 0, 0], s.margin.to_a.map(&:value)
+    s.margin   = [1]
+    assert_equal [1, 1, 1, 1], s.margin.to_a.map(&:value)
+    s.margin   = [1, 2]
+    assert_equal [1, 2, 1, 2], s.margin.to_a.map(&:value)
+    s.margin   = [1, 2, 3]
+    assert_equal [1, 2, 3, 2], s.margin.to_a.map(&:value)
+    s.margin   = [1, 2, 3, 4]
+    assert_equal [1, 2, 3, 4], s.margin.to_a.map(&:value)
+
+    assert_equal [0, 0, 0, 0], s.padding.to_a.map(&:value)
+    s.padding   = [1]
+    assert_equal [1, 1, 1, 1], s.padding.to_a.map(&:value)
+    s.padding   = [1, 2]
+    assert_equal [1, 2, 1, 2], s.padding.to_a.map(&:value)
+    s.padding   = [1, 2, 3]
+    assert_equal [1, 2, 3, 2], s.padding.to_a.map(&:value)
+    s.padding   = [1, 2, 3, 4]
+    assert_equal [1, 2, 3, 4], s.padding.to_a.map(&:value)
+  end
+
+  def test_background_color ()
+    assert_equal [0, 0, 0, 1], style.background_color.to_a
+  end
+
+  def test_background_image ()
+    assert_equal nil, style.background_image
+  end
+
+end# TestStyle

data/test/test_style_length.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestStyleLength < Test::Unit::TestCase
+
+  def len (*args, &block)
+    Reflex::StyleLength.new *args, &block
+  end
+
+  def test_initialize ()
+    assert_equal 0,   len.value
+    assert_equal nil, len.unit
+    assert_equal 100, len(100).value
+    assert_equal :px, len(100).unit
+    assert_equal 100, len(100, :px).value
+    assert_equal :px, len(100, :px).unit
+    #assert_equal :%,  len(100, :%).unit
+    assert_equal 100, len('100px').value
+    assert_equal :px, len('100px').unit
+    #assert_equal :%,  len('100%').unit
+  end
+
+  def test_to_s ()
+    assert_equal '100px',  len(100,   :px).to_s
+    #assert_equal '100%',   len(100,   :%).to_s
+    #assert_equal '100.5%', len(100.5, :%).to_s
+    assert_raises(Rucy::NativeError) {len.to_s}
+    assert ((len.to_s rescue $!.message)) =~ /InvalidStateError/
+  end
+
+  def test_inspect ()
+    assert_nothing_raised {len.inspect}
+  end
+
+end# TestStyleLength

data/test/test_style_length2.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestStyleLength2 < Test::Unit::TestCase
+
+  def len2 (w = 0, h = 0, &block)
+    Reflex::StyleLength2.new width: w, height: h, &block
+  end
+
+  def test_initialize ()
+    assert_equal 0, len2(*%w[])       .width.value
+    assert_equal 1, len2(*%w[1px])    .width.value
+    assert_equal 2, len2(*%w[1px 2px]).height.value
+    assert_equal :px, len2(*%w[1px]).width.unit
+    #assert_equal :%,  len2(*%w[1%]).width.unit
+  end
+
+  def test_wh ()
+    assert_equal '1px', len2(1)   .width.to_s
+    assert_equal '2px', len2(1, 2).height.to_s
+  end
+
+  def test_to_a ()
+    assert_equal [0, 0],    len2.to_a.map(&:value)
+    assert_equal [:px] * 2, len2.to_a.map(&:unit)
+    assert_equal [1, 2],    len2(1, 2).to_a.map(&:value)
+    assert_equal [:px] * 2, len2(1, 2).to_a.map(&:unit)
+  end
+
+  def test_get_set_at ()
+    l = len2 1, 2
+
+    assert_equal 1, l[0].value
+    assert_equal 2, l[1].value
+
+    l[0] = '10px'
+    assert_equal 10, l[0].value
+    l[1] = '40px'
+    assert_equal 40, l[1].value
+    l[-1] = '30px'
+    assert_equal 30, l[ 1].value
+    assert_equal 30, l[-1].value
+
+    assert_raises(IndexError) {l[2] = '50px'}
+  end
+
+end# TestStyleLength2

data/test/test_style_length4.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestStyleLength4 < Test::Unit::TestCase
+
+  def len4 (l = 0, t = 0, r = 0, b = 0, &block)
+    Reflex::StyleLength4.new left: l, top: t, right: r, bottom: b, &block
+  end
+
+  def test_initialize ()
+    assert_equal 0, len4(*%w[])               .left.value
+    assert_equal 1, len4(*%w[1px])            .left.value
+    assert_equal 2, len4(*%w[1px 2px])        .top.value
+    assert_equal 3, len4(*%w[1px 2px 3px])    .right.value
+    assert_equal 4, len4(*%w[1px 2px 3px 4px]).bottom.value
+    assert_equal :px, len4(*%w[1px]).left.unit
+    #assert_equal :%,  len4(*%w[1%]).left.unit
+  end
+
+  def test_ltrb ()
+    assert_equal '1px', len4(1)         .left.to_s
+    assert_equal '2px', len4(1, 2)      .top.to_s
+    assert_equal '3px', len4(1, 2, 3)   .right.to_s
+    assert_equal '4px', len4(1, 2, 3, 4).bottom.to_s
+  end
+
+  def test_to_a ()
+    assert_equal [0, 0, 0, 0], len4.to_a.map(&:value)
+    assert_equal [:px] * 4,    len4.to_a.map(&:unit)
+    assert_equal [1, 2, 3, 4], len4(1, 2, 3, 4).to_a.map(&:value)
+    assert_equal [:px] * 4,    len4(1, 2, 3, 4).to_a.map(&:unit)
+  end
+
+  def test_get_set_at ()
+    l = len4 1, 2, 3, 4
+
+    assert_equal 1, l[0].value
+    assert_equal 2, l[1].value
+    assert_equal 3, l[2].value
+    assert_equal 4, l[3].value
+
+    l[0] = '10px'
+    assert_equal 10, l[0].value
+    l[3] = '40px'
+    assert_equal 40, l[3].value
+    l[-1] = '30px'
+    assert_equal 30, l[ 3].value
+    assert_equal 30, l[-1].value
+
+    assert_raises(IndexError) {l[4] = '50px'}
+  end
+
+end# TestStyleLength4