teacup 1.3.4 → 2.0.0

data/lib/teacup/stylesheet_extensions/transform.rb

@@ -0,0 +1,88 @@
+
+module Teacup
+  class Stylesheet
+
+    def pi
+      Math::PI
+    end
+
+    def transform_view
+      @@transform_layer ||= TransformView.new
+    end
+
+    def transform_layer
+      @@transform_layer ||= TransformLayer.new
+    end
+
+    def identity
+      NSLog("The Stylesheet method `identity` is deprecated, use `transform_layer.identity` instead")
+      [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]
+    end
+
+  end
+
+  class TransformLayer
+
+    def identity
+      [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]
+    end
+
+    # rotates the "up & down" direction.  The bottom of the view will rotate
+    # towards the user as angle increases.
+    def flip(angle)
+      CATransform3DRotate(identity, angle, 1, 0, 0)
+    end
+
+    # rotates the "left & right" direction.  The right side of the view will
+    # rotate towards the user as angle increases.
+    def twist(angle)
+      CATransform3DRotate(identity, angle, 0, 1, 0)
+    end
+
+    # spins, along the z axis.  This is probably the one you want, for
+    # "spinning" a view like you might a drink coaster or paper napkin.
+    def spin(angle)
+      CATransform3DRotate(identity, angle, 0, 0, 1)
+    end
+
+    # rotates the layer arbitrarily
+    def rotate(angle, x, y, z)
+      CATransform3DRotate(identity, angle, x, y, z)
+    end
+
+  end
+
+  class TransformView
+
+    def identity
+      [1, 0, 0, 1, 0, 0]
+    end
+
+    # Rotates the view counterclockwise
+    def rotate angle
+      CGAffineTransformMakeRotation(angle)
+    end
+
+    # Scales the view
+    def scale scale_x, scale_y=nil
+      scale_y ||= scale_x
+      CGAffineTransformMakeScale(scale_x, scale_y)
+    end
+
+    # Translates the view
+    def translate point, y=nil
+      if point.respond_to?(:x) &&point.respond_to?(:y)
+        x = point.x
+        y = point.y
+      elsif point.is_a? Array
+        x = point[0]
+        y = point[1]
+      else
+        x = point
+      end
+      CGAffineTransformMakeTranslation(x, y)
+    end
+
+  end
+
+end

data/lib/teacup/teacup_controller.rb

@@ -0,0 +1,122 @@
+# Adds methods to the UIViewController/NSViewController/NSWindowController
+# classes to make defining a layout and stylesheet very easy.  Also provides
+# rotation methods that analyze
+module Teacup
+  module ControllerClass
+
+    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
+    #   class 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
+
+  end
+
+  module Controller
+    def self.included(base)
+      base.extend ControllerClass
+    end
+
+    # 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
+
+    # 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 or windowDidLoad (they call this method).
+    def teacupDidLoad
+      # 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(top_level_view, stylename, properties, &block)
+      end
+
+      if should_restyle
+        Teacup.should_restyle!
+        self.top_level_view.restyle!
+      end
+
+      if defined? NSLayoutConstraint
+        self.top_level_view.apply_constraints
+      end
+
+      layoutDidLoad
+    end
+
+    def layoutDidLoad
+      true
+    end
+
+  end
+
+end

data/lib/teacup/teacup_util.rb

@@ -1,17 +1,22 @@
 module Teacup
   module_function
 
+  # Returns all the subviews of `target` that have a stylename.  `target` is not
+  # included in the list.  Used by the motion-layout integration in layout.rb.
+  def get_styled_subviews(target)
+    retval = target.subviews.select { |v| v.stylename }
+    retval.concat(target.subviews.map do |subview|
+      get_styled_subviews(subview)
+    end)
+    retval.flatten
+  end
+
   def to_instance(class_or_instance)
     if class_or_instance.is_a? Class
-      unless class_or_instance <= UIView
-        raise "Expected subclass of UIView, got: #{class_or_instance.inspect}"
-      end
       return class_or_instance.new
-    elsif class_or_instance.is_a?(UIView)
-      return class_or_instance
     else
-      raise "Expected a UIView, got: #{class_or_instance.inspect}"
+      return class_or_instance
     end
   end
 
-end
+end

data/lib/teacup/teacup_view.rb

@@ -0,0 +1,329 @@
+# Teacup's View extensions defines some utility functions for View 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.
+module Teacup
+  module View
+
+    # The current stylename that is used to look up properties in the stylesheet.
+    attr_reader :stylename
+
+    # A list of style classes that will be merged in (lower priority than stylename)
+    attr_reader :style_classes
+
+    # 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.
+    #
+    # If you are using Pixate, it will also set the pixate `styleId` property.
+    #
+    # @param Symbol  stylename
+    def stylename=(new_stylename)
+      @stylename = new_stylename
+      if respond_to?(:'setStyleId:')
+        setStyleId(new_stylename)
+      end
+      if respond_to?(:'setNuiClass:')
+        setNuiClass(new_stylename)
+      end
+      restyle!
+    end
+
+    # Why stop at just one stylename!?  Assign a bunch of them using
+    # `style_classes`. These are distinct from `stylename`, and `stylename` styles
+    # are given priority of `style_classes`.
+    #
+    # If you are using Pixate, it will also set the pixate `styleClass` property.
+    #
+    # @param Array [Symbol] style_classes
+    def style_classes=(new_style_classes)
+      @style_classes = new_style_classes
+      if respond_to?(:setStyleClass)
+        setStyleClass(new_style_classes.join(' '))
+      end
+      restyle!
+    end
+
+    def style_classes
+      @style_classes ||= []
+    end
+
+    def add_style_class(stylename)
+      unless style_classes.include?
+        style_classes << stylename
+        restyle!
+      end
+    end
+
+    def remove_style_class(stylename)
+      if style_classes.delete(stylename)
+        restyle!
+      end
+    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_classes.each do |stylename|
+            style(stylesheet.query(stylename, self, orientation))
+          end
+          style(stylesheet.query(self.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.map do |original_constraint|
+        constraint = original_constraint.copy
+
+        view_class = self.class
+
+        case original_constraint.target
+        when view_class
+          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 view_class
+          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
+
+      unless my_constraints.empty?
+        self.setTranslatesAutoresizingMaskIntoConstraints(false)
+      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
+
+    # Applies styles pulled from a stylesheet, but does not assign those styles to
+    # any property.  This is a one-shot use method, meant to be used as
+    # initialization or to apply styles that should not be reapplied during a
+    # rotation.
+    def apply_stylename(stylename)
+      if stylesheet && stylesheet.is_a?(Teacup::Stylesheet)
+        style(stylesheet.query(stylename, self))
+      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
+
+      teacup_animation(options) do
+        self.stylename = stylename
+      end
+    end
+
+    # Animate a change to a new list of style_classes.
+    #
+    # This is equivalent to wrapping a call to .style_classes= 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_styles(style_classes, options={})
+      return if self.style_classes == style_classes
+
+      teacup_animation(options) do
+        self.style_classes = style_classes
+      end
+    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)
+      teacup_animation(options) do
+        self.style(style)
+      end
+    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
+
+      apply_style_properties(properties)
+    end
+
+    def apply_style_properties(properties)
+      Teacup.apply_hash self, properties
+    end
+
+    def add_uniq_constraints(constraint)
+      @teacup_constraints ||= {}
+
+      if constraint.is_a? Array
+        constraint.each do |constraint|
+          add_uniq_constraints(constraint)
+        end
+      elsif constraint.is_a? Hash
+        constraint.each do |sym, relative_to|
+          @teacup_constraints[sym] = relative_to
+        end
+      elsif constraint.is_a?(Teacup::Constraint) || constraint.is_a?(Symbol)
+        @teacup_constraints[constraint] = true
+      else
+        raise "Unsupported constraint: #{constraint.inspect}"
+      end
+    end
+
+
+  end
+end

data/lib/teacup/version.rb

@@ -1,5 +1,5 @@
 module Teacup
 
-  VERSION = '1.3.4'
+  VERSION = '2.0.0'
 
 end

data/lib/teacup-ios/appearance.rb

@@ -0,0 +1,96 @@
+module Teacup
+  # An interface to style views using the UIAppearance protocol.
+  #
+  # Work similarly as the Stylesheet class.
+  #
+  # @example
+  #
+  # Teacup::Appearance.new do
+  #
+  #   style UINavigationBar,
+  #     tintColor: UIColor.colorWithRed(0.886, green:0.635, blue:0, alpha: 1)
+  #
+  # end
+  class Appearance < Stylesheet
+    TeacupAppearanceApplyNotification = 'TeacupAppearanceApplyNotification'
+
+    def self.apply
+      NSNotificationCenter.defaultCenter.postNotificationName(TeacupAppearanceApplyNotification, object:nil)
+    end
+
+    # Contains a list of styles associated with "containers".  These do not get
+    # merged like the usual `style` declarations.
+    def when_contained_in
+      @when_contained_in ||= []
+    end
+
+    # disable the stylesheet 'name' parameter, and assign the "super secret"
+    # stylesheet name
+    def initialize(&block)
+      NSNotificationCenter.defaultCenter.addObserver(self,
+              selector: :'apply_appearance:',
+              name: UIApplicationDidFinishLaunchingNotification,
+              object: nil)
+      NSNotificationCenter.defaultCenter.addObserver(self,
+              selector: :'apply_appearance:',
+              name: TeacupAppearanceApplyNotification,
+              object: nil)
+
+      super(&block)
+    end
+
+    def exclude_instance_vars
+      @exclude_instance_vars ||= super + [:@when_contained_in]
+    end
+
+    # Styles that have the `when_contained_in` setting need to be kept separate
+    def style(*queries)
+      # do not modify queries, it gets passed to `super`
+      if queries[-1].is_a? Hash
+        properties = queries[-1]
+      else
+        # empty style declarations are allowed, but accomplish nothing.
+        return
+      end
+
+      if properties.include?(:when_contained_in)
+        # okay NOW modify queries
+        queries.pop
+        queries.each do |stylename|
+          style = Style.new
+          style.stylename = stylename
+          style.stylesheet = self
+          style.merge!(properties)
+
+          when_contained_in << [stylename, style]
+        end
+      else
+        super
+      end
+    end
+
+    # This block is only run once, and the properties object from
+    # when_contained_in is a copy (via Teacup::Style.new), so we remove the
+    # when_contained_in property using `delete`
+    def apply_appearance(notification=nil)
+      return unless run_block
+      NSNotificationCenter.defaultCenter.removeObserver(self, name:UIApplicationDidFinishLaunchingNotification, object:nil)
+      NSNotificationCenter.defaultCenter.removeObserver(self, name:TeacupAppearanceApplyNotification, object:nil)
+
+      when_contained_in.each do |klass, properties|
+        contained_in = properties.delete(:when_contained_in)
+        contained_in = [contained_in] unless contained_in.is_a?(NSArray)
+        # make a copy and add nil to the end
+        contained_in += [nil]
+        appearance = klass.send(:'appearanceWhenContainedIn:', *contained_in)
+        Teacup.apply_hash appearance, properties.build, klass
+      end
+      styles.each do |klass, properties|
+        appearance = klass.appearance
+        Teacup.apply_hash appearance, properties.build, klass
+      end
+    end
+
+  end
+
+end