reflexion 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f4670b432d3c7b5118a704adeaf2cb4dddc11cc6
-  data.tar.gz: b688cf9645c078dc5e4fbb2ad811b534c0aac1eb
+SHA256:
+  metadata.gz: a2bb469e3b1abf80f565057e6d358a8e94e655903f9e0ba4305fedbaeda4c784
+  data.tar.gz: c142e94f6412857c9c72e6edbc1556e1dd8e1c8b37f02c9135719684928a6a12
 SHA512:
-  metadata.gz: 73f6c4bf4329acf985fd06453bbe7955dce476bc216ba9253bc5d142a27c81a0cd3fec27a3ba65f58257886111a5e5b0bd02621f6bfc123d54b6f359d387fb52
-  data.tar.gz: 3f1b72930a6baa7e3f97a28cf5715e39123e03fcb0283988f7d0929ace59612ec11dbe3f2f96ae6ab0ddf7c8723a7bcef169b008a5d30f4f483f61695b0202d5
+  metadata.gz: a2f43e90b2c849dda364feba2465a820ddf10d7319de25763d36732fecb00aa0e1586bb133b5f28392674f8f686badcb209f846b06ad71597af6780c9f915c8e
+  data.tar.gz: a2112d4d6af9a6027c736a6ba099a1c3e672add1d9fec42b420bd114481ae1bfe1feabd072e3c1edccc18f857b63f45f36448aa6b15264ec2125c5176c92f932

data/.doc/ext/reflex/application.cpp

@@ -1,13 +1,9 @@
 #include "reflex/ruby/application.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Application)
 
 #define THIS      to<Reflex::Application*>(self)
@@ -15,7 +11,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Application)
 #define CHECK_OBJ RUCY_CHECK_OBJ(   Reflex::Application, self)
 #define CHECK     RUCY_CHECK_OBJECT(Reflex::Application, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::Application, THIS, fun)
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
 static
@@ -73,6 +69,13 @@ VALUE on_quit(VALUE self, VALUE event)
 	CALL(on_quit(to<Reflex::Event*>(event)));
 }
 
+static
+VALUE on_motion(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_motion(to<Reflex::MotionEvent*>(event)));
+}
+
 static
 VALUE on_preference(VALUE self, VALUE event)
 {
@@ -109,6 +112,7 @@ Init_application ()
 	rb_define_method(cApplication, "name", RUBY_METHOD_FUNC(get_name), 0);
 	rb_define_method(cApplication, "on_start", RUBY_METHOD_FUNC(on_start), 1);
 	rb_define_method(cApplication, "on_quit", RUBY_METHOD_FUNC(on_quit), 1);
+	rb_define_method(cApplication, "on_motion", RUBY_METHOD_FUNC(on_motion), 1);
 	rb_define_method(cApplication, "on_preference", RUBY_METHOD_FUNC(on_preference), 1);
 	rb_define_method(cApplication, "on_about", RUBY_METHOD_FUNC(on_about), 1);
 	rb_define_singleton_method(cApplication, "instance", RUBY_METHOD_FUNC(instance), 0);

data/.doc/ext/reflex/capture_event.cpp

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

data/.doc/ext/reflex/contact_event.cpp

@@ -1,14 +1,11 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
+#include "reflex/ruby/shape.h"
 #include "reflex/ruby/view.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::ContactEvent)
 
 #define THIS  to<Reflex::ContactEvent*>(self)
@@ -28,8 +25,10 @@ VALUE initialize(VALUE self)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "ContactEvent#initialize", argc, 0, 2);
 
-	THIS->type = (argc >= 1) ? (Reflex::ContactEvent::Type) to<int>(argv[0]) : Reflex::ContactEvent::NONE;
-	THIS->view = (argc >= 2) ? to<Reflex::View*>(argv[1]) : NULL;
+	THIS->type  = (argc >= 1)
+		? (Reflex::ContactEvent::Type) to<int>(argv[0])
+		: Reflex::ContactEvent::NONE;
+	THIS->shape = (argc >= 2) ? to<Reflex::Shape*>(argv[1]) : NULL;
 
 	return rb_call_super(0, NULL);
 }
@@ -43,14 +42,21 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE get_type(VALUE self)
+VALUE type(VALUE self)
 {
 	CHECK;
 	return value(THIS->type);
 }
 
 static
-VALUE get_view(VALUE self)
+VALUE shape(VALUE self)
+{
+	CHECK;
+	return value(THIS->shape);
+}
+
+static
+VALUE view(VALUE self)
 {
 	CHECK;
 	return value(THIS->view);
@@ -68,8 +74,9 @@ Init_contact_event ()
 	rb_define_alloc_func(cContactEvent, alloc);
 	rb_define_private_method(cContactEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cContactEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cContactEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
-	rb_define_method(cContactEvent, "view", RUBY_METHOD_FUNC(get_view), 0);
+	rb_define_method(cContactEvent, "type", RUBY_METHOD_FUNC(type), 0);
+	rb_define_method(cContactEvent, "shape", RUBY_METHOD_FUNC(shape), 0);
+	rb_define_method(cContactEvent, "view", RUBY_METHOD_FUNC(view), 0);
 	cContactEvent.define_const("TYPE_NONE",  Reflex::ContactEvent::NONE);
 	cContactEvent.define_const("TYPE_BEGIN", Reflex::ContactEvent::BEGIN);
 	cContactEvent.define_const("TYPE_END",   Reflex::ContactEvent::END);

data/.doc/ext/reflex/draw_event.cpp

@@ -1,15 +1,11 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include <rays/ruby/painter.h>
 #include <rays/ruby/bounds.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::DrawEvent)
 
 #define THIS  to<Reflex::DrawEvent*>(self)
@@ -29,7 +25,7 @@ VALUE initialize(VALUE self)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "DrawEvent#initialize", argc, 0, 1);
 
-	THIS->dt = (argc >= 1) ? argv[0].as_f() : 0;
+	THIS->dt = (argc >= 1) ? to<float>(argv[0]) : 0;
 
 	return rb_call_super(0, NULL);
 }

data/.doc/ext/reflex/ellipse_shape.cpp

@@ -1,49 +1,76 @@
-#include "reflex/ruby/shape_view.h"
+#include "reflex/ruby/shape.h"
 
 
-#include <rucy.h>
-
-
-using namespace Rucy;
-
-using Reflex::coord;
+#include "defs.h"
 
 
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::EllipseShape)
 
 #define THIS      to<Reflex::EllipseShape*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::EllipseShape, self)
+#define CHECK     RUCY_CHECK_OBJ(Reflex::EllipseShape, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::EllipseShape, THIS, fun)
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return value(new Reflex::RubyShapeView<Reflex::EllipseShape>, klass);
+	return value(new Reflex::RubyShape<Reflex::EllipseShape>, klass);
+}
+
+static
+VALUE set_angle_from(VALUE self, VALUE degree)
+{
+	CHECK;
+	THIS->set_angle_from(to<float>(degree));
+	return self;
+}
+
+static
+VALUE get_angle_from(VALUE self)
+{
+	CHECK;
+	return value(THIS->angle_from());
+}
+
+static
+VALUE set_angle_to(VALUE self, VALUE degree)
+{
+	CHECK;
+	THIS->set_angle_to(to<float>(degree));
+	return self;
 }
 
 static
-VALUE set_radius_min(VALUE self, VALUE radius)
+VALUE get_angle_to(VALUE self)
 {
 	CHECK;
-	THIS->set_radius_min(radius.as_f(true));
-	return radius;
+	return value(THIS->angle_to());
 }
 
 static
-VALUE get_radius_min(VALUE self)
+VALUE set_hole_size(VALUE self)
 {
 	CHECK;
-	return value(THIS->radius_min());
+	check_arg_count(__FILE__, __LINE__, "EllipseShape#set_hole_size", argc, 1, 2, 3);
+
+	THIS->set_hole_size(to<Rays::Point>(argc, argv));
+	return value(THIS->hole_size());
+}
+
+static
+VALUE get_hole_size(VALUE self)
+{
+	CHECK;
+	return value(THIS->hole_size());
 }
 
 static
 VALUE set_nsegment(VALUE self, VALUE nsegment)
 {
 	CHECK;
-	THIS->set_nsegment(nsegment.as_i(true));
+	THIS->set_nsegment(to<uint>(nsegment));
 	return nsegment;
 }
 
@@ -54,9 +81,6 @@ VALUE get_nsegment(VALUE self)
 	return value(THIS->nsegment());
 }
 
-static
-RUCY_DEF_clear_override_flags(cof, Reflex::EllipseShape);
-
 
 static Class cEllipseShape;
 
@@ -65,13 +89,16 @@ Init_ellipse_shape ()
 {
 	Module mReflex = rb_define_module("Reflex");
 
-	cEllipseShape = mReflex.define_class("EllipseShape", Reflex::shape_view_class());
+	cEllipseShape = mReflex.define_class("EllipseShape", Reflex::shape_class());
 	rb_define_alloc_func(cEllipseShape, alloc);
-	rb_define_private_method(cEllipseShape, "radius_min=", RUBY_METHOD_FUNC(set_radius_min), 1);
-	rb_define_method(cEllipseShape, "radius_min", RUBY_METHOD_FUNC(get_radius_min), 0);
-	rb_define_private_method(cEllipseShape, "nsegment=", RUBY_METHOD_FUNC(set_nsegment), 1);
+	rb_define_method(cEllipseShape, "angle_from=", RUBY_METHOD_FUNC(set_angle_from), 1);
+	rb_define_method(cEllipseShape, "angle_from", RUBY_METHOD_FUNC(get_angle_from), 0);
+	rb_define_method(cEllipseShape, "angle_to=", RUBY_METHOD_FUNC(set_angle_to), 1);
+	rb_define_method(cEllipseShape, "angle_to", RUBY_METHOD_FUNC(get_angle_to), 0);
+	rb_define_method(cEllipseShape, "hole_size=", RUBY_METHOD_FUNC(set_hole_size), -1);
+	rb_define_method(cEllipseShape, "hole_size", RUBY_METHOD_FUNC(get_hole_size), 0);
+	rb_define_method(cEllipseShape, "nsegment=", RUBY_METHOD_FUNC(set_nsegment), 1);
 	rb_define_method(cEllipseShape, "nsegment", RUBY_METHOD_FUNC(get_nsegment), 0);
-	
 }
 
 

data/.doc/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/.doc/ext/reflex/filter.cpp

@@ -0,0 +1,81 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyFilter<Reflex::Filter>, klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE arg)
+{
+	CHECK;
+
+	THIS->set_shader(to<Rays::Shader>(arg));
+}
+
+static
+VALUE apply(VALUE self, VALUE painter, VALUE image)
+{
+	CHECK;
+	CALL(apply(to<Rays::Painter*>(painter), to<const Rays::Image&>(image)));
+}
+
+static
+VALUE set_shader(VALUE self, VALUE shader)
+{
+	CHECK;
+	THIS->set_shader(to<Rays::Shader>(shader));
+}
+
+static
+VALUE get_shader(VALUE self)
+{
+	CHECK;
+	return value(THIS->shader());
+}
+
+
+static Class cFilter;
+
+void
+Init_filter ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cFilter = rb_define_class_under(mReflex, "Filter", rb_cObject);
+	rb_define_alloc_func(cFilter, alloc);
+	rb_define_private_method(cFilter, "initialize", RUBY_METHOD_FUNC(initialize), 1);
+	rb_define_method(cFilter, "apply", RUBY_METHOD_FUNC(apply), 2);
+	rb_define_method(cFilter, "shader=", RUBY_METHOD_FUNC(set_shader), 1);
+	rb_define_method(cFilter, "shader", RUBY_METHOD_FUNC(get_shader), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	filter_class ()
+	{
+		return cFilter;
+	}
+
+
+}// Reflex

data/.doc/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)
@@ -23,13 +19,13 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self, VALUE type, VALUE focus, VALUE last)
+VALUE initialize(VALUE self, VALUE type, VALUE current, VALUE 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);
 }
@@ -43,17 +39,17 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE get_type(VALUE self)
+VALUE type(VALUE self)
 {
 	CHECK;
 	return value(THIS->type);
 }
 
 static
-VALUE focus(VALUE self)
+VALUE current(VALUE self)
 {
 	CHECK;
-	return THIS->focus ? value(THIS->focus) : nil();
+	return THIS->current ? value(THIS->current) : nil();
 }
 
 static
@@ -75,8 +71,8 @@ Init_focus_event ()
 	rb_define_alloc_func(cFocusEvent, alloc);
 	rb_define_private_method(cFocusEvent, "initialize", RUBY_METHOD_FUNC(initialize), 3);
 	rb_define_private_method(cFocusEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cFocusEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
-	rb_define_method(cFocusEvent, "focus", RUBY_METHOD_FUNC(focus), 0);
+	rb_define_method(cFocusEvent, "type", RUBY_METHOD_FUNC(type), 0);
+	rb_define_method(cFocusEvent, "current", RUBY_METHOD_FUNC(current), 0);
 	rb_define_method(cFocusEvent, "last", RUBY_METHOD_FUNC(last), 0);
 	cFocusEvent.define_const("TYPE_NONE",  Reflex::FocusEvent::NONE);
 	cFocusEvent.define_const("TYPE_FOCUS", Reflex::FocusEvent::FOCUS);

data/.doc/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)
@@ -97,6 +91,41 @@ VALUE dsize(VALUE self)
 	return value(Rays::Point(THIS->dw, THIS->dh));
 }
 
+static
+VALUE angle(VALUE self)
+{
+	CHECK;
+	return value(THIS->angle);
+}
+
+static
+VALUE dangle(VALUE self)
+{
+	CHECK;
+	return value(THIS->dangle);
+}
+
+static
+VALUE is_move(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_move());
+}
+
+static
+VALUE is_resize(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_resize());
+}
+
+static
+VALUE is_rotate(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_rotate());
+}
+
 
 static Class cFrameEvent;
 
@@ -116,6 +145,11 @@ Init_frame_event ()
 	rb_define_method(cFrameEvent, "dheight", RUBY_METHOD_FUNC(dheight), 0);
 	rb_define_method(cFrameEvent, "dposition", RUBY_METHOD_FUNC(dposition), 0);
 	rb_define_method(cFrameEvent, "dsize", RUBY_METHOD_FUNC(dsize), 0);
+	rb_define_method(cFrameEvent, "angle", RUBY_METHOD_FUNC(angle), 0);
+	rb_define_method(cFrameEvent, "dangle", RUBY_METHOD_FUNC(dangle), 0);
+	cFrameEvent.define_method("move?",   is_move);
+	cFrameEvent.define_method("resize?", is_resize);
+	cFrameEvent.define_method("rotate?", is_rotate);
 }
 
 

data/.doc/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)
@@ -42,9 +37,6 @@ VALUE set_image(VALUE self, VALUE image)
 	return image;
 }
 
-static
-RUCY_DEF_clear_override_flags(cof, Reflex::ImageView);
-
 
 static Class cImageView;
 
@@ -57,7 +49,6 @@ Init_image_view ()
 	rb_define_alloc_func(cImageView, alloc);
 	rb_define_private_method(cImageView, "set_image", RUBY_METHOD_FUNC(set_image), 1);
 	rb_define_method(cImageView, "image", RUBY_METHOD_FUNC(get_image), 0);
-	
 }
 
 

data/.doc/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)
@@ -45,7 +41,7 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE get_type(VALUE self)
+VALUE type(VALUE self)
 {
 	CHECK;
 	return value(THIS->type);
@@ -98,7 +94,7 @@ Init_key_event ()
 	rb_define_alloc_func(cKeyEvent, alloc);
 	rb_define_private_method(cKeyEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cKeyEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cKeyEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_method(cKeyEvent, "type", RUBY_METHOD_FUNC(type), 0);
 	rb_define_method(cKeyEvent, "chars", RUBY_METHOD_FUNC(chars), 0);
 	rb_define_method(cKeyEvent, "code", RUBY_METHOD_FUNC(code), 0);
 	rb_define_method(cKeyEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);

data/.doc/ext/reflex/line_shape.cpp

@@ -0,0 +1,99 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyShape<Reflex::LineShape>, klass);
+}
+
+static
+VALUE add_point(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "LineShape#add_point", argc, 1, 2, 3);
+
+	THIS->add_point(to<Rays::Point>(argc, argv));
+	return self;
+}
+
+static
+VALUE add_points(VALUE self)
+{
+	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;
+}
+
+static
+VALUE set_loop(VALUE self, VALUE loop)
+{
+	CHECK;
+	THIS->set_loop(loop);
+	return loop;
+}
+
+static
+VALUE get_loop(VALUE self)
+{
+	CHECK;
+	return value(THIS->loop());
+}
+
+
+static Class cLineShape;
+
+void
+Init_line_shape ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cLineShape = mReflex.define_class("LineShape", Reflex::shape_class());
+	rb_define_alloc_func(cLineShape, alloc);
+	rb_define_method(cLineShape, "add_point", RUBY_METHOD_FUNC(add_point), -1);
+	rb_define_method(cLineShape, "add_points", RUBY_METHOD_FUNC(add_points), -1);
+	rb_define_method(cLineShape, "loop=", RUBY_METHOD_FUNC(set_loop), 1);
+	rb_define_method(cLineShape, "loop", RUBY_METHOD_FUNC(get_loop), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	line_shape_class ()
+	{
+		return cLineShape;
+	}
+
+
+}// Reflex