motion-kit 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1027d089bb3ce6aafe9f4f55d152a6e3c22a4511
-  data.tar.gz: 7e6b2b1bca51e2d3e0aae3d71a2adb76cf31c768
+  metadata.gz: 2b2b7891f4a764ec64a5a015e75cb609f161d744
+  data.tar.gz: ca6b9958b22c9dbc6d78efe6eaf9281878e1db98
 SHA512:
-  metadata.gz: f45d382fbffb1edea0cf1f4f53ca14344d997de32441319a4978d428fecf5721fe32f51e67c37437e28f335b932ab3ee3747059e6c269ec1f96df15f5bf032c2
-  data.tar.gz: 02332a86a6625fa6175423524e4bc94865a34c2d7da9a39318699edd144dea3e54893276c38331680e736ba64c67280a68284aa4852fdb31baaf99f2f8edf3b5
+  metadata.gz: 904f76837a3321502bccc36587931301d48d500ab597482df30d5541b218cb4de7cd7d21df78b3e4fa7d7e98b6d7e876e2926439ca4e761fa2345db9c258f419
+  data.tar.gz: c905dcff79b15598662c7cd2055ae8121cb763db31df07bca51d32002643b92ca942455242f514ddbdb14872a59c5326d73bb935fb11bea481a711bd392291bc

data/README.md

@@ -9,7 +9,7 @@
 2. Simple, easy to learn DSL
 3. Crossframework compatibility:
    - [UIKit][readmore-uikit]
-   - [ApplicationKit][readmore-applicationkit]
+   - [AppKit][readmore-appkit]
    - [AutoLayout][readmore-autolayout]
    - [Frame geometry][readmore-frames]
    - [CoreAnimation][readmore-coreanimation]
@@ -29,8 +29,9 @@
 [SweetKit]: https://github.com/rubymotion/sweet-kit
 
 [READMORE]: https://github.com/rubymotion/motion-kit/blob/master/READMORE.md
+[readmore-migrating]:      https://github.com/rubymotion/motion-kit/blob/master/READMORE.md#migrating-from-teacup
 [readmore-uikit]:          https://github.com/rubymotion/motion-kit/blob/master/READMORE.md#uikit
-[readmore-applicationkit]: https://github.com/rubymotion/motion-kit/blob/master/READMORE.md#applicationkit
+[readmore-appkit]: https://github.com/rubymotion/motion-kit/blob/master/READMORE.md#appkit
 [readmore-coreanimation]:  https://github.com/rubymotion/motion-kit/blob/master/READMORE.md#coreanimation
 [readmore-frames]:         https://github.com/rubymotion/motion-kit/blob/master/READMORE.md#frames
 [readmore-autolayout]:     https://github.com/rubymotion/motion-kit/blob/master/READMORE.md#autolayout
@@ -42,6 +43,10 @@
 You can [read all about](#goodbye-teacup) why Colin decided that Teacup needed to
 be replaced with a new project, rather than upgraded or refactored.
 
+If you need to update your app to use MotionKit, see
+[READMORE.md][readmore-migrating] for an example of migrating stylesheets,
+styles, and constraints.
+
 
 ## Usage
 
@@ -188,7 +193,7 @@ class LoginLayout < MotionKit::Layout
         frame [[10, 10], ['100% - 10', :auto]]
       end
       add UITextField, :password_input do
-        frame below(:username_input, margin: 8)
+        frame below(:username_input, down: 8)
       end
     end
   end
@@ -241,10 +246,11 @@ include multiple stylesheets this way, just be careful around name collisions.
 module LoginStyles
 
   def login_button_style
+    # this example uses SugarCube to create UIColor and CGColor objects.
     background_color '#51A8E7'.uicolor
     title 'Log In'
     # `layer` returns a CALayer, which in turn becomes the new context inside
-    # this block!
+    # this block
     layer do
       corner_radius 7.0
       shadow_color '#000000'.cgcolor
@@ -342,8 +348,11 @@ root view, so retain one yourself to prevent it from being deallocated.
 If you've used RMQ's Stylers, you'll recognize a very similar pattern here. In
 RMQ the 'style' methods are handed a 'Styler' instance, which wraps access to
 the view.  In MotionKit we make use of `method_missing` to call these methods
-indirectly.  That takes care of most methods related to styling, except those
-that take multiple arguments.  Those can get "helper" methods.
+indirectly.  That takes care of most methods related to styling, but you might
+want to write some "helper" methods so that your styling code is more concise.
+Some examples are included in the MotionKit core, but the [SweetKit][] gem has
+many more.  If you are writing helpers for UIKit or AppKit, please consider
+adding them to SweetKit, so we can all share in the productivity boost! :smiley:
 
 ```ruby
   def login_label_style
@@ -356,6 +365,7 @@ that take multiple arguments.  Those can get "helper" methods.
     title 'Press me'
     # this gets delegated to UIButtonHelpers#title(title), which in turn calls
     # button.setTitle(title, forState: UIControlStateNormal)
+    # See uibutton_helpers.rb for implementation.
   end
 ```
 
@@ -384,8 +394,8 @@ benchmarking it is insignificant and undetectable. Let us know if you find any
 performance issues.
 
 You can easily add your own helpers to MotionKit. They
-are all named consistenly, e.g. `MotionKit::UIViewHelpers`, e.g.
-`MotionKit::UILabelHelpers`.  You just need to specify the "target class" that
+should all be named consistenly, e.g. `MotionKit::UIViewHelpers`,
+`MotionKit::UILabelHelpers`, etc.  You just need to specify the "target class" that
 your helper class is meant to work with.  Each class can only have *one helper
 class*.
 
@@ -926,6 +936,16 @@ annoying subtletees of the NSCell/NSControl dichotomy.
     gem install sweet-kit
 
 
+# Gotchas
+
+### A Note on `add` and `remove`
+
+When you use the `add` method to add a subview, that view will be retained by
+the Layout *even if you remove it from the view hierarchy*.  If you want the
+Layout to forget all about the view, call `remove(view)` (which also calls
+`removeFromSuperview`) or `forget(element_id)` (which only removes it from the
+Layout) on the Layout.
+
 # Contributing
 
 We welcome your contributions! Please be sure to run the specs before you do,

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

@@ -730,7 +730,9 @@ module MotionKit
 
     def update_constraint
       if @resolved
-        @resolved.each do
+        [0, 1].each do |index|
+          constraint = @resolved[index]
+          constraint.constant = self.constant[index]
         end
       end
     end

data/lib/motion-kit-osx/helpers/nswindow_frame_helpers.rb

@@ -0,0 +1,361 @@
+# @requires MotionKit::NSWindowHelpers
+module MotionKit
+  class NSWindowHelpers
+
+    def _fix_frame_value(value)
+      if value.is_a?(Hash) && value[:relative]
+        return value.merge(flipped: true)
+      end
+      return value
+    end
+
+    def frame(value, autosave_name=nil)
+      value = _fix_frame_value(value)
+      screen = target.screen || NSScreen.mainScreen
+      value = MotionKit.calculate(target, :frame, value, screen)
+      target.setFrame(value, display: true)
+      if autosave_name
+        target.setFrameAutosaveName(autosave_name)
+      end
+      return target.frame
+    end
+
+    def x(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.origin.x = MotionKit.calculate(target, :width, value, screen)
+      target.setFrame(f, display: true)
+      return CGRectGetMinX(f)
+    end
+    alias left x
+
+    def right(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.origin.x = MotionKit.calculate(target, :width, value, screen) - f.size.width
+      target.setFrame(f, display: true)
+      return CGRectGetMaxX(f)
+    end
+
+    def center_x(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.origin.x = MotionKit.calculate(target, :width, value, screen)
+      f.origin.x -= f.size.width / 2
+      target.setFrame(f, display: true)
+      return CGRectGetMidX(target.frame)
+    end
+    alias middle_x center_x
+
+    def y(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.origin.y = MotionKit.calculate(target, :height, value, screen)
+      target.setFrame(f, display: true)
+      return CGRectGetMinY(f)
+    end
+
+    def bottom(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.origin.y = MotionKit.calculate(target, :height, value, screen)
+      target.setFrame(f, display: true)
+
+      return CGRectGetMinY(target.frame)
+    end
+
+    def top(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.origin.y = MotionKit.calculate(target, :height, value, screen)
+      f.origin.y -= f.size.height
+      target.setFrame(f, display: true)
+
+      return CGRectGetMaxY(f)
+    end
+
+    def center_y(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.origin.y = MotionKit.calculate(target, :height, value, screen)
+      f.origin.y -= f.size.height / 2
+      target.setFrame(f, display: true)
+      return CGRectGetMidY(target.frame)
+    end
+    alias middle_y center_y
+
+    def width(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.size.width = MotionKit.calculate(target, :width, value, screen)
+      target.setFrame(f, display: true)
+      return CGRectGetWidth(f)
+    end
+    alias w width
+
+    def height(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.size.height = MotionKit.calculate(target, :height, value, screen)
+      target.setFrame(f, display: true)
+      return CGRectGetHeight(f)
+    end
+    alias h height
+
+    def origin(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.origin = MotionKit.calculate(target, :origin, value, screen)
+      target.setFrame(f, display: true)
+      return target.frame.origin
+    end
+
+    def center(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      center = MotionKit.calculate(target, :center, value, screen)
+      origin = CGPoint.new(center.x, center.y)
+      origin.x -= f.size.width / 2
+      origin.y -= f.size.height / 2
+      f.origin = origin
+      target.setFrame(f, display: true)
+      return center
+    end
+    alias middle center
+
+    def size(value)
+      value = _fix_frame_value(value)
+      f = target.frame
+      screen = target.screen || NSScreen.mainScreen
+      f.size = MotionKit.calculate(target, :size, value, screen)
+      target.setFrame(f, display: true)
+      return target.frame.size
+    end
+
+    def _calculate_frame(f, from: from_window, relative_to: point)
+      if from_window.is_a?(Symbol)
+        from_window = self.get_view(from_window)
+      end
+
+      from_window_size = from_window.frame.size
+
+      calculate_window = target
+
+      if point[:x] == :reset || point[:y] == :reset
+        calculate_window = NSWindow.alloc.init
+        calculate_window.setFrame([[0, 0], target.frame.size], display: false)
+      end
+
+      if f.is_a?(Hash)
+        f = f.merge(relative: true, flipped: true)
+      end
+      f = MotionKit.calculate(calculate_window, :frame, f, from_window)
+      if from_window.is_a?(NSWindow)
+        f.origin.x += from_window.frame.origin.x
+        f.origin.y += from_window.frame.origin.y
+      end
+
+      case point[:x]
+      when :min, :reset
+        # pass
+      when :mid
+        f.origin.x += (from_window_size.width - f.size.width) / 2.0
+      when :max
+        f.origin.x += from_window_size.width - f.size.width
+      when :before
+        f.origin.x -= f.size.width
+      when :after
+        f.origin.x += from_window_size.width
+      else
+        f.origin.x += point[:x]
+      end
+
+      case point[:y]
+      when :reset, :min
+        # pass
+      when :mid
+        f.origin.y += (from_window_size.height - f.size.height) / 2.0
+      when :max
+        f.origin.y += from_window_size.height - f.size.height
+      when :above
+        f.origin.y += from_window_size.height
+      when :below
+        f.origin.y -= f.size.height
+      else
+        f.origin.y += point[:y]
+      end
+
+      return f
+    end
+
+    # The first arg can be a window 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_window=nil, f=nil)
+      if from_window.is_a?(Hash)
+        f = from_window
+        from_window = nil
+      end
+      f ||= {}
+      from_window ||= target.screen || NSScreen.mainScreen
+      _calculate_frame(f, from: from_window, relative_to: { x: :min, y: :max })
+    end
+
+    # The first arg can be a window or a frame
+    # @example
+    #   frame from_top(width: 80, height: 22)
+    #   frame from_top(another_view, width: 80, height: 22)
+    def from_top(from_window=nil, f=nil)
+      if from_window.is_a?(Hash)
+        f = from_window
+        from_window = nil
+      end
+      f ||= {}
+      from_window ||= target.screen || NSScreen.mainScreen
+      _calculate_frame(f, from: from_window, relative_to: { x: :mid, y: :max })
+    end
+
+    # The first arg can be a window 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_window=nil, f=nil)
+      if from_window.is_a?(Hash)
+        f = from_window
+        from_window = nil
+      end
+      f ||= {}
+      from_window ||= target.screen || NSScreen.mainScreen
+      _calculate_frame(f, from: from_window, relative_to: { x: :max, y: :max })
+    end
+
+    # The first arg can be a window or a frame
+    # @example
+    #   frame from_left(width: 80, height: 22)
+    #   frame from_left(another_view, width: 80, height: 22)
+    def from_left(from_window=nil, f=nil)
+      if from_window.is_a?(Hash)
+        f = from_window
+        from_window = nil
+      end
+      f ||= {}
+      from_window ||= target.screen || NSScreen.mainScreen
+      _calculate_frame(f, from: from_window, relative_to: { x: :min, y: :mid })
+    end
+
+    # The first arg can be a window or a frame
+    # @example
+    #   frame from_center(width: 80, height: 22)
+    #   frame from_center(another_view, width: 80, height: 22)
+    def from_center(from_window=nil, f=nil)
+      if from_window.is_a?(Hash)
+        f = from_window
+        from_window = nil
+      end
+      f ||= {}
+      from_window ||= target.screen || NSScreen.mainScreen
+      _calculate_frame(f, from: from_window, relative_to: { x: :mid, y: :mid })
+    end
+
+    # The first arg can be a window or a frame
+    # @example
+    #   frame from_right(width: 80, height: 22)
+    #   frame from_right(another_view, width: 80, height: 22)
+    def from_right(from_window=nil, f=nil)
+      if from_window.is_a?(Hash)
+        f = from_window
+        from_window = nil
+      end
+      f ||= {}
+      from_window ||= target.screen || NSScreen.mainScreen
+      _calculate_frame(f, from: from_window, relative_to: { x: :max, y: :mid })
+    end
+
+    # The first arg can be a window 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_window=nil, f=nil)
+      if from_window.is_a?(Hash)
+        f = from_window
+        from_window = nil
+      end
+      f ||= {}
+      from_window ||= target.screen || NSScreen.mainScreen
+      _calculate_frame(f, from: from_window, relative_to: { x: :min, y: :min })
+    end
+
+    # The first arg can be a window or a frame
+    # @example
+    #   frame from_bottom(width: 80, height: 22)
+    #   frame from_bottom(another_view, width: 80, height: 22)
+    def from_bottom(from_window=nil, f=nil)
+      if from_window.is_a?(Hash)
+        f = from_window
+        from_window = nil
+      end
+      f ||= {}
+      from_window ||= target.screen || NSScreen.mainScreen
+      _calculate_frame(f, from: from_window, relative_to: { x: :mid, y: :min })
+    end
+
+    # The first arg can be a window 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_window=nil, f=nil)
+      if from_window.is_a?(Hash)
+        f = from_window
+        from_window = nil
+      end
+      f ||= {}
+      from_window ||= target.screen || NSScreen.mainScreen
+      _calculate_frame(f, from: from_window, relative_to: { x: :max, y: :min })
+    end
+
+    # The first arg can be a window or a frame
+    # @example
+    def above(from_window, f={})
+      _calculate_frame(f, from: from_window, relative_to: { x: :reset, y: :above })
+    end
+
+    # The first arg can be a window or a frame
+    # @example
+    def below(from_window, f={})
+      _calculate_frame(f, from: from_window, relative_to: { x: :reset, y: :below })
+    end
+
+    # The first arg can be a window or a frame
+    # @example
+    def before(from_window, f={})
+      _calculate_frame(f, from: from_window, relative_to: { x: :before, y: :reset })
+    end
+    alias left_of before
+
+    # The first arg can be a window or a frame
+    # @example
+    def after(from_window, f={})
+      _calculate_frame(f, from: from_window, relative_to: { x: :after, y: :reset })
+    end
+    alias right_of after
+
+    # The first arg must be a view
+    # @example
+    def relative_to(from_window, f)
+      _calculate_frame(f, from: from_window, relative_to: { x: :reset, y: :reset })
+    end
+
+  end
+end