reflexion 0.1.6 → 0.1.7

data/ext/reflex/capture_event.cpp

@@ -0,0 +1,92 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "rays/ruby/point.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cCaptureEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::CaptureEvent, cCaptureEvent)
+
+#define THIS  to<Reflex::CaptureEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::CaptureEvent, cCaptureEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::CaptureEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(initialize)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "CaptureEvent#initialize", argc, 0, 1, 2);
+
+	THIS->begin = (argc >= 1) ? to<uint>(argv[0]) : 0;
+	THIS->end   = (argc >= 2) ? to<uint>(argv[1]) : 0;
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::CaptureEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(begin)
+{
+	CHECK;
+	return value(THIS->begin);
+}
+RUCY_END
+
+static
+RUCY_DEF0(end)
+{
+	CHECK;
+	return value(THIS->end);
+}
+RUCY_END
+
+
+void
+Init_capture_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cCaptureEvent = mReflex.define_class("CaptureEvent", Reflex::event_class());
+	cCaptureEvent.define_alloc_func(alloc);
+	cCaptureEvent.define_private_method("initialize", initialize);
+	cCaptureEvent.define_private_method("initialize_copy", initialize_copy);
+	cCaptureEvent.define_private_method("get_begin", begin);
+	cCaptureEvent.define_private_method("get_end",   end);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	capture_event_class ()
+	{
+		return cCaptureEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/draw_event.cpp

@@ -0,0 +1,110 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include <rays/ruby/painter.h>
+#include <rays/ruby/bounds.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cDrawEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::DrawEvent, cDrawEvent)
+
+#define THIS  to<Reflex::DrawEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::DrawEvent, cDrawEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::DrawEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(initialize)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "DrawEvent#initialize", argc, 0, 1);
+
+	THIS->dt = (argc >= 1) ? argv[0].as_f() : 0;
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::DrawEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(painter)
+{
+	CHECK;
+	return value(THIS->painter);
+}
+RUCY_END
+
+static
+RUCY_DEF0(bounds)
+{
+	CHECK;
+	return value(THIS->bounds);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dt)
+{
+	CHECK;
+	return value(THIS->dt);
+}
+RUCY_END
+
+static
+RUCY_DEF0(fps)
+{
+	CHECK;
+	return value(THIS->fps);
+}
+RUCY_END
+
+
+void
+Init_draw_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cDrawEvent = mReflex.define_class("DrawEvent", Reflex::event_class());
+	cDrawEvent.define_alloc_func(alloc);
+	cDrawEvent.define_private_method("initialize", initialize);
+	cDrawEvent.define_private_method("initialize_copy", initialize_copy);
+	cDrawEvent.define_method("painter", painter);
+	cDrawEvent.define_method("bounds", bounds);
+	cDrawEvent.define_method("dt", dt);
+	cDrawEvent.define_method("fps", fps);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	draw_event_class ()
+	{
+		return cDrawEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/event.cpp

@@ -0,0 +1,77 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::Event, cEvent)
+
+#define THIS  to<Reflex::Event*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::Event, cEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::Event>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Event&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(block)
+{
+	CHECK;
+	THIS->block();
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_blocked)
+{
+	CHECK;
+	return value(THIS->is_blocked());
+}
+RUCY_END
+
+
+void
+Init_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cEvent = mReflex.define_class("Event");
+	cEvent.define_alloc_func(alloc);
+	cEvent.define_private_method("initialize_copy", initialize_copy);
+	cEvent.define_method("block", block);
+	cEvent.define_method("block?", is_blocked);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	event_class ()
+	{
+		return cEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/extconf.rb

@@ -1,82 +1,32 @@
 # -*- 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 'mkmf'
-require 'xot/rake'
+require 'xot/extconf'
 require 'xot/module'
 require 'rucy/module'
 require 'rays/module'
 require 'reflex/module'
 
-include Xot::Rake
 
+Xot::ExtConf.new Xot, Rucy, Rays, Reflex do
+  setup do
+    headers    << 'boost/scoped_array.hpp' << 'boost/shared_ptr.hpp' << 'ruby.h'
+    local_libs << 'rucy'
+    libs.unshift 'gdi21', 'opengl32' if win32?
+    frameworks << 'Cocoa' if osx?
+    $LDFLAGS   << ' -Wl,--out-implib=native.dll.a' if cygwin?
 
-debug = env :DEBUG, false
+    unless osx?
+      lib_dirs << Rays::Module.lib_dir
+      libs     << 'rays/native'
+    end
+  end
 
-
-DEFS    = []
-INCDIRS = %w[
-  /opt/local/include
-  /opt/include
-]
-LIBDIRS = []
-
-HEADERS    = %w[
-  boost/shared_ptr.hpp
-  boost/scoped_array.hpp
-  ruby.h
-  xot.h
-  rucy.h
-  rays.h
-  reflex.h
-]
-LIBS = %w[
-  stdc++
-  xot
-  rucy
-  rays
-  reflex
-]
-FRAMEWORKS = []
-
-
-DEFS << '_DEBUG' if debug
-DEFS << 'NDEBUG' unless debug
-DEFS << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
-LIBDIRS.concat Rays.lib_dirs
-LIBS << 'rays/native' unless cocoa?
-if win32?
-  DEFS << 'WINDOWS' << 'WIN32'
-  LIBS.unshift 'gdi32', 'opengl32'
-elsif cocoa?
-  DEFS << 'COCOA'
-  FRAMEWORKS << 'Cocoa'# << 'OpenGL'
-end
-
-$CPPFLAGS   << DEFS.map       {|s| " -D#{s}"}.join
-$CPPFLAGS   << INCDIRS.map    {|s| " -I#{s}"}.join
-$LDFLAGS    << LIBDIRS.map    {|s| " -L#{s}"}.join
-$LDFLAGS    << FRAMEWORKS.map {|s| " -framework #{s}"}.join
-$LDFLAGS    << ' -Wl,--out-implib=native.dll.a' if cygwin?
-$CFLAGS     << ' --stdlib=libc++' if clang?
-$LOCAL_LIBS << ' -lrucy'
-
-RbConfig::CONFIG.each do |key, val|
-  {'gcc' => 'g++', 'clang' => 'clang++'}.each {|from, to| val.gsub! from, to}
+  dir_config 'boost'
+  create_makefile 'reflex/native'
 end
-
-
-dir_config 'boost'
-dir_config 'xot',    Xot.root_dir
-dir_config 'rucy',   Rucy.root_dir
-dir_config 'rays',   Rays.root_dir
-dir_config 'reflex', Reflex.root_dir
-
-exit 1 unless HEADERS.all? {|s| have_header(s)}
-exit 1 unless LIBS.all?    {|s| have_library(s)}
-
-
-create_makefile 'reflex/native'

data/ext/reflex/focus_event.cpp

@@ -0,0 +1,104 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "reflex/ruby/view.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cFocusEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::FocusEvent, cFocusEvent)
+
+#define THIS  to<Reflex::FocusEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::FocusEvent, cFocusEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::FocusEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF3(initialize, type, focus, last)
+{
+	CHECK;
+
+	THIS->focus = to<Reflex::View*>(focus);
+	THIS->focus = to<Reflex::View*>(focus);
+	THIS->last  = to<Reflex::View*>(last);
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::FocusEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_type)
+{
+	CHECK;
+	return value(THIS->type);
+}
+RUCY_END
+
+static
+RUCY_DEF0(focus)
+{
+	CHECK;
+	return THIS->focus ? value(THIS->focus) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF0(last)
+{
+	CHECK;
+	return THIS->last ? value(THIS->last) : nil();
+}
+RUCY_END
+
+
+void
+Init_focus_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cFocusEvent = mReflex.define_class("FocusEvent", Reflex::event_class());
+	cFocusEvent.define_alloc_func(alloc);
+	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_const("TYPE_NONE",  Reflex::FocusEvent::NONE);
+	cFocusEvent.define_const("TYPE_FOCUS", Reflex::FocusEvent::FOCUS);
+	cFocusEvent.define_const("TYPE_BLUR",  Reflex::FocusEvent::BLUR);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	focus_event_class ()
+	{
+		return cFocusEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/frame_event.cpp

@@ -0,0 +1,143 @@
+#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;
+
+
+static Class cFrameEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::FrameEvent, cFrameEvent)
+
+#define THIS  to<Reflex::FrameEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::FrameEvent, cFrameEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::FrameEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(initialize)
+{
+	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;
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::FrameEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(frame)
+{
+	CHECK;
+	return value(THIS->frame);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dx)
+{
+	CHECK;
+	return value(THIS->dx);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dy)
+{
+	CHECK;
+	return value(THIS->dy);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dwidth)
+{
+	CHECK;
+	return value(THIS->dwidth);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dheight)
+{
+	CHECK;
+	return value(THIS->dheight);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dposition)
+{
+	CHECK;
+	return value(Rays::Point(THIS->dx, THIS->dy));
+}
+RUCY_END
+
+static
+RUCY_DEF0(dsize)
+{
+	CHECK;
+	return value(Rays::Point(THIS->dw, THIS->dh));
+}
+RUCY_END
+
+
+void
+Init_frame_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cFrameEvent = mReflex.define_class("FrameEvent", Reflex::event_class());
+	cFrameEvent.define_alloc_func(alloc);
+	cFrameEvent.define_private_method("initialize", initialize);
+	cFrameEvent.define_private_method("initialize_copy", initialize_copy);
+	cFrameEvent.define_method("frame", frame);
+	cFrameEvent.define_method("dx", dx);
+	cFrameEvent.define_method("dy", dy);
+	cFrameEvent.define_method("dwidth",  dwidth);
+	cFrameEvent.define_method("dheight", dheight);
+	cFrameEvent.define_method("dposition", dposition);
+	cFrameEvent.define_method("dsize",     dsize);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	frame_event_class ()
+	{
+		return cFrameEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/image_view.cpp

@@ -0,0 +1,77 @@
+#include "reflex/ruby/image_view.h"
+
+
+#include <rucy.h>
+#include "reflex/ruby/view.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+static Class cImageView;
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::ImageView, cImageView)
+
+#define THIS      to<Reflex::ImageView*>(self)
+
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::ImageView, cImageView, self)
+
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::ImageView, THIS, fun)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyView<Reflex::ImageView>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_image)
+{
+	CHECK;
+	Rays::Image image = THIS->get_image();
+	return image ? value(image) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_image, image)
+{
+	CHECK;
+	THIS->set_image(image ? to<Rays::Image&>(image) : Rays::Image());
+	return image;
+}
+RUCY_END
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::ImageView, cImageView);
+
+
+void
+Init_image_view ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cImageView = mReflex.define_class("ImageView", Reflex::view_class());
+	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);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	image_view_class ()
+	{
+		return cImageView;
+	}
+
+
+}// Reflex