reflexion 0.1.1

data/ext/reflex/window.cpp

@@ -0,0 +1,357 @@
+#include "reflex/ruby/window.h"
+
+
+#include <rucy.h>
+#include <reflex/ruby/key.h>
+#include <reflex/ruby/points.h>
+#include "reflex.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+namespace Reflex
+{
+
+
+	Class
+	window_class ()
+	{
+		static Class c = reflex_module().define_class("Window");
+		return c;
+	}
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Reflex::Window& window)
+	{
+		return new_type<Reflex::Window>(
+			Reflex::window_class(), new Reflex::Window(window));
+	}
+
+
+}// Rucy
+
+
+class RubyWindow : public Reflex::Window
+{
+
+	public:
+
+		typedef Reflex::Window Super;
+
+		Value self;
+
+		void mark ()
+		{
+			self.mark();
+		}
+
+		virtual bool close ()
+		{
+			SYM(close);
+			return self.call(close);
+		}
+
+		virtual bool show ()
+		{
+			SYM(show);
+			return self.call(show);
+		}
+
+		virtual bool hide ()
+		{
+			SYM(hide);
+			return self.call(hide);
+		}
+
+		virtual void update ()
+		{
+			SYM(update);
+			self.call(update);
+		}
+
+		virtual void draw ()
+		{
+			SYM(draw);
+			self.call(draw);
+		}
+
+		virtual void moved (coord x, coord y)
+		{
+			SYM(moved);
+			self.call(moved, x, y);
+		}
+
+		virtual void resized (coord width, coord height)
+		{
+			SYM(resized);
+			self.call(resized, width, height);
+		}
+
+		virtual void key_down (const Reflex::Key& key)
+		{
+			SYM(key_down);
+			self.call(key_down, value(key));
+		}
+
+		virtual void key_up (const Reflex::Key& key)
+		{
+			SYM(key_up);
+			self.call(key_up, value(key));
+		}
+
+		virtual void points_down (const Reflex::Points& points)
+		{
+			SYM(points_down);
+			self.call(points_down, value(points));
+		}
+
+		virtual void points_up (const Reflex::Points& points)
+		{
+			SYM(points_up);
+			self.call(points_up, value(points));
+		}
+
+		virtual void points_moved (const Reflex::Points& points)
+		{
+			SYM(points_moved);
+			self.call(points_moved, value(points));
+		}
+
+};// RubyWindow
+
+
+#define this ((RubyWindow*) to<Reflex::Window*>(self))
+
+#define CHECK CHECK_OBJECT(self, RubyWindow, Reflex::window_class())
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	RubyWindow* win = new RubyWindow;
+	return win->self = new_type<RubyWindow>(klass, win, mark_type<RubyWindow>);
+}
+RUBY_END
+
+static
+RUBY_DEF0(close)
+{
+	CHECK;
+	if (!this->Super::close())
+		system_error("failed to close window.");
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(show)
+{
+	CHECK;
+	if (!this->Super::show())
+		system_error("failed to show window.");
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(hide)
+{
+	CHECK;
+	if (!this->Super::hide())
+		system_error("failed to hide window.");
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(hidden)
+{
+	CHECK;
+	return value(this->hidden());
+}
+RUBY_END
+
+static
+RUBY_DEF0(update)
+{
+	CHECK;
+	this->Super::update();
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(draw)
+{
+	CHECK;
+	this->Super::draw();
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(redraw)
+{
+	CHECK;
+	if (!this->Super::redraw())
+		system_error("failed to redraw window.");
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_title)
+{
+	CHECK;
+	String s;
+	if (!this->get_title(&s))
+		system_error("failed to get title of window.");
+	return value(s.c_str());
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_title, title)
+{
+	CHECK;
+	if (!this->set_title(title.c_str()))
+		system_error("failed to set title of window.");
+	return title;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_bounds)
+{
+	CHECK;
+	coord x = 0, y = 0, width = 0, height = 0;
+	if (!this->get_bounds(&x, &y, &width, &height))
+		system_error("failed to get bounds of window.");
+	Value ret[] = {x, y, width, height};
+	return value(4, ret);
+}
+RUBY_END
+
+static
+RUBY_DEF4(set_bounds, x, y, width, height)
+{
+	CHECK;
+	if (!this->set_bounds(
+		to<coord>(x), to<coord>(y), to<coord>(width), to<coord>(height)))
+	{
+		system_error("failed to set bounds of window.");
+	}
+	Value ret[] = {x, y, width, height};
+	return value(4, ret);
+}
+RUBY_END
+
+static
+RUBY_DEF2(moved, x, y)
+{
+	CHECK;
+	this->Super::moved(to<coord>(x), to<coord>(y));
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF2(resized, width, height)
+{
+	CHECK;
+	this->Super::resized(to<coord>(width), to<coord>(height));
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(key_down, key)
+{
+	CHECK;
+	Reflex::Key* k = to<Reflex::Key*>(key);
+	if (!k) argument_error();
+	this->Super::key_down(*k);
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(key_up, key)
+{
+	CHECK;
+	Reflex::Key* k = to<Reflex::Key*>(key);
+	if (!k) argument_error();
+	this->Super::key_up(*k);
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(points_down, points)
+{
+	CHECK;
+	Reflex::Points* p = to<Reflex::Points*>(points);
+	if (!p) argument_error();
+	this->Super::points_down(*p);
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(points_up, points)
+{
+	CHECK;
+	Reflex::Points* p = to<Reflex::Points*>(points);
+	if (!p) argument_error();
+	this->Super::points_up(*p);
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(points_moved, points)
+{
+	CHECK;
+	Reflex::Points* p = to<Reflex::Points*>(points);
+	if (!p) argument_error();
+	this->Super::points_moved(*p);
+	return self;
+}
+RUBY_END
+
+
+void
+Init_window ()
+{
+	Reflex::window_class()
+		.define_alloc_func(alloc)
+		.define_method("close",  close)
+		.define_method("show",   show)
+		.define_method("hide",   hide)
+		.define_method("hidden", hidden)
+		.define_method("update", update)
+		.define_method("draw",   draw)
+		.define_method("redraw", redraw)
+		.define_method("title",  get_title)
+		.define_method("title=", set_title)
+		.define_private_method("get_bounds", get_bounds)
+		.define_private_method("set_bounds", set_bounds)
+		.define_method("moved",   moved)
+		.define_method("resized", resized)
+		.define_method("key_down", key_down)
+		.define_method("key_up",   key_up)
+		.define_method("points_down", points_down)
+		.define_method("points_up",   points_up)
+		.define_method("points_moved", points_moved);
+}

data/include/reflex/application.h

@@ -0,0 +1,50 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_APPLICATION_H__
+#define __REFLEX_APPLICATION_H__
+
+
+#include <reflex/defs.h>
+#include <reflex/helpers.h>
+
+
+namespace Reflex
+{
+
+
+	class Application
+	{
+
+		public:
+
+			Application ();
+
+			virtual ~Application ();
+
+			virtual bool run ();
+
+			virtual bool quit ();
+
+			virtual bool preference ();
+
+			virtual bool about ();
+
+			virtual bool get_name (String* name) const;
+
+			virtual bool set_name (const char* name);
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Impl<Data> self;
+
+	};// Application
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/defs.h

@@ -0,0 +1,258 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_DEFS_H__
+#define __REFLEX_DEFS_H__
+
+
+#include <string>
+#include <vector>
+
+
+namespace Reflex
+{
+
+
+	typedef unsigned char  uchar;
+
+	typedef unsigned short ushort;
+
+	typedef unsigned int   uint;
+
+	typedef unsigned long  ulong;
+
+	typedef float coord;
+
+	typedef std::string String;
+
+
+	enum {UNKNOWN = 0};
+
+
+	enum KeyCodes
+	{
+
+		KEY_NONE = UNKNOWN,
+
+		KEY_RETURN,
+		KEY_ENTER = KEY_RETURN,
+		KEY_ESCAPE,
+		KEY_SPACE,
+		KEY_BACKSPACE,
+		KEY_TAB,
+
+		KEY_LEFT,
+		KEY_UP,
+		KEY_RIGHT,
+		KEY_DOWN,
+
+		KEY_INSERT,
+		KEY_DELETE,
+		KEY_HOME,
+		KEY_END,
+		KEY_PAGEUP,
+		KEY_PAGEDOWN,
+
+		KEY_SHIFT,
+		KEY_LSHIFT,
+		KEY_RSHIFT,
+
+		KEY_CONTROL,
+		KEY_LCONTROL,
+		KEY_RCONTROL,
+
+		KEY_ALT,
+		KEY_LALT,
+		KEY_RALT,
+
+		KEY_OPTION  = KEY_ALT,
+		KEY_LOPTION = KEY_LALT,
+		KEY_ROPTION = KEY_RALT,
+
+		KEY_COMMAND,
+		KEY_LCOMMAND,
+		KEY_RCOMMAND,
+
+		KEY_WIN,
+		KEY_LWIN,
+		KEY_RWIN,
+
+		KEY_CAPSLOCK,
+		KEY_NUMLOCK,
+		KEY_SCROLLLOCK,
+
+		KEY_PRINTSCREEN,
+		KEY_PAUSE,
+
+		KEY_KANA,
+		KEY_KANJI,
+
+		KEY_SLEEP,
+		KEY_EXECUTE,
+		KEY_HELP,
+		KEY_PRINT,
+		KEY_APPS,
+		KEY_SELECT,
+		KEY_ACCEPT,
+		KEY_CANCEL,
+		KEY_CLEAR,
+		KEY_FINAL,
+		KEY_CONVERT,
+		KEY_NONCONVERT,
+		KEY_MODECHANGE,
+		KEY_JUNJA,
+
+		KEY_F1,
+		KEY_F2,
+		KEY_F3,
+		KEY_F4,
+		KEY_F5,
+		KEY_F6,
+		KEY_F7,
+		KEY_F8,
+		KEY_F9,
+		KEY_F10,
+		KEY_F11,
+		KEY_F12,
+		KEY_F13,
+		KEY_F14,
+		KEY_F15,
+		KEY_F16,
+		KEY_F17,
+		KEY_F18,
+		KEY_F19,
+		KEY_F20,
+		KEY_F21,
+		KEY_F22,
+		KEY_F23,
+		KEY_F24,
+		KEY_F25,
+		KEY_F26,
+		KEY_F27,
+		KEY_F28,
+		KEY_F29,
+		KEY_F30,
+		KEY_F31,
+		KEY_F32,
+		KEY_F33,
+		KEY_F34,
+		KEY_F35,
+
+	};// KeyCodes
+
+
+	enum PointTypes
+	{
+
+		POINT_NONE         = UNKNOWN,
+
+		POINT_MOUSE_LEFT   = 0x1 << 0,
+
+		POINT_MOUSE_RIGHT  = 0x1 << 1,
+
+		POINT_MOUSE_MIDDLE = 0x1 << 2,
+
+		POINT_TOUCH        = 0x1 << 3,
+
+		MOUSE_LEFT         = POINT_MOUSE_LEFT,
+
+		MOUSE_RIGHT        = POINT_MOUSE_RIGHT,
+
+		MOUSE_MIDDLE       = POINT_MOUSE_MIDDLE
+
+	};// PointTypes
+
+
+	enum Modifiers
+	{
+
+		MOD_NONE     = UNKNOWN,
+
+		MOD_SHIFT    = 0x1 << 0,
+
+		MOD_CONTROL  = 0x1 << 1,
+
+		MOD_ALT      = 0x1 << 2,
+
+		MOD_OPTION   = MOD_ALT,
+
+		MOD_COMMAND  = 0x1 << 3,
+
+		MOD_HELP     = 0x1 << 4,
+
+		MOD_FUNCTION = 0x1 << 5,
+
+		MOD_NUMPAD   = 0x1 << 6,
+
+		MOD_CAPS     = 0x1 << 7,
+
+	};// Modifiers
+
+
+	struct Key
+	{
+
+		String chars;
+
+		int code, repeat;
+
+		uint modifiers;
+
+		Key ();
+
+		Key (
+			const char* chars, int code,
+			uint modifiers = 0, int repeat = 0);
+
+	};// Key
+
+
+	struct Points
+	{
+
+		struct Point
+		{
+
+			coord x, y;
+
+		};// Point
+
+		enum {MAX = 10};
+
+		int type;
+
+		size_t size;
+
+		uint modifiers, count;
+
+		bool drag;
+
+		union
+		{
+
+			struct {coord x, y;};
+
+			Point points[MAX];
+
+		};
+
+		Points ();
+
+		Points (
+			int type, coord x, coord y,
+			uint modifiers = 0, uint count = 1, bool drag = false);
+
+		Points (
+			int type, const Point* points, size_t size,
+			uint modifiers = 0, uint count = 1, bool drag = false);
+
+		      Point& operator [] (size_t i)       {return points[i];}
+
+		const Point& operator [] (size_t i) const {return points[i];}
+
+	};// Points
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/helpers.h

@@ -0,0 +1,32 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_HELPERS_H__
+#define __REFLEX_HELPERS_H__
+
+
+#include <boost/shared_ptr.hpp>
+
+
+namespace Reflex
+{
+
+
+	template <typename T>
+	class Impl : public boost::shared_ptr<T>
+	{
+
+		typedef boost::shared_ptr<T> Super;
+
+		public:
+
+			Impl () : Super(new T) {}
+
+			Impl (T* p) : Super(p) {}
+
+	};// Impl
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/reflex.h

@@ -0,0 +1,26 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_REFLEX_H__
+#define __REFLEX_REFLEX_H__
+
+
+#include <stddef.h>
+
+
+namespace Reflex
+{
+
+
+	bool init ();
+
+	bool fin ();
+
+	bool run (const char* name = NULL);
+
+	bool quit ();
+
+
+}// Reflex
+
+
+#endif//EOH