motion-kit 0.0.1 → 0.9.0

data/lib/motion-kit-ios/layouts/uiview_layout_autoresizing.rb

@@ -0,0 +1,75 @@
+# @requires MotionKit::UIViewLayout
+module MotionKit
+  class UIViewLayout
+
+    def autoresizing_mask(*values)
+      value = 0
+      values.each do |mask|
+        case mask
+        when :flexible_left
+          value |= UIViewAutoresizingFlexibleLeftMargin
+        when :flexible_width
+          value |= UIViewAutoresizingFlexibleWidth
+        when :flexible_right
+          value |= UIViewAutoresizingFlexibleRightMargin
+        when :flexible_top
+          value |= UIViewAutoresizingFlexibleTopMargin
+        when :flexible_height
+          value |= UIViewAutoresizingFlexibleHeight
+        when :flexible_bottom
+          value |= UIViewAutoresizingFlexibleBottomMargin
+
+        when :rigid_left
+          value ^= UIViewAutoresizingFlexibleLeftMargin
+        when :rigid_width
+          value ^= UIViewAutoresizingFlexibleWidth
+        when :rigid_right
+          value ^= UIViewAutoresizingFlexibleRightMargin
+        when :rigid_top
+          value ^= UIViewAutoresizingFlexibleTopMargin
+        when :rigid_height
+          value ^= UIViewAutoresizingFlexibleHeight
+        when :rigid_bottom
+          value ^= UIViewAutoresizingFlexibleBottomMargin
+
+        when :fill
+          value |= UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight
+        when :fill_top
+          value |= UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleBottomMargin
+        when :fill_bottom
+          value |= UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleTopMargin
+        when :fill_left
+          value |= UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleRightMargin
+        when :fill_right
+          value |= UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleLeftMargin
+
+        when :pin_to_top_left
+          value |= UIViewAutoresizingFlexibleRightMargin | UIViewAutoresizingFlexibleBottomMargin
+        when :pin_to_top
+          value |= UIViewAutoresizingFlexibleLeftMargin | UIViewAutoresizingFlexibleRightMargin | UIViewAutoresizingFlexibleBottomMargin
+        when :pin_to_top_right
+          value |= UIViewAutoresizingFlexibleLeftMargin | UIViewAutoresizingFlexibleBottomMargin
+        when :pin_to_left
+          value |= UIViewAutoresizingFlexibleTopMargin | UIViewAutoresizingFlexibleBottomMargin | UIViewAutoresizingFlexibleRightMargin
+        when :pin_to_center, :pin_to_middle
+          value |= UIViewAutoresizingFlexibleTopMargin | UIViewAutoresizingFlexibleBottomMargin | UIViewAutoresizingFlexibleLeftMargin | UIViewAutoresizingFlexibleRightMargin
+        when :pin_to_right
+          value |= UIViewAutoresizingFlexibleTopMargin | UIViewAutoresizingFlexibleBottomMargin | UIViewAutoresizingFlexibleLeftMargin
+        when :pin_to_bottom_left
+          value |= UIViewAutoresizingFlexibleRightMargin | UIViewAutoresizingFlexibleTopMargin
+        when :pin_to_bottom
+          value |= UIViewAutoresizingFlexibleLeftMargin | UIViewAutoresizingFlexibleRightMargin | UIViewAutoresizingFlexibleTopMargin
+        when :pin_to_bottom_right
+          value |= UIViewAutoresizingFlexibleLeftMargin | UIViewAutoresizingFlexibleTopMargin
+        else
+          value |= mask
+        end
+      end
+
+      target.autoresizingMask = value
+      value
+    end
+    alias autoresizingMask autoresizing_mask
+
+  end
+end

data/lib/motion-kit-ios/layouts/uiview_layout_constraints.rb

@@ -0,0 +1,36 @@
+# @requires MotionKit::UIViewLayout
+module MotionKit
+  class UIViewLayout
+
+    def constraints(view=nil, &block)
+      view ||= target
+      if view.is_a?(Symbol)
+        view = self.get(view)
+      end
+      view.setTranslatesAutoresizingMaskIntoConstraints(false)
+
+      deferred do
+        constraints_target = ConstraintsTarget.new(view)
+        context(constraints_target, &block)
+        constraints_target.apply_all_constraints(self, view)
+      end
+    end
+
+  end
+
+  class Layout
+
+    # Ensure we always have a context in this method; makes it easier to define
+    # constraints in an `add_constraints` method.
+    def constraints(view=nil, &block)
+      if @context
+        apply(:constraints, view, &block)
+      else
+        context(self.view) do
+          constraints(view, &block)
+        end
+      end
+    end
+
+  end
+end

data/lib/motion-kit-ios/layouts/uiview_layout_frame.rb

@@ -0,0 +1,307 @@
+# @requires MotionKit::UIViewLayout
+module MotionKit
+  class UIViewLayout
+    override_start
+
+    def x(value)
+      f = target.frame
+      f.origin.x = MotionKit.calculate(target, :width, value)
+      target.frame = f
+      return CGRectGetMinX(f)
+    end
+    alias left x
+
+    def right(value)
+      f = target.frame
+      f.origin.x = MotionKit.calculate(target, :width, value) - f.size.width
+      target.frame = f
+      return CGRectGetMaxX(f)
+    end
+
+    def center_x(value)
+      c = target.center
+      c.x = MotionKit.calculate(target, :width, value)
+      target.center = c
+      return CGRectGetMidX(target.frame)
+    end
+    alias middle_x center_x
+
+    def y(value)
+      f = target.frame
+      f.origin.y = MotionKit.calculate(target, :height, value)
+      target.frame = f
+      return CGRectGetMinY(f)
+    end
+    alias top y
+
+    def bottom(value)
+      f = target.frame
+      f.origin.y = MotionKit.calculate(target, :height, value) - f.size.height
+      target.frame = f
+      return CGRectGetMaxY(f)
+    end
+
+    def center_y(value)
+      c = target.center
+      c.y = MotionKit.calculate(target, :height, value)
+      target.center = c
+      return CGRectGetMidY(target.frame)
+    end
+    alias middle_y center_y
+
+    def width(value)
+      f = target.frame
+      f.size.width = MotionKit.calculate(target, :width, value)
+      target.frame = f
+      return CGRectGetWidth(f)
+    end
+    alias w width
+
+    def height(value)
+      f = target.frame
+      f.size.height = MotionKit.calculate(target, :height, value)
+      target.frame = f
+      return CGRectGetHeight(f)
+    end
+    alias h height
+
+    def origin(value)
+      f = target.frame
+      f.origin = MotionKit.calculate(target, :origin, value)
+      target.frame = f
+      return target.frame.origin
+    end
+
+    def center(value)
+      target.center = MotionKit.calculate(target, :center, value)
+      return target.center
+    end
+    alias middle center
+
+    def size(value)
+      f = target.frame
+      f.size = MotionKit.calculate(target, :size, value)
+      target.frame = f
+      return target.frame.size
+    end
+
+    def frame(value)
+      target.frame = MotionKit.calculate(target, :frame, value)
+      return target.frame
+    end
+
+    def _calculate_frame(f, from: from_view, relative_to: point)
+      if from_view.is_a?(Symbol)
+        from_view = self.get(from_view)
+      end
+
+      from_view_size = from_view.frame.size
+      o = from_view.convertPoint([0, 0], toView: target.superview)
+
+      calculate_view = target
+
+      if point[:x] == :reset || point[:y] == :reset
+        calculate_view = UIView.alloc.initWithFrame([[0, 0], target.frame.size])
+      end
+
+      if f.is_a?(Hash)
+        f = f.merge(relative: true)
+      end
+      f = MotionKit.calculate(calculate_view, :frame, f, from_view)
+      f.origin.x += o.x
+      f.origin.y += o.y
+
+      case point[:x]
+      when :min, :reset
+        # pass
+      when :mid
+        f.origin.x += (from_view_size.width - f.size.width) / 2.0
+      when :max
+        f.origin.x += from_view_size.width - f.size.width
+      when :before
+        f.origin.x -= f.size.width
+      when :after
+        f.origin.x += from_view_size.width
+      else
+        f.origin.x += point[:x]
+      end
+
+      case point[:y]
+      when :min, :reset
+        # pass
+      when :mid
+        f.origin.y += (from_view_size.height - f.size.height) / 2.0
+      when :max
+        f.origin.y += from_view_size.height - f.size.height
+      when :above
+        f.origin.y -= f.size.height
+      when :below
+        f.origin.y += from_view_size.height
+      else
+        f.origin.y += point[:y]
+      end
+
+      return f
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    #   frame from_top_left(width: 80, height: 22)
+    #   frame from_top_left(another_view, width: 80, height: 22)
+    def from_top_left(from_view=nil, f=nil)
+      if from_view.is_a?(Hash)
+        f = from_view
+        from_view = nil
+      end
+      f ||= {}
+      from_view ||= target.superview
+      _calculate_frame(f, from: from_view, relative_to: { x: :min, y: :min })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    #   frame from_top(width: 80, height: 22)
+    #   frame from_top(another_view, width: 80, height: 22)
+    def from_top(from_view=nil, f=nil)
+      if from_view.is_a?(Hash)
+        f = from_view
+        from_view = nil
+      end
+      f ||= {}
+      from_view ||= target.superview
+      _calculate_frame(f, from: from_view, relative_to: { x: :mid, y: :min })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    #   frame from_top_right(width: 80, height: 22)
+    #   frame from_top_right(another_view, width: 80, height: 22)
+    def from_top_right(from_view=nil, f=nil)
+      if from_view.is_a?(Hash)
+        f = from_view
+        from_view = nil
+      end
+      f ||= {}
+      from_view ||= target.superview
+      _calculate_frame(f, from: from_view, relative_to: { x: :max, y: :min })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    #   frame from_left(width: 80, height: 22)
+    #   frame from_left(another_view, width: 80, height: 22)
+    def from_left(from_view=nil, f=nil)
+      if from_view.is_a?(Hash)
+        f = from_view
+        from_view = nil
+      end
+      f ||= {}
+      from_view ||= target.superview
+      _calculate_frame(f, from: from_view, relative_to: { x: :min, y: :mid })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    #   frame from_center(width: 80, height: 22)
+    #   frame from_center(another_view, width: 80, height: 22)
+    def from_center(from_view=nil, f=nil)
+      if from_view.is_a?(Hash)
+        f = from_view
+        from_view = nil
+      end
+      f ||= {}
+      from_view ||= target.superview
+      _calculate_frame(f, from: from_view, relative_to: { x: :mid, y: :mid })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    #   frame from_right(width: 80, height: 22)
+    #   frame from_right(another_view, width: 80, height: 22)
+    def from_right(from_view=nil, f=nil)
+      if from_view.is_a?(Hash)
+        f = from_view
+        from_view = nil
+      end
+      f ||= {}
+      from_view ||= target.superview
+      _calculate_frame(f, from: from_view, relative_to: { x: :max, y: :mid })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    #   frame from_bottom_left(width: 80, height: 22)
+    #   frame from_bottom_left(another_view, width: 80, height: 22)
+    def from_bottom_left(from_view=nil, f=nil)
+      if from_view.is_a?(Hash)
+        f = from_view
+        from_view = nil
+      end
+      f ||= {}
+      from_view ||= target.superview
+      _calculate_frame(f, from: from_view, relative_to: { x: :min, y: :max })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    #   frame from_bottom(width: 80, height: 22)
+    #   frame from_bottom(another_view, width: 80, height: 22)
+    def from_bottom(from_view=nil, f=nil)
+      if from_view.is_a?(Hash)
+        f = from_view
+        from_view = nil
+      end
+      f ||= {}
+      from_view ||= target.superview
+      _calculate_frame(f, from: from_view, relative_to: { x: :mid, y: :max })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    #   frame from_bottom_right(width: 80, height: 22)
+    #   frame from_bottom_right(another_view, width: 80, height: 22)
+    def from_bottom_right(from_view=nil, f=nil)
+      if from_view.is_a?(Hash)
+        f = from_view
+        from_view = nil
+      end
+      f ||= {}
+      from_view ||= target.superview
+      _calculate_frame(f, from: from_view, relative_to: { x: :max, y: :max })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    def above(from_view, f={})
+      _calculate_frame(f, from: from_view, relative_to: { x: :reset, y: :above })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    def below(from_view, f={})
+      _calculate_frame(f, from: from_view, relative_to: { x: :reset, y: :below })
+    end
+
+    # The first arg can be a view or a frame
+    # @example
+    def before(from_view, f={})
+      _calculate_frame(f, from: from_view, relative_to: { x: :before, y: :reset })
+    end
+    alias left_of before
+
+    # The first arg can be a view or a frame
+    # @example
+    def after(from_view, f={})
+      _calculate_frame(f, from: from_view, relative_to: { x: :after, y: :reset })
+    end
+    alias right_of after
+
+    # The first arg must be a view
+    # @example
+    def relative_to(from_view, f)
+      _calculate_frame(f, from: from_view, relative_to: { x: :reset, y: :reset })
+    end
+
+    override_stop
+  end
+end

data/lib/motion-kit-ios/layouts/uiview_layout_gradient.rb

@@ -0,0 +1,20 @@
+# @requires MotionKit::UIViewLayout
+module MotionKit
+  class UIViewLayout
+
+    # gradient colors:
+    def gradient(&block)
+      gradient_layer = target.motion_kit_meta(:motionkit_gradient_layer) || begin
+        gradient_layer = CAGradientLayer.layer
+        gradient_layer.frame = CGRect.new([0, 0], target.frame.size)
+        target.layer.insertSublayer(gradient_layer, atIndex:0)
+
+        gradient_layer
+      end
+      context(gradient_layer, &block)
+
+      gradient_layer
+    end
+
+  end
+end

data/lib/motion-kit-osx/dummy.rb

@@ -0,0 +1,89 @@
+class DummyView < NSView
+private
+  def dummy
+    setFrame(nil)
+    setOpaque(nil)
+    setClipsToBounds(nil)
+    setUserInteractionEnabled(nil)
+    setAutoresizingMask(nil)
+    NSView.appearanceWhenContainedIn(NSView, nil)
+    NSView.appearance
+  end
+end
+
+class DummyTableView < NSTableView
+private
+ def dummy
+   setAllowSelection(value)
+   setSelectionHighlightStyle(value)
+ end
+end
+
+class DummyTableColumn < NSTableColumn
+private
+  def dummy
+    setEditable(nil)
+  end
+end
+
+class DummyButton < NSButton
+private
+  def dummy
+    setTitleEdgeInsets(nil)
+    setTarget(nil)
+    setAction(nil)
+    setBezelStyle(nil)
+    setBordered(nil)
+    setImagePosition(nil)
+  end
+end
+
+class DummyScrollView < NSScrollView
+private
+  def dummy
+    setScrollEnabled(nil)
+    setHasVerticalScroller(nil)
+    setHasHorizontalScroller(nil)
+    setDocumentView(nil)
+  end
+end
+
+class DummyTextField < NSTextField
+private
+  def dummy
+    setAdjustsFontSizeToFitWidth(nil)
+    setFormatter(nil)
+    setBezeled(nil)
+    setBezelStyle(nil)
+    setDrawsBackground(nil)
+  end
+end
+
+class DummyTextView < NSTextView
+private
+  def dummy
+    setSecureTextEntry(nil)
+    setReturnKeyType(nil)
+    setAutocapitalizationType(nil)
+    setAutocorrectionType(nil)
+    setSpellCheckingType(nil)
+    setDrawsBackground(nil)
+  end
+end
+
+class DummyLayer < CALayer
+private
+  def dummy
+    setCornerRadius(nil)
+    setTransform(nil)
+    setMasksToBounds(nil)
+    setShadowOffset(nil)
+    setShadowOpacity(nil)
+    setShadowRadius(nil)
+    setShadowOffset(nil)
+    setShadowColor(nil)
+    setShadowPath(nil)
+    setOpaque(nil)
+    setTranslucent(nil)
+  end
+end