reflexion 0.1.6 → 0.1.7

data/include/reflex/style.h

@@ -0,0 +1,144 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_STYLE_H__
+#define __REFLEX_STYLE_H__
+
+
+#include <xot/ref.h>
+#include <rays/color.h>
+#include <rays/image.h>
+#include <reflex/defs.h>
+#include <reflex/selector.h>
+#include <reflex/style_length.h>
+
+
+namespace Reflex
+{
+
+
+	class Style
+	{
+
+		typedef Style This;
+
+		public:
+
+			enum Flow {FLOW_NONE = 0, FLOW_DOWN, FLOW_RIGHT, FLOW_UP, FLOW_LEFT, FLOW_LAST};
+
+			typedef Selector::      iterator       tag_iterator;
+
+			typedef Selector::const_iterator const_tag_iterator;
+
+			Style (const char* name = NULL);
+
+			Style (const This& obj);
+
+			Style& operator = (const This& obj);
+
+			~Style ();
+
+			void    set_name (const char* name);
+
+			const char* name () const;
+
+			void           add_tag (const char* tag);
+
+			void        remove_tag (const char* tag);
+
+			      tag_iterator tag_begin ();
+
+			const_tag_iterator tag_begin () const;
+
+			      tag_iterator tag_end ();
+
+			const_tag_iterator tag_end () const;
+
+			void        set_selector (const Selector& selector);
+
+			      Selector& selector ();
+
+			const Selector& selector () const;
+
+			void set_flow (Flow main, Flow sub = FLOW_NONE);
+
+			void get_flow (Flow* main, Flow* sub) const;
+
+			void            set_size (const StyleLength2& size);
+
+			void            set_width  (const StyleLength& width);
+
+			void            set_height (const StyleLength& height);
+
+			const StyleLength2& size () const;
+
+			void            set_position (const StyleLength4& position);
+
+			void            set_left   (const StyleLength& left);
+
+			void            set_top    (const StyleLength& top);
+
+			void            set_right  (const StyleLength& right);
+
+			void            set_bottom (const StyleLength& bottom);
+
+			const StyleLength4& position () const;
+
+			void            set_offset (const StyleLength4& offset);
+
+			void            set_offset_left   (const StyleLength& left);
+
+			void            set_offset_top    (const StyleLength& top);
+
+			void            set_offset_right  (const StyleLength& right);
+
+			void            set_offset_bottom (const StyleLength& bottom);
+
+			const StyleLength4& offset () const;
+
+			void            set_margin (const StyleLength4& margin);
+
+			void            set_margin_left   (const StyleLength& left);
+
+			void            set_margin_top    (const StyleLength& top);
+
+			void            set_margin_right  (const StyleLength& right);
+
+			void            set_margin_bottom (const StyleLength& bottom);
+
+			const StyleLength4& margin () const;
+
+			void            set_padding (const StyleLength4& padding);
+
+			void            set_padding_left   (const StyleLength& left);
+
+			void            set_padding_top    (const StyleLength& top);
+
+			void            set_padding_right  (const StyleLength& right);
+
+			void            set_padding_bottom (const StyleLength& bottom);
+
+			const StyleLength4& padding () const;
+
+			void     set_background_color (const Color& value);
+
+			const Color& background_color () const;
+
+			void     set_background_image (const Image& value);
+
+			const Image& background_image () const;
+
+			friend bool operator == (const This& lhs, const This& rhs);
+
+			friend bool operator != (const This& lhs, const This& rhs);
+
+			struct Data;
+
+			Xot::Ref<Data> ref;
+
+	};// Style
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/style_length.h

@@ -0,0 +1,147 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_STYLE_LENGTH_H__
+#define __REFLEX_STYLE_LENGTH_H__
+
+
+#include <xot/pimpl.h>
+#include <reflex/defs.h>
+
+
+namespace Reflex
+{
+
+
+	class StyleLength
+	{
+
+		public:
+
+			typedef coord Value;
+
+			enum Unit {NONE = 0, PIXEL, PERCENT, UNIT_LAST};
+
+			StyleLength ();
+
+			StyleLength (Value value, Unit unit = PIXEL);
+
+			explicit StyleLength (const char* str);
+
+			StyleLength copy () const;
+
+			void reset (Value value = 0, Unit unit = NONE);
+
+			void reset (const char* str);
+
+			Value value () const;
+
+			Unit unit () const;
+
+			bool get_pixel (coord* pixel, coord parent_size) const;
+
+			String to_s () const;
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Xot::PImpl<Data, true> self;
+
+	};// StyleLength
+
+
+	class StyleLength2
+	{
+
+		public:
+
+			StyleLength2 ();
+
+			StyleLength2 (const StyleLength& all);
+
+			StyleLength2 (const StyleLength& width, const StyleLength& height);
+
+			StyleLength2 copy () const;
+
+			void           set_width (const StyleLength& width);
+
+			const StyleLength& width () const;
+
+			void           set_height (const StyleLength& height);
+
+			const StyleLength& height () const;
+
+			size_t size () const;
+
+			      StyleLength& operator [] (size_t i);
+
+			const StyleLength& operator [] (size_t i) const;
+
+			struct Data;
+
+			Xot::PImpl<Data, true> self;
+
+	};// StyleLength2
+
+
+	class StyleLength4
+	{
+
+		public:
+
+			StyleLength4 ();
+
+			StyleLength4 (const StyleLength& all);
+
+			StyleLength4 (
+				const StyleLength& horizontal,
+				const StyleLength& vertical);
+
+			StyleLength4 (
+				const StyleLength& left,
+				const StyleLength& vertical,
+				const StyleLength& right);
+
+			StyleLength4 (
+				const StyleLength& left,
+				const StyleLength& top,
+				const StyleLength& right,
+				const StyleLength& bottom);
+
+			StyleLength4 copy () const;
+
+			void           set_left (const StyleLength& left);
+
+			const StyleLength& left () const;
+
+			void           set_top (const StyleLength& top);
+
+			const StyleLength& top () const;
+
+			void           set_right (const StyleLength& right);
+
+			const StyleLength& right () const;
+
+			void           set_bottom (const StyleLength& bottom);
+
+			const StyleLength& bottom () const;
+
+			size_t size () const;
+
+			      StyleLength& operator [] (size_t i);
+
+			const StyleLength& operator [] (size_t i) const;
+
+			struct Data;
+
+			Xot::PImpl<Data, true> self;
+
+	};// StyleLength4
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/view.h

@@ -7,7 +7,13 @@
 #include <vector>
 #include <xot/ref.h>
 #include <xot/pimpl.h>
+#include <rays/point.h>
 #include <reflex/defs.h>
+#include <reflex/style.h>
+#include <reflex/event.h>
+
+
+//#define REFLEX_VIEW_REF_DEBUG 1
 
 
 namespace Rays
@@ -36,36 +42,135 @@ namespace Reflex
 
 			typedef Xot::Ref<This> Ref;
 
-			View ();
+			typedef std::vector<Ref>   ChildList;
 
-			virtual bool show ();
+			typedef std::vector<Style> StyleList;
 
-			virtual bool hide ();
+			typedef ChildList::      iterator       child_iterator;
 
-			virtual bool redraw ();
+			typedef ChildList::const_iterator const_child_iterator;
 
-			virtual bool add_child (View* child);
+			typedef StyleList::      iterator       style_iterator;
 
-			virtual bool remove_child (View* child);
+			typedef StyleList::const_iterator const_style_iterator;
 
-			virtual       View* find_child (
-				const char* name, size_t index = 0, bool recursive = false);
+			typedef Selector::       iterator         tag_iterator;
 
-			virtual const View* find_child (
-				const char* name, size_t index = 0, bool recursive = false) const;
+			typedef Selector:: const_iterator   const_tag_iterator;
 
-			virtual bool    set_name (const char* name);
+			enum Capture
+			{
 
-			virtual const char* name () const;
+				CAPTURE_NONE      = 0,
+
+				CAPTURE_KEY       = 0x1 << 0,
+
+				CAPTURE_POINTER   = 0x1 << 1,
 
-			virtual bool      set_bounds (coord x, coord y, coord width, coord height);
+				CAPTURE_ALL       = CAPTURE_KEY | CAPTURE_POINTER,
 
-			virtual bool      set_bounds (const Bounds& bounds);
+			};// Capture
 
-			virtual const Bounds& bounds () const;
+			View (const char* name = NULL);
+
+			virtual void show ();
+
+			virtual void hide ();
 
 			virtual bool hidden () const;
 
+			virtual void redraw ();
+
+			virtual void             add_child (View* child);
+
+			virtual void          remove_child (View* child);
+
+			virtual void            find_children (
+				ChildList* result, const Selector& selector, bool recursive = false) const;
+
+			virtual       child_iterator child_begin ();
+
+			virtual const_child_iterator child_begin () const;
+
+			virtual       child_iterator child_end ();
+
+			virtual const_child_iterator child_end () const;
+
+			virtual       Style&         style ();
+
+			virtual const Style&         style () const;
+
+			virtual void             add_style (const Style& style);
+
+			virtual void          remove_style (const Style& style);
+
+			virtual       Style*     get_style (const Selector& selector);
+
+			virtual const Style*     get_style (const Selector& selector) const;
+
+			virtual void            find_styles (
+				StyleList* result, const Selector& selector, bool recursive = false) const;
+
+			virtual       style_iterator style_begin ();
+
+			virtual const_style_iterator style_begin () const;
+
+			virtual       style_iterator style_end ();
+
+			virtual const_style_iterator style_end () const;
+
+			virtual void focus (bool state = true);
+
+			virtual void blur ();
+
+			virtual bool has_focus () const;
+
+			virtual void resize_to_fit ();
+
+			virtual Rays::Point content_size () const;
+
+			virtual void    set_name (const char* name);
+
+			virtual const char* name () const;
+
+			virtual void           add_tag (const char* tag);
+
+			virtual void        remove_tag (const char* tag);
+
+			virtual       tag_iterator tag_begin ();
+
+			virtual const_tag_iterator tag_begin () const;
+
+			virtual       tag_iterator tag_end ();
+
+			virtual const_tag_iterator tag_end () const;
+
+			virtual void        set_selector (const Selector& selector);
+
+			virtual       Selector& selector ();
+
+			virtual const Selector& selector () const;
+
+			virtual void      set_frame (coord x, coord y, coord width, coord height);
+
+			virtual void      set_frame (const Bounds& bounds);
+
+			virtual const Bounds& frame () const;
+
+			virtual void               scroll_to (coord x, coord y, coord z = 0);
+
+			virtual void               scroll_to (const Rays::Point& scroll);
+
+			virtual void               scroll_by (coord x, coord y, coord z = 0);
+
+			virtual void               scroll_by (const Rays::Point& dscroll);
+
+			virtual const Rays::Point& scroll () const;
+
+			virtual void set_capture (uint types);
+
+			virtual uint     capture () const;
+
 			virtual       View* parent ();
 
 			virtual const View* parent () const;
@@ -74,13 +179,53 @@ namespace Reflex
 
 			virtual const Window* window () const;
 
-			virtual void update (float dt);
+			virtual Rays::Point from_parent (const Rays::Point& point) const;
+
+			virtual Rays::Point   to_parent (const Rays::Point& point) const;
+
+			virtual Rays::Point from_window (const Rays::Point& point) const;
+
+			virtual Rays::Point   to_window (const Rays::Point& point) const;
 
-			virtual void draw (Painter* p, const Bounds& b);
+			virtual Rays::Point from_screen (const Rays::Point& point) const;
 
-			virtual void moved (coord dx, coord dy);
+			virtual Rays::Point   to_screen (const Rays::Point& point) const;
 
-			virtual void resized (coord dwidth, coord dheight);
+			virtual void on_attach (Event* e);
+
+			virtual void on_detach (Event* e);
+
+			virtual void on_update (UpdateEvent* e);
+
+			virtual void on_draw   (DrawEvent* e);
+
+			virtual void on_move   (FrameEvent* e);
+
+			virtual void on_resize (FrameEvent* e);
+
+			virtual void on_scroll (ScrollEvent* e);
+
+			virtual void on_focus (FocusEvent* e);
+
+			virtual void on_blur (FocusEvent* e);
+
+			virtual void on_key      (KeyEvent* e);
+
+			virtual void on_key_down (KeyEvent* e);
+
+			virtual void on_key_up   (KeyEvent* e);
+
+			virtual void on_pointer      (PointerEvent* e);
+
+			virtual void on_pointer_down (PointerEvent* e);
+
+			virtual void on_pointer_up   (PointerEvent* e);
+
+			virtual void on_pointer_move (PointerEvent* e);
+
+			virtual void on_wheel (WheelEvent* e);
+
+			virtual void on_capture (CaptureEvent* e);
 
 			virtual operator bool () const;
 
@@ -90,6 +235,24 @@ namespace Reflex
 
 			Xot::PImpl<Data> self;
 
+			#ifdef REFLEX_VIEW_REF_DEBUG
+				virtual void retain (void* data = NULL) const
+				{
+					RefCountable::retain(data);
+					String spaces = "";
+					for (int i = 0; i < refc_count(); ++i) spaces += " ";
+					printf("(%d)%s-> %s\n", refc_count(), spaces.c_str(), name());
+				}
+
+				virtual void release (void* data = NULL) const
+				{
+					RefCountable::release(data);
+					String spaces = "";
+					for (int i = 0; i < refc_count(); ++i) spaces += " ";
+					printf("(%d)%s<- %s\n", refc_count(), spaces.c_str(), name());
+				}
+			#endif// REFLEX_VIEW_REF_DEBUG
+
 		protected:
 
 			virtual ~View ();

data/include/reflex/window.h

@@ -6,13 +6,15 @@
 
 #include <xot/ref.h>
 #include <xot/pimpl.h>
+#include <rays/point.h>
 #include <reflex/defs.h>
+#include <reflex/event.h>
 
 
 namespace Rays
 {
 
-	class Bounds;
+	struct Bounds;
 
 	class Painter;
 
@@ -37,23 +39,23 @@ namespace Reflex
 
 			Window ();
 
-			virtual bool show ();
+			virtual void show ();
 
-			virtual bool hide ();
+			virtual void hide ();
 
-			virtual bool close ();
+			virtual void close ();
 
-			virtual bool redraw ();
+			virtual void redraw ();
 
-			virtual bool    set_title (const char* title);
+			virtual void    set_title (const char* title);
 
 			virtual const char* title () const;
 
-			virtual bool set_bounds (coord x, coord y, coord width, coord height);
+			virtual void set_frame (coord x, coord y, coord width, coord height);
 
-			virtual bool set_bounds (const Bounds& bounds);
+			virtual void set_frame (const Bounds& bounds);
 
-			virtual Bounds   bounds () const;
+			virtual Bounds   frame () const;
 
 			virtual bool hidden () const;
 
@@ -61,27 +63,41 @@ namespace Reflex
 
 			virtual const View* root () const;
 
+			virtual       View* focus ();
+
+			virtual const View* focus () const;
+
 			virtual       Painter* painter ();
 
 			virtual const Painter* painter () const;
 
-			virtual void update (float dt);
+			virtual Rays::Point from_screen (const Rays::Point& point) const;
+
+			virtual Rays::Point   to_screen (const Rays::Point& point) const;
+
+			virtual void on_update (UpdateEvent* e);
+
+			virtual void on_draw   (DrawEvent* e);
+
+			virtual void on_move   (FrameEvent* e);
+
+			virtual void on_resize (FrameEvent* e);
 
-			virtual void draw ();
+			virtual void on_key      (KeyEvent* e);
 
-			virtual void moved (coord x, coord y);
+			virtual void on_key_down (KeyEvent* e);
 
-			virtual void resized (coord width, coord height);
+			virtual void on_key_up   (KeyEvent* e);
 
-			virtual void key_down (const Key& key);
+			virtual void on_pointer      (PointerEvent* e);
 
-			virtual void key_up (const Key& key);
+			virtual void on_pointer_down (PointerEvent* e);
 
-			virtual void points_down (const Points& points);
+			virtual void on_pointer_up   (PointerEvent* e);
 
-			virtual void points_up (const Points& points);
+			virtual void on_pointer_move (PointerEvent* e);
 
-			virtual void points_moved (const Points& points);
+			virtual void on_wheel (WheelEvent* e);
 
 			operator bool () const;
 
@@ -89,7 +105,7 @@ namespace Reflex
 
 			struct Data;
 
-			Xot::PImpl<Data, true> self;
+			Xot::PImpl<Data> self;
 
 		protected:
 

data/include/reflex.h

@@ -7,9 +7,16 @@
 #include <reflex/defs.h>
 #include <reflex/reflex.h>
 #include <reflex/exception.h>
+
+#include <reflex/selector.h>
+#include <reflex/style.h>
+#include <reflex/event.h>
+
 #include <reflex/application.h>
 #include <reflex/window.h>
 #include <reflex/view.h>
 
+#include <reflex/image_view.h>
+
 
 #endif//EOH

data/lib/reflex/application.rb

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
 
 
-require 'xot/hookable'
 require 'xot/setter'
+require 'xot/block_util'
 require 'reflex/ext'
+require 'reflex/helper'
 
 
 module Reflex
@@ -11,13 +12,21 @@ module Reflex
 
   class Application
 
-    include Xot::Hookable
     include Xot::Setter
+    include Hookable
 
-    def initialize (opts = {})
+    def initialize (opts = {}, &block)
       super()
-      opts.each {|key, value| set key.intern, *value}
-      yield self if block_given?
+      set opts
+      @start_block = block
+    end
+
+    def on_start (e)
+      Xot::BlockUtil.instance_eval_or_block_call self, &@start_block if @start_block
+    end
+
+    def self.start (*args, &block)
+      self.new(*args, &block).start
     end
 
   end# Application