walt 0.1

data/lib/walt/asset/text.rb

@@ -0,0 +1,64 @@
+=begin
+  {
+    text: "This goes on the screen",
+    text_color: "ff0000",
+    background_color: "00ff00",
+    number_of_lines: 2,
+    text_alignment: :center,
+    font: "MarkerFelt" # see support/font.rb
+    attributes: {...} # see support/font.rb
+  }
+=end
+module Walt
+  class TextAsset < Asset
+    PROPERTIES = [:text, :text_color, :background_color, :number_of_lines, :font, :attributes, :text_alignment]
+    attr_accessor *PROPERTIES
+
+    attr_default :content_mode, [UIViewContentModeRedraw]
+    attr_default :text_color, UIColor.blackColor
+    attr_default :background_color, UIColor.clearColor
+    attr_default :number_of_lines, 1
+
+    def initialize(params = {})
+      super
+
+      params.is_a?(NSDictionary) && params.each do |key, value|
+        if PROPERTIES.include?(key.to_sym)
+          self.send("#{key}=", value)
+        end
+      end
+    end
+
+    def view
+      @view ||= UILabel.alloc.initWithFrame(CGRectZero).tap do |view|
+        view.frame = [self.position || CGPointZero, self.size || CGSizeZero]
+        view.contentMode = self.view_content_mode
+        view.clipsToBounds = self.clips_to_bounds
+        view.text = self.text
+        view.textColor = self.text_color.to_color
+        view.backgroundColor = self.background_color.to_color
+        view.numberOfLines = self.number_of_lines
+        view.font = Walt::Font.make(self.font) if self.font
+        view.textAlignment = Walt::Support.constant("UITextAlignment", self.text_alignment) if self.text_alignment
+
+        if self.attributes
+          attributes = Walt::Font.attributes(self.attributes)
+          view.font = attributes[UITextAttributeFont] if attributes[UITextAttributeFont]
+          view.textColor = attributes[UITextAttributeTextColor] if attributes[UITextAttributeTextColor]
+          view.shadowColor = attributes[UITextAttributeTextShadowColor] if attributes[UITextAttributeTextShadowColor]
+          if attributes[UITextAttributeTextShadowOffset]
+            view.shadowOffset = CGSizeMake(self.attributes[:shadow_offset][:x], self.attributes[:shadow_offset][:y])
+          end
+        end
+
+        if !self.size
+          view.sizeToFit
+        end
+
+        Dispatch::Queue.main.async do
+          self.on_ready(true)
+        end
+      end
+    end
+  end
+end

data/lib/walt/operation/base.rb

@@ -0,0 +1,60 @@
+=begin
+  {
+    type: :move,
+    id: :one
+  }
+=end
+
+module Walt
+  module Operation
+    class Base
+      extend Walt::Support::AttrDefault
+
+      PROPERTIES = [:id, :type]
+      attr_accessor *PROPERTIES
+
+      def initialize(params = {})
+        params.each do |key, value|
+          if PROPERTIES.include?(key.to_sym)
+            self.send("#{key}=", value)
+          end
+        end
+      end
+
+      def setup(view, animation)
+        # do initial before animation
+      end
+
+      def finalize(view, animation = nil)
+        # do whatever occurs during the animation
+      end
+    end
+
+    module_function
+    def for(hash)
+      # Check classes in module for corresponding operation
+      type = hash[:type] || hash["type"]
+
+      # Check for the form {operation_type: :id}
+      if !type
+        type = (hash.keys.map(&:to_s) | self.operation_types)[0]
+        hash[:id] = (hash[type] || hash[type.to_sym])
+        hash[:type] = type
+      end
+
+      if type.is_a?(Symbol) || type.is_a?(String)
+        string = "#{type.to_s.downcase}_operation".camelize
+        if not const_defined? string
+          raise "Invalid Operation value for operation #{hash.inspect}. Create a class called #{string}."
+        end
+        return Walt::Operation.const_get(string).new(hash)
+      end
+
+      self.new(hash)
+    end
+
+    def operation_types
+      Walt::Operation.constants(false).select { |constant_name| constant_name =~ /Operation$/ }.collect! { |op| op.to_s.gsub("Operation", "").underscore }
+    end
+  end
+end

data/lib/walt/operation/fade.rb

@@ -0,0 +1,35 @@
+=begin
+  {
+    from: 0.0,
+    to: 0.8
+  }
+=end
+
+module Walt
+  module Operation
+    class FadeOperation < Base
+      PROPERTIES = [:from, :to]
+      attr_accessor *PROPERTIES
+
+      def initialize(params = {})
+        super
+
+        params.each do |key, value|
+          if PROPERTIES.include?(key.to_sym)
+            self.send("#{key}=", value)
+          end
+        end
+      end
+
+      def setup(view, animation)
+        if self.from
+          view.alpha = self.from
+        end
+      end
+
+      def finalize(view, animation)
+        view.alpha = self.to
+      end
+    end
+  end
+end

data/lib/walt/operation/move.rb

@@ -0,0 +1,73 @@
+=begin
+  {
+    from: [0, 0],
+    to: [10, 20]
+  }
+
+  {
+    from: 100,
+    to: 200,
+    axis: :y
+  }
+=end
+
+module Walt
+  module Operation
+    class MoveOperation < Base
+      PROPERTIES = [:from, :to, :axis]
+      attr_accessor *PROPERTIES
+
+      attr_default :axis, :x
+
+      def initialize(params = {})
+        super
+
+        if axis = (params[:axis] || params["axis"])
+          self.axis = axis
+        end
+
+        params.each do |key, value|
+          if PROPERTIES.include?(key.to_sym)
+            self.send("#{key}=", value)
+          end
+        end
+      end
+
+      ["from", "to"].each do |point|
+        define_method("#{point}=") do |new_point|
+          _point = new_point
+          case new_point
+          when Numeric
+            if self.axis.to_sym == :x
+              _point = [new_point, nil]
+            else
+              _point = [nil, new_point]
+            end
+          when CGPoint
+            _point = [new_point.x, new_point.y]
+          when NSArray
+          else
+            raise "Invalid class for #{point}=: #{new_point.inspect}"
+          end
+          instance_variable_set("@#{point}", _point)
+        end
+      end
+
+      def setup(view, animation)
+        if self.from
+          origin = view.frame.origin
+          origin.x = (self.from[0] || origin.x) 
+          origin.y = (self.from[1] || origin.y)
+          view.frame = [origin, view.frame.size]
+        end
+      end
+
+      def finalize(view, animation)
+        origin = view.frame.origin
+        origin.x = (self.to[0] || origin.x) 
+        origin.y = (self.to[1] || origin.y)
+        view.frame = [origin, view.frame.size]
+      end
+    end
+  end
+end

data/lib/walt/operation/rotate.rb

@@ -0,0 +1,41 @@
+=begin
+  {
+    from: 0,
+    to: 45
+  }
+=end
+
+module Walt
+  module Operation
+    class RotateOperation < Base
+      PROPERTIES = [:from, :to]
+      attr_accessor *PROPERTIES
+
+      def initialize(params = {})
+        super
+
+        params.each do |key, value|
+          if PROPERTIES.include?(key.to_sym)
+            self.send("#{key}=", value)
+          end
+        end
+      end
+
+      def finalize(view, animation)
+        rotate = CABasicAnimation.animationWithKeyPath("transform.rotation")
+
+        from = self.from || view.instance_variable_get("@__last_rotation") || 0
+        rotate.fromValue = NSNumber.numberWithFloat(from)
+
+        rotate.toValue = NSNumber.numberWithFloat(self.to * Math::PI / 180)
+        view.instance_variable_set("@__last_rotation", rotate.toValue.to_f)
+
+        rotate.duration = animation.duration
+        rotate.removedOnCompletion = false
+        rotate.fillMode = KCAFillModeForwards
+
+        view.layer.addAnimation(rotate, forKey:nil)
+      end
+    end
+  end
+end

data/lib/walt/operation/scale.rb

@@ -0,0 +1,41 @@
+=begin
+  {
+    from: 1.0,
+    to: 1.2
+  }
+=end
+
+module Walt
+  module Operation
+    class ScaleOperation < Base
+      PROPERTIES = [:from, :to]
+      attr_accessor *PROPERTIES
+
+      def initialize(params = {})
+        super
+
+        params.each do |key, value|
+          if PROPERTIES.include?(key.to_sym)
+            self.send("#{key}=", value)
+          end
+        end
+      end
+
+      def finalize(view, animation)
+        scale = CABasicAnimation.animationWithKeyPath("transform.scale")
+
+        from = self.from || view.instance_variable_get("@__last_scale") || 1.0
+        scale.fromValue = NSNumber.numberWithFloat(from)
+
+        scale.toValue = NSNumber.numberWithFloat(self.to)
+        view.instance_variable_set("@__last_scale", scale.toValue.to_f)
+
+        scale.duration = animation.duration
+        scale.removedOnCompletion = false
+        scale.fillMode = KCAFillModeForwards
+
+        view.layer.addAnimation(scale, forKey:nil)
+      end
+    end
+  end
+end

data/lib/walt/patch/ui_color.rb

@@ -0,0 +1,5 @@
+class UIColor
+  def to_color
+    self
+  end
+end

data/lib/walt/support/attr_default.rb

@@ -0,0 +1,16 @@
+module Walt
+  module Support
+    module AttrDefault
+      def attr_default(attribute, default)
+        attr_accessor attribute
+        define_method(attribute) do
+          ivar = "@#{attribute}"
+          if !instance_variable_defined?(ivar)
+            instance_variable_set(ivar, default)
+          end
+          instance_variable_get(ivar)
+        end
+      end
+    end
+  end
+end

data/lib/walt/support/const_get.rb

@@ -0,0 +1,60 @@
+module Walt
+  module Support
+    module_function
+
+=begin
+  Constant.for("UIViewAnimationOption", value)
+=end
+
+    def constant(base, value)
+      return value if value.is_a? Numeric
+      value = value.to_s.camelize
+      Kernel.const_get("#{base}#{value}")
+    end
+
+    private
+    def hack
+      [
+        UIViewAnimationOptionLayoutSubviews,
+        UIViewAnimationOptionAllowUserInteraction,
+        UIViewAnimationOptionBeginFromCurrentState,
+        UIViewAnimationOptionRepeat,
+        UIViewAnimationOptionAutoreverse,
+        UIViewAnimationOptionOverrideInheritedDuration,
+        UIViewAnimationOptionOverrideInheritedCurve,
+        UIViewAnimationOptionAllowAnimatedContent,
+        UIViewAnimationOptionShowHideTransitionViews,
+        UIViewAnimationOptionCurveEaseInOut,
+        UIViewAnimationOptionCurveEaseIn,
+        UIViewAnimationOptionCurveEaseOut,
+        UIViewAnimationOptionCurveLinear,
+        UIViewAnimationOptionTransitionNone,
+        UIViewAnimationOptionTransitionFlipFromLeft,
+        UIViewAnimationOptionTransitionFlipFromRight,
+        UIViewAnimationOptionTransitionCurlUp,
+        UIViewAnimationOptionTransitionCurlDown,
+        UIViewAnimationOptionTransitionCrossDissolve,
+        UIViewAnimationOptionTransitionFlipFromTop,
+        UIViewAnimationOptionTransitionFlipFromBottom,
+
+        UIViewContentModeScaleToFill,
+        UIViewContentModeScaleAspectFit,
+        UIViewContentModeScaleAspectFill,
+        UIViewContentModeRedraw,
+        UIViewContentModeCenter,
+        UIViewContentModeTop,
+        UIViewContentModeBottom,
+        UIViewContentModeLeft,
+        UIViewContentModeRight,
+        UIViewContentModeTopLeft,
+        UIViewContentModeTopRight,
+        UIViewContentModeBottomLeft,
+        UIViewContentModeBottomRight,
+
+        UITextAlignmentLeft,
+        UITextAlignmentRight,
+        UITextAlignmentCenter
+      ]
+    end
+  end
+end

data/lib/walt/support/font.rb

@@ -0,0 +1,87 @@
+module Walt
+  module Font
+    module_function
+
+    def bold(size)
+      Font.make(:bold, size)
+    end
+
+    def system(size)
+      Font.make(:system, size)
+    end
+
+    def italic(size)
+      Font.make(:italic, size)
+    end
+
+    # Create font with params:
+    # String => The name of the font
+    # Hash => {
+    #   size: Integer,
+    #   name: String (see above)
+    # }
+    def make(params = {}, *args)
+      if params.is_a?(UIFont)
+        return params
+      end
+
+      _font = nil
+      if params.is_a?(NSString)
+        params = {name: params}
+      end
+      if args && args[0]
+        params.merge!({size: args[0]})
+      end
+      params[:size] ||= UIFont.systemFontSize
+      if [:system, :bold, :italic].member?(params[:name])
+        case params[:name]
+        when :system
+          _font = UIFont.systemFontOfSize(params[:size].to_f)
+        when :bold
+          _font = UIFont.boldSystemFontOfSize(params[:size].to_f)
+        when :italic
+          _font = UIFont.italicSystemFontOfSize(params[:size].to_f)
+        end
+      end
+
+      if !_font
+        begin
+          _font = UIFont.fontWithName(params[:name], size: params[:size])
+        rescue
+        end
+      end
+
+      if !_font
+        raise "Invalid font for parameters: #{params.inspect} args #{args.inspect}"
+      end
+
+      _font
+    end
+
+    # Create font attributes with keys:
+    # {
+    #   font: String or Hash (see Font.make),
+    #   color: String,
+    #   shadow_color: String,
+    #   shadow_offset: {
+    #     x: Integer,
+    #     y: Integer
+    #   }
+    # }
+    def attributes(params = {})
+      _attributes = {}
+
+      _attributes[UITextAttributeFont] = Font.make(params[:font]) if params[:font]
+      _attributes[UITextAttributeTextColor] = params[:color].to_color if params[:color]
+      _attributes[UITextAttributeTextShadowColor] = params[:shadow_color].to_color if params[:shadow_color]
+      _attributes[UITextAttributeTextShadowOffset] = begin
+        x = params[:shadow_offset][:x]
+        y = params[:shadow_offset][:y]
+        offset = UIOffsetMake(x,y)
+        NSValue.valueWithUIOffset(offset)
+      end if params[:shadow_offset]
+
+      _attributes
+    end
+  end
+end