motion-kit 0.0.1 → 0.9.0

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

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

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

@@ -0,0 +1,34 @@
+# @requires MotionKit::NSViewLayout
+module MotionKit
+  class NSViewLayout
+
+    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
+
+    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-osx/layouts/nsview_layout_frame.rb

@@ -0,0 +1,375 @@
+# @requires MotionKit::NSViewLayout
+module MotionKit
+  class NSViewLayout
+    override_start
+
+    def _fix_frame_value(value)
+      if value.is_a?(Hash) && value[:relative]
+        return value.merge(flipped: flipped?)
+      end
+      return value
+    end
+
+    def flipped?
+      target.superview && !target.superview.flipped?
+    end
+
+    def x(value)
+      value = _fix_frame_value(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)
+      value = _fix_frame_value(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)
+      value = _fix_frame_value(value)
+      f = target.frame
+      f.origin.x = MotionKit.calculate(target, :width, value)
+      f.origin.x -= f.size.width / 2
+      target.frame = f
+      return CGRectGetMidX(target.frame)
+    end
+    alias middle_x center_x
+
+    def y(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      f.origin.y = MotionKit.calculate(target, :height, value)
+      target.frame = f
+      return CGRectGetMinY(f)
+    end
+
+    def bottom(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      f.origin.y = MotionKit.calculate(target, :height, value)
+      unless flipped?
+        f.origin.y -= f.size.height
+      end
+      target.frame = f
+
+      if flipped?
+        return CGRectGetMinY(target.frame)
+      else
+        return CGRectGetMaxY(target.frame)
+      end
+    end
+
+    def top(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      f.origin.y = MotionKit.calculate(target, :height, value)
+      if flipped?
+        f.origin.y -= f.size.height
+      end
+      target.frame = f
+
+      if flipped?
+        return CGRectGetMaxY(f)
+      else
+        return CGRectGetMinY(f)
+      end
+    end
+
+    def center_y(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      f.origin.y = MotionKit.calculate(target, :height, value)
+      f.origin.y -= f.size.height / 2
+      target.frame = f
+      return CGRectGetMidY(target.frame)
+    end
+    alias middle_y center_y
+
+    def width(value)
+      value = _fix_frame_value(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)
+      value = _fix_frame_value(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)
+      value = _fix_frame_value(value)
+      f = target.frame
+      f.origin = MotionKit.calculate(target, :origin, value)
+      target.frame = f
+      return target.frame.origin
+    end
+
+    def center(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      center = MotionKit.calculate(target, :center, value)
+      origin = CGPoint.new(center.x, center.y)
+      origin.x -= f.size.width / 2
+      origin.y -= f.size.height / 2
+      f.origin = origin
+      target.frame = f
+      return center
+    end
+    alias middle center
+
+    def size(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      f.size = MotionKit.calculate(target, :size, value)
+      target.frame = f
+      return target.frame.size
+    end
+
+    def frame(value)
+      value = _fix_frame_value(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 = NSView.alloc.initWithFrame([[0, 0], target.frame.size])
+      end
+
+      if f.is_a?(Hash)
+        f = f.merge(relative: true, flipped: flipped?)
+      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 :reset
+        # pass
+      when :min
+        unless flipped?
+          f.origin.y += from_view_size.height - f.size.height
+        end
+      when :mid
+        f.origin.y += (from_view_size.height - f.size.height) / 2.0
+      when :max
+        if flipped?
+          f.origin.y += from_view_size.height - f.size.height
+        end
+      when :above
+        if flipped?
+          f.origin.y += from_view_size.height
+        else
+          f.origin.y -= from_view_size.height + f.size.height
+        end
+      when :below
+        if flipped?
+          f.origin.y -= f.size.height
+        else
+          # pass
+        end
+      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: :max })
+    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: :max })
+    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: :max })
+    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: :min })
+    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: :min })
+    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: :min })
+    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