reflexion 0.1.7 → 0.1.8

data/.doc/ext/reflex/style_length2.cpp

@@ -8,13 +8,11 @@
 using namespace Rucy;
 
 
-static Class cStyleLength2;
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::StyleLength2, cStyleLength2)
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::StyleLength2)
 
 #define THIS  to<Reflex::StyleLength2*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::StyleLength2, cStyleLength2, self)
+#define CHECK RUCY_CHECK_OBJ(Reflex::StyleLength2, self)
 
 
 static
@@ -88,6 +86,8 @@ VALUE get_at(VALUE self, VALUE index)
 }
 
 
+static Class cStyleLength2;
+
 void
 Init_style_length2 ()
 {

data/.doc/ext/reflex/style_length4.cpp

@@ -8,13 +8,11 @@
 using namespace Rucy;
 
 
-static Class cStyleLength4;
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::StyleLength4, cStyleLength4)
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::StyleLength4)
 
 #define THIS  to<Reflex::StyleLength4*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::StyleLength4, cStyleLength4, self)
+#define CHECK RUCY_CHECK_OBJ(Reflex::StyleLength4, self)
 
 
 static
@@ -116,6 +114,8 @@ VALUE get_at(VALUE self, VALUE index)
 }
 
 
+static Class cStyleLength4;
+
 void
 Init_style_length4 ()
 {

data/.doc/ext/reflex/update_event.cpp

@@ -8,13 +8,11 @@
 using namespace Rucy;
 
 
-static Class cUpdateEvent;
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::UpdateEvent, cUpdateEvent)
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::UpdateEvent)
 
 #define THIS  to<Reflex::UpdateEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::UpdateEvent, cUpdateEvent, self)
+#define CHECK RUCY_CHECK_OBJ(Reflex::UpdateEvent, self)
 
 
 static
@@ -50,6 +48,8 @@ VALUE dt(VALUE self)
 }
 
 
+static Class cUpdateEvent;
+
 void
 Init_update_event ()
 {

data/.doc/ext/reflex/view.cpp

@@ -8,6 +8,7 @@
 #include "reflex/ruby/window.h"
 #include "reflex/ruby/selector.h"
 #include "reflex/ruby/style.h"
+#include "reflex/ruby/body.h"
 
 
 using namespace Rucy;
@@ -15,13 +16,11 @@ using namespace Rucy;
 using Reflex::coord;
 
 
-static Class cView;
-
-RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::View, cView)
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::View)
 
 #define THIS      to<Reflex::View*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::View, cView, self)
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::View, self)
 
 #define CALL(fun) RUCY_WRAPPER_CALL(Reflex::View, THIS, fun)
 
@@ -46,7 +45,7 @@ static
 VALUE show(VALUE self)
 {
 	CHECK;
-	CALL(show());
+	THIS->show();
 	return self;
 }
 
@@ -54,7 +53,7 @@ static
 VALUE hide(VALUE self)
 {
 	CHECK;
-	CALL(hide());
+	THIS->hide();
 	return self;
 }
 
@@ -209,6 +208,20 @@ VALUE content_size(VALUE self)
 	return value(THIS->content_size());
 }
 
+static
+VALUE make_body(VALUE self)
+{
+	CHECK;
+	CALL(make_body());
+}
+
+static
+VALUE clear_body(VALUE self)
+{
+	CHECK;
+	THIS->clear_body();
+}
+
 static
 VALUE set_name(VALUE self, VALUE name)
 {
@@ -351,6 +364,67 @@ VALUE window(VALUE self)
 	return value(THIS->window());
 }
 
+static
+VALUE body(VALUE self)
+{
+	CHECK;
+	return value(THIS->body());
+}
+
+static
+VALUE set_density(VALUE self, VALUE value)
+{
+	CHECK;
+	THIS->set_density(value.as_f(true));
+	return value;
+}
+
+static
+VALUE set_friction(VALUE self, VALUE value)
+{
+	CHECK;
+	THIS->set_friction(value.as_f(true));
+	return value;
+}
+
+static
+VALUE set_restitution(VALUE self, VALUE value)
+{
+	CHECK;
+	THIS->set_restitution(value.as_f(true));
+	return value;
+}
+
+static
+VALUE set_gravity(VALUE self, VALUE x, VALUE y)
+{
+	CHECK;
+	THIS->set_gravity(x.as_f(true), y.as_f(true));
+	return self;
+}
+
+static
+VALUE get_gravity(VALUE self)
+{
+	CHECK;
+	return value(THIS->gravity());
+}
+
+static
+VALUE set_debug(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->set_debug(state);
+	return state;
+}
+
+static
+VALUE is_debug(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_debug());
+}
+
 static
 VALUE on_attach(VALUE self, VALUE event)
 {
@@ -365,6 +439,20 @@ VALUE on_detach(VALUE self, VALUE event)
 	CALL(on_detach(to<Reflex::Event*>(event)));
 }
 
+static
+VALUE on_show(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_show(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_hide(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_hide(to<Reflex::Event*>(event)));
+}
+
 static
 VALUE on_update(VALUE self, VALUE event)
 {
@@ -478,9 +566,11 @@ VALUE on_capture(VALUE self, VALUE event)
 }
 
 static
-RUCY_DEF_clear_override_flags(cof, Reflex::View, cView);
+RUCY_DEF_clear_override_flags(cof, Reflex::View);
 
 
+static Class cView;
+
 void
 Init_view ()
 {
@@ -506,6 +596,8 @@ Init_view ()
 	cView.define_method("focus?", has_focus);
 	rb_define_method(cView, "resize_to_fit", RUBY_METHOD_FUNC(resize_to_fit), 0);
 	rb_define_method(cView, "content_size", RUBY_METHOD_FUNC(content_size), 0);
+	rb_define_method(cView, "make_body", RUBY_METHOD_FUNC(make_body), 0);
+	rb_define_method(cView, "clear_body", RUBY_METHOD_FUNC(clear_body), 0);
 	rb_define_method(cView, "name=", RUBY_METHOD_FUNC(set_name), 1);
 	rb_define_method(cView, "name", RUBY_METHOD_FUNC(get_name), 0);
 	rb_define_method(cView, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
@@ -522,8 +614,18 @@ Init_view ()
 	rb_define_method(cView, "get_capture", RUBY_METHOD_FUNC(get_capture), 0);
 	rb_define_method(cView, "parent", RUBY_METHOD_FUNC(parent), 0);
 	rb_define_method(cView, "window", RUBY_METHOD_FUNC(window), 0);
-	rb_define_method(cView, "on_attach", RUBY_METHOD_FUNC(on_attach), 1);
+	rb_define_method(cView, "body", RUBY_METHOD_FUNC(body), 0);
+	rb_define_method(cView, "density=", RUBY_METHOD_FUNC(set_density), 1);
+	rb_define_method(cView, "friction=", RUBY_METHOD_FUNC(set_friction), 1);
+	rb_define_method(cView, "restitution=", RUBY_METHOD_FUNC(set_restitution), 1);
+	rb_define_method(cView, "set_gravity", RUBY_METHOD_FUNC(set_gravity), 2);
+	rb_define_method(cView, "gravity", RUBY_METHOD_FUNC(get_gravity), 0);
+	rb_define_method(cView, "debug=", RUBY_METHOD_FUNC(set_debug), 1);
+	cView.define_method("debug?",  is_debug);
+	cView.define_method("on_attach!", on_attach);
 	rb_define_method(cView, "on_detach", RUBY_METHOD_FUNC(on_detach), 1);
+	rb_define_method(cView, "on_show", RUBY_METHOD_FUNC(on_show), 1);
+	rb_define_method(cView, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
 	rb_define_method(cView, "on_update", RUBY_METHOD_FUNC(on_update), 1);
 	rb_define_method(cView, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
 	rb_define_method(cView, "on_move", RUBY_METHOD_FUNC(on_move), 1);

data/.doc/ext/reflex/wheel_event.cpp

@@ -11,13 +11,11 @@ using namespace Rucy;
 using Reflex::coord;
 
 
-static Class cWheelEvent;
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::WheelEvent, cWheelEvent)
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::WheelEvent)
 
 #define THIS  to<Reflex::WheelEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::WheelEvent, cWheelEvent, self)
+#define CHECK RUCY_CHECK_OBJ(Reflex::WheelEvent, self)
 
 
 static
@@ -111,6 +109,8 @@ VALUE position(VALUE self)
 }
 
 
+static Class cWheelEvent;
+
 void
 Init_wheel_event ()
 {

data/.doc/ext/reflex/window.cpp

@@ -12,13 +12,11 @@ using namespace Rucy;
 using Reflex::coord;
 
 
-static Class cWindow;
-
-RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Window, cWindow)
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Window)
 
 #define THIS      to<Reflex::Window*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::Window, cWindow, self)
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::Window, self)
 
 #define CALL(fun) RUCY_WRAPPER_CALL(Reflex::Window, THIS, fun)
 
@@ -30,26 +28,26 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE close(VALUE self)
+VALUE show(VALUE self)
 {
 	CHECK;
-	CALL(close());
+	THIS->show();
 	return self;
 }
 
 static
-VALUE show(VALUE self)
+VALUE hide(VALUE self)
 {
 	CHECK;
-	CALL(show());
+	THIS->hide();
 	return self;
 }
 
 static
-VALUE hide(VALUE self)
+VALUE close(VALUE self)
 {
 	CHECK;
-	CALL(hide());
+	THIS->close();
 	return self;
 }
 
@@ -118,6 +116,27 @@ VALUE painter(VALUE self)
 	return value(THIS->painter());
 }
 
+static
+VALUE on_show(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_show(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_hide(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_hide(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_close(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_close(to<Reflex::Event*>(event)));
+}
+
 static
 VALUE on_update(VALUE self, VALUE event)
 {
@@ -203,8 +222,10 @@ VALUE on_wheel(VALUE self, VALUE event)
 }
 
 static
-RUCY_DEF_clear_override_flags(cof, Reflex::Window, cWindow);
+RUCY_DEF_clear_override_flags(cof, Reflex::Window);
+
 
+static Class cWindow;
 
 void
 Init_window ()
@@ -213,9 +234,9 @@ Init_window ()
 
 	cWindow = rb_define_class_under(mReflex, "Window", rb_cObject);
 	rb_define_alloc_func(cWindow, alloc);
-	rb_define_method(cWindow, "close", RUBY_METHOD_FUNC(close), 0);
 	rb_define_method(cWindow, "show", RUBY_METHOD_FUNC(show), 0);
 	rb_define_method(cWindow, "hide", RUBY_METHOD_FUNC(hide), 0);
+	rb_define_method(cWindow, "close", RUBY_METHOD_FUNC(close), 0);
 	rb_define_method(cWindow, "redraw", RUBY_METHOD_FUNC(redraw), 0);
 	rb_define_method(cWindow, "title=", RUBY_METHOD_FUNC(set_title), 1);
 	rb_define_method(cWindow, "title", RUBY_METHOD_FUNC(get_title), 0);
@@ -225,6 +246,9 @@ Init_window ()
 	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(root), 0);
 	rb_define_method(cWindow, "focus", RUBY_METHOD_FUNC(focus), 0);
 	rb_define_method(cWindow, "painter", RUBY_METHOD_FUNC(painter), 0);
+	cWindow.define_method("on_show!", on_show);
+	rb_define_method(cWindow, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
+	rb_define_method(cWindow, "on_close", RUBY_METHOD_FUNC(on_close), 1);
 	rb_define_method(cWindow, "on_update", RUBY_METHOD_FUNC(on_update), 1);
 	rb_define_method(cWindow, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
 	rb_define_method(cWindow, "on_move", RUBY_METHOD_FUNC(on_move), 1);

data/README.md

@@ -1,4 +1,4 @@
 
-= Reflex - A Graphical User Interface Tool Kit.
+# Reflex - A Graphical User Interface Tool Kit.
 
-== by snori@xord.org
+## by snori@xord.org

data/Rakefile

@@ -17,6 +17,7 @@ include Xot::Rake
 MODULES     = [Xot, Rucy, Rays, Reflex].map {|m| m.const_get :Module}
 MODULE      = MODULES.last
 GEMNAME     = 'reflexion'
+INCDIRS     = ['src/physics']
 TESTS_ALONE = ['test/test_reflex.rb']
 
 
@@ -25,4 +26,4 @@ task :default => :build
 task :build => :ext
 
 
-MODULES.each {|m| m.load_tasks :lib, :ext, :test, :doc, :gem}
+MODULES.each {|m| m.load_tasks :lib, :ext, :test, :doc, :gem, :box2d}

data/VERSION

@@ -1 +1 @@
-0.1.7
+0.1.8

data/ext/reflex/application.cpp

@@ -8,13 +8,11 @@
 using namespace Rucy;
 
 
-static Class cApplication;
-
-RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Application, cApplication)
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Application)
 
 #define THIS      to<Reflex::Application*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::Application, cApplication, self)
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::Application, self)
 
 #define CALL(fun) RUCY_WRAPPER_CALL(Reflex::Application, THIS, fun)
 
@@ -101,6 +99,8 @@ RUCY_DEF0(instance)
 RUCY_END
 
 
+static Class cApplication;
+
 void
 Init_application ()
 {
@@ -109,13 +109,13 @@ Init_application ()
 	cApplication = mReflex.define_class("Application");
 	cApplication.define_alloc_func(alloc);
 	cApplication.define_method("start", start);
-	cApplication.define_method("quit", quit);
+	cApplication.define_method("quit",  quit);
 	cApplication.define_method("name=", set_name);
 	cApplication.define_method("name",  get_name);
-	cApplication.define_method("on_start", on_start);
-	cApplication.define_method("on_quit", on_quit);
+	cApplication.define_method("on_start!", on_start);
+	cApplication.define_method("on_quit",   on_quit);
 	cApplication.define_method("on_preference", on_preference);
-	cApplication.define_method("on_about", on_about);
+	cApplication.define_method("on_about",      on_about);
 	cApplication.define_singleton_method("instance", instance);
 }
 

data/ext/reflex/body.cpp

@@ -0,0 +1,181 @@
+#include "reflex/ruby/body.h"
+
+
+#include <rucy.h>
+#include "rays/ruby/point.h"
+#include "reflex/ruby/fixture.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::Body)
+
+#define THIS  to<Reflex::Body*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::Body, self)
+
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Body&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF2(add_box, width, height)
+{
+	CHECK;
+	return value(THIS->add_box(width.as_f(true), height.as_f(true)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(add_circle, size)
+{
+	CHECK;
+	return value(THIS->add_circle(size.as_f(true)));
+}
+RUCY_END
+
+static
+RUCY_DEF0(clear_fixtures)
+{
+	CHECK;
+	THIS->clear_fixtures();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_position)
+{
+	CHECK;
+	return value(THIS->position());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_angle)
+{
+	CHECK;
+	return value(THIS->angle());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_static, state)
+{
+	CHECK;
+	THIS->set_static(state);
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_static)
+{
+	CHECK;
+	return value(THIS->is_static());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_dynamic, state)
+{
+	CHECK;
+	THIS->set_dynamic(state);
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_dynamic)
+{
+	CHECK;
+	return value(THIS->is_dynamic());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_density, density)
+{
+	CHECK;
+	THIS->set_density(density.as_f(true));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_friction, friction)
+{
+	CHECK;
+	THIS->set_friction(friction.as_f(true));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_restitution, restitution)
+{
+	CHECK;
+	THIS->set_restitution(restitution.as_f(true));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(each)
+{
+	CHECK;
+
+	Value ret;
+	Reflex::Body::iterator end = THIS->end();
+	for (Reflex::Body::iterator it = THIS->begin(); it != end; ++it)
+		ret = rb_yield(value(*it));
+	return ret;
+}
+RUCY_END
+
+
+static Class cBody;
+
+void
+Init_body ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cBody = mReflex.define_class("Body");
+	cBody.define_private_method("initialize_copy", initialize_copy);
+	cBody.define_method("add_box",    add_box);
+	cBody.define_method("add_circle", add_circle);
+	cBody.define_method("clear_fixtures", clear_fixtures);
+	cBody.define_method("position", get_position);
+	cBody.define_method("angle",    get_angle);
+	cBody.define_method("static=", set_static);
+	cBody.define_method("static?",  is_static);
+	cBody.define_method("dynamic=", set_dynamic);
+	cBody.define_method("dynamic?",  is_dynamic);
+	cBody.define_method("density=",     set_density);
+	cBody.define_method("friction=",    set_friction);
+	cBody.define_method("restitution=", set_restitution);
+	cBody.define_method("each", each);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	body_class ()
+	{
+		return cBody;
+	}
+
+
+}// Reflex

data/ext/reflex/capture_event.cpp

@@ -9,13 +9,11 @@
 using namespace Rucy;
 
 
-static Class cCaptureEvent;
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::CaptureEvent, cCaptureEvent)
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::CaptureEvent)
 
 #define THIS  to<Reflex::CaptureEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::CaptureEvent, cCaptureEvent, self)
+#define CHECK RUCY_CHECK_OBJ(Reflex::CaptureEvent, self)
 
 
 static
@@ -64,6 +62,8 @@ RUCY_DEF0(end)
 RUCY_END
 
 
+static Class cCaptureEvent;
+
 void
 Init_capture_event ()
 {

data/ext/reflex/draw_event.cpp

@@ -10,13 +10,11 @@
 using namespace Rucy;
 
 
-static Class cDrawEvent;
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::DrawEvent, cDrawEvent)
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::DrawEvent)
 
 #define THIS  to<Reflex::DrawEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::DrawEvent, cDrawEvent, self)
+#define CHECK RUCY_CHECK_OBJ(Reflex::DrawEvent, self)
 
 
 static
@@ -80,6 +78,8 @@ RUCY_DEF0(fps)
 RUCY_END
 
 
+static Class cDrawEvent;
+
 void
 Init_draw_event ()
 {