motion-kit 0.0.1 → 0.9.0

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

@@ -0,0 +1,14 @@
+# @requires MotionKit::NSWindowLayout
+module MotionKit
+  class NSWindowLayout
+
+    def frame(value, autosave_name=nil)
+      retval = target.setFrame(value, display: true)
+      if autosave_name
+        target.setFrameAutosaveName(autosave_name)
+      end
+      return retval
+    end
+
+  end
+end

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

@@ -0,0 +1,77 @@
+# @provides MotionKit::WindowLayout
+# @provides MotionKit::NSWindowLayout
+# @requires MotionKit::ViewLayout
+module MotionKit
+  class WindowLayout < ViewLayout
+
+    # A more sensible name for the window that is created.
+    def window
+      self.view
+    end
+
+    # platform specific default root view
+    def default_root
+      # child WindowLayout classes can return *their* NSView subclass from self.nsview_class
+      view_class = self.class.targets || NSWindow
+      view_class.alloc.initWithContentRect([[0, 0], [0, 0]],
+        styleMask: NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask,
+        backing: NSBackingStoreBuffered,
+        defer: false)
+    end
+
+    def add_child(subview)
+      target.contentView.addSubview(subview)
+    end
+
+    def remove_child(subview)
+      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
+      super(window.contentView)
+    end
+
+    def get(element_id)
+      if self.window.motion_kit_id == element_id
+        return self.window
+      else
+        self.get(element_id, in: self.window.contentView)
+      end
+    end
+
+    def last(element_id)
+      if last = self.last(element_id, in: self.window.contentView)
+        last
+      elsif self.window.motion_kit_id == element_id
+        self.window
+      else
+        nil
+      end
+    end
+
+    def all(element_id)
+      found = self.all(element_id, in: self.window.contentView)
+      if self.window.motion_kit_id == element_id
+        found << self.window
+      end
+      return found
+    end
+
+    def nth(element_id, index)
+      self.all(element_id, in: self.window.contentView)[index]
+    end
+
+    def remove(element_id)
+      self.remove(element_id, from: self.window.contentView)
+    end
+
+  end
+
+  class NSWindowLayout < WindowLayout
+    targets NSWindow
+  end
+
+end

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

@@ -0,0 +1,16 @@
+module MotionKit
+  module_function
+
+  def base_view_class
+    NSView
+  end
+
+  def default_view_class
+    NSView
+  end
+
+  def no_intrinsic_metric
+    NSViewNoInstrinsicMetric
+  end
+
+end

data/lib/motion-kit.rb

@@ -0,0 +1,33 @@
+unless defined?(Motion::Project::Config)
+  raise "The MotionKit gem must be required within a RubyMotion project Rakefile."
+end
+
+
+require 'dbt'
+
+Motion::Project::App.setup do |app|
+  core_lib = File.join(File.dirname(__FILE__), 'motion-kit')
+  cocoa_lib = File.join(File.dirname(__FILE__), 'motion-kit-cocoa')
+  platform = app.respond_to?(:template) ? app.template : :ios
+  platform_lib = File.join(File.dirname(__FILE__), "motion-kit-#{platform}")
+  unless File.exists? platform_lib
+    raise "Sorry, the platform #{platform.inspect} is not supported by MotionKit"
+  end
+
+  # scans app.files until it finds app/ (the default)
+  # if found, it inserts just before those files, otherwise it will insert to
+  # the end of the list
+  insert_point = app.files.find_index { |file| file =~ /^(?:\.\/)?app\// } || 0
+
+  Dir.glob(File.join(platform_lib, '**/*.rb')).reverse.each do |file|
+    app.files.insert(insert_point, file)
+  end
+  Dir.glob(File.join(cocoa_lib, '**/*.rb')).reverse.each do |file|
+    app.files.insert(insert_point, file)
+  end
+  Dir.glob(File.join(core_lib, '**/*.rb')).reverse.each do |file|
+    app.files.insert(insert_point, file)
+  end
+
+  DBT.analyze(app)
+end

data/lib/motion-kit/calculate.rb

@@ -0,0 +1,263 @@
+# @provides MotionKit::Calculator
+module MotionKit
+  module_function
+
+  def calculate(view, dimension, amount, full_view=nil)
+    if amount.is_a? Proc
+      return view.instance_exec(&amount)
+    elsif dimension == :origin || dimension == :center
+      return calculate_origin(view, dimension, amount, nil, full_view)
+    elsif dimension == :size
+      return calculate_size(view, amount, full_view)
+    elsif dimension == :frame
+      return calculate_frame(view, amount, full_view)
+    elsif amount == :full
+      return calculate(view, dimension, '100%', full_view)
+    elsif amount == :auto
+      size_that_fits = intrinsic_size(view)
+
+      return case dimension
+      when :width
+        return size_that_fits.width
+      when :height
+        return size_that_fits.height
+      end
+    elsif amount.is_a?(String) && amount.include?('%')
+      full_view ||= view.superview
+      unless full_view
+        raise NoSuperviewError.new("Cannot calculate #{amount}% of #{dimension.inspect} because view #{view} has no superview.")
+      end
+      calc = Calculator.scan(amount)
+
+      factor = calc.factor
+      constant = calc.constant
+
+      return case dimension
+      when :width
+        return (view.superview.frame.size.width * factor + constant).round
+      when :height
+        return (view.superview.frame.size.height * factor + constant).round
+      else
+        raise "Unknown dimension #{dimension}"
+      end
+    else
+      return amount
+    end
+  end
+
+  def calculate_origin(view, dimension, amount, my_size=nil, full_view)
+    my_size ||= view.frame.size
+
+    if amount == :center
+      x = calculate(view, :width, '50%', full_view) - my_size.width / 2.0
+      y = calculate(view, :height, '50%', full_view) - my_size.height / 2.0
+      return CGPoint.new(x, y)
+    elsif amount.is_a?(Array) || amount.is_a?(Hash)
+      x_offset = 0
+      y_offset = 0
+
+      if amount.is_a?(Hash)
+        if amount.fetch(:relative, false)
+          if amount.key?(:x)
+            x = amount[:x]
+          else
+            x = view.frame.origin.x
+            if dimension == :center
+              x += my_size.width / 2.0
+            end
+          end
+
+          if amount.key?(:y)
+            y = amount[:y]
+          else
+            y = view.frame.origin.y
+            if dimension == :center
+              y += my_size.height / 2.0
+            end
+          end
+
+          if amount.key?(:right)
+            x_offset = amount[:right]
+          elsif amount.key?(:left)
+            x_offset = -amount[:left]
+          end
+
+          if amount.key?(:down)
+            y_offset = amount[:down]
+          elsif amount.key?(:up)
+            y_offset = -amount[:up]
+          end
+          y_offset = -y_offset if amount[:flipped]
+        else
+          if amount.key?(:right)
+            x_offset = -my_size.width
+            x = amount.fetch(:right, view.frame.origin.x)
+          elsif amount.key?(:x) || amount.key?(:left)
+            x = amount[:x] || amount[:left]
+          elsif dimension == :center
+            x = view.frame.origin.x
+            x += my_size.width / 2
+          else
+            x = view.frame.origin.x
+          end
+
+          if amount.key?(:bottom)
+            y_offset = -my_size.height
+            y = amount.fetch(:bottom, view.frame.origin.y)
+          elsif amount.key?(:y) || amount.key?(:top)
+            y = amount[:y] || amount[:top]
+          elsif dimension == :center
+            y = view.frame.origin.y
+            y += my_size.height / 2
+          else
+            y = view.frame.origin.y
+          end
+        end
+      else
+        x = amount[0]
+        y = amount[1]
+      end
+
+      x = calculate(view, :width, x, full_view) + x_offset
+      y = calculate(view, :height, y, full_view) + y_offset
+      return CGPoint.new(x, y)
+    else
+      return amount
+    end
+  end
+
+  def calculate_size(view, amount, full_view)
+    if amount.is_a?(Array) || amount.is_a?(Hash)
+      if amount.is_a?(Hash)
+        w = amount.fetch(:w, amount.fetch(:width, view.frame.size.width))
+        h = amount.fetch(:h, amount.fetch(:height, view.frame.size.height))
+      else
+        w = amount[0]
+        h = amount[1]
+      end
+
+      # scaling is handled a little differently, because it is dependent on
+      # the other amount and the intrinsic size.
+      if w == :scale || h == :scale
+        if w == :scale && h == :scale
+          raise "Either width or height can be :scale, but not both"
+        elsif w == :scale
+          h = calculate(view, :height, h, full_view)
+          size = intrinsic_size(view)
+          w = h * size.width / size.height
+        elsif h == :scale
+          w = calculate(view, :width, w, full_view)
+          size = intrinsic_size(view)
+          h = w * size.height / size.width
+        end
+      else
+        w = calculate(view, :width, w, full_view)
+        h = calculate(view, :height, h, full_view)
+      end
+
+      return CGSize.new(w, h)
+    elsif amount == :full
+      w = calculate(view, :width, '100%', full_view)
+      h = calculate(view, :height, '100%', full_view)
+      return CGSize.new(w, h)
+    elsif amount == :auto
+      return intrinsic_size(view)
+    elsif amount.is_a?(Symbol)
+      raise "Unrecognized amount symbol #{amount.inspect} in MotionKit#calculate_size"
+    else
+      return amount
+    end
+  end
+
+  def calculate_frame(view, amount, full_view)
+    if amount.is_a?(Symbol)
+      case amount
+      when :full, :auto
+        size = calculate_size(view, amount, full_view)
+        origin = [0, 0]
+      when :center
+        size = view.frame.size
+        origin = calculate_origin(view, :center, ['50%', '50%'], size, full_view)
+        origin.x -= size.width / 2.0
+        origin.y -= size.height / 2.0
+      else
+        raise "Unrecognized amount symbol #{amount.inspect} in MotionKit#calculate_frame"
+      end
+
+      return CGRect.new(origin, size)
+    elsif amount.is_a?(Array)
+      if amount.length == 2
+        size = calculate_size(view, amount[1], full_view)
+        origin = calculate_origin(view, :origin, amount[0], size, full_view)
+      elsif amount.length == 4
+        size = calculate_size(view, [amount[2], amount[3]], full_view)
+        origin = calculate_origin(view, :origin, [amount[0], amount[1]], size, full_view)
+      else
+        raise "Don't know what to do with frame value #{amount.inspect}"
+      end
+
+      return CGRect.new(origin, size)
+    elsif amount.is_a?(Hash)
+      if amount.key?(:size)
+        size = calculate_size(view, amount[:size], full_view)
+      else
+        size = calculate_size(view, amount, full_view)
+      end
+
+      if amount.key?(:center)
+        origin = calculate_origin(view, :center, amount[:center], size, full_view)
+        origin.x -= size.width / 2
+        origin.y -= size.height / 2
+      elsif amount.key?(:origin)
+        origin = calculate_origin(view, :origin, amount[:origin], size, full_view)
+      else
+        origin = calculate_origin(view, :origin, amount, size, full_view)
+      end
+
+      return CGRect.new(origin, size)
+    else
+      return amount
+    end
+  end
+
+  def intrinsic_size(view)
+    size_that_fits = view.intrinsicContentSize
+    if size_that_fits.width == MotionKit.no_intrinsic_metric
+      size_that_fits.width = 0
+    end
+    if size_that_fits.height == MotionKit.no_intrinsic_metric
+      size_that_fits.height = 0
+    end
+    return size_that_fits
+  end
+
+  class Calculator
+    attr_accessor :factor, :constant
+
+    def self.memo
+      @memo ||= {}
+    end
+
+    def self.scan(amount)
+      amount = amount.gsub(' ', '')
+      return Calculator.memo[amount] if Calculator.memo[amount]
+
+      calc = Calculator.new
+
+      location = amount.index '%'
+      if location
+        calc.factor = amount.slice(0, location).to_f / 100.0
+        location += 1
+      else
+        calc.factor = 0
+        location = 0
+      end
+      calc.constant = amount.slice(location, amount.size).to_f
+
+      Calculator.memo[amount] = calc
+      return calc
+    end
+
+  end
+
+end

data/lib/motion-kit/layouts/base_layout.rb

@@ -0,0 +1,299 @@
+# @provides MotionKit::BaseLayout
+# @requires MotionKit::BaseLayoutClassMethods
+module MotionKit
+  # Abstract base class, responsible for "registration" of layout classes with
+  # the class `targets` method.
+  #
+  # Very few methods are defined on BaseLayout, and any unknown methods are
+  # delegated to the 'apply' method, which accepts a method name, arguments, and
+  # an optional block to set the new context.
+  #
+  # The ViewLayout subclass defines methods that are appropriate for adding and
+  # removing views to a view hierarchy.
+  class BaseLayout
+    # Class methods reside in base_layout_class_methods.rb
+    extend BaseLayoutClassMethods
+
+    attr :parent
+
+    def initialize
+      # @layout is the object we look in for style methods
+      @layout = self
+      # the Layout object that implements custom style methods. Leave this as nil
+      # in the initializer.
+      @layout_delegate = nil
+      @layout_state = :initial
+    end
+
+    def set_layout(layout)
+      @layout = layout && WeakRef.new(layout)
+    end
+
+    def target
+      if @layout.nil? || @layout == self
+        # only the "root layout" instance is allowed to change the context.
+        # if there isn't a context set, try and create a root instance; this
+        # will fail if we're not in a state that allows the root to be created
+        @context ||= create_default_root_context
+      else
+        # child layouts get the context from the root layout
+        @layout.target
+      end
+    end
+    def v ; target ; end
+
+    # Runs a block of code with a new object as the 'context'. Methods from the
+    # Layout classes are applied to this target object, and missing methods are
+    # delegated to a new Layout instance that is created based on the new
+    # context.
+    #
+    # This method is part of the public API, you can pass in any object to have
+    # it become the 'context'.
+    #
+    # Example:
+    #     def table_view_style
+    #       content = target.contentView
+    #       if content
+    #         context(content) do
+    #           background_color UIColor.clearColor
+    #         end
+    #       end
+    #
+    #       # usually you use 'context' automatically via method_missing, by
+    #       # passing a block to a method that returns an object. That object becomes
+    #       # the new context.
+    #       layer do
+    #         # self is now a CALayerLayout instance
+    #         corner_radius 5
+    #       end
+    #     end
+    def context(target, &block)
+      return target unless block
+      # this little line is incredibly important; the context is only set on
+      # the top-level Layout object.
+      return @layout.context(target, &block) if @layout != self
+
+      if target.is_a?(Symbol)
+        target = self.get(target)
+      end
+
+      context_was, parent_was, delegate_was = @context, @parent, @layout_delegate
+
+      was_top_level = @is_top_level
+      if @is_top_level.nil?
+        @is_top_level = true
+      else
+        @is_top_level = false
+      end
+      @parent = MK::Parent.new(context_was)
+      @context = target
+      @context.motion_kit_meta[:delegate] ||= Layout.layout_for(@layout, @context.class)
+      @layout_delegate = @context.motion_kit_meta[:delegate]
+      yield
+      @layout_delegate, @context, @parent = delegate_was, context_was, parent_was
+      if @is_top_level
+        run_deferred(target)
+      end
+      @is_top_level = was_top_level
+
+      target
+    end
+
+    # Blocks passed to `deferred` are run at the end of a "session", usually
+    # after a call to Layout#layout.
+    def deferred(&block)
+      if @layout != self
+        return @layout.add_deferred_block(self, &block)
+      else
+        return self.add_deferred_block(self, &block)
+      end
+    end
+
+    # Only intended for private use
+    def add_deferred_block(layout, &block)
+      raise InvalidDeferredError.new('deferred must be run inside of a context') if @is_top_level.nil?
+      raise ArgumentError.new('Block required') unless block
+
+      self.deferred_blocks << [@context, block]
+
+      self
+    end
+
+    # Only intended for private use
+    def deferred_blocks
+      @deferred_blocks ||= []
+    end
+
+    # Only intended for private use
+    def run_deferred(top_level_context)
+      deferred_blocks = self.deferred_blocks
+      @deferred_blocks = nil
+
+      deferred_blocks.each do |target, block|
+        context(target, &block)
+      end
+
+      if @deferred_blocks
+        run_deferred(top_level_context)
+      end
+    end
+
+    # @example
+    #     def login_button_style
+    #       frame [[0, 0], [100, 20]]
+    #       title 'Login'
+    #     end
+    #
+    # Methods that style the view start out as missing methods. This just calls
+    # 'apply', which searches for the method in the delegate
+    # (`@layout_delegate`) or using inspection (`respond_to?(:setFoo)`).
+    def method_missing(method_name, *args, &block)
+      self.apply(method_name, *args, &block)
+    end
+
+    # Tries to call the setter (`foo 'value'` => `view.setFoo('value')`), or
+    # assignment method (`foo 'value'` => `view.foo = 'value'`), or if a block
+    # is given, then the object returned by 'method_name' is assigned as the new
+    # context, and the block is executed.
+    #
+    # You can call this method directly, but usually it is called via
+    # method_missing.
+    def apply(method_name, *args, &block)
+      method_name = method_name.to_s
+      raise ApplyError.new("Cannot apply #{method_name.inspect} to instance of #{target.class.name}") if method_name.length == 0
+
+      # if there is no target, than we should raise the NoMethodError; someone
+      # called a method on the layout directly.
+      begin
+        target = self.target
+      rescue NoContextError => e
+        raise NoMethodError.new(method_name)
+      end
+
+      if args.length == 2 && args[1].is_a?(Hash) && !args[1].empty?
+        long_method_name = "#{method_name}:#{args[1].keys.join(':')}:"
+        long_method_args = [args[0]].concat args[1].values
+      else
+        long_method_name = nil
+        long_method_args = nil
+      end
+
+      @layout_delegate ||= Layout.layout_for(@layout, target.class)
+      if long_method_name && @layout_delegate.respond_to?(long_method_name)
+        return @layout_delegate.send(long_method_name, *long_method_args, &block)
+      elsif @layout_delegate.respond_to?(method_name)
+        return @layout_delegate.send(method_name, *args, &block)
+      end
+
+      if block
+        apply_with_context(method_name, *args, &block)
+      else
+        apply_with_target(method_name, *args)
+      end
+    end
+
+    def apply_with_context(method_name, *args, &block)
+      if args.length == 2 && args[1].is_a?(Hash) && !args[1].empty?
+        long_method_name = "#{method_name}:#{args[1].keys.join(':')}:"
+        long_method_args = [args[0]].concat args[1].values
+      else
+        long_method_name = nil
+        long_method_args = nil
+      end
+
+      if long_method_name && target.respond_to?(long_method_name)
+        new_context = target.send(long_method_name, *long_method_args)
+        self.context(new_context, &block)
+      elsif target.respond_to?(method_name)
+        new_context = target.send(method_name, *args)
+        self.context(new_context, &block)
+      elsif method_name.include?('_')
+        objc_name = MotionKit.objective_c_method_name(method_name)
+        self.apply(objc_name, *args, &block)
+      else
+        raise ApplyError.new("Cannot apply #{method_name.inspect} to instance of #{target.class.name}")
+      end
+    end
+
+    def apply_with_target(method_name, *args)
+      setter = MotionKit.setter(method_name)
+      assign = "#{method_name}="
+      if args.length == 2 && args[1].is_a?(Hash) && !args[1].empty?
+        long_method_name = "#{method_name}:#{args[1].keys.join(':')}:"
+        long_method_args = [args[0]].concat args[1].values
+      else
+        long_method_name = nil
+        long_method_args = nil
+      end
+
+      # The order is important here.
+      # - unchanged method name if no args are passed (e.g. `layer`)
+      # - setter (`setLayer(val)`)
+      # - assign (`layer=val`)
+      # - unchanged method name *again*, because many Ruby classes provide a
+      #   combined getter/setter (`layer(val)`)
+      # - lastly, try again after converting to camelCase
+      if long_method_name && target.respond_to?(long_method_name)
+        target.send(long_method_name, *long_method_args)
+      elsif args.empty? && target.respond_to?(method_name)
+        target.send(method_name, *args)
+      elsif target.respond_to?(setter)
+        target.send(setter, *args)
+      elsif target.respond_to?(assign)
+        target.send(assign, *args)
+      elsif target.respond_to?(method_name)
+        target.send(method_name, *args)
+      # UIAppearance classes are a whole OTHER thing; they never return 'true'
+      elsif target.is_a?(MotionKit.appearance_class)
+        target.send(setter, *args)
+      # Finally, try again with camel case if there's an underscore.
+      elsif method_name.include?('_')
+        objc_name = MotionKit.objective_c_method_name(method_name)
+        self.apply(objc_name, *args)
+      else
+        target.send(setter, *args)
+        # raise ApplyError.new("Cannot apply #{method_name.inspect} to instance of #{target.class.name} (from #{@layout_delegate && @layout_delegate.class})")
+      end
+    end
+
+  public
+
+    class << self
+
+      def override_start
+        @allow_all_override = true
+      end
+
+      def override_stop
+        @allow_all_override = false
+      end
+
+      def overrides(method_name)
+        overridden_methods << method_name
+      end
+
+      def overridden_methods
+        @overridden_methods ||= []
+      end
+
+      # this last little "catch-all" method is helpful to warn against methods
+      # that are defined already. Since magic methods are so important, this
+      # warning can come in handy.
+      def method_added(method_name)
+        return if @allow_all_override
+
+        if self < BaseLayout && BaseLayout.method_defined?(method_name)
+          if overridden_methods.include?(method_name)
+            overridden_methods.delete(method_name)
+          else
+            NSLog("Warning! The method #{self.name}##{method_name} has already been defined on MotionKit::BaseLayout or one of its ancestors.")
+          end
+        end
+      end
+
+    end
+
+
+  end
+
+end