reflexion 0.5.2 → 0.6.0

data/ext/reflex/window.cpp

@@ -3,8 +3,9 @@
 
 #include <rays/ruby/bounds.h>
 #include <rays/ruby/painter.h>
-#include "reflex/ruby/screen.h"
 #include "reflex/ruby/view.h"
+#include "reflex/ruby/menu.h"
+#include "reflex/ruby/screen.h"
 #include "defs.h"
 
 
@@ -84,6 +85,14 @@ RUCY_DEF1(to_screen, point)
 }
 RUCY_END
 
+static
+RUCY_DEF0(is_active)
+{
+	CHECK;
+	return value(THIS->active());
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_title, title)
 {
@@ -118,6 +127,23 @@ RUCY_DEF0(get_frame)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_menu, menu)
+{
+	CHECK;
+	THIS->set_menu(menu ? to<Reflex::Menu*>(menu) : NULL);
+	return menu;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_menu)
+{
+	CHECK;
+	return value(THIS->menu());
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_closable, state)
 {
@@ -266,46 +292,46 @@ RUCY_DEF0(get_painter)
 RUCY_END
 
 static
-RUCY_DEF1(on_activate, event)
+RUCY_DEF1(on_show, event)
 {
 	CHECK;
-	CALL(on_activate(to<Reflex::Event*>(event)));
+
+	RUCY_SYM(call_show_block);
+	self.call(call_show_block);
+
+	CALL(on_show(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
 static
-RUCY_DEF1(on_deactivate, event)
+RUCY_DEF1(on_hide, event)
 {
 	CHECK;
-	CALL(on_deactivate(to<Reflex::Event*>(event)));
+	CALL(on_hide(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
 static
-RUCY_DEF1(on_show, event)
+RUCY_DEF1(on_close, event)
 {
 	CHECK;
-
-	RUCY_SYM(call_show_block);
-	self.call(call_show_block);
-
-	CALL(on_show(to<Reflex::Event*>(event)));
+	CALL(on_close(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
 static
-RUCY_DEF1(on_hide, event)
+RUCY_DEF1(on_activate, event)
 {
 	CHECK;
-	CALL(on_hide(to<Reflex::Event*>(event)));
+	CALL(on_activate(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
 static
-RUCY_DEF1(on_close, event)
+RUCY_DEF1(on_deactivate, event)
 {
 	CHECK;
-	CALL(on_close(to<Reflex::Event*>(event)));
+	CALL(on_deactivate(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
@@ -405,6 +431,22 @@ RUCY_DEF1(on_pointer_cancel, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_pointer_enter, event)
+{
+	CHECK;
+	CALL(on_pointer_enter(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_pointer_leave, event)
+{
+	CHECK;
+	CALL(on_pointer_leave(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_wheel, event)
 {
@@ -469,10 +511,13 @@ Init_reflex_window ()
 	cWindow.define_method("redraw", redraw);
 	cWindow.define_method("from_screen", from_screen);
 	cWindow.define_method(  "to_screen",   to_screen);
+	cWindow.define_method("active?", is_active);
 	cWindow.define_method("title=", set_title);
-	cWindow.define_method("title", get_title);
+	cWindow.define_method("title",  get_title);
 	cWindow.define_method("frame=", set_frame);
 	cWindow.define_method("frame",  get_frame);
+	cWindow.define_method("menu=",  set_menu);
+	cWindow.define_method("menu",   get_menu);
 	cWindow.define_method("closable=",    set_closable);
 	cWindow.define_method("closable?",     is_closable);
 	cWindow.define_method("minimizable=", set_minimizable);
@@ -488,11 +533,11 @@ Init_reflex_window ()
 	cWindow.define_method("root",    get_root);
 	cWindow.define_method("focus",   get_focus);
 	cWindow.define_method("painter", get_painter);
-	cWindow.define_method("on_activate",   on_activate);
-	cWindow.define_method("on_deactivate", on_deactivate);
 	cWindow.define_method("on_show",  on_show);
 	cWindow.define_method("on_hide",  on_hide);
 	cWindow.define_method("on_close", on_close);
+	cWindow.define_method("on_activate",   on_activate);
+	cWindow.define_method("on_deactivate", on_deactivate);
 	cWindow.define_method("on_update", on_update);
 	cWindow.define_method("on_draw",   on_draw);
 	cWindow.define_method("on_move",   on_move);
@@ -505,6 +550,8 @@ Init_reflex_window ()
 	cWindow.define_method("on_pointer_up",     on_pointer_up);
 	cWindow.define_method("on_pointer_move",   on_pointer_move);
 	cWindow.define_method("on_pointer_cancel", on_pointer_cancel);
+	cWindow.define_method("on_pointer_enter",  on_pointer_enter);
+	cWindow.define_method("on_pointer_leave",  on_pointer_leave);
 	cWindow.define_method("on_wheel",          on_wheel);
 	cWindow.define_method("on_midi",           on_midi);
 	cWindow.define_method("on_note",           on_note);

data/include/reflex/application.h

@@ -16,6 +16,9 @@ namespace Reflex
 {
 
 
+	class Menu;
+
+
 	class Application : public Xot::RefCountable<>
 	{
 
@@ -41,6 +44,12 @@ namespace Reflex
 
 			virtual const char* name () const;
 
+			virtual void    set_menu (Menu* menu);
+
+			virtual       Menu* menu ();
+
+			virtual const Menu* menu () const;
+
 			virtual       window_iterator window_begin ();
 
 			virtual const_window_iterator window_begin () const;

data/include/reflex/clipboard.h

@@ -0,0 +1,53 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_CLIPBOARD_H__
+#define __REFLEX_CLIPBOARD_H__
+
+
+#include <xot/pimpl.h>
+#include <reflex/defs.h>
+
+
+namespace Reflex
+{
+
+
+	class Clipboard
+	{
+
+		public:
+
+			Clipboard (const char* text = NULL);
+
+			~Clipboard ();
+
+			void    set_text (const char* text);
+
+			const char* text () const;
+
+			void     set_image (const Image& image);
+
+			const Image* image () const;
+
+			void clear ();
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+	};// Clipboard
+
+
+	void      set_clipboard (const Clipboard& clipboard);
+
+	Clipboard get_clipboard ();
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/constraint.h

@@ -0,0 +1,275 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_CONSTRAINT_H__
+#define __REFLEX_CONSTRAINT_H__
+
+
+#include <xot/ref.h>
+#include <xot/pimpl.h>
+#include <rays/point.h>
+#include <reflex/defs.h>
+#include <reflex/selector.h>
+
+
+namespace Reflex
+{
+
+
+	class View;
+	class Pin;
+
+
+	class Constraint : public Xot::RefCountable<>, public HasSelector
+	{
+
+		typedef Constraint This;
+
+		public:
+
+			typedef Xot::Ref<This> Ref;
+
+			virtual ~Constraint ();
+
+			virtual void remove ();
+
+			virtual const Pin& pin (size_t index) const;
+
+			virtual       View* view (size_t index);
+
+			virtual const View* view (size_t index) const;
+
+			virtual void set_spring (float hertz);
+
+			virtual float    spring () const;
+
+			virtual void set_damping (float ratio);
+
+			virtual float    damping () const;
+
+			virtual void set_collide (bool state);
+
+			virtual bool can_collide () const;
+
+			virtual bool is_removed () const;
+
+			virtual operator bool () const;
+
+			virtual bool operator ! () const;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+		protected:
+
+			Constraint (Data* data);
+
+			virtual SelectorPtr* get_selector_ptr () override;
+
+	};// Constraint
+
+
+	class SnapConstraint : public Constraint
+	{
+
+		typedef Constraint Super;
+
+		public:
+
+			virtual ~SnapConstraint ();
+
+			virtual void   set_angle (float min_degree, float max_degree);
+
+			virtual void clear_angle ();
+
+			virtual float      angle_min () const;
+
+			virtual float      angle_max () const;
+
+			virtual bool   has_angle () const;
+
+			virtual void   set_motor (float degrees_per_second);
+
+			virtual void clear_motor ();
+
+			virtual float      motor () const;
+
+			virtual bool   has_motor () const;
+
+			virtual void   set_force (float max_torque);
+			// the default is 1000 * mass, and 0 makes the motor powerless
+
+			virtual void clear_force ();
+
+			virtual float      force () const;
+
+			virtual bool   has_force () const;
+
+		protected:
+
+			SnapConstraint ();
+
+			friend class Pin;
+
+			friend SnapConstraint* SnapConstraint_create ();
+
+	};// SnapConstraint
+
+
+	class LinkConstraint : public Constraint
+	{
+
+		typedef Constraint Super;
+
+		public:
+
+			virtual ~LinkConstraint ();
+
+			virtual void     set_axis (coord x, coord y);
+
+			virtual void     set_axis (const Point& direction);
+
+			virtual void   clear_axis ();
+
+			virtual const Point& axis () const;
+
+			virtual bool     has_axis () const;
+
+			virtual void      set_distance (coord distance);
+
+			virtual void    clear_distance ();
+
+			virtual coord         distance () const;
+
+			virtual bool      has_distance () const;
+
+			virtual coord current_distance () const;
+
+			virtual void   set_range (coord min, coord max);
+
+			virtual void clear_range ();
+
+			virtual coord      range_min () const;
+
+			virtual coord      range_max () const;
+
+			virtual bool   has_range () const;
+
+			virtual void   set_motor (coord pixels_per_second);
+
+			virtual void clear_motor ();
+
+			virtual coord      motor () const;
+
+			virtual bool   has_motor () const;
+
+			virtual void   set_force (float max_force);
+			// the default is 1000 * mass, and 0 makes it powerless
+
+			virtual void clear_force ();
+
+			virtual float      force () const;
+
+			virtual bool   has_force () const;
+
+		protected:
+
+			LinkConstraint ();
+
+			friend class Pin;
+
+			friend LinkConstraint* LinkConstraint_create ();
+
+	};// LinkConstraint
+
+
+	class WheelConstraint : public Constraint
+	{
+
+		typedef Constraint Super;
+
+		public:
+
+			virtual ~WheelConstraint ();
+
+			virtual void     set_axis (coord x, coord y);
+
+			virtual void     set_axis (const Point& direction);
+
+			virtual const Point& axis () const;
+
+			virtual void   set_range (coord min, coord max);
+
+			virtual void clear_range ();
+
+			virtual coord      range_min () const;
+
+			virtual coord      range_max () const;
+
+			virtual bool   has_range () const;
+
+			virtual void   set_motor (float degrees_per_second);
+
+			virtual void clear_motor ();
+
+			virtual float      motor () const;
+
+			virtual bool   has_motor () const;
+
+			virtual void   set_force (float max_torque);
+			// the default is 1000 * mass, and 0 makes the motor powerless
+
+			virtual void clear_force ();
+
+			virtual float      force () const;
+
+			virtual bool   has_force () const;
+
+		protected:
+
+			WheelConstraint ();
+
+			friend class Pin;
+
+			friend WheelConstraint* WheelConstraint_create ();
+
+	};// WheelConstraint
+
+
+	class ChaseConstraint : public Constraint
+	{
+
+		typedef Constraint Super;
+
+		public:
+
+			virtual ~ChaseConstraint ();
+
+			virtual void   set_target (const Pin& target);
+
+			virtual const Pin& target () const;
+
+			virtual void   set_force (float max_force);
+			// the default is 1000 * mass, and 0 makes it powerless
+
+			virtual void clear_force ();
+
+			virtual float      force () const;
+
+			virtual bool   has_force () const;
+
+		protected:
+
+			ChaseConstraint ();
+
+			friend class Pin;
+
+			friend ChaseConstraint* ChaseConstraint_create ();
+
+	};// ChaseConstraint
+
+
+}// Reflex
+
+
+#endif//EOH