teacup 1.3.4 → 2.0.0

data/lib/teacup/z_core_extensions/ui_view.rb

@@ -1,262 +0,0 @@
-# Teacup's UIView extensions defines some utility functions for UIView that
-# enable a lot of the magic for Teacup::Layout.
-
-# Users of teacup should be able to ignore the contents of this file for
-# the most part.
-class UIView
-  include Teacup::Layout
-
-  # The current stylename that is used to look up properties in the stylesheet.
-  attr_reader :stylename
-
-  # Any class that includes Teacup::Layout gets a `layout` method, which assigns
-  # itself as the 'teacup_next_responder'.
-  attr_accessor :teacup_next_responder
-
-  # Enable debug messages for this object
-  attr_accessor :debug
-
-  # Alter the stylename of this view.
-  #
-  # This will cause new styles to be applied from the stylesheet.
-  #
-  # @param Symbol  stylename
-  def stylename=(new_stylename)
-    @stylename = new_stylename
-    restyle!
-  end
-
-  # Alter the stylesheet of this view.
-  #
-  # This will cause new styles to be applied using the current stylename,
-  # and will recurse into subviews.
-  #
-  # If you would prefer that a given UIView object does not inherit the
-  # stylesheet from its parents, override the 'stylesheet' method to
-  # return the correct value at all times.
-  #
-  # @param Teacup::Stylesheet  stylesheet.
-  def stylesheet=(new_stylesheet)
-    should_restyle = Teacup.should_restyle_and_block
-
-    @stylesheet = new_stylesheet
-
-    if should_restyle
-      Teacup.should_restyle!
-      restyle!
-    end
-  end
-
-  def stylesheet
-    if @stylesheet.is_a? Symbol
-      @stylesheet = Teacup::Stylesheet[@stylesheet]
-    end
-    # is a stylesheet assigned explicitly?
-    retval = @stylesheet
-    return retval if retval
-
-    # the 'teacup_next_responder' is assigned in the `layout` method, and links
-    # any views created there to the custom class (could be a controller, could
-    # be any class that includes Teacup::Layout).  That responder is checked
-    # next, but only if it wouldn't result in a circular loop.
-    if ! retval && @teacup_next_responder && teacup_next_responder != self
-      retval = @teacup_next_responder.stylesheet
-    end
-
-    # lastly, go up the chain; either a controller or superview
-    if ! retval && nextResponder && nextResponder.respond_to?(:stylesheet)
-      retval = nextResponder.stylesheet
-    end
-
-    return retval
-  end
-
-  def restyle!(orientation=nil)
-    if Teacup.should_restyle?
-      if stylesheet && stylesheet.is_a?(Teacup::Stylesheet)
-        style(stylesheet.query(stylename, self, orientation))
-      end
-      subviews.each{ |subview| subview.restyle!(orientation) }
-    end
-  end
-
-  def get_ns_constraints
-    # gets the array of Teacup::Constraint objects
-    my_constraints = (@teacup_constraints || []).map { |constraint, relative_to|
-      if constraint.is_a?(Teacup::Constraint)
-        constraint
-      else
-        if relative_to == true
-          Teacup::Constraint.from_sym(constraint)
-        else
-          Teacup::Constraint.from_sym(constraint, relative_to)
-        end
-      end
-    }.flatten.tap{ |my_constraints|
-      unless my_constraints.empty?
-        self.setTranslatesAutoresizingMaskIntoConstraints(false)
-      end
-    }.map do |original_constraint|
-      constraint = original_constraint.copy
-
-      case original_constraint.target
-      when UIView
-        constraint.target = original_constraint.target
-      when :self
-        constraint.target = self
-      when :superview
-        constraint.target = self.superview
-      when Symbol, String
-        container = self
-        constraint.target = nil
-        while container && constraint.target.nil?
-          constraint.target = container.viewWithStylename(original_constraint.target)
-          container = container.superview
-        end
-      end
-
-      case original_constraint.relative_to
-      when nil
-        constraint.relative_to = nil
-      when UIView
-        constraint.relative_to = original_constraint.relative_to
-      when :self
-        constraint.relative_to = self
-      when :superview
-        constraint.relative_to = self.superview
-      when Symbol, String
-        # TODO: this re-checks lots of views - everytime it goes up to the
-        # superview, it checks all the leaves again.
-        container = self
-        constraint.relative_to = nil
-        while container && constraint.relative_to.nil?
-          constraint.relative_to = container.viewWithStylename(original_constraint.relative_to)
-          container = container.superview
-        end
-      end
-
-      if original_constraint.relative_to && ! constraint.relative_to
-        puts "Could not find #{original_constraint.relative_to.inspect}"
-        container = self
-        tab = '  '
-        while container && constraint.relative_to.nil?
-          tab << '->'
-          puts "#{tab} #{container.stylename.inspect}"
-          container = container.superview
-        end
-      end
-
-      # the return value, for the map
-      constraint.nslayoutconstraint
-    end
-
-    # now add all che child constraints
-    subviews.each do |subview|
-      my_constraints.concat(subview.get_ns_constraints)
-    end
-
-    my_constraints
-  end
-
-  def apply_constraints
-    if @teacup_added_constraints
-      @teacup_added_constraints.each do |constraint|
-        self.removeConstraint(constraint)
-      end
-    end
-    @teacup_added_constraints = nil
-    all_constraints = get_ns_constraints
-
-    return if all_constraints.empty?
-
-    @teacup_added_constraints = []
-    all_constraints.each do |ns_constraint|
-      @teacup_added_constraints << ns_constraint
-      self.addConstraint(ns_constraint)
-    end
-  end
-
-  # Animate a change to a new stylename.
-  #
-  # This is equivalent to wrapping a call to .stylename= inside
-  # UIView.beginAnimations.
-  #
-  # @param Symbol  the new stylename
-  # @param Options  the options for the animation (may include the
-  #                 duration and the curve)
-  #
-  def animate_to_stylename(stylename, options={})
-    return if self.stylename == stylename
-
-    UIView.beginAnimations(nil, context: nil)
-    # TODO: This should be in a style-sheet!
-    UIView.setAnimationDuration(options[:duration]) if options[:duration]
-    UIView.setAnimationCurve(options[:curve]) if options[:curve]
-    UIView.setAnimationDelay(options[:delay]) if options[:delay]
-    self.stylename = stylename
-    UIView.commitAnimations
-  end
-
-  # Animate a change to new styles
-  #
-  # This is equivalent to wrapping a call to .style() inside
-  # UIView.beginAnimations.
-  #
-  # @param Hash   the new styles and options for the animation
-  #
-  def animate_to_style(style)
-    UIView.beginAnimations(nil, context: nil)
-    UIView.setAnimationDuration(style[:duration]) if style[:duration]
-    UIView.setAnimationCurve(style[:curve]) if style[:curve]
-    UIView.setAnimationDelay(style[:delay]) if style[:delay]
-    style(style)
-    UIView.commitAnimations
-  end
-
-  # Apply style properties to this element.
-  #
-  # Takes a hash of properties such as may have been read from a stylesheet
-  # or passed as parameters to {Teacup::Layout#layout}, and applies them to
-  # the element.
-  #
-  # Does a little bit of magic (that may be split out as 'sugarcube') to
-  # make properties work as you'd expect.
-  #
-  # If you try and assign something in properties that is not supported,
-  # a warning message will be emitted.
-  #
-  # @param Hash  the properties to set.
-  def style(properties)
-    if properties.key?(:constraints)
-      add_uniq_constraints(properties.delete(:constraints))
-    end
-
-    Teacup.apply_hash self, properties
-
-    self.setNeedsDisplay
-    self.setNeedsLayout
-  end
-
-  def top_level_view
-    return self
-  end
-
-  def add_uniq_constraints(constraint)
-    @teacup_constraints ||= {}
-
-    if constraint.is_a? Array
-      constraint.each { |constraint|
-        add_uniq_constraints(constraint)
-      }
-    elsif constraint.is_a? Hash
-      constraint.each { |sym, relative_to|
-        @teacup_constraints[sym] = relative_to
-      }
-    elsif constraint.is_a?(Teacup::Constraint) || constraint.is_a?(Symbol)
-      @teacup_constraints[constraint] = true
-    else
-      raise "Unsupported constraint: #{constraint.inspect}"
-    end
-  end
-
-end

data/lib/teacup/z_core_extensions/ui_view_controller.rb

@@ -1,263 +0,0 @@
-# Adds methods to the UIViewController class to make defining a layout and
-# stylesheet very easy.  Also provides rotation methods that analyze
-class UIViewController
-  include Teacup::Layout
-
-  class << self
-    attr_reader :layout_definition
-
-    # Define the layout of a controller's view.
-    #
-    # This function is analogous to Teacup::Layout#layout, though it is
-    # designed so you can create an entire layout in a declarative manner in
-    # your controller.
-    #
-    # The hope is that this declarativeness will allow us to automatically
-    # deal with common iOS programming tasks (like releasing views when
-    # low-memory conditions occur) for you. This is still not implemented
-    # though.
-    #
-    # @param name  The stylename for your controller's view.
-    #
-    # @param properties  Any extra styles that you want to apply.
-    #
-    # @param &block  The block in which you should define your layout.
-    #                It will be instance_exec'd in the context of a
-    #                controller instance.
-    #
-    # @example
-    #   MyViewController < UIViewController
-    #     layout :my_view do
-    #       subview UILabel, title: "Test"
-    #       subview UITextField, {
-    #         frame: [[200, 200], [100, 100]]
-    #         delegate: self
-    #       }
-    #       subview UIView, :shiny_thing) {
-    #         subview UIView, :centre_of_shiny_thing
-    #       }
-    #     end
-    #   end
-    #
-    def layout(stylename=nil, properties={}, &block)
-      @layout_definition = [stylename, properties, block]
-    end
-
-    def stylesheet(new_stylesheet=nil)
-      if new_stylesheet.nil?
-        return @stylesheet
-      end
-
-      @stylesheet = new_stylesheet
-    end
-
-  end # class << self
-
-  # Assigning a new stylesheet triggers {restyle!}.
-  #
-  # Assigning a stylesheet is an *alternative* to returning a Stylesheet in
-  # the {stylesheet} method. Note that {restyle!} calls {stylesheet}, so while
-  # assigning a stylesheet will trigger {restyle!}, your stylesheet will not
-  # be picked up if you don't return it in a custom stylesheet method.
-  #
-  # @return Teacup::Stylesheet
-  #
-  # @example
-  #
-  #   stylesheet = Teacup::Stylesheet[:ipadhorizontal]
-  #   stylesheet = :ipadhorizontal
-  def stylesheet=(new_stylesheet)
-    super
-    if self.viewLoaded?
-      self.view.restyle!
-    end
-  end
-
-  def top_level_view
-    return self.view
-  end
-
-
-  # Instantiate the layout from the class, and then call layoutDidLoad.
-  #
-  # If you want to use Teacup in your controller, please hook into layoutDidLoad,
-  # not viewDidLoad.
-  def viewDidLoad
-    # look for a layout_definition in the list of ancestors
-    layout_definition = nil
-    my_stylesheet = self.stylesheet
-    parent_class = self.class
-    while parent_class != NSObject and not (layout_definition && my_stylesheet)
-      if not my_stylesheet and parent_class.respond_to?(:stylesheet)
-        my_stylesheet = parent_class.stylesheet
-      end
-
-      if not layout_definition and parent_class.respond_to?(:layout_definition)
-        layout_definition = parent_class.layout_definition
-      end
-      parent_class = parent_class.superclass
-    end
-
-    should_restyle = Teacup.should_restyle_and_block
-
-    if my_stylesheet and not self.stylesheet
-      self.stylesheet = my_stylesheet
-    end
-
-    if layout_definition
-      stylename, properties, block = layout_definition
-      layout(view, stylename, properties, &block)
-    end
-
-    if should_restyle
-      Teacup.should_restyle!
-      self.view.restyle!
-    end
-
-    if defined? NSLayoutConstraint
-      self.view.apply_constraints
-    end
-
-    layoutDidLoad
-  end
-
-  def layoutDidLoad
-    true
-  end
-
-  # This method *used* to be useful for the `shouldAutorotateToOrientation`
-  # method, but the iOS 6 update deprecates that method.  Instead, use the
-  # `supportedInterfaceOrientations` and return `autorotateMask`.
-  def autorotateToOrientation(orientation)
-    if view.stylesheet and view.stylesheet.is_a?(Teacup::Stylesheet) and view.stylename
-      properties = view.stylesheet.query(view.stylename, self, orientation)
-
-      # check for orientation-specific properties
-      case orientation
-      when UIInterfaceOrientationPortrait
-        # portrait is "on" by default, must be turned off explicitly
-        if properties.supports?(:portrait) == nil and properties.supports?(:upside_up) == nil
-          return true
-        end
-
-        return (properties.supports?(:portrait) or properties.supports?(:upside_up))
-      when UIInterfaceOrientationPortraitUpsideDown
-        if UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPhone
-          # iphone must have an explicit upside-down style, otherwise this returns
-          # false
-          return properties.supports?(:upside_down)
-        else
-          # ipad can just have a portrait style
-          return (properties.supports?(:portrait) or properties.supports?(:upside_down))
-        end
-      when UIInterfaceOrientationLandscapeLeft
-        return (properties.supports?(:landscape) or properties.supports?(:landscape_left))
-      when UIInterfaceOrientationLandscapeRight
-        return (properties.supports?(:landscape) or properties.supports?(:landscape_right))
-      end
-
-      return false
-    end
-
-    # returns the system default
-    if device == UIUserInterfaceIdiomPhone
-      return orientation != UIInterfaceOrientationPortraitUpsideDown
-    else
-      return true
-    end
-  end
-
-  # You can use this method in `supportedInterfaceOrientations`, and it will
-  # query the stylesheet for the supported orientations, based on what
-  # orientations are defined.  At a minimum, to opt-in to this feature, you'll
-  # need to define styles like `style :root, landscape: true`
-  def autorotateMask
-    device = UIDevice.currentDevice.userInterfaceIdiom
-    if view.stylesheet and view.stylesheet.is_a?(Teacup::Stylesheet) and view.stylename
-      properties = view.stylesheet.query(view.stylename, self, orientation)
-
-      orientations = 0
-      if properties.supports?(:portrait) or properties.supports?(:upside_up)
-        orientations |= UIInterfaceOrientationPortrait
-      end
-
-      if device == UIUserInterfaceIdiomPhone
-        # :portrait does not imply upside_down on the iphone
-        if properties.supports?(:upside_down)
-          orientations |= UIInterfaceOrientationPortraitUpsideDown
-        end
-      else
-        # but does on the ipad
-        if properties.supports?(:portrait) or properties.supports?(:upside_down)
-          orientations |= UIInterfaceOrientationPortraitUpsideDown
-        end
-      end
-
-      if properties.supports?(:landscape) or properties.supports?(:landscape_left)
-        orientations |= UIInterfaceOrientationLandscapeLeft
-      end
-
-      if properties.supports?(:landscape) or properties.supports?(:landscape_right)
-        orientations |= UIInterfaceOrientationLandscapeRight
-      end
-
-      if orientations == 0
-        orientations |= UIInterfaceOrientationPortrait
-      end
-      return orientations
-    end
-
-    # returns the system default
-    if device == UIUserInterfaceIdiomPhone
-      return UIInterfaceOrientationMaskAllButUpsideDown
-    else
-      return UIInterfaceOrientationMaskAll
-    end
-  end
-
-  # restyles the view!  be careful about putting styles in your stylesheet that
-  # you change in your controller.  anything that might change over time should
-  # be applied in your controller using `style`
-  def willAnimateRotationToInterfaceOrientation(orientation, duration:duration)
-    view.restyle!(orientation)
-  end
-
-  ##|
-  ##|  Motion-Layout support
-  ##|
-
-  # Calling this method uses Nick Quaranto's motion-layout gem to provide ASCII
-  # art style access to autolayout.  It assigns all the subviews by stylename,
-  # and assigns `self.view` as the target view.  Beyond that, it's up to you to
-  # implement the layout methods:
-  #
-  #     auto do
-  #       metrics 'margin' => 20
-  #       vertical "|-[top]-margin-[bottom]-|"
-  #       horizontal "|-margin-[top]-margin-|"
-  #       horizontal "|-margin-[bottom]-margin-|"
-  #     end
-  def auto(layout_view=self.view, layout_subviews={}, &layout_block)
-    raise "gem install 'motion-layout'" unless defined? Motion::Layout
-
-    Teacup.get_subviews(self.view).each do |view|
-      if view.stylename && ! layout_subviews[view.stylename.to_s]
-        layout_subviews[view.stylename.to_s] = view
-      end
-    end
-
-    Motion::Layout.new do |layout|
-      layout.view layout_view
-      layout.subviews layout_subviews
-      layout.instance_eval(&layout_block)
-    end
-  end
-
-end
-
-
-def Teacup.get_subviews(target)
-  [target] + target.subviews.map { |subview|
-    get_subviews(subview).select{ |v| v.stylename }
-  }.flatten
-end

data/lib/teacup/z_core_extensions/ui_view_getters.rb

@@ -1,58 +0,0 @@
-# Methods to retrieve a subview using the stylename as a key
-# Kinda similar to jQuery-style $(el).find('stylename')
-class UIView
-
-  # get one subview by stylename or class.  If the receiver matches, it will be
-  # returned
-  # my_view.viewWithStylename :button => #<UIButton..>
-  # my_view.viewWithStylename UIButton => #<UIButton..>
-  def viewWithStylename name_or_class
-    return self if self._teacup_check_stylename(name_or_class)
-
-    view = subviews.find { |view| view._teacup_check_stylename(name_or_class) }
-    return view if view
-
-    # found_subview will get assigned to the view we want, but the subview is
-    # what is returned.
-    found_subview = nil
-    view = subviews.find { |subview| found_subview = subview.viewWithStylename(name_or_class) }
-    return found_subview if view
-
-    return nil  # couldn't find it
-  end
-
-  # get all subviews by stylename or class
-  # my_view.viewsWithStylename :button => [#<UIButton..>, #<UIButton...>]
-  # my_view.viewsWithStylename UIButton => [#<UIButton..>, #<UIButton...>]
-  def viewsWithStylename name_or_class
-    retval = []
-    retval << self if self._teacup_check_stylename(name_or_class)
-
-    search_views = [].concat(self.subviews)
-    # ewww, a traditional for loop! the search_views array is modified in place,
-    # and `each` and other methods don't like that.
-    index = 0
-    while index < search_views.length
-      view = search_views[index]
-      if view._teacup_check_stylename(name_or_class)
-        retval << view
-      end
-      search_views.concat(view.subviews)
-      index += 1
-    end
-
-    return retval
-  end
-
-  def _teacup_check_stylename(name_or_class)
-    if name_or_class.is_a? Class
-      return self.is_a?(name_or_class)
-    elsif stylename == name_or_class
-      return true
-    elsif stylesheet.is_a?(Teacup::Stylesheet)
-      return stylesheet.extends_style?(self.stylename, name_or_class)
-    end
-    return false
-  end
-
-end