reflexion 0.3.4 → 0.3.6

data/ext/reflex/native.cpp

@@ -4,6 +4,7 @@
 void Init_reflex ();
 void Init_reflex_exception ();
 
+void Init_reflex_pointer ();
 void Init_reflex_selector ();
 void Init_reflex_style ();
 void Init_reflex_style_length ();
@@ -11,19 +12,19 @@ void Init_reflex_timer ();
 void Init_reflex_filter ();
 
 void Init_reflex_event ();
-void Init_reflex_motion_event ();
+void Init_reflex_device_event ();
 void Init_reflex_update_event ();
 void Init_reflex_draw_event ();
 void Init_reflex_frame_event ();
 void Init_reflex_scroll_event ();
 void Init_reflex_focus_event ();
 void Init_reflex_key_event ();
-void Init_reflex_pointer ();
 void Init_reflex_pointer_event ();
 void Init_reflex_wheel_event ();
 void Init_reflex_capture_event ();
 void Init_reflex_timer_event ();
 void Init_reflex_contact_event ();
+void Init_reflex_motion_event ();
 
 void Init_reflex_shape ();
 void Init_reflex_polygon_shape ();
@@ -55,6 +56,7 @@ extern "C" void
 	Init_reflex();
 	Init_reflex_exception();
 
+	Init_reflex_pointer();
 	Init_reflex_selector();
 	Init_reflex_style();
 	Init_reflex_style_length();
@@ -62,19 +64,19 @@ extern "C" void
 	Init_reflex_filter();
 
 	Init_reflex_event();
-	Init_reflex_motion_event();
+	Init_reflex_device_event();
 	Init_reflex_update_event();
 	Init_reflex_draw_event();
 	Init_reflex_frame_event();
 	Init_reflex_scroll_event();
 	Init_reflex_focus_event();
 	Init_reflex_key_event();
-	Init_reflex_pointer();
 	Init_reflex_pointer_event();
 	Init_reflex_wheel_event();
 	Init_reflex_capture_event();
 	Init_reflex_timer_event();
 	Init_reflex_contact_event();
+	Init_reflex_motion_event();
 
 	Init_reflex_shape();
 	Init_reflex_polygon_shape();

data/ext/reflex/reflex.cpp

@@ -251,6 +251,30 @@ Init_reflex ()
 	DEFINE_CONST(KEY_LAUNCH_APP1);
 	DEFINE_CONST(KEY_LAUNCH_APP2);
 
+	DEFINE_CONST(KEY_GAMEPAD_LEFT);
+	DEFINE_CONST(KEY_GAMEPAD_RIGHT);
+	DEFINE_CONST(KEY_GAMEPAD_UP);
+	DEFINE_CONST(KEY_GAMEPAD_DOWN);
+
+	DEFINE_CONST(KEY_GAMEPAD_A);
+	DEFINE_CONST(KEY_GAMEPAD_B);
+	DEFINE_CONST(KEY_GAMEPAD_X);
+	DEFINE_CONST(KEY_GAMEPAD_Y);
+
+	DEFINE_CONST(KEY_GAMEPAD_LSHOULDER);
+	DEFINE_CONST(KEY_GAMEPAD_RSHOULDER);
+	DEFINE_CONST(KEY_GAMEPAD_LTRIGGER);
+	DEFINE_CONST(KEY_GAMEPAD_RTRIGGER);
+	DEFINE_CONST(KEY_GAMEPAD_LTHUMB);
+	DEFINE_CONST(KEY_GAMEPAD_RTHUMB);
+
+	DEFINE_CONST(KEY_GAMEPAD_HOME);
+	DEFINE_CONST(KEY_GAMEPAD_MENU);
+	DEFINE_CONST(KEY_GAMEPAD_OPTION);
+	DEFINE_CONST(KEY_GAMEPAD_SHARE);
+	DEFINE_CONST(KEY_GAMEPAD_START);
+	DEFINE_CONST(KEY_GAMEPAD_SELECT);
+
 	DEFINE_CONST(MOD_SHIFT);
 	DEFINE_CONST(MOD_CONTROL);
 	DEFINE_CONST(MOD_ALT);

data/include/reflex/application.h

@@ -53,6 +53,10 @@ namespace Reflex
 
 			virtual void on_quit (Event* e);
 
+			virtual void on_device_connect    (DeviceEvent* e);
+
+			virtual void on_device_disconnect (DeviceEvent* e);
+
 			virtual void on_motion (MotionEvent* e);
 
 			virtual void on_preference (Event* e);

data/include/reflex/defs.h

@@ -277,6 +277,66 @@ namespace Reflex
 
 		#undef NATIVE_VK
 
+		KEY_GAMEPAD_LEFT  = 0x100,
+		KEY_GAMEPAD_RIGHT,
+		KEY_GAMEPAD_UP,
+		KEY_GAMEPAD_DOWN,
+
+		KEY_GAMEPAD_LSTICK_LEFT,
+		KEY_GAMEPAD_LSTICK_RIGHT,
+		KEY_GAMEPAD_LSTICK_UP,
+		KEY_GAMEPAD_LSTICK_DOWN,
+
+		KEY_GAMEPAD_RSTICK_LEFT,
+		KEY_GAMEPAD_RSTICK_RIGHT,
+		KEY_GAMEPAD_RSTICK_UP,
+		KEY_GAMEPAD_RSTICK_DOWN,
+
+		KEY_GAMEPAD_A,
+		KEY_GAMEPAD_B,
+		KEY_GAMEPAD_X,
+		KEY_GAMEPAD_Y,
+
+		KEY_GAMEPAD_LSHOULDER,
+		KEY_GAMEPAD_RSHOULDER,
+		KEY_GAMEPAD_LTRIGGER,
+		KEY_GAMEPAD_RTRIGGER,
+		KEY_GAMEPAD_LTHUMB,
+		KEY_GAMEPAD_RTHUMB,
+
+		KEY_GAMEPAD_LPADDLE_0,
+		KEY_GAMEPAD_LPADDLE_1,
+		KEY_GAMEPAD_RPADDLE_0,
+		KEY_GAMEPAD_RPADDLE_1,
+
+		KEY_GAMEPAD_HOME,
+		KEY_GAMEPAD_MENU,
+		KEY_GAMEPAD_OPTION,
+		KEY_GAMEPAD_SHARE,
+		KEY_GAMEPAD_START,
+		KEY_GAMEPAD_SELECT,
+
+		KEY_GAMEPAD_BUTTON_TOUCH,
+
+		KEY_GAMEPAD_BUTTON_0,
+		KEY_GAMEPAD_BUTTON_1,
+		KEY_GAMEPAD_BUTTON_2,
+		KEY_GAMEPAD_BUTTON_3,
+		KEY_GAMEPAD_BUTTON_4,
+		KEY_GAMEPAD_BUTTON_5,
+		KEY_GAMEPAD_BUTTON_6,
+		KEY_GAMEPAD_BUTTON_7,
+		KEY_GAMEPAD_BUTTON_8,
+		KEY_GAMEPAD_BUTTON_9,
+		KEY_GAMEPAD_BUTTON_10,
+		KEY_GAMEPAD_BUTTON_11,
+		KEY_GAMEPAD_BUTTON_12,
+		KEY_GAMEPAD_BUTTON_13,
+		KEY_GAMEPAD_BUTTON_14,
+		KEY_GAMEPAD_BUTTON_15,
+
+		KEY_GAMEPAD_BUTTON_MAX
+
 	};// KeyCode
 
 

data/include/reflex/device.h

@@ -4,10 +4,32 @@
 #define __REFLEX_DEVICE_H__
 
 
+#include <xot/ref.h>
+#include <reflex/defs.h>
+
+
 namespace Reflex
 {
 
 
+	class Device : public Xot::RefCountable<>
+	{
+
+		public:
+
+			typedef Xot::Ref<Device> Ref;
+
+			virtual ~Device ();
+
+			virtual const char* name () const = 0;
+
+			virtual operator bool () const;
+
+			bool operator ! () const;
+
+	};// Device
+
+
 	void vibrate ();
 
 

data/include/reflex/event.h

@@ -17,6 +17,7 @@ namespace Reflex
 {
 
 
+	class Device;
 	class Shape;
 	class View;
 
@@ -47,6 +48,30 @@ namespace Reflex
 	};// Event
 
 
+	class DeviceEvent : public Event
+	{
+
+		public:
+
+			DeviceEvent (Device* device = NULL);
+
+			DeviceEvent dup () const;
+
+			      Device* device ();
+
+			const Device* device () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+		private:
+
+			DeviceEvent (const DeviceEvent* src);
+
+	};// DeviceEvent
+
+
 	class UpdateEvent : public Event
 	{
 

data/include/reflex/gamepad.h

@@ -0,0 +1,175 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_GAMEPAD_H__
+#define __REFLEX_GAMEPAD_H__
+
+
+#include <xot/ref.h>
+#include <xot/pimpl.h>
+#include <xot/util.h>
+#include <reflex/device.h>
+#include <reflex/event.h>
+
+
+namespace Reflex
+{
+
+
+	class Gamepad : public Device
+	{
+
+		public:
+
+			typedef Xot::Ref<Gamepad>         Ref;
+
+			typedef std::vector<Gamepad::Ref> List;
+
+			enum Index
+			{
+
+				INDEX_LEFT = 0, INDEX_RIGHT, INDEX_MAX
+
+			};// Index
+
+			enum Button
+			{
+
+				LEFT         = Xot::bit<ulonglong>(0),
+
+				RIGHT        = Xot::bit<ulonglong>(1),
+
+				UP           = Xot::bit<ulonglong>(2),
+
+				DOWN         = Xot::bit<ulonglong>(3),
+
+				LSTICK_LEFT  = Xot::bit<ulonglong>(4),
+
+				LSTICK_RIGHT = Xot::bit<ulonglong>(5),
+
+				LSTICK_UP    = Xot::bit<ulonglong>(6),
+
+				LSTICK_DOWN  = Xot::bit<ulonglong>(7),
+
+				RSTICK_LEFT  = Xot::bit<ulonglong>(8),
+
+				RSTICK_RIGHT = Xot::bit<ulonglong>(9),
+
+				RSTICK_UP    = Xot::bit<ulonglong>(10),
+
+				RSTICK_DOWN  = Xot::bit<ulonglong>(11),
+
+				BUTTON_A     = Xot::bit<ulonglong>(12),
+
+				BUTTON_B     = Xot::bit<ulonglong>(13),
+
+				BUTTON_X     = Xot::bit<ulonglong>(14),
+
+				BUTTON_Y     = Xot::bit<ulonglong>(15),
+
+				LSHOULDER    = Xot::bit<ulonglong>(16),
+
+				RSHOULDER    = Xot::bit<ulonglong>(17),
+
+				LTRIGGER     = Xot::bit<ulonglong>(18),
+
+				RTRIGGER     = Xot::bit<ulonglong>(19),
+
+				LTHUMB       = Xot::bit<ulonglong>(20),
+
+				RTHUMB       = Xot::bit<ulonglong>(21),
+
+				LPADDLE_0    = Xot::bit<ulonglong>(22),
+
+				LPADDLE_1    = Xot::bit<ulonglong>(23),
+
+				RPADDLE_0    = Xot::bit<ulonglong>(24),
+
+				RPADDLE_1    = Xot::bit<ulonglong>(25),
+
+				HOME         = Xot::bit<ulonglong>(26),
+
+				MENU         = Xot::bit<ulonglong>(27),
+
+				OPTION       = Xot::bit<ulonglong>(28),
+
+				SHARE        = Xot::bit<ulonglong>(29),
+
+				START        = Xot::bit<ulonglong>(30),
+
+				SELECT       = Xot::bit<ulonglong>(31),
+
+				BUTTON_TOUCH = Xot::bit<ulonglong>(32),
+
+				BUTTON_0     = Xot::bit<ulonglong>(33),
+
+				BUTTON_1     = Xot::bit<ulonglong>(34),
+
+				BUTTON_2     = Xot::bit<ulonglong>(35),
+
+				BUTTON_3     = Xot::bit<ulonglong>(36),
+
+				BUTTON_4     = Xot::bit<ulonglong>(37),
+
+				BUTTON_5     = Xot::bit<ulonglong>(38),
+
+				BUTTON_6     = Xot::bit<ulonglong>(39),
+
+				BUTTON_7     = Xot::bit<ulonglong>(40),
+
+				BUTTON_8     = Xot::bit<ulonglong>(41),
+
+				BUTTON_9     = Xot::bit<ulonglong>(42),
+
+				BUTTON_10    = Xot::bit<ulonglong>(43),
+
+				BUTTON_11    = Xot::bit<ulonglong>(44),
+
+				BUTTON_12    = Xot::bit<ulonglong>(45),
+
+				BUTTON_13    = Xot::bit<ulonglong>(46),
+
+				BUTTON_14    = Xot::bit<ulonglong>(47),
+
+				BUTTON_15    = Xot::bit<ulonglong>(48),
+
+			};// Button
+
+			Gamepad ();
+
+			virtual ~Gamepad ();
+
+			virtual const char* name () const;
+
+			virtual ulonglong buttons () const;
+
+			virtual const Point& stick (size_t index = INDEX_LEFT) const;
+
+			virtual float trigger      (size_t index = INDEX_LEFT) const;
+
+			const Gamepad* prev () const;
+
+			virtual void on_key      (KeyEvent* e);
+
+			virtual void on_key_down (KeyEvent* e);
+
+			virtual void on_key_up   (KeyEvent* e);
+
+			//virtual void on_stick (StickEvent* e);
+
+			//virtual void on_trigger (TriggerEvent* e);
+
+			virtual operator bool () const;
+
+			static const List& all ();
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// Gamepad
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/ruby/application.h

@@ -65,6 +65,24 @@ namespace Reflex
 					return Super::on_quit(e);
 			}
 
+			virtual void on_device_connect (DeviceEvent* e)
+			{
+				RUCY_SYM(on_device_connect);
+				if (this->is_overridable())
+					this->value.call(on_device_connect, Rucy::value(e));
+				else
+					return Super::on_device_connect(e);
+			}
+
+			virtual void on_device_disconnect (DeviceEvent* e)
+			{
+				RUCY_SYM(on_device_disconnect);
+				if (this->is_overridable())
+					this->value.call(on_device_disconnect, Rucy::value(e));
+				else
+					return Super::on_device_disconnect(e);
+			}
+
 			virtual void on_motion (MotionEvent* e)
 			{
 				RUCY_SYM(on_motion);

data/include/reflex/ruby/device.h

@@ -0,0 +1,40 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_DEVICE_H__
+#define __REFLEX_RUBY_DEVICE_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/device.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Device)
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class device_class ();
+	// class Reflex::Device
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Device> ()
+	{
+		return Reflex::device_class();
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/event.h

@@ -11,6 +11,8 @@
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Event)
 
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DeviceEvent)
+
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::UpdateEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DrawEvent)
@@ -43,6 +45,9 @@ namespace Reflex
 	REFLEX_EXPORT Rucy::Class event_class ();
 	// class Reflex::Event
 
+	REFLEX_EXPORT Rucy::Class device_event_class ();
+	// class Reflex::DeviceEvent
+
 	REFLEX_EXPORT Rucy::Class update_event_class ();
 	// class Reflex::UpdateEvent
 
@@ -93,6 +98,12 @@ namespace Rucy
 		return Reflex::event_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Reflex::DeviceEvent> ()
+	{
+		return Reflex::device_event_class();
+	}
+
 	template <> inline Class
 	get_ruby_class<Reflex::UpdateEvent> ()
 	{

data/reflex.gemspec

@@ -25,9 +25,9 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_dependency 'xot',   '~> 0.3.4', '>= 0.3.4'
-  s.add_dependency 'rucy',  '~> 0.3.4', '>= 0.3.4'
-  s.add_dependency 'rays',  '~> 0.3.4', '>= 0.3.4'
+  s.add_dependency 'xot',   '~> 0.3.6', '>= 0.3.6'
+  s.add_dependency 'rucy',  '~> 0.3.6', '>= 0.3.6'
+  s.add_dependency 'rays',  '~> 0.3.6', '>= 0.3.6'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/application.cpp

@@ -4,6 +4,7 @@
 #include "reflex/exception.h"
 #include "reflex/debug.h"
 #include "window.h"
+#include "gamepad.h"
 
 
 namespace Reflex
@@ -18,6 +19,37 @@ namespace Reflex
 	}// global
 
 
+	void
+	Application_call_start (Application* app, Event* e)
+	{
+		Gamepad_init(app);
+
+		app->on_start(e);
+	}
+
+	void
+	Application_call_quit (Application* app, Event* e)
+	{
+		app->on_quit(e);
+		if (e->is_blocked()) return;
+
+		Gamepad_fin(app);
+	}
+
+	void
+	Application_call_device_connect (Application* app, Device* device)
+	{
+		DeviceEvent e(device);
+		app->on_device_connect(&e);
+	}
+
+	void
+	Application_call_device_disconnect (Application* app, Device* device)
+	{
+		DeviceEvent e(device);
+		app->on_device_disconnect(&e);
+	}
+
 	Application*
 	app ()
 	{
@@ -78,6 +110,41 @@ namespace Reflex
 		return Window_all().end();
 	}
 
+	void
+	Application::on_start (Event* e)
+	{
+	}
+
+	void
+	Application::on_quit (Event* e)
+	{
+	}
+
+	void
+	Application::on_device_connect (DeviceEvent* e)
+	{
+	}
+
+	void
+	Application::on_device_disconnect (DeviceEvent* e)
+	{
+	}
+
+	void
+	Application::on_motion (MotionEvent* e)
+	{
+	}
+
+	void
+	Application::on_preference (Event* e)
+	{
+	}
+
+	Application::operator bool () const
+	{
+		return true;
+	}
+
 	bool
 	Application::operator ! () const
 	{

data/src/application.h

@@ -22,6 +22,15 @@ namespace Reflex
 	Application::Data* Application_create_data ();
 
 
+	void Application_call_start (Application* app, Event* e);
+
+	void Application_call_quit  (Application* app, Event* e);
+
+	void Application_call_device_connect    (Application* app, Device* device);
+
+	void Application_call_device_disconnect (Application* app, Device* device);
+
+
 }// Reflex
 
 

data/src/device.cpp

@@ -0,0 +1,24 @@
+#include "reflex/device.h"
+
+
+namespace Reflex
+{
+
+
+	Device::~Device ()
+	{
+	}
+
+	Device::operator bool () const
+	{
+		return true;
+	}
+
+	bool
+	Device::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/event.cpp

@@ -2,6 +2,7 @@
 
 
 #include <algorithm>
+#include "reflex/device.h"
 #include "reflex/timer.h"
 #include "reflex/shape.h"
 #include "reflex/exception.h"
@@ -69,6 +70,43 @@ namespace Reflex
 	}
 
 
+	struct DeviceEvent::Data
+	{
+
+		Device::Ref device;
+
+	};// DeviceEvent::Data
+
+
+	DeviceEvent::DeviceEvent (Device* device)
+	{
+		if (device) self->device = device;
+	}
+
+	DeviceEvent::DeviceEvent (const DeviceEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
+	}
+
+	DeviceEvent
+	DeviceEvent::dup () const
+	{
+		return DeviceEvent(this);
+	}
+
+	Device*
+	DeviceEvent::device ()
+	{
+		return self->device;
+	}
+
+	const Device*
+	DeviceEvent::device () const
+	{
+		return self->device;
+	}
+
+
 	struct UpdateEvent::Data
 	{