reflexion 0.1.6 → 0.1.7

data/lib/reflex/model.rb

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+
+
+require 'xot/invoker'
+require 'xot/setter'
+require 'xot/block_util'
+require 'reflex/color'
+
+
+module Reflex
+
+
+  class Model
+
+    include Enumerable
+    include Xot::Invoker
+    include Xot::Setter
+
+    attr_reader :data
+
+    def initialize (data = nil, &block)
+      self.data = data if data
+      Xot::BlockUtil.instance_eval_or_block_call self, &block if block
+    end
+
+    def data= (data)
+      skip, data = apply_filters(data).tap do |filtered|
+        skip = filtered.nil? && !data.nil?
+        break skip, filtered
+      end
+      if !skip && data != @data
+        @data = data
+        invoke :update
+      end
+      @data
+    end
+
+    def add_handler (handler)
+      super
+      invoke :attach, {}, only: handler
+    end
+
+    def remove_handler (handler)
+      invoke :detach, {}, only: handler
+      super
+    end
+
+    def invoke (name, attributes = {}, options = {})
+      attributes[:data] ||= @data
+      super "on_data_#{name}".intern, attributes, options
+    end
+
+    def add_filter (&block)
+      (@filters ||= []).push block
+    end
+
+    def remove_filter (&block)
+      @filters.delete block if @filters
+    end
+
+    alias filter add_filter
+
+    def validate (&block)
+      filter {|data| block.call(data) ? data : nil}
+    end
+
+    def min= (min)
+      filter {|data| data < min ? min : data}
+    end
+
+    def max= (max)
+      filter {|data| data > max ? max : data}
+    end
+
+    def minmax= (range)
+      min, max = range.min, range.max
+      filter {|data| data < min ? min : data > max ? max : data}
+    end
+
+    def int (defvar = nil)
+      call_symbols INT_SYMS
+    end
+
+    def float (defvar = nil)
+      call_symbols FLOAT_SYMS
+    end
+
+    def string (defvar = nil)
+      call_symbols STRING_SYMS
+    end
+
+    def [] (*args)
+      call_symbols ARRAY_GET_SYMS, *args
+    end
+
+    def []= (*args)
+      ret = call_symbols ARRAY_SET_SYMS, *args
+      invoke :update
+      ret
+    end
+
+    def size ()
+      call_symbols(ARRAY_SIZE_SYMS) || 0
+    end
+
+    def each (&block)
+      data.each &block if block && data.respond_to?(:each)
+    end
+
+    def inspect ()
+      "#<Model data:#{@data.inspect}>"
+    end
+
+    private
+
+      INT_SYMS       = [:to_i, :to_int]
+
+      FLOAT_SYMS     = [:to_f, :to_float]
+
+      STRING_SYMS    = [:to_s, :to_str, :to_string]
+
+      ARRAY_GET_SYMS = [:[], :at]
+
+      ARRAY_SET_SYMS = [:[]=, :set_at]
+
+      ARRAY_SIZE_SYMS = [:size, :length]
+
+      def apply_filters (data)
+        return data unless @filters
+        @filters.each do |filter|
+          break if data.nil?
+          data = filter.call data
+        end
+        data
+      end
+
+      def call_symbols (symbols, *args)
+        if dat = data
+          symbols.each do |symbol|
+            return dat.send symbol, *args if dat.respond_to? symbol
+          end
+        end
+        nil
+      end
+
+  end# Model
+
+
+end# Reflex

data/lib/reflex/model_owner.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/model'
+
+
+module Reflex
+
+
+  module ModelOwner
+
+    attr_reader :model
+
+    def model= (model)
+      return if model == @model
+      @model.remove_handler self if @model
+      @model = model
+      @model.add_handler self    if @model
+      model
+    end
+
+    def data= (data)
+      unless data.nil?
+        self.model = Model.new unless @model
+        @model.data = data
+      else
+        self.model = nil
+      end
+      data
+    end
+
+    def data ()
+      @model ? @model.data : nil
+    end
+
+    def invoke (*args)
+      @model.invoke *args if @model
+    end
+
+    def on_data_attach (e)
+      invoke :update, {}, only: self
+    end
+
+    def on_data_detach (e)
+      invoke :update, {}, only: self
+    end
+
+    [:int, :float, :string, :[], :[]=].each do |name|
+      define_method name do |*args|
+        @model ? @model.send(name, *args) : nil
+      end
+    end
+
+  end# ModelOwner
+
+
+end# Reflex

data/lib/reflex/model_view.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/model_owner'
+
+
+module Reflex
+
+
+  module ModelView
+
+    include ModelOwner
+
+    def on_data_update (e)
+      resize_to_fit
+      redraw
+    end
+
+  end# ModelView
+
+
+end# Reflex

data/lib/reflex/module.rb

@@ -4,7 +4,11 @@
 module Reflex
 
 
-  extend module ModuleInfo
+  module Module
+
+    def name ()
+      super.split('::')[-2]
+    end
 
     def version ()
       open(root_dir 'VERSION') {|f| f.readline.chomp}
@@ -14,12 +18,12 @@ module Reflex
       File.expand_path "../../../#{path}", __FILE__
     end
 
-    def include_dirs ()
-      %w[include].map {|dir| root_dir dir}
+    def include_dir ()
+      root_dir 'include'
     end
 
-    def lib_dirs ()
-      %w[lib].map {|dir| root_dir dir}
+    def lib_dir ()
+      root_dir 'lib'
     end
 
     def task_dir ()
@@ -37,9 +41,9 @@ module Reflex
       end
     end
 
-    self
+    extend self
 
-  end# ModuleInfo
+  end# Module
 
 
 end# Reflex

data/lib/reflex/pointer_event.rb

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/ext'
+
+
+module Reflex
+
+
+  class PointerEvent
+
+    alias pos position
+
+    def type ()
+      TYPE2SYM[get_type] || :none
+    end
+
+    def down? ()
+      get_type == TYPE_DOWN
+    end
+
+    def up? ()
+      get_type == TYPE_UP
+    end
+
+    def move? ()
+      get_type == TYPE_MOVE
+    end
+
+    def left? ()
+      pointer_type.include? :mouse_left
+    end
+
+    def right? ()
+      pointer_type.include? :mouse_right
+    end
+
+    def middle? ()
+      pointer_type.include? :mouse_middle
+    end
+
+    def touch? ()
+      pointer_type.include? :touch
+    end
+
+    def pen? ()
+      pointer_type.include? :pen
+    end
+
+    def pointer_type ()
+      type_, array = get_pointer_type, []
+      POINTER_TYPE_LAST.to_s(2).sub(/^0+/, '').size.times do |i|
+        bit = 0x1 << i
+        if (type_ & bit) != 0
+          sym = POINTERTYPE2SYM[bit]
+          array << sym if sym
+        end
+      end
+      array
+    end
+
+    def inspect ()
+      "#<Reflex::PointerEvent type:#{type}/#{pointer_type} x:#{x} y:#{y} size:#{size} mod:#{modifiers} count:#{count} drag:#{drag?}>"
+    end
+
+    private
+
+      TYPE2SYM = {
+        TYPE_DOWN => :down,
+        TYPE_UP   => :up,
+        TYPE_MOVE => :move
+      }
+
+      POINTERTYPE2SYM = {
+        POINTER_MOUSE_LEFT   => :mouse_left,
+        POINTER_MOUSE_RIGHT  => :mouse_right,
+        POINTER_MOUSE_MIDDLE => :mouse_middle,
+        POINTER_TOUCH        => :touch,
+        POINTER_PEN          => :pen,
+      }
+
+  end# PointerEvent
+
+
+end# Reflex

data/lib/reflex/rect_shape.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/shape'
+
+
+module Reflex
+
+
+  class RectShape < Shape
+
+    def on_draw (e)
+      p, b = e.painter, e.bounds
+      attach_color_and_border(p) {p.rect b}
+    end
+
+  end# RectShape
+
+
+end# Reflex

data/lib/reflex/reflex.rb

@@ -2,6 +2,7 @@
 
 
 require 'reflex/ext'
+require 'reflex/window'
 
 
 module Reflex
@@ -9,8 +10,18 @@ module Reflex
 
   extend module ClassMethods
 
-    def run (name = nil)
-      run! name
+    def start (*args, &block)
+      Application.new(*args, &block).start
+    end
+
+    def quit ()
+      Application.instance.quit
+    end
+
+    def window (*args, &block)
+      w = Window.new *args, &block
+      w.show
+      w
     end
 
     self

data/lib/reflex/scroll_event.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/ext'
+
+
+module Reflex
+
+
+  class ScrollEvent
+
+    def inspect ()
+      "#<Reflex::ScrollEvent x:#{x} y:#{y} z:#{z} dx:#{dx} dy:#{dy} dz:#{dz}>"
+    end
+
+  end# ScrollEvent
+
+
+end# Reflex

data/lib/reflex/selector.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+
+require 'xot/setter'
+require 'xot/block_util'
+require 'reflex/ext'
+require 'reflex/helper'
+
+
+module Reflex
+
+
+  class Selector
+
+    include Xot::Setter
+    include HasTags
+
+    def initialize (opts = {}, &block)
+      super()
+      set opts
+      Xot::BlockUtil.instance_eval_or_block_call self, &block if block
+    end
+
+    def inspect ()
+      "#<#{self.class} name:'#{name}' tags:[#{tags.map{|s| "'#{s}'"}.to_a.join ','}]>"
+    end
+
+  end# Selector
+
+
+end# Reflex

data/lib/reflex/shader.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/shader'
+
+
+module Reflex
+
+
+  Shader = Rays::Shader
+
+
+end# Reflex

data/lib/reflex/shape.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/view'
+
+
+module Reflex
+
+
+  class Shape < View
+
+    attr_accessor :color, :border
+
+    def initialize (*args, &block)
+      @color  = :white
+      @border = :none
+      super
+    end
+
+    private
+
+      def attach_color_and_border (painter, &block)
+        fill, stroke = painter.color @color, @border
+        if block
+          block.call
+          painter.color fill, stroke
+        end
+        return fill, stroke
+      end
+
+  end# Shape
+
+
+end# Reflex

data/lib/reflex/style.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+
+require 'xot/setter'
+require 'xot/block_util'
+require 'reflex/ext'
+require 'reflex/helper'
+
+
+module Reflex
+
+
+  class Style
+
+    include Xot::Setter
+    include HasTags
+
+    def initialize (opts = {}, &block)
+      super()
+      set opts
+      Xot::BlockUtil.instance_eval_or_block_call self, &block if block
+    end
+
+    def flow= (*syms)
+      set_flow *syms.flatten.map {|sym| sym2flow sym}
+    end
+
+    def flow ()
+      get_flow.map {|n| flow2sym n}
+    end
+
+    private
+
+      SYM2FLOW = {
+        none:  FLOW_NONE,
+        down:  FLOW_DOWN,
+        right: FLOW_RIGHT,
+        up:    FLOW_UP,
+        left:  FLOW_LEFT,
+      }
+
+      FLOW2SYM = SYM2FLOW.inject({}) {|h, (k, v)| h[v] = k; h}
+
+      def sym2flow (sym)
+        SYM2FLOW[sym] || FLOW_NONE
+      end
+
+      def flow2sym (flow)
+        FLOW2SYM[flow] || :none
+      end
+
+  end# Style
+
+
+end# Reflex

data/lib/reflex/style_length.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/ext'
+
+
+module Reflex
+
+
+  class StyleLength
+
+    def initialize (*args)
+      return if args.empty?
+      case args[0]
+      when Numeric
+        args << :px if args.size < 2
+        setup_num *args
+      when String
+        setup_str *args
+      end
+    end
+
+    def inspect ()
+      "#<Reflex::StyleLength #{value}#{unit}>"
+    end
+
+  end# StyleLength
+
+
+end# Reflex

data/lib/reflex/style_length2.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+
+require 'xot/setter'
+require 'xot/block_util'
+require 'reflex/ext'
+
+
+module Reflex
+
+
+  class StyleLength2
+
+    include Xot::Setter
+
+    alias w= width=
+    alias w  width
+    alias h= height=
+    alias h  height
+
+    def initialize (opts = {}, &block)
+      super()
+      set opts
+      Xot::BlockUtil.instance_eval_or_block_call self, &block if block
+    end
+
+    def to_a ()
+      [width, height]
+    end
+
+  end# StyleLength2
+
+
+end# Reflex

data/lib/reflex/style_length4.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+
+require 'xot/setter'
+require 'xot/block_util'
+require 'reflex/ext'
+
+
+module Reflex
+
+
+  class StyleLength4
+
+    include Xot::Setter
+
+    alias l= left=
+    alias l  left
+    alias t= top=
+    alias t  top
+    alias r= right=
+    alias r  right
+    alias b= bottom=
+    alias b  bottom
+
+    def initialize (opts = {}, &block)
+      super()
+      set opts
+      Xot::BlockUtil.instance_eval_or_block_call self, &block if block
+    end
+
+    def to_a ()
+      [left, top, right, bottom]
+    end
+
+  end# StyleLength4
+
+
+end# Reflex