reflexion 0.1.12 → 0.1.17

data/ext/reflex/event.cpp

@@ -1,13 +1,9 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::Event)
 
 #define THIS  to<Reflex::Event*>(self)

data/ext/reflex/extconf.rb

@@ -15,7 +15,7 @@ require 'reflex/module'
 
 Xot::ExtConf.new Xot, Rucy, Rays, Reflex do
   setup do
-    headers    << 'boost/scoped_array.hpp' << 'boost/shared_ptr.hpp' << 'ruby.h'
+    headers    << 'ruby.h'
     local_libs << 'rucy'
     libs.unshift 'gdi21', 'opengl32' if win32?
     frameworks << 'Cocoa' if osx?
@@ -27,6 +27,5 @@ Xot::ExtConf.new Xot, Rucy, Rays, Reflex do
     end
   end
 
-  dir_config 'boost'
   create_makefile 'reflex/native'
 end

data/ext/reflex/filter.cpp

@@ -0,0 +1,86 @@
+#include "reflex/ruby/filter.h"
+
+
+#include <rays/ruby/painter.h>
+#include <rays/ruby/image.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Filter)
+
+#define THIS      to<Reflex::Filter*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Filter, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyFilter<Reflex::Filter>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize, arg)
+{
+	CHECK;
+
+	THIS->set_shader(to<Rays::Shader>(arg));
+}
+RUCY_END
+
+static
+RUCY_DEF2(apply, painter, image)
+{
+	CHECK;
+	CALL(apply(to<Rays::Painter*>(painter), to<const Rays::Image&>(image)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_shader, shader)
+{
+	CHECK;
+	THIS->set_shader(to<Rays::Shader>(shader));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_shader)
+{
+	CHECK;
+	return value(THIS->shader());
+}
+RUCY_END
+
+
+static Class cFilter;
+
+void
+Init_filter ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cFilter = mReflex.define_class("Filter");
+	cFilter.define_alloc_func(alloc);
+	cFilter.define_private_method("initialize", initialize);
+	cFilter.define_method("apply", apply);
+	cFilter.define_method("shader=", set_shader);
+	cFilter.define_method("shader",  get_shader);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	filter_class ()
+	{
+		return cFilter;
+	}
+
+
+}// Reflex

data/ext/reflex/focus_event.cpp

@@ -1,14 +1,10 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "reflex/ruby/view.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::FocusEvent)
 
 #define THIS  to<Reflex::FocusEvent*>(self)
@@ -24,13 +20,13 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF3(initialize, type, focus, last)
+RUCY_DEF3(initialize, type, current, last)
 {
 	CHECK;
 
-	THIS->focus = to<Reflex::View*>(focus);
-	THIS->focus = to<Reflex::View*>(focus);
-	THIS->last  = to<Reflex::View*>(last);
+	THIS->type    = (Reflex::FocusEvent::Type) to<uint>(type);
+	THIS->current = to<Reflex::View*>(current);
+	THIS->last    = to<Reflex::View*>(last);
 
 	return rb_call_super(0, NULL);
 }
@@ -46,7 +42,7 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEF0(get_type)
+RUCY_DEF0(type)
 {
 	CHECK;
 	return value(THIS->type);
@@ -54,10 +50,10 @@ RUCY_DEF0(get_type)
 RUCY_END
 
 static
-RUCY_DEF0(focus)
+RUCY_DEF0(current)
 {
 	CHECK;
-	return THIS->focus ? value(THIS->focus) : nil();
+	return THIS->current ? value(THIS->current) : nil();
 }
 RUCY_END
 
@@ -79,11 +75,11 @@ Init_focus_event ()
 
 	cFocusEvent = mReflex.define_class("FocusEvent", Reflex::event_class());
 	cFocusEvent.define_alloc_func(alloc);
-	cFocusEvent.define_private_method("initialize", initialize);
+	cFocusEvent.define_private_method("initialize",      initialize);
 	cFocusEvent.define_private_method("initialize_copy", initialize_copy);
-	cFocusEvent.define_method("get_type", get_type);
-	cFocusEvent.define_method("focus", focus);
-	cFocusEvent.define_method("last",  last);
+	cFocusEvent.define_method("type", type);
+	cFocusEvent.define_method("current", current);
+	cFocusEvent.define_method("last", last);
 	cFocusEvent.define_const("TYPE_NONE",  Reflex::FocusEvent::NONE);
 	cFocusEvent.define_const("TYPE_FOCUS", Reflex::FocusEvent::FOCUS);
 	cFocusEvent.define_const("TYPE_BLUR",  Reflex::FocusEvent::BLUR);

data/ext/reflex/frame_event.cpp

@@ -1,17 +1,11 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "rays/ruby/point.h"
 #include "rays/ruby/bounds.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Reflex::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::FrameEvent)
 
 #define THIS  to<Reflex::FrameEvent*>(self)
@@ -27,16 +21,15 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEFN(initialize)
+RUCY_DEF5(initialize, frame, dx, dy, dwidth, dheight)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "FrameEvent#initialize", argc, 0, 1, 2, 3, 4, 5);
 
-	THIS->frame   = (argc >= 1) ? to<Rays::Bounds&>(argv[0]) : Rays::Bounds(0);
-	THIS->dx      = (argc >= 2) ? to<coord>(argv[1]) : 0;
-	THIS->dy      = (argc >= 3) ? to<coord>(argv[2]) : 0;
-	THIS->dwidth  = (argc >= 4) ? to<coord>(argv[3]) : 0;
-	THIS->dheight = (argc >= 5) ? to<coord>(argv[4]) : 0;
+	THIS->frame   = to<Rays::Bounds>(frame);
+	THIS->dx      = to<coord>(dx);
+	THIS->dy      = to<coord>(dy);
+	THIS->dwidth  = to<coord>(dwidth);
+	THIS->dheight = to<coord>(dheight);
 
 	return rb_call_super(0, NULL);
 }
@@ -107,6 +100,46 @@ RUCY_DEF0(dsize)
 }
 RUCY_END
 
+static
+RUCY_DEF0(angle)
+{
+	CHECK;
+	return value(THIS->angle);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dangle)
+{
+	CHECK;
+	return value(THIS->dangle);
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_move)
+{
+	CHECK;
+	return value(THIS->is_move());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_resize)
+{
+	CHECK;
+	return value(THIS->is_resize());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_rotate)
+{
+	CHECK;
+	return value(THIS->is_rotate());
+}
+RUCY_END
+
 
 static Class cFrameEvent;
 
@@ -117,7 +150,7 @@ Init_frame_event ()
 
 	cFrameEvent = mReflex.define_class("FrameEvent", Reflex::event_class());
 	cFrameEvent.define_alloc_func(alloc);
-	cFrameEvent.define_private_method("initialize", initialize);
+	cFrameEvent.define_private_method("initialize",      initialize);
 	cFrameEvent.define_private_method("initialize_copy", initialize_copy);
 	cFrameEvent.define_method("frame", frame);
 	cFrameEvent.define_method("dx", dx);
@@ -126,6 +159,11 @@ Init_frame_event ()
 	cFrameEvent.define_method("dheight", dheight);
 	cFrameEvent.define_method("dposition", dposition);
 	cFrameEvent.define_method("dsize",     dsize);
+	cFrameEvent.define_method( "angle",  angle);
+	cFrameEvent.define_method("dangle", dangle);
+	cFrameEvent.define_method("move?",   is_move);
+	cFrameEvent.define_method("resize?", is_resize);
+	cFrameEvent.define_method("rotate?", is_rotate);
 }
 
 

data/ext/reflex/image_view.cpp

@@ -1,14 +1,9 @@
 #include "reflex/ruby/image_view.h"
 
 
-#include <rucy.h>
 #include <rays/ruby/point.h>
 #include "reflex/ruby/view.h"
-
-
-using namespace Rucy;
-
-using Reflex::coord;
+#include "defs.h"
 
 
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::ImageView)
@@ -45,9 +40,6 @@ RUCY_DEF1(set_image, image)
 }
 RUCY_END
 
-static
-RUCY_DEF_clear_override_flags(cof, Reflex::ImageView);
-
 
 static Class cImageView;
 
@@ -60,7 +52,6 @@ Init_image_view ()
 	cImageView.define_alloc_func(alloc);
 	cImageView.define_private_method("set_image", set_image);
 	cImageView.define_method(            "image", get_image);
-	cImageView.define_clear_override_flags(cof);
 }
 
 

data/ext/reflex/key_event.cpp

@@ -1,13 +1,9 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::KeyEvent)
 
 #define THIS  to<Reflex::KeyEvent*>(self)
@@ -23,16 +19,15 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEFN(initialize)
+RUCY_DEF5(initialize, type, chars, code, repeat, modifiers)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "KeyEvent#initialize", argc, 0, 1, 2, 3, 4, 5);
 
-	THIS->type      = (argc >= 1) ? (Reflex::KeyEvent::Type) to<int>(argv[0]) : Reflex::KeyEvent::NONE;
-	THIS->chars     = (argc >= 2) ? argv[1].c_str()   : NULL;
-	THIS->code      = (argc >= 3) ? to<int>(argv[2])  : Reflex::KEY_NONE;
-	THIS->repeat    = (argc >= 4) ? to<int>(argv[3])  : 1;
-	THIS->modifiers = (argc >= 5) ? to<uint>(argv[4]) : (uint) Reflex::MOD_NONE;
+	THIS->type      = (Reflex::KeyEvent::Type) to<int>(type);
+	THIS->chars     = chars.c_str();
+	THIS->code      = to<int>(code);
+	THIS->repeat    = to<int>(repeat);
+	THIS->modifiers = to<uint>(modifiers);
 
 	return rb_call_super(0, NULL);
 }
@@ -48,7 +43,7 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEF0(get_type)
+RUCY_DEF0(type)
 {
 	CHECK;
 	return value(THIS->type);
@@ -105,9 +100,9 @@ Init_key_event ()
 
 	cKeyEvent = mReflex.define_class("KeyEvent", Reflex::event_class());
 	cKeyEvent.define_alloc_func(alloc);
-	cKeyEvent.define_private_method("initialize", initialize);
+	cKeyEvent.define_private_method("initialize",      initialize);
 	cKeyEvent.define_private_method("initialize_copy", initialize_copy);
-	cKeyEvent.define_method("get_type", get_type);
+	cKeyEvent.define_method("type", type);
 	cKeyEvent.define_method("chars", chars);
 	cKeyEvent.define_method("code", code);
 	cKeyEvent.define_method("modifiers", modifiers);

data/ext/reflex/line_shape.cpp

@@ -0,0 +1,104 @@
+#include "reflex/ruby/shape.h"
+
+
+#include <rays/ruby/point.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::LineShape)
+
+#define THIS      to<Reflex::LineShape*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::LineShape, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyShape<Reflex::LineShape>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(add_point)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "LineShape#add_point", argc, 1, 2, 3);
+
+	THIS->add_point(to<Rays::Point>(argc, argv));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEFN(add_points)
+{
+	CHECK;
+
+	if (argc <= 0) return self;
+
+	if (argv[0].is_num())
+	{
+		if (argc % 2 != 0)
+			argument_error(__FILE__, __LINE__);
+
+		for (int i = 0; i < argc; i += 2)
+			THIS->add_point(to<coord>(argv[i]), to<coord>(argv[i + 1]));
+	}
+	else
+	{
+		for (int i = 0; i < argc; ++i)
+			THIS->add_point(to<Rays::Point>(argv[i]));
+	}
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_loop, loop)
+{
+	CHECK;
+	THIS->set_loop(loop);
+	return loop;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_loop)
+{
+	CHECK;
+	return value(THIS->loop());
+}
+RUCY_END
+
+
+static Class cLineShape;
+
+void
+Init_line_shape ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cLineShape = mReflex.define_class("LineShape", Reflex::shape_class());
+	cLineShape.define_alloc_func(alloc);
+	cLineShape.define_method("add_point",  add_point);
+	cLineShape.define_method("add_points", add_points);
+	cLineShape.define_method("loop=", set_loop);
+	cLineShape.define_method("loop",  get_loop);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	line_shape_class ()
+	{
+		return cLineShape;
+	}
+
+
+}// Reflex