reflexion 0.6.0 → 0.7.0

data/include/reflex/event.h

@@ -293,6 +293,40 @@ namespace Reflex
 	};// KeyEvent
 
 
+	class TextEvent : public Event
+	{
+
+		public:
+
+			enum Action {ACTION_NONE = 0, PREEDIT, COMMIT};
+
+			TextEvent ();
+
+			TextEvent (
+				Action action, const char* text,
+				int selection_offset = -1, int selection_size = 0);
+
+			TextEvent dup () const;
+
+			Action action () const;
+
+			const char* text () const;
+
+			int selection_offset () const;
+
+			int selection_size () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+		private:
+
+			TextEvent (const TextEvent* src);
+
+	};// TextEvent
+
+
 	class PointerEvent : public Event
 	{
 
@@ -334,6 +368,10 @@ namespace Reflex
 				coord x, coord y, coord z, coord dx, coord dy, coord dz,
 				uint modifiers = 0);
 
+			WheelEvent (
+				const Point& position, const Point& dposition,
+				uint modifiers = 0);
+
 			WheelEvent dup () const;
 
 			      Point& position ();
@@ -357,51 +395,56 @@ namespace Reflex
 	};// WheelEvent
 
 
-	class MIDIEvent : public Event
+	class CaptureEvent : public Event
 	{
 
 		public:
 
-			enum Action
-			{
+			CaptureEvent ();
 
-				ACTION_NONE = 0,
+			CaptureEvent (uint begin, uint end);
 
-				NOTE_ON,
+			CaptureEvent dup () const;
 
-				NOTE_OFF,
+			uint begin () const;
 
-				CONTROL_CHANGE,
+			uint end () const;
 
-				PROGRAM_CHANGE,
+			struct Data;
 
-				CHANNEL_PRESSURE,
+			Xot::PSharedImpl<Data> self;
 
-				KEY_PRESSURE,
+		private:
 
-				PITCH_BEND_CHANGE,
+			CaptureEvent (const CaptureEvent* src);
 
-				SYSTEM
+	};// CaptureEvent
 
-			};// Action
 
-			MIDIEvent ();
+	class TimerEvent : public Event
+	{
 
-			MIDIEvent (MIDI* midi, const uchar* bytes, double time);
+		public:
 
-			MIDIEvent dup () const;
+			TimerEvent ();
 
-			MIDI* midi () const;
+			TimerEvent (Timer* timer);
 
-			Action action () const;
+			TimerEvent dup () const;
 
-			int channel () const;
+			      Timer* timer ();
 
-			uchar data1 () const;
+			const Timer* timer () const;
 
-			uchar data2 () const;
+			View* owner () const;
 
-			bool is_captured () const;
+			int id () const;
+
+			float interval () const;
+
+			int count () const;
+
+			bool is_finished () const;
 
 			struct Data;
 
@@ -409,36 +452,33 @@ namespace Reflex
 
 		private:
 
-			MIDIEvent (const MIDIEvent* src);
+			TimerEvent (const TimerEvent* src);
 
-	};// MIDIEvent
+	};// TimerEvent
 
 
-	class NoteEvent : public Event
+	class ContactEvent : public Event
 	{
 
 		public:
 
-			enum Action {ACTION_NONE = 0, ON, OFF};
+			enum Action {ACTION_NONE = 0, BEGIN, END};
 
-			NoteEvent ();
+			ContactEvent ();
 
-			NoteEvent (
-				Action action, int channel, int note, float velocity, double time);
+			ContactEvent (Action action, Shape* shape);
 
-			NoteEvent dup () const;
+			ContactEvent dup () const;
 
 			Action action () const;
 
-			int channel () const;
-
-			int note () const;
+			      Shape* shape ();
 
-			float frequency () const;
+			const Shape* shape () const;
 
-			float velocity () const;
+			      View* view ();
 
-			bool is_captured () const;
+			const View* view () const;
 
 			struct Data;
 
@@ -446,30 +486,49 @@ namespace Reflex
 
 		private:
 
-			NoteEvent (const NoteEvent* src);
+			ContactEvent (const ContactEvent* src);
 
-	};// NoteEvent
+	};// ContactEvent
 
 
-	class ControlChangeEvent : public Event
+	class MotionEvent : public Event
 	{
 
 		public:
 
-			ControlChangeEvent ();
+			MotionEvent (const Point& gravity = Point(0, 9.8));
 
-			ControlChangeEvent (
-				int channel, int controller, float value, double time);
+			MotionEvent dup () const;
 
-			ControlChangeEvent dup () const;
+			const Point& gravity () const;
 
-			int channel () const;
+			struct Data;
 
-			int controller () const;
+			Xot::PSharedImpl<Data> self;
 
-			float value () const;
+		private:
 
-			bool is_captured () const;
+			MotionEvent (const MotionEvent* src);
+
+	};// MotionEvent
+
+
+	class FileEvent : public Event
+	{
+
+		public:
+
+			enum Action {ACTION_NONE = 0, OPEN, SAVE};
+
+			FileEvent ();
+
+			FileEvent (Action action, const StringList& paths);
+
+			FileEvent dup () const;
+
+			Action action () const;
+
+			const StringList& paths () const;
 
 			struct Data;
 
@@ -477,25 +536,23 @@ namespace Reflex
 
 		private:
 
-			ControlChangeEvent (const ControlChangeEvent* src);
+			FileEvent (const FileEvent* src);
 
-	};// ControlChangeEvent
+	};// FileEvent
 
 
-	class CaptureEvent : public Event
+	class ColorEvent : public Event
 	{
 
 		public:
 
-			CaptureEvent ();
+			ColorEvent ();
 
-			CaptureEvent (uint begin, uint end);
+			ColorEvent (const Color& color);
 
-			CaptureEvent dup () const;
+			ColorEvent dup () const;
 
-			uint begin () const;
-
-			uint end () const;
+			const Color& color () const;
 
 			struct Data;
 
@@ -503,35 +560,56 @@ namespace Reflex
 
 		private:
 
-			CaptureEvent (const CaptureEvent* src);
+			ColorEvent (const ColorEvent* src);
 
-	};// CaptureEvent
+	};// ColorEvent
 
 
-	class TimerEvent : public Event
+	class MIDIEvent : public Event
 	{
 
 		public:
 
-			TimerEvent ();
+			enum Action
+			{
 
-			TimerEvent (Timer* timer);
+				ACTION_NONE = 0,
 
-			TimerEvent dup () const;
+				NOTE_ON,
 
-			      Timer* timer ();
+				NOTE_OFF,
 
-			const Timer* timer () const;
+				CONTROL_CHANGE,
 
-			View* owner () const;
+				PROGRAM_CHANGE,
 
-			int id () const;
+				CHANNEL_PRESSURE,
 
-			float interval () const;
+				KEY_PRESSURE,
 
-			int count () const;
+				PITCH_BEND_CHANGE,
 
-			bool is_finished () const;
+				SYSTEM
+
+			};// Action
+
+			MIDIEvent ();
+
+			MIDIEvent (MIDI* midi, const uchar* bytes, double time);
+
+			MIDIEvent dup () const;
+
+			MIDI* midi () const;
+
+			Action action () const;
+
+			int channel () const;
+
+			uchar data1 () const;
+
+			uchar data2 () const;
+
+			bool is_captured () const;
 
 			struct Data;
 
@@ -539,33 +617,36 @@ namespace Reflex
 
 		private:
 
-			TimerEvent (const TimerEvent* src);
+			MIDIEvent (const MIDIEvent* src);
 
-	};// TimerEvent
+	};// MIDIEvent
 
 
-	class ContactEvent : public Event
+	class NoteEvent : public Event
 	{
 
 		public:
 
-			enum Action {ACTION_NONE = 0, BEGIN, END};
+			enum Action {ACTION_NONE = 0, ON, OFF};
 
-			ContactEvent ();
+			NoteEvent ();
 
-			ContactEvent (Action action, Shape* shape);
+			NoteEvent (
+				Action action, int channel, int note, float velocity, double time);
 
-			ContactEvent dup () const;
+			NoteEvent dup () const;
 
 			Action action () const;
 
-			      Shape* shape ();
+			int channel () const;
 
-			const Shape* shape () const;
+			int note () const;
 
-			      View* view ();
+			float frequency () const;
 
-			const View* view () const;
+			float velocity () const;
+
+			bool is_captured () const;
 
 			struct Data;
 
@@ -573,21 +654,30 @@ namespace Reflex
 
 		private:
 
-			ContactEvent (const ContactEvent* src);
+			NoteEvent (const NoteEvent* src);
 
-	};// ContactEvent
+	};// NoteEvent
 
 
-	class MotionEvent : public Event
+	class ControlChangeEvent : public Event
 	{
 
 		public:
 
-			MotionEvent (const Point& gravity = Point(0, 9.8));
+			ControlChangeEvent ();
 
-			MotionEvent dup () const;
+			ControlChangeEvent (
+				int channel, int controller, float value, double time);
 
-			const Point& gravity () const;
+			ControlChangeEvent dup () const;
+
+			int channel () const;
+
+			int controller () const;
+
+			float value () const;
+
+			bool is_captured () const;
 
 			struct Data;
 
@@ -595,9 +685,9 @@ namespace Reflex
 
 		private:
 
-			MotionEvent (const MotionEvent* src);
+			ControlChangeEvent (const ControlChangeEvent* src);
 
-	};// MotionEvent
+	};// ControlChangeEvent
 
 
 }// Reflex

data/include/reflex/file_dialog.h

@@ -0,0 +1,73 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_FILE_DIALOG_H__
+#define __REFLEX_FILE_DIALOG_H__
+
+
+#include <xot/ref.h>
+#include <xot/pimpl.h>
+#include <reflex/defs.h>
+#include <reflex/event.h>
+
+
+namespace Reflex
+{
+
+
+	class Window;
+
+
+	class FileDialog : public Xot::RefCountable<>
+	{
+
+		typedef FileDialog This;
+
+		public:
+
+			typedef Xot::Ref<This> Ref;
+
+			FileDialog ();
+
+			virtual ~FileDialog ();
+
+			virtual void open_file      (const char* dir = NULL);
+
+			virtual void open_files     (const char* dir = NULL);
+
+			virtual void open_directory (const char* dir = NULL);
+
+			virtual void save_file      (const char* dir = NULL, const char* name = NULL);
+
+			virtual void      set_owner (Window* window);
+
+			virtual       Window* owner ();
+
+			virtual const Window* owner () const;
+
+			virtual void    set_title (const char* title);
+
+			virtual const char* title () const;
+
+			virtual void          set_extensions (const StringList& extensions);
+
+			virtual const StringList& extensions () const;
+
+			virtual void on_file (FileEvent* e);
+
+			virtual void on_cancel (Event* e);
+
+			virtual operator bool () const;
+
+			virtual bool operator ! () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+	};// FileDialog
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/gamepad.h

@@ -169,6 +169,9 @@ namespace Reflex
 	};// Gamepad
 
 
+	void enable_gamepad ();
+
+
 }// Reflex
 
 

data/include/reflex/menu.h

@@ -65,11 +65,11 @@ namespace Reflex
 
 			virtual bool is_checked () const;
 
-			virtual void    set_shortcut (const char* key, uint modifiers = MOD_NONE);
+			virtual void set_shortcut (KeyCode key, uint modifiers = MOD_NONE);
 
-			virtual const char* shortcut_key () const;
+			virtual KeyCode  shortcut_key () const;
 
-			virtual uint        shortcut_modifiers () const;
+			virtual uint     shortcut_modifiers () const;
 
 			virtual void     set_image (const Image& image);
 

data/include/reflex/midi.h

@@ -51,6 +51,9 @@ namespace Reflex
 	};// MIDI
 
 
+	void enable_midi ();
+
+
 }// Reflex
 
 

data/include/reflex/reflex.h

@@ -18,6 +18,8 @@ namespace Reflex
 
 	void process_events ();
 
+	void alert (const char* message, const char* title = NULL);
+
 
 }// Reflex
 

data/include/reflex/ruby/application.h

@@ -49,9 +49,14 @@ namespace Reflex
 
 			virtual void on_start (Event* e)
 			{
-				RUCY_SYM(on_start);
 				if (this->is_overridable())
+				{
+					RUCY_SYM(call_start_block);
+					this->value.call(call_start_block);
+
+					RUCY_SYM(on_start);
 					this->value.call(on_start, Rucy::value(e));
+				}
 				else
 					return Super::on_start(e);
 			}

data/include/reflex/ruby/color_picker.h

@@ -0,0 +1,89 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_COLOR_PICKER_H__
+#define __REFLEX_RUBY_COLOR_PICKER_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/color_picker.h>
+#include <reflex/ruby/event.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ColorPicker)
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class color_picker_class ();
+	// class Reflex::ColorPicker
+
+
+	template <typename T>
+	class RubyColorPicker : public Rucy::ClassWrapper<T>
+	{
+
+		typedef Rucy::ClassWrapper<T> Super;
+
+		public:
+
+			virtual void on_color (ColorEvent* e)
+			{
+				if (this->is_overridable())
+				{
+					RUCY_SYM(call_color_block);
+					this->value.call(call_color_block, Rucy::value(e));
+
+					if (!e->is_blocked())
+					{
+						RUCY_SYM(on_color);
+						this->value.call(on_color, Rucy::value(e));
+					}
+				}
+				else
+					Super::on_color(e);
+			}
+
+			virtual void on_close (Event* e)
+			{
+				if (this->is_overridable())
+				{
+					RUCY_SYM(clear_color_block);
+					this->value.call(clear_color_block);
+
+					RUCY_SYM(on_close);
+					this->value.call(on_close, Rucy::value(e));
+				}
+				else
+					Super::on_close(e);
+			}
+
+	};// RubyColorPicker
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::ColorPicker> ()
+	{
+		return Reflex::color_picker_class();
+	}
+
+	inline Value
+	value (Reflex::ColorPicker::Ref& ref, Value klass = Reflex::color_picker_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
+
+
+#endif//EOH