motion-kit 0.14.1 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18f1f9da189410e1683214e3227a873166251cd7
-  data.tar.gz: 9acef866d767505e18fe4dc7defa0cc0cb41727d
+  metadata.gz: 4aef617ad6abab23df20a00836c0189ae5f7d962
+  data.tar.gz: 5795cf1d58ea7c33a713b0f964dd812bdccc57fc
 SHA512:
-  metadata.gz: be182328f8a528833582295c4d189c6985755742165e3d708f7f9aca15532bfb7fc7c15c70285e018c0edf57c515a8637abb1658e06b1db25b70c71205a32edb
-  data.tar.gz: 749585a9301994dea5f870876dd2fa9980eee29cfaf2d6e3a1a9f274d0f3ca2a8be820acfd82785b5fa878915d130003a71aad76ca3baafffda4d14be3f21196
+  metadata.gz: 99f22fcf82ab5a2dda61e570725cd0450455512ad99366595d4119cf39c94ed6b59981e5b7adc9579568116a3fc900b2feaf3dd72f3566a88ad857064ada680b
+  data.tar.gz: 349f157dac34e5b4aa2ef0ce58776a75b6b931d0668de50f1e597747051510af00f15cfe1b846fec04734c5350f4e46047890de6f59b89e327708f5acb525026

data/README.md

@@ -598,7 +598,7 @@ pin_to_center:       View stays centered, size does not change.
 pin_to_right:        View stays centered on the right, size does not change.
 pin_to_bottom_left:  View stays in bottom-left corner, size does not change.
 pin_to_bottom:       View stays in bottom-center, size does not change.
-pin_to_bottom_right: View stays in bottom-left corner, size does not change.
+pin_to_bottom_right: View stays in bottom-right corner, size does not change.
 ```
 
 

data/lib/motion-kit-cocoa/calculator/view_calculator.rb

@@ -23,8 +23,16 @@ module MotionKit
       elsif amount == :auto
         return intrinsic_size(view).send(dimension) # :left or :right
       elsif amount.is_a?(String) && amount.include?('%')
-        full_view ||= view.superview || begin
-          raise NoSuperviewError.new("Cannot calculate #{amount}% of #{dimension.inspect} because view #{view} has no superview.")
+        if not full_view
+          if view.is_a?(MotionKit.base_view_class)
+            full_view = view.superview
+          elsif view.is_a?(CALayer)
+            full_view = view.superlayer
+          end
+
+          if not full_view
+            raise NoSuperviewError.new("Cannot calculate #{amount.inspect} of #{dimension.inspect} because view #{view} has no superview.")
+          end
         end
         calc = Calculator.scan(amount)
 

data/lib/motion-kit-cocoa/helpers/calayer_frame_helpers.rb

@@ -0,0 +1,329 @@
+# @requires MotionKit::CALayerHelpers
+module MotionKit
+  class CALayerHelpers
+
+    def x(value)
+      f = target.frame
+      superview = target.superlayer || parent_layout.parent
+      f.origin.x = MotionKit.calculate(target, :width, value, superview)
+      target.frame = f
+      return CGRectGetMinX(f)
+    end
+    alias left x
+
+    def right(value)
+      f = target.frame
+      superview = target.superlayer || parent_layout.parent
+      f.origin.x = MotionKit.calculate(target, :width, value, superview) - f.size.width
+      target.frame = f
+      return CGRectGetMaxX(f)
+    end
+
+    def center_x(value)
+      c = target.center
+      superview = target.superlayer || parent_layout.parent
+      c.x = MotionKit.calculate(target, :width, value, superview)
+      target.center = c
+      return CGRectGetMidX(target.frame)
+    end
+    alias middle_x center_x
+
+    def y(value)
+      f = target.frame
+      superview = target.superlayer || parent_layout.parent
+      f.origin.y = MotionKit.calculate(target, :height, value, superview)
+      target.frame = f
+      return CGRectGetMinY(f)
+    end
+    alias top y
+
+    def bottom(value)
+      f = target.frame
+      superview = target.superlayer || parent_layout.parent
+      f.origin.y = MotionKit.calculate(target, :height, value, superview) - f.size.height
+      target.frame = f
+      return CGRectGetMaxY(f)
+    end
+
+    def center_y(value)
+      c = target.center
+      superview = target.superlayer || parent_layout.parent
+      c.y = MotionKit.calculate(target, :height, value, superview)
+      target.center = c
+      return CGRectGetMidY(target.frame)
+    end
+    alias middle_y center_y
+
+    def width(value)
+      f = target.frame
+      superview = target.superlayer || parent_layout.parent
+      f.size.width = MotionKit.calculate(target, :width, value, superview)
+      target.frame = f
+      return CGRectGetWidth(f)
+    end
+    alias w width
+
+    def height(value)
+      f = target.frame
+      superview = target.superlayer || parent_layout.parent
+      f.size.height = MotionKit.calculate(target, :height, value, superview)
+      target.frame = f
+      return CGRectGetHeight(f)
+    end
+    alias h height
+
+    def origin(value)
+      f = target.frame
+      superview = target.superlayer || parent_layout.parent
+      f.origin = MotionKit.calculate(target, :origin, value, superview)
+      target.frame = f
+      return target.frame.origin
+    end
+
+    def center(value)
+      superview = target.superlayer || parent_layout.parent
+      target.center = MotionKit.calculate(target, :center, value, superview)
+      return target.center
+    end
+    alias middle center
+
+    def size(value)
+      f = target.frame
+      superview = target.superlayer || parent_layout.parent
+      f.size = MotionKit.calculate(target, :size, value, superview)
+      target.frame = f
+      return target.frame.size
+    end
+
+    def frame(value)
+      superview = target.superlayer || parent_layout.parent
+      target.frame = MotionKit.calculate(target, :frame, value, superview)
+      return target.frame
+    end
+
+    def _calculate_frame(f, from: from_layer, relative_to: point)
+      if from_layer.is_a?(Symbol)
+        from_layer = self.get_view(from_layer)
+      end
+
+      from_layer_size = from_layer.frame.size
+      o = from_layer.convertPoint([0, 0], toLayer: target.superlayer)
+
+      calculate_layer = CALayer.layer
+      calculate_layer.frame = [[0, 0], target.frame.size]
+
+      if f.is_a?(Hash)
+        f = f.merge(relative: true)
+      end
+      f = MotionKit.calculate(calculate_layer, :frame, f, target.superlayer || parent_layout.parent)
+      f.origin.x += o.x
+      f.origin.y += o.y
+
+      case point[:x]
+      when :min, :reset
+        # pass
+      when :mid
+        f.origin.x += (from_layer_size.width - f.size.width) / 2.0
+      when :max
+        f.origin.x += from_layer_size.width - f.size.width
+      when :before
+        f.origin.x -= f.size.width
+      when :after
+        f.origin.x += from_layer_size.width
+      else
+        f.origin.x += point[:x]
+      end
+
+      case point[:y]
+      when :min, :reset
+        # pass
+      when :mid
+        f.origin.y += (from_layer_size.height - f.size.height) / 2.0
+      when :max
+        f.origin.y += from_layer_size.height - f.size.height
+      when :above
+        f.origin.y -= f.size.height
+      when :below
+        f.origin.y += from_layer_size.height
+      else
+        f.origin.y += point[:y]
+      end
+
+      return f
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame from_top_left(width: 80, height: 22)
+    #   frame from_top_left(another_layer, width: 80, height: 22)
+    def from_top_left(from_layer=nil, f=nil)
+      if from_layer.is_a?(Hash)
+        f = from_layer
+        from_layer = nil
+      end
+      f ||= {}
+      from_layer ||= target.superlayer
+      _calculate_frame(f, from: from_layer, relative_to: { x: :min, y: :min })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame from_top(width: 80, height: 22)
+    #   frame from_top(another_layer, width: 80, height: 22)
+    def from_top(from_layer=nil, f=nil)
+      if from_layer.is_a?(Hash)
+        f = from_layer
+        from_layer = nil
+      end
+      f ||= {}
+      from_layer ||= target.superlayer
+      _calculate_frame(f, from: from_layer, relative_to: { x: :mid, y: :min })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame from_top_right(width: 80, height: 22)
+    #   frame from_top_right(another_layer, width: 80, height: 22)
+    def from_top_right(from_layer=nil, f=nil)
+      if from_layer.is_a?(Hash)
+        f = from_layer
+        from_layer = nil
+      end
+      f ||= {}
+      from_layer ||= target.superlayer
+      _calculate_frame(f, from: from_layer, relative_to: { x: :max, y: :min })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame from_left(width: 80, height: 22)
+    #   frame from_left(another_layer, width: 80, height: 22)
+    def from_left(from_layer=nil, f=nil)
+      if from_layer.is_a?(Hash)
+        f = from_layer
+        from_layer = nil
+      end
+      f ||= {}
+      from_layer ||= target.superlayer
+      _calculate_frame(f, from: from_layer, relative_to: { x: :min, y: :mid })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame from_center(width: 80, height: 22)
+    #   frame from_center(another_layer, width: 80, height: 22)
+    def from_center(from_layer=nil, f=nil)
+      if from_layer.is_a?(Hash)
+        f = from_layer
+        from_layer = nil
+      end
+      f ||= {}
+      from_layer ||= target.superlayer
+      _calculate_frame(f, from: from_layer, relative_to: { x: :mid, y: :mid })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame from_right(width: 80, height: 22)
+    #   frame from_right(another_layer, width: 80, height: 22)
+    def from_right(from_layer=nil, f=nil)
+      if from_layer.is_a?(Hash)
+        f = from_layer
+        from_layer = nil
+      end
+      f ||= {}
+      from_layer ||= target.superlayer
+      _calculate_frame(f, from: from_layer, relative_to: { x: :max, y: :mid })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame from_bottom_left(width: 80, height: 22)
+    #   frame from_bottom_left(another_layer, width: 80, height: 22)
+    def from_bottom_left(from_layer=nil, f=nil)
+      if from_layer.is_a?(Hash)
+        f = from_layer
+        from_layer = nil
+      end
+      f ||= {}
+      from_layer ||= target.superlayer
+      _calculate_frame(f, from: from_layer, relative_to: { x: :min, y: :max })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame from_bottom(width: 80, height: 22)
+    #   frame from_bottom(another_layer, width: 80, height: 22)
+    def from_bottom(from_layer=nil, f=nil)
+      if from_layer.is_a?(Hash)
+        f = from_layer
+        from_layer = nil
+      end
+      f ||= {}
+      from_layer ||= target.superlayer
+      _calculate_frame(f, from: from_layer, relative_to: { x: :mid, y: :max })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame from_bottom_right(width: 80, height: 22)
+    #   frame from_bottom_right(another_layer, width: 80, height: 22)
+    def from_bottom_right(from_layer=nil, f=nil)
+      if from_layer.is_a?(Hash)
+        f = from_layer
+        from_layer = nil
+      end
+      f ||= {}
+      from_layer ||= target.superlayer
+      _calculate_frame(f, from: from_layer, relative_to: { x: :max, y: :max })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame above(layer, [[0, 0], [100, 20]])
+    #   frame above(:layer, x: 0, y: 0, width: 100, height: 20)
+    #   frame above(:layer, down: 0, right: 0, width: 100, height: 20)
+    def above(from_layer, f={})
+      _calculate_frame(f, from: from_layer, relative_to: { x: :reset, y: :above })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame below(layer, [[0, 0], [100, 20]])
+    #   frame below(:layer, x: 0, y: 0, width: 100, height: 20)
+    #   frame below(:layer, down: 0, right: 0, width: 100, height: 20)
+    def below(from_layer, f={})
+      _calculate_frame(f, from: from_layer, relative_to: { x: :reset, y: :below })
+    end
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame before(layer, [[0, 0], [100, 20]])
+    #   frame before(:layer, x: 0, y: 0, width: 100, height: 20)
+    #   frame before(:layer, down: 0, right: 0, width: 100, height: 20)
+    def before(from_layer, f={})
+      _calculate_frame(f, from: from_layer, relative_to: { x: :before, y: :reset })
+    end
+    alias left_of before
+
+    # The first arg can be a layer or a frame
+    # @example
+    #   frame after(layer, [[0, 0], [100, 20]])
+    #   frame after(:layer, x: 0, y: 0, width: 100, height: 20)
+    #   frame after(:layer, down: 0, right: 0, width: 100, height: 20)
+    def after(from_layer, f={})
+      _calculate_frame(f, from: from_layer, relative_to: { x: :after, y: :reset })
+    end
+    alias right_of after
+
+    # The first arg must be a layer
+    # @example
+    #   frame relative_to(layer, [[0, 0], [100, 20]])
+    #   frame relative_to(:layer, x: 0, y: 0, width: 100, height: 20)
+    #   frame relative_to(:layer, down: 0, right: 0, width: 100, height: 20)
+    def relative_to(from_layer, f)
+      _calculate_frame(f, from: from_layer, relative_to: { x: :reset, y: :reset })
+    end
+
+  end
+end

data/lib/motion-kit/helpers/parent.rb

@@ -10,6 +10,10 @@ module MotionKit
       @element = element
     end
 
+    def frame
+      try(:frame)
+    end
+
     def origin
       try(:frame, :origin)
     end

data/lib/motion-kit/version.rb

@@ -1,3 +1,3 @@
 module MotionKit
-  VERSION = '0.14.1'
+  VERSION = '0.14.2'
 end

data/spec/ios/calayer_spec.rb

@@ -1,10 +1,23 @@
-describe CALayer do
+describe 'CALayerHelpers' do
 
   before do
+    @subject = TestCALayerLayout.new.build
   end
 
-  it 'should style a CALayer' do
-    1.should == 1
+  describe 'should style a CALayer' do
+    describe 'should style :gradient layer' do
+      it 'should set the frame' do
+        @subject.get(:gradient).frame.should == CGRectMake(0, 0, 20, 20)
+      end
+      it 'should set the colors' do
+        @subject.get(:gradient).colors.length.should == 2
+      end
+    end
+    describe 'should style :bottom layer' do
+      it 'should set the frame' do
+        @subject.get(:bottom).frame.should == CGRectMake(0, 20, 20, 10)
+      end
+    end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: motion-kit
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.14.2
 platform: ruby
 authors:
 - Colin T.A. Gray
@@ -54,6 +54,7 @@ files:
 - lib/motion-kit-cocoa/constraints/constraints_target.rb
 - lib/motion-kit-cocoa/helpers/accessibility_compat.rb
 - lib/motion-kit-cocoa/helpers/cagradientlayer_helpers.rb
+- lib/motion-kit-cocoa/helpers/calayer_frame_helpers.rb
 - lib/motion-kit-cocoa/helpers/calayer_helpers.rb
 - lib/motion-kit-cocoa/helpers/sugarcube_compat.rb
 - lib/motion-kit-ios/deprecated.rb