motion-kit 0.10.11 → 0.11.0

data/lib/motion-kit-cocoa/constraints/constraint.rb

@@ -74,7 +74,6 @@ module MotionKit
     def ==(compare)
       if @compare_flag
         equals(compare)
-        @compare_flag = false
 
         self
       else
@@ -89,7 +88,6 @@ module MotionKit
         end
 
         gte(compare)
-        @compare_flag = false
 
         self
       else
@@ -104,7 +102,6 @@ module MotionKit
         end
 
         lte(compare)
-        @compare_flag = false
 
         self
       else
@@ -279,23 +276,23 @@ module MotionKit
       def axis_lookup(axis)
         case axis
         when :horizontal
-          axis = UILayoutConstraintAxisHorizontal
+          UILayoutConstraintAxisHorizontal
         when :vertical
-          axis = UILayoutConstraintAxisVertical
+          UILayoutConstraintAxisVertical
+        else
+          axis
         end
-
-        return axis
       end
 
       def orientation_lookup(orientation)
         case orientation
         when :horizontal
-          orientation = NSLayoutConstraintOrientationHorizontal
+          NSLayoutConstraintOrientationHorizontal
         when :vertical
-          orientation = NSLayoutConstraintOrientationVertical
+          NSLayoutConstraintOrientationVertical
+        else
+          orientation
         end
-
-        return orientation
       end
 
       def view_lookup(layout, view, target)
@@ -303,10 +300,12 @@ module MotionKit
           target
         elsif target.is_a?(ConstraintPlaceholder)
           target.resolve(layout)
+        elsif target == :self
+          view
         elsif target == :superview
           view.superview
         else
-          layout.get(target)
+          layout.get_view(target)
         end
       end
 

data/lib/motion-kit-cocoa/constraints/constraint_placeholder.rb

@@ -10,11 +10,11 @@ module MotionKit
     def resolve(layout)
       case @type
       when :first
-        layout.get(@name)
+        layout.get_view(@name)
       when :last
-        layout.last(@name)
+        layout.last_view(@name)
       when :nth
-        layout.nth(@name, @value)
+        layout.nth_view(@name, @value)
       end
     end
 

data/lib/motion-kit-cocoa/constraints/constraints_layout.rb

@@ -22,134 +22,134 @@ module MotionKit
       ConstraintPlaceholder.new(:nth, name, value)
     end
 
-    def x(value=nil)
-      target_constraint(:left, :equal, value)
+    def x(value=nil, rel=:equal)
+      target_constraint(:left, rel, value)
     end
     alias left x
 
     def min_x(value=nil)
-      target_constraint(:left, :gte, value)
+      x(value, :gte)
     end
     alias min_left min_x
 
     def max_x(value=nil)
-      target_constraint(:left, :lte, value)
+      x(value, :lte)
     end
     alias max_left max_x
 
-    def leading(value=nil)
-      target_constraint(:leading, :equal, value)
+    def leading(value=nil, rel=:equal)
+      target_constraint(:leading, rel, value)
     end
 
     def min_leading(value=nil)
-      target_constraint(:leading, :gte, value)
+      leading(value, :gte)
     end
 
     def max_leading(value=nil)
-      target_constraint(:leading, :lte, value)
+      leading(value, :lte)
     end
 
-    def center_x(value=nil)
-      target_constraint(:center_x, :equal, value)
+    def center_x(value=nil, rel=:equal)
+      target_constraint(:center_x, rel, value)
     end
 
     def min_center_x(value=nil)
-      target_constraint(:center_x, :gte, value)
+      center_x(value, :gte)
     end
 
     def max_center_x(value=nil)
-      target_constraint(:center_x, :lte, value)
+      center_x(value, :lte)
     end
 
-    def right(value=nil)
-      target_constraint(:right, :equal, value)
+    def right(value=nil, rel=:equal)
+      target_constraint(:right, rel, value)
     end
 
     def min_right(value=nil)
-      target_constraint(:right, :gte, value)
+      right(value, :gte)
     end
 
     def max_right(value=nil)
-      target_constraint(:right, :lte, value)
+      right(value, :lte)
     end
 
-    def trailing(value=nil)
-      target_constraint(:trailing, :equal, value)
+    def trailing(value=nil, rel=:equal)
+      target_constraint(:trailing, rel, value)
     end
 
     def min_trailing(value=nil)
-      target_constraint(:trailing, :gte, value)
+      trailing(value, :gte)
     end
 
     def max_trailing(value=nil)
-      target_constraint(:trailing, :lte, value)
+      trailing(value, :lte)
     end
 
-    def y(value=nil)
-      target_constraint(:top, :equal, value)
+    def y(value=nil, rel=:equal)
+      target_constraint(:top, rel, value)
     end
     alias top y
 
     def min_y(value=nil)
-      target_constraint(:top, :gte, value)
+      y(value, :gte)
     end
     alias min_top min_y
 
     def max_y(value=nil)
-      target_constraint(:top, :lte, value)
+      y(value, :lte)
     end
     alias max_top max_y
 
-    def center_y(value=nil)
-      target_constraint(:center_y, :equal, value)
+    def center_y(value=nil, rel=:equal)
+      target_constraint(:center_y, rel, value)
     end
 
     def min_center_y(value=nil)
-      target_constraint(:center_y, :gte, value)
+      center_y(value, :gte)
     end
 
     def max_center_y(value=nil)
-      target_constraint(:center_y, :lte, value)
+      center_y(value, :lte)
     end
 
-    def bottom(value=nil)
-      target_constraint(:bottom, :equal, value)
+    def bottom(value=nil, rel=:equal)
+      target_constraint(:bottom, rel, value)
     end
 
     def min_bottom(value=nil)
-      target_constraint(:bottom, :gte, value)
+      bottom(value, :gte)
     end
 
     def max_bottom(value=nil)
-      target_constraint(:bottom, :lte, value)
+      bottom(value, :lte)
     end
 
-    def baseline(value=nil)
-      target_constraint(:baseline, :equal, value)
+    def baseline(value=nil, rel=:equal)
+      target_constraint(:baseline, rel, value)
     end
 
     def min_baseline(value=nil)
-      target_constraint(:baseline, :gte, value)
+      baseline(value, :gte)
     end
 
     def max_baseline(value=nil)
-      target_constraint(:baseline, :lte, value)
+      baseline(value, :lte)
     end
 
-    def width(value=nil)
-      target_constraint(:width, :equal, value)
+    def width(value=nil, rel=:equal)
+      target_constraint(:width, rel, value)
     end
     alias w width
 
     def min_width(value=nil)
-      target_constraint(:width, :gte, value)
+      width(value, :gte)
     end
 
     def max_width(value=nil)
-      target_constraint(:width, :lte, value)
+      width(value, :lte)
     end
 
-    def height(value=nil)
+    def height(value=nil, rel=:equal)
       target_constraint(:height, :equal, value)
     end
     alias h height
@@ -162,45 +162,79 @@ module MotionKit
       target_constraint(:height, :lte, value)
     end
 
-    def size(value=nil)
-      target_constraint(:size, :equal, value, SizeConstraint)
+    def size(value=nil, rel=:equal)
+      target_constraint(:size, rel, value, SizeConstraint)
     end
 
     def min_size(value=nil)
-      target_constraint(:size, :gte, value, SizeConstraint)
+      size(value, :gte)
     end
 
     def max_size(value=nil)
-      target_constraint(:size, :lte, value, SizeConstraint)
+      size(value, :lte)
     end
 
-    def center(value=nil)
-      target_constraint([:center_x, :center_y], :equal, value, PointConstraint)
+    def center(value=nil, rel=:equal)
+      target_constraint([:center_x, :center_y], rel, value, PointConstraint)
     end
 
     def min_center(value=nil)
-      target_constraint([:center_x, :center_y], :gte, value, PointConstraint)
+      center(value, :gte)
     end
 
     def max_center(value=nil)
-      target_constraint([:center_x, :center_y], :lte, value, PointConstraint)
+      center(value, :lte)
     end
 
-    def top_left(value=nil)
-      target_constraint([:left, :top], :equal, value, PointConstraint)
+    def top_left(value=nil, rel=:equal)
+      target_constraint([:left, :top], rel, value, PointConstraint)
     end
     alias origin top_left
 
-    def top_right(value=nil)
-      target_constraint([:right, :top], :equal, value, PointConstraint)
+    def min_top_left(value=nil)
+      top_left(value, :gte)
     end
+    alias min_origin min_top_left
 
-    def bottom_left(value=nil)
-      target_constraint([:left, :bottom], :equal, value, PointConstraint)
+    def max_top_left(value=nil)
+      top_left(value, :lte)
     end
+    alias max_origin max_top_left
 
-    def bottom_right(value=nil)
-      target_constraint([:right, :bottom], :equal, value, PointConstraint)
+    def top_right(value=nil, rel=:equal)
+      target_constraint([:right, :top], rel, value, PointConstraint)
+    end
+
+    def min_top_right(value=nil)
+      top_right(value, :gte)
+    end
+
+    def max_top_right(value=nil)
+      top_right(value, :lte)
+    end
+
+    def bottom_left(value=nil, rel=:equal)
+      target_constraint([:left, :bottom], rel, value, PointConstraint)
+    end
+
+    def min_bottom_left(value=nil)
+      bottom_left(value, :gte)
+    end
+
+    def max_bottom_left(value=nil)
+      bottom_left(value, :lte)
+    end
+
+    def bottom_right(value=nil, rel=:equal)
+      target_constraint([:right, :bottom], rel, value, PointConstraint)
+    end
+
+    def min_bottom_right(value=nil)
+      bottom_right(value, :gte)
+    end
+
+    def max_bottom_right(value=nil)
+      bottom_right(value, :lte)
     end
 
     def above(view)
@@ -242,7 +276,18 @@ module MotionKit
     def target_constraint(attribute, relationship, value=nil, constraint_class=nil)
       constraint_class ||= Constraint
       constraint = constraint_class.new(constraint_target.view, attribute, relationship)
-      constraint.equals(value) if value
+      if value == :scale
+        size = ViewCalculator.intrinsic_size(constraint_target.view)
+        if attribute == :width
+          constraint.equals(:self, :height).times(size.width / size.height)
+        elsif attribute == :height
+          constraint.equals(:self, :width).times(size.height / size.width)
+        else
+          raise "Cannot apply :scale relationship to #{attribute}"
+        end
+      elsif value
+        constraint.equals(value)
+      end
       constraint_target.add_constraints([constraint])
       constraint
     end

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

@@ -1,9 +1,10 @@
-# @requires MotionKit::ConstraintsLayout
+# @requires MotionKit::UIViewLayout
 module MotionKit
-  class ConstraintsLayout
+  class UIViewLayout
 
     def content_compression_resistance_priority(value, for_axis: axis)
       axis = Constraint.axis_lookup(axis)
+      target.setContentCompressionResistancePriority(value, forAxis: axis)
     end
 
     def compression_priority(value, for_axis: axis)
@@ -12,6 +13,7 @@ module MotionKit
 
     def content_hugging_priority(value, for_axis: axis)
       axis = Constraint.axis_lookup(axis)
+      target.setContentHuggingPriority(value, forAxis: axis)
     end
 
     def hugging_priority(value, for_axis: axis)

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

@@ -19,23 +19,6 @@ module MotionKit
       subview.removeFromSuperview
     end
 
-    # UIViews AND CALayers are updated
-    def reapply!(root=nil)
-      if root.is_a?(CALayer)
-        @layout_state = :reapply
-        MotionKit.find_all_layers(root) do |layer|
-          call_style_method(layer, layer.motion_kit_id) if layer.motion_kit_id
-        end
-        @layout_state = :initial
-      else
-        root ||= self.view
-        reapply!(root.layer)
-        super(root)
-      end
-
-      return self
-    end
-
   end
 
   class UIViewLayout < Layout

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

@@ -2,17 +2,17 @@
 module MotionKit
   class UIViewLayout
 
-    def constraints(view=nil, &block)
-      view ||= target
-      if view.is_a?(Symbol)
-        view = self.get(view)
+    def constraints(add_to_view=nil, &block)
+      add_to_view ||= target
+      if add_to_view.is_a?(Symbol)
+        add_to_view = self.get_view(add_to_view)
       end
-      view.setTranslatesAutoresizingMaskIntoConstraints(false)
+      add_to_view.setTranslatesAutoresizingMaskIntoConstraints(false)
 
-      constraints_target = ConstraintsTarget.new(view)
+      constraints_target = ConstraintsTarget.new(add_to_view)
       deferred(constraints_target) do
         context(constraints_target, &block)
-        constraints_target.apply_all_constraints(self, view)
+        constraints_target.apply_all_constraints(self, add_to_view)
       end
     end
 
@@ -22,12 +22,12 @@ module MotionKit
 
     # 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)
+    def constraints(add_to_view=nil, &block)
       if has_context?
-        apply(:constraints, view, &block)
+        apply(:constraints, add_to_view, &block)
       else
         context(self.view) do
-          constraints(view, &block)
+          constraints(add_to_view, &block)
         end
       end
     end

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

@@ -91,7 +91,7 @@ module MotionKit
 
     def _calculate_frame(f, from: from_view, relative_to: point)
       if from_view.is_a?(Symbol)
-        from_view = self.get(from_view)
+        from_view = self.get_view(from_view)
       end
 
       from_view_size = from_view.frame.size

data/lib/motion-kit-osx/layouts/constraints_layout.rb

@@ -1,39 +1,41 @@
-# @requires MotionKit::ConstraintsLayout
+# @requires MotionKit::NSViewLayout
 module MotionKit
-  class ConstraintsLayout
+  class NSViewLayout
 
     def content_compression_resistance_priority(value, for_orientation: orientation)
       orientation = Constraint.orientation_lookup(orientation)
-    end
-
-    # consistency with iOS methods:
-    def content_compression_resistance_priority(value, for_axis: orientation)
-      content_compression_resistance_priority(value, for_orientation: orientation)
+      target.setContentCompressionResistancePriority(value, forOrientation: axis)
     end
 
     def compression_priority(value, for_orientation: orientation)
       content_compression_resistance_priority(value, for_orientation: orientation)
     end
 
-    # consistency with iOS methods:
-    def compression_priority(value, for_axis: orientation)
-      content_compression_resistance_priority(value, for_orientation: orientation)
-    end
-
     def content_hugging_priority(value, for_orientation: orientation)
       orientation = Constraint.orientation_lookup(orientation)
+      target.setContentHuggingPriority(value, forOrientation: axis)
     end
 
-    # consistency with iOS methods:
-    def content_hugging_priority(value, for_axis: orientation)
+    def hugging_priority(value, for_orientation: orientation)
       content_hugging_priority(value, for_orientation: orientation)
     end
 
-    def hugging_priority(value, for_orientation: orientation)
+    ##|
+    ##|  Aliases for consistency with iOS versions:
+    ##|
+
+    def content_compression_resistance_priority(value, for_axis: orientation)
+      content_compression_resistance_priority(value, for_orientation: orientation)
+    end
+
+    def compression_priority(value, for_axis: orientation)
+      content_compression_resistance_priority(value, for_orientation: orientation)
+    end
+
+    def content_hugging_priority(value, for_axis: orientation)
       content_hugging_priority(value, for_orientation: orientation)
     end
 
-    # consistency with iOS methods:
     def hugging_priority(value, for_axis: orientation)
       content_hugging_priority(value, for_orientation: orientation)
     end

data/lib/motion-kit-osx/layouts/nstableview_layout.rb

@@ -13,8 +13,21 @@ module MotionKit
       end
       target.addTableColumn(column)
       context(column, &block)
+
+      column
     end
     alias add_table_column add_column
 
+    def column(column_or_identifier, &block)
+      if column_or_identifier.is_a?(NSTableColumn)
+        column = column_or_identifier
+      else
+        column_index = target.columnWithIdentifier(column_or_identifier)
+        column = target.tableColumns[column_index]
+      end
+      context(column, &block)
+    end
+    alias table_column column
+
   end
 end

data/lib/motion-kit-osx/layouts/nsview_layout.rb

@@ -19,25 +19,6 @@ module MotionKit
       subview.removeFromSuperview
     end
 
-    # NSViews AND CALayers are updated
-    def reapply!(root=nil)
-      if root.is_a?(CALayer)
-        @layout_state = :reapply
-        MotionKit.find_all_layers(root) do |layer|
-          call_style_method(layer, layer.motion_kit_id) if layer.motion_kit_id
-        end
-        @layout_state = :initial
-      else
-        root ||= self.view
-        if root.layer
-          reapply!(root.layer)
-        end
-        super(root)
-      end
-
-      return self
-    end
-
   end
 
   class NSViewLayout < Layout

data/lib/motion-kit-osx/layouts/nsview_layout_constraints.rb

@@ -2,17 +2,17 @@
 module MotionKit
   class NSViewLayout
 
-    def constraints(view=nil, &block)
-      view ||= target
-      if view.is_a?(Symbol)
-        view = self.get(view)
+    def constraints(add_to_view=nil, &block)
+      add_to_view ||= target
+      if add_to_view.is_a?(Symbol)
+        add_to_view = self.get_view(add_to_view)
       end
-      view.setTranslatesAutoresizingMaskIntoConstraints(false)
+      add_to_view.setTranslatesAutoresizingMaskIntoConstraints(false)
 
-      constraints_target = ConstraintsTarget.new(view)
+      constraints_target = ConstraintsTarget.new(add_to_view)
       deferred(constraints_target) do
         context(constraints_target, &block)
-        constraints_target.apply_all_constraints(self, view)
+        constraints_target.apply_all_constraints(self, add_to_view)
       end
     end
 
@@ -20,12 +20,12 @@ module MotionKit
 
   class Layout
 
-    def constraints(view=nil, &block)
+    def constraints(add_to_view=nil, &block)
       if has_context?
-        apply(:constraints, view, &block)
+        apply(:constraints, add_to_view, &block)
       else
         context(self.view) do
-          constraints(view, &block)
+          constraints(add_to_view, &block)
         end
       end
     end

data/lib/motion-kit-osx/layouts/nsview_layout_frame.rb

@@ -145,7 +145,7 @@ module MotionKit
 
     def _calculate_frame(f, from: from_view, relative_to: point)
       if from_view.is_a?(Symbol)
-        from_view = self.get(from_view)
+        from_view = self.get_view(from_view)
       end
 
       from_view_size = from_view.frame.size

data/lib/motion-kit-osx/layouts/nswindow_layout.rb

@@ -27,55 +27,6 @@ module MotionKit
       subview.removeFromSuperview
     end
 
-    # NSWindow doesn't have immediate children; restyle its contentView.
-    def reapply!(window=nil)
-      window ||= self.window
-      call_style_method(window, window.motion_kit_id) if window.motion_kit_id
-      context(window) do
-        super(window.contentView)
-      end
-    end
-
-    def get(element_id)
-      if self.window.motion_kit_id == element_id
-        return self.window
-      elsif self._root == self.window
-        self.get(element_id, in: self.window.contentView)
-      else
-        super
-      end
-    end
-
-    def last(element_id)
-      if self._root == self.window && last = self.last(element_id, in: self.window.contentView)
-        last
-      elsif self.window.motion_kit_id == element_id
-        self.window
-      else
-        super
-      end
-    end
-
-    def all(element_id)
-      if self._root == self.window
-        found = self.all(element_id, in: self.window.contentView)
-        if self.window.motion_kit_id == element_id
-          found << self.window
-        end
-        return found
-      else
-        super
-      end
-    end
-
-    def remove(element_id)
-      if self._root == self.window
-        self.remove(element_id, from: self.window.contentView)
-      else
-        super
-      end
-    end
-
   end
 
   class NSWindowLayout < WindowLayout