motion-xray 1.0.4

data/lib/motion-xray/plugins/save_ui_plugin.rb

@@ -0,0 +1,142 @@
+module Motion ; module Xray
+
+  class SaveUIPlugin < Plugin
+    name 'Save UI'
+
+    def initialize(type=nil)
+      @type = type
+    end
+
+    def type
+      @type || :teacup
+    end
+
+    class << self
+
+      # @param format [Symbol] :teacup or :pixate
+      # @param type [Class] The class that this encoder can handle
+      # @block handler This block should accept an instance (of `type`) and return a string.
+      def register(format, type, &handler)
+        # don't care about the return - the side effect is to establish
+        # @encoders
+        encoders(format)[type] = handler
+      end
+
+      def encoders(format, type=nil)
+        @encoders ||= {}
+        @encoders[format] ||= {}
+        unless @did_startup
+          @did_startup = true
+          startup
+        end
+
+        if type
+          retval = nil
+          while type
+            retval = @encoders[format][type]
+            break if retval
+            type = type.superclass
+          end
+          return retval
+        else
+          return @encoders[format]
+        end
+      end
+
+      def encode(format, object)
+        handler = encoders(format, object.class)
+        if handler
+          handler.call(object)
+        else
+          nil
+        end
+      end
+
+      def startup
+        register(:teacup, CGRect) { |rect| "[[#{rect.origin.x}, #{rect.origin.y}], [#{rect.size.width}, #{rect.size.height}]]"}
+        register(:teacup, CGPoint) { |rect| "[#{rect.origin.x}, #{rect.origin.y}]"}
+        register(:teacup, CGSize) { |rect| "[#{rect.size.width}, #{rect.size.height}]"}
+        register(:teacup, true.class) { |t| 'true' }
+        register(:teacup, false.class) { |t| 'false' }
+        # fall back
+        register(:teacup, NSObject) { |v| v.inspect }
+      end
+
+    end
+
+    def initialize
+      # uiview instance => list of changes
+      @changes = {}
+    end
+
+    def plugin_view(canvas)
+      @log = UITextView.alloc.initWithFrame(canvas.bounds)
+      @log.editable = false
+      @log.font = :monospace.uifont
+      @log.textColor = 0xBCBEAB.uicolor
+      @log.backgroundColor = 0x2b2b2b.uicolor
+      return @log
+    end
+
+    def save_changes(notification)
+      @changes[@target] ||= {}
+      property = notification.userInfo['property']
+      value = notification.userInfo['value']
+      original = notification.userInfo['original']
+
+      if value == original
+        @changes[@target].delete(property)
+      else
+        @changes[@target][property] = notification.userInfo['value']
+      end
+    end
+
+    def edit(target)
+      super
+      XrayTargetDidChangeNotification.remove_observer(self)
+      XrayTargetDidChangeNotification.add_observer(self, :'save_changes:', @target)
+    end
+
+    def show
+      if type
+        @log.text = send("#{type}_text")
+      end
+    end
+
+    def teacup_text
+      apply = {}
+      @changes.each do |view, properties|
+        properties.each do |property, value|
+          encoded = SaveUIPlugin.encode(:teacup, value)
+          if encoded
+            apply[view] ||= []
+            apply[view] << [property, encoded]
+          end
+        end
+      end
+
+      text = ''
+      apply.each do |view, stuff|
+        first_line = true
+        if view.stylesheet && view.stylename
+          name = "Teacup::Stylesheet[#{view.stylesheet.name.inspect}].style #{view.stylename.inspect},\n  "
+        else
+          name = "#{view.class.name.downcase}.style "
+        end
+
+        text << "#{name}"
+        stuff.each do |property, encoded|
+          unless first_line
+            text << ",\n  "
+          end
+          text << "#{property}: #{encoded}"
+          first_line = false
+        end
+        text << "\n\n"
+      end
+      return text
+    end
+
+  end
+
+end end

data/lib/motion-xray/plugins/ui_plugin.rb

@@ -0,0 +1,41 @@
+module Motion ; module Xray
+
+  class UIPlugin < Plugin
+    name 'UI'
+
+    def initialize
+      @editor_instances = []
+    end
+
+    def plugin_view(canvas)
+      @editors = XrayTypewriterView.alloc.initWithFrame(canvas.bounds)
+      @editors.scroll_view = canvas
+      @editors
+    end
+
+    def edit(target)
+      super
+      @editors.subviews.each &:removeFromSuperview
+      @editor_instances = []
+
+      properties = @target.xray
+      sections = properties.keys
+      properties.each do |section, editors|
+        section_view = XraySectionHeader.alloc.initWithFrame([[0, 0], [Xray.ui.full_screen_width, 20]])
+        section_view.text = section
+        @editors << section_view
+        editors.each do |property, editor_class|
+          next unless editor_class
+
+          editor_instance = editor_class.with_target(@target, property:property)
+          @editor_instances << editor_instance
+          section_view.tracking_view << editor_instance.get_edit_view(@editors.bounds.size.width)
+        end
+        @editors << section_view.tracking_view
+      end
+      @editors.layoutIfNeeded
+    end
+
+  end
+
+end end

data/lib/motion-xray/version.rb

@@ -0,0 +1,5 @@
+module Motion
+  module Xray
+    Version = '1.0.4'
+  end
+end

data/lib/motion-xray/views/xray_color_swatch.rb

@@ -0,0 +1,234 @@
+module Motion ; module Xray
+
+  class XrayColorSwatch < UIControl
+
+    def initWithFrame(frame)
+      super.tap do
+        gradient_view = XrayGradientView.alloc.initWithFrame(self.bounds).tap do |gradient_view|
+          gradient_view.layer.borderWidth = 1
+          gradient_view.layer.borderColor = :gray.uicolor.CGColor
+          gradient_view.userInteractionEnabled = false
+        end
+        self << gradient_view
+
+        swatch_rect = gradient_view.bounds.shrink(3)
+
+        gradient_view << XrayTriangleSwatch.alloc.initWithFrame(swatch_rect)
+
+        @color_swatch = UIView.alloc.initWithFrame(swatch_rect).tap do |color_swatch|
+          color_swatch.layer.borderWidth = 1
+          color_swatch.layer.borderColor = :dimgray.uicolor.CGColor
+        end
+        gradient_view << @color_swatch
+
+        @pressed_shader = UIView.alloc.initWithFrame(self.bounds).tap do |pressed_shader|
+          pressed_shader.backgroundColor = :black.uicolor(0.5)
+          pressed_shader.hide
+        end
+        self << @pressed_shader
+
+        self.on :touch_start do
+          @pressed_shader.show
+        end
+        self.on :touch_stop do
+          @pressed_shader.hide
+        end
+      end
+    end
+
+    def color=(value)
+      @color_swatch.backgroundColor = value && value.uicolor
+    end
+
+    def color
+      @color_swatch.backgroundColor
+    end
+
+  end
+
+  class XrayTriangleSwatch < UIView
+
+    def drawRect(rect)
+      context = UIGraphicsGetCurrentContext()
+
+      path = UIBezierPath.bezierPath
+      path.moveToPoint(bounds.top_right)
+      path.addLineToPoint(bounds.bottom_right)
+      path.addLineToPoint(bounds.bottom_left)
+      CGContextAddPath(context, path.CGPath)
+      :black.uicolor.setFill
+      CGContextFillPath(context)
+
+      path = UIBezierPath.bezierPath
+      path.moveToPoint(bounds.bottom_left)
+      path.addLineToPoint(bounds.top_left)
+      path.addLineToPoint(bounds.top_right)
+      CGContextAddPath(context, path.CGPath)
+      :white.uicolor.setFill
+      CGContextFillPath(context)
+    end
+
+  end
+
+  class XrayColorSliders < UIControl
+    attr_reader :color
+
+    def initWithFrame(frame)
+      super.tap do
+        self.backgroundColor = :black.uicolor
+        @color = :clear.uicolor
+        @triangle = XrayTriangleSwatch.alloc.initWithFrame(CGRect.empty)
+      end
+    end
+
+    def color=(value)
+      @color = value.uicolor
+      setNeedsDisplay
+    end
+
+    def drawRect(rect)
+      super
+
+      r = color.red
+      g = color.green
+      b = color.blue
+      a = color.alpha
+      return unless r && g && b && a
+
+      context = UIGraphicsGetCurrentContext()
+      color_space = CGColorSpaceCreateDeviceRGB()
+      slider_height = bounds.height / 5
+      slider_size = bounds.size
+      slider_size.height = slider_height
+      path = UIBezierPath.bezierPathWithRect([[0, 0], slider_size])
+      @triangle.frame = [[0, 0], slider_size]
+      @triangle.drawRect(rect)
+
+      CGContextSaveGState(context)
+      CGContextTranslateCTM(context, 0, 0)
+      color.setFill
+      path.fill
+      CGContextRestoreGState(context)
+
+      big_oval_width = slider_height - 4
+      big_oval = [[-big_oval_width / 2, (slider_height - big_oval_width) / 2], [big_oval_width, big_oval_width]]
+      big_oval_path = UIBezierPath.bezierPathWithOvalInRect(big_oval)
+      small_oval_width = 4
+      small_oval = [[-small_oval_width / 2, (slider_height - small_oval_width) / 2], [small_oval_width, small_oval_width]]
+      small_oval_path = UIBezierPath.bezierPathWithOvalInRect(small_oval)
+
+      points = [0, 1].to_pointer(:float)
+
+      cgcolors_red = [
+        UIColor.colorWithRed(0, green:g, blue:b, alpha:1).CGColor,
+        UIColor.colorWithRed(1, green:g, blue:b, alpha:1).CGColor,
+      ]
+      gradient_red = CGGradientCreateWithColors(color_space, cgcolors_red, points)
+      CGContextSaveGState(context)
+      CGContextTranslateCTM(context, 0, 1 * slider_height)
+      path.addClip
+      CGContextDrawLinearGradient(context, gradient_red, self.bounds.top_left, self.bounds.top_right, 0)
+      CGContextTranslateCTM(context, r * bounds.width, 0)
+      UIColor.colorWithRed(1, green:g, blue:b, alpha:1).invert.setStroke
+      big_oval_path.stroke
+      small_oval_path.stroke
+      CGContextRestoreGState(context)
+
+      cgcolors_green = [
+        UIColor.colorWithRed(r, green:0, blue:b, alpha:1).CGColor,
+        UIColor.colorWithRed(r, green:1, blue:b, alpha:1).CGColor,
+      ]
+      gradient_green = CGGradientCreateWithColors(color_space, cgcolors_green, points)
+      CGContextSaveGState(context)
+      CGContextTranslateCTM(context, 0, 2 * slider_height)
+      path.addClip
+      CGContextDrawLinearGradient(context, gradient_green, self.bounds.top_left, self.bounds.top_right, 0)
+      CGContextTranslateCTM(context, g * bounds.width, 0)
+      UIColor.colorWithRed(r, green:1, blue:b, alpha:1).invert.setStroke
+      big_oval_path.stroke
+      small_oval_path.stroke
+      CGContextRestoreGState(context)
+
+      cgcolors_blue = [
+        UIColor.colorWithRed(r, green:g, blue:0, alpha:1).CGColor,
+        UIColor.colorWithRed(r, green:g, blue:1, alpha:1).CGColor,
+      ]
+      gradient_blue = CGGradientCreateWithColors(color_space, cgcolors_blue, points)
+      CGContextSaveGState(context)
+      CGContextTranslateCTM(context, 0, 3 * slider_height)
+      path.addClip
+      CGContextDrawLinearGradient(context, gradient_blue, self.bounds.top_left, self.bounds.top_right, 0)
+      CGContextTranslateCTM(context, b * bounds.width, 0)
+      UIColor.colorWithRed(r, green:g, blue:1, alpha:1).invert.setStroke
+      big_oval_path.stroke
+      small_oval_path.stroke
+      CGContextRestoreGState(context)
+
+      cgcolors_alpha = [
+        UIColor.colorWithRed(r, green:g, blue:b, alpha:0).CGColor,
+        UIColor.colorWithRed(r, green:g, blue:b, alpha:1).CGColor,
+      ]
+      gradient_alpha = CGGradientCreateWithColors(color_space, cgcolors_alpha, points)
+      CGContextSaveGState(context)
+      CGContextTranslateCTM(context, 0, 4 * slider_height)
+      path.addClip
+      CGContextDrawLinearGradient(context, gradient_alpha, self.bounds.top_left, self.bounds.top_right, 0)
+      CGContextTranslateCTM(context, a * bounds.width, 0)
+      :white.uicolor.mix_with(color.uicolor(1).invert, a).setStroke
+      big_oval_path.stroke
+      small_oval_path.stroke
+      CGContextRestoreGState(context)
+    end
+
+    def touchesBegan(touches, withEvent:event)
+      point = touches.anyObject.locationInView(self)
+      @touched_section = nil
+      touched_color_at(point)
+    end
+
+    def touchesMoved(touches, withEvent:event)
+      point = touches.anyObject.locationInView(self)
+      touched_color_at(point)
+    end
+
+    ColorSection = 0
+    RedSection = 1
+    GreenSection = 2
+    BlueSection = 3
+    AlphaSection = 4
+
+    def touched_color_at(point)
+      slider_height = bounds.height / 5
+      section = (point.y / slider_height).floor
+      amount = [[point.x / bounds.width, 0].max, 1].min
+
+      # assigns @touched_section only the first time (in `touchesBegan()`)
+      @touched_section ||= section
+      # makes sure we're still touching the same section
+      section = @touched_section
+      return if section == ColorSection
+
+      r = color.red
+      g = color.green
+      b = color.blue
+      a = color.alpha
+
+      case section
+      when RedSection
+        r = amount
+      when GreenSection
+        g = amount
+      when BlueSection
+        b = amount
+      when AlphaSection
+        amount = (amount * 100).round / 100.0
+        a = amount
+      end
+
+      self.color = UIColor.colorWithRed(r, green:g, blue:b, alpha:a)
+      self.sendActionsForControlEvents(:value_changed.uicontrolevent)
+    end
+
+  end
+
+end end

data/lib/motion-xray/views/xray_dpad.rb

@@ -0,0 +1,142 @@
+module Motion ; module Xray
+
+  class XrayDpad < UIView
+
+    def initWithFrame(frame)
+      super.tap do
+        @pressed = {
+          up: 'xray_dpad_up'.uiimage,
+          down: 'xray_dpad_down'.uiimage,
+          left: 'xray_dpad_left'.uiimage,
+          right: 'xray_dpad_right'.uiimage,
+          center: 'xray_dpad_center'.uiimage,
+        }
+        @default = 'xray_dpad'.uiimage
+        @image_view = 'xray_dpad'.uiimageview
+        @pressing = nil
+        self << @image_view
+      end
+    end
+
+    def set_pressing_image(direction)
+      image = @pressed[direction] || @default
+      @image_view.image = image
+    end
+
+    def get_pressing(point)
+      center = CGRect.new([24.5, 24.5], [23.0, 23.0])
+      pressing = nil
+      if not self.bounds.contains? point
+        return nil
+      elsif center.contains? point
+        return :center
+      else
+        if point.x < point.y
+          if point.x < self.frame.height - point.y
+            return :left
+          else
+            return :down
+          end
+        else
+          if point.x < self.frame.height - point.y
+            return :up
+          else
+            return :right
+          end
+        end
+      end
+    end
+
+    def targets
+      @targets ||= []
+    end
+
+    def add_listener(target, action)
+      targets << [target, action]
+    end
+
+    def fire(delta)
+      if delta.is_a?(Symbol)
+        dx = 0
+        dy = 0
+        case delta
+        when :up
+          dy = -1
+        when :down
+          dy = 1
+        when :left
+          dx = -1
+        when :right
+          dx = 1
+        when :center
+          # pass
+        else
+          raise "huh? #{delta.inspect}"
+        end
+        delta = CGPoint.new(dx, dy)
+      end
+
+      targets.each { |target, action| target.send(action, delta) }
+    end
+
+    def touchesBegan(touches, withEvent:event)
+      super
+      point = touches.anyObject.locationInView(self)
+
+      @pressing = get_pressing(point)
+      @was_pressing = true
+      @started_location = point
+      if @pressing != :center
+        @started_time = NSDate.new.to_i
+        @started_timer = 0.1.every do
+          new_time = NSDate.new.to_i
+          delta = new_time - @started_time
+          break if delta < 0.5
+
+          if @was_pressing
+            fire(@pressing)
+          end
+        end
+        fire(@pressing)
+      end
+      set_pressing_image(@pressing)
+    end
+
+    def touchesMoved(touches, withEvent:event)
+      super
+      return unless @pressing
+
+      point = touches.anyObject.locationInView(self)
+      if @pressing == :center
+        dx = point.x - @started_location.x
+        dy = point.y - @started_location.y
+        fire(CGPoint.new(dx, dy))
+        @started_location = point
+      else
+        if get_pressing(point) != @pressing
+          @was_pressing = false
+          set_pressing_image(nil)
+        else
+          @was_pressing = true
+          set_pressing_image(@pressing)
+        end
+      end
+    end
+
+    def touchesEnded(touches, withEvent:event)
+      super
+      @started_timer.invalidate if @started_timer
+      set_pressing_image(nil)
+      @started_timer = nil
+    end
+
+    def touchesCancelled(touches, withEvent:event)
+      super
+      @started_timer.invalidate if @started_timer
+      set_pressing_image(nil)
+      @started_timer = nil
+    end
+
+  end
+
+end end