teacup 0.3.12 → 1.0.0

data/lib/teacup/stylesheet_extensions/constraints.rb

@@ -0,0 +1,69 @@
+module Teacup
+  class Stylesheet
+
+    def constrain(target, attribute=nil)
+      if attribute.nil?
+        attribute = target
+        target = :self
+      end
+      Teacup::Constraint.new(target, attribute)
+    end
+
+    ##|
+    def constrain_xy(x, y)
+      [
+        Teacup::Constraint.new(:self, :left).equals(:superview, :left).plus(x),
+        Teacup::Constraint.new(:self, :top).equals(:superview, :top).plus(y),
+      ]
+    end
+
+    def constrain_left(x)
+      Teacup::Constraint.new(:self, :left).equals(:superview, :left).plus(x)
+    end
+
+    def constrain_right(x)
+      Teacup::Constraint.new(:self, :right).equals(:superview, :right).plus(x)
+    end
+
+    def constrain_top(y)
+      Teacup::Constraint.new(:self, :top).equals(:superview, :top).plus(y)
+    end
+
+    def constrain_bottom(y)
+      Teacup::Constraint.new(:self, :bottom).equals(:superview, :bottom).plus(y)
+    end
+
+    def constrain_width(width)
+      Teacup::Constraint.new(:self, :width).equals(width)
+    end
+
+    def constrain_height(height)
+      Teacup::Constraint.new(:self, :height).equals(height)
+    end
+
+    def constrain_size(width, height)
+      [
+        Teacup::Constraint.new(:self, :right).equals(:self, :left).plus(width),
+        Teacup::Constraint.new(:self, :bottom).equals(:self, :top).plus(height),
+      ]
+    end
+
+    ##|
+    def constrain_below(relative_to, margin=0)
+      Teacup::Constraint.new(:self, :top).equals(relative_to, :bottom).plus(margin)
+    end
+
+    def constrain_above(relative_to, margin=0)
+      Teacup::Constraint.new(:self, :bottom).equals(relative_to, :top).plus(margin)
+    end
+
+    def constrain_to_left(relative_to, margin=0)
+      Teacup::Constraint.new(:self, :right).equals(relative_to, :left).plus(margin)
+    end
+
+    def constrain_to_right(relative_to, margin=0)
+      Teacup::Constraint.new(:self, :left).equals(relative_to, :right).plus(margin)
+    end
+
+  end
+end

data/lib/teacup/stylesheet_extensions/geometry.rb

@@ -0,0 +1,75 @@
+# Example:
+#     Teacup::Stylesheet.new :main do
+#       style :root,
+#         origin: [0, 0]
+#
+#       # device returns a bitmask of devices,
+#       # device? expects a device bitmask, and returns true if it is present in
+#       # device (the conditions below are equivalent)
+#       if 0 < device & iPhone || device? iPhone
+#         style :root, width: 320
+#
+#         if 0 < device & iPhone5 || device? iPhone5
+#           style :root, height: 548
+#         elsif 0 < device & iPhone || device? iPhone
+#           style :root, height: 460
+#         end
+#       elsif 0 < device & iPad || device? iPad
+#         style :root,
+#           width: 768,
+#           height: 1004
+#       end
+#
+#       # that's a mess!  and this does the same thing anyway:
+#       style :root,
+#         frame: [[0, 0], app_size]
+#     end
+module Teacup
+  class Stylesheet
+    def iPhone       ; 1 << 1 ; end
+    def iPhoneRetina ; 1 << 2 ; end
+    def iPhone5      ; 1 << 3 ; end
+    def iPad         ; 1 << 4 ; end
+    def iPadRetina   ; 1 << 5 ; end
+
+    # returns the device size in points, regardless of status bar
+    def screen_size
+      UIScreen.mainScreen.bounds.size
+    end
+
+    # returns the application frame, which takes the status bar into account
+    def app_size
+      UIScreen.mainScreen.applicationFrame.size
+    end
+
+    # returns a bit-wise OR of the device masks
+    def device
+      @@this_device ||= nil
+      return @@this_device if @@this_device
+
+      @@this_device = 0
+      if UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPhone
+        @@this_device |= iPhone
+        if UIScreen.mainScreen.respond_to? :scale
+          @@this_device |= iPhoneRetina
+          if UIScreen.mainScreen.bounds.size.height == 568
+            @@this_device |= iPhone5
+          end
+        end
+      else
+        @@this_device |= iPad
+        if UIScreen.mainScreen.respond_to? :scale
+          @@this_device |= iPadRetina
+        end
+      end
+
+      return @@this_device
+    end
+
+    def device_is?(this_device)
+      this_device = self.send(this_device) if this_device.is_a? Symbol
+      return device & this_device > 0
+    end
+
+  end
+end

data/lib/teacup/stylesheet_extensions/rotation.rb

@@ -1,7 +1,7 @@
 
 module Teacup
-
   class Stylesheet
+
     def identity
       [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]
     end
@@ -34,5 +34,4 @@ module Teacup
     end
 
   end
-
 end

data/lib/teacup/version.rb

@@ -1,5 +1,5 @@
 module Teacup
 
-  VERSION = '0.3.12'
+  VERSION = '1.0.0'
 
 end

data/lib/teacup/z_core_extensions/ui_view.rb

@@ -12,17 +12,6 @@ class UIView
   # Enable debug messages for this object
   attr_accessor :debug
 
-  # The current stylesheet will be looked at when properties are needed.  It
-  # is loaded lazily, so that assignment can occur before the Stylesheet has
-  # been created.
-  def stylesheet
-    if @stylesheet.is_a? Symbol
-      @stylesheet = Teacup::Stylesheet[@stylesheet]
-    end
-
-    @stylesheet
-  end
-
   # Alter the stylename of this view.
   #
   # This will cause new styles to be applied from the stylesheet.
@@ -50,8 +39,8 @@ class UIView
     subviews.each{ |subview| subview.set_stylesheet_quickly(new_stylesheet) }
 
     if should_restyle
-      restyle!
       Teacup.should_restyle!
+      restyle!
     end
   end
 
@@ -62,7 +51,9 @@ class UIView
 
   def restyle!(orientation=nil)
     if Teacup.should_restyle?
-      if stylesheet
+      resetTeacupConstraints
+
+      if stylesheet && stylesheet.is_a?(Teacup::Stylesheet)
         style(stylesheet.query(stylename, self, orientation))
       end
       subviews.each{ |subview| subview.restyle!(orientation) }
@@ -118,11 +109,77 @@ class UIView
   #
   # @param Hash  the properties to set.
   def style(properties, orientation=nil)
-    Teacup.apply_hash self, properties
-    properties.each do |key, value|
-      Teacup.apply self, key, value
+    if properties.key?(:constraints)
+      new_constraints = add_uniq_constraints(properties.delete(:constraints))
+
+      self.setTranslatesAutoresizingMaskIntoConstraints(false) unless new_constraints.empty?
+
+      @teacup_added_constraints ||= []
+      new_constraints.each do |original_constraint|
+        constraint = original_constraint.copy
+
+        case original_constraint.target
+        when :self
+          constraint.target = self
+        when :superview
+          constraint.target = self.superview
+        when Symbol, String
+          container = self
+          constraint.target = nil
+          while container.superview && constraint.target == nil
+            constraint.target = container.viewWithStylename(original_constraint.target)
+            container = container.superview
+          end
+        end
+
+        case 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.superview && constraint.relative_to == nil
+            constraint.relative_to = container.viewWithStylename(original_constraint.relative_to)
+            container = container.superview
+          end
+        end
+
+        add_constraint_to = nil
+        if constraint.target == constraint.relative_to || constraint.relative_to.nil?
+          add_constraint_to = constraint.target.superview
+        elsif constraint.target.isDescendantOfView(constraint.relative_to)
+          add_constraint_to = constraint.relative_to
+        elsif constraint.relative_to.isDescendantOfView(constraint.target)
+          add_constraint_to = constraint.target
+        else
+          parent = constraint.relative_to.superview
+          while parent
+            if constraint.target.isDescendantOfView(parent)
+              add_constraint_to = parent
+              parent = nil
+            elsif parent.superview
+              parent = parent.superview
+            end
+          end
+        end
+
+        if add_constraint_to
+          ns_constraint = constraint.nslayoutconstraint
+
+          @teacup_added_constraints << { target: add_constraint_to, constraint: ns_constraint }
+          add_constraint_to.addConstraint(ns_constraint)
+        else
+          raise "The two views #{original_constraint.target} and #{original_constraint.relative_to} do not have a common ancestor"
+        end
+      end
     end
 
+    Teacup.apply_hash self, properties
+
     self.setNeedsDisplay
     self.setNeedsLayout
   end
@@ -131,4 +188,46 @@ class UIView
     return self
   end
 
+  def teacup_added_constraints ; @teacup_added_constraints ; end
+
+  def resetTeacupConstraints
+    if @teacup_added_constraints
+      @teacup_added_constraints.each do |added_constraint|
+        target = added_constraint[:target]
+        constraint = added_constraint[:constraint]
+        target.removeConstraint(constraint)
+      end
+    end
+    @teacup_added_constraints = nil
+    @teacup_constrain_just_once = nil
+  end
+
+  def add_uniq_constraints(constraint)
+    @teacup_constrain_just_once ||= {}
+
+    if constraint.is_a? Array
+      new_consraints = constraint.map{|constraint| add_uniq_constraints(constraint) }.flatten
+    elsif constraint.is_a? Hash
+      new_consraints = constraint.select{|sym, relative_to|
+        @teacup_constrain_just_once[sym].nil?
+      }.map{|sym, relative_to|
+        @teacup_constrain_just_once[sym] = true
+        Teacup::Constraint.from_sym(sym, relative_to)
+      }
+    else
+      if @teacup_constrain_just_once[constraint]
+        new_consraints = []
+      else
+        @teacup_constrain_just_once[constraint] = true
+        if constraint.is_a? Symbol
+          new_consraints = [Teacup::Constraint.from_sym(constraint)]
+        else
+          new_consraints = [constraint]
+        end
+      end
+    end
+
+    return new_consraints
+  end
+
 end

data/lib/teacup/z_core_extensions/ui_view_controller.rb

@@ -53,30 +53,6 @@ class UIViewController
 
   end # class << self
 
-  # Returns a stylesheet to use to style the contents of this controller's
-  # view.  You can also assign a stylesheet to {stylesheet=}, which will in
-  # turn call {restyle!}.
-  #
-  # This method will be queried each time {restyle!} is called, and also
-  # implicitly whenever Teacup needs to draw your layout (currently only at
-  # view load time).
-  #
-  # @return Teacup::Stylesheet
-  #
-  # @example
-  #
-  #  def stylesheet
-  #    if [UIInterfaceOrientationLandscapeLeft,
-  #        UIInterfaceOrientationLandscapeRight].include?(UIInterface.currentDevice.orientation)
-  #      Teacup::Stylesheet[:ipad]
-  #    else
-  #      Teacup::Stylesheet[:ipadvertical]
-  #    end
-  #  end
-  def stylesheet
-    @stylesheet
-  end
-
   # Assigning a new stylesheet triggers {restyle!}, so do this during a
   # rotation to get your different layouts applied.
   #
@@ -129,14 +105,27 @@ class UIViewController
 
     if layout_definition
       stylename, properties, block = layout_definition
+      should_restyle = Teacup.should_restyle_and_block
       layout(view, stylename, properties, &block)
+      Teacup.should_restyle! if should_restyle
     end
 
     layoutDidLoad
   end
 
+  alias old_viewWillAppear viewWillAppear
+
   def viewWillAppear(animated)
-    self.view.restyle!
+    old_viewWillAppear(animated)
+    self.view.restyle! unless @teacup_view_appeared
+    @teacup_view_appeared = true
+  end
+
+  alias old_viewDidDisappear viewDidDisappear
+
+  def viewDidDisappear(animated)
+    old_viewDidDisappear(animated)
+    @teacup_view_appeared = false
   end
 
   def layoutDidLoad
@@ -152,7 +141,7 @@ class UIViewController
   #
   # the teacup developers apologize for any inconvenience. :-)
   def autorotateToOrientation(orientation)
-    if view.stylesheet and view.stylename
+    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
@@ -185,6 +174,45 @@ class UIViewController
     return orientation == UIInterfaceOrientationPortrait
   end
 
+  def autorotateMask
+    if view.stylesheet and view.stylesheet.is_a?(Teacup::Stylesheet) and view.stylename
+      properties = view.stylesheet.query(view.stylename, self, orientation)
+      device = UIDevice.currentDevice.userInterfaceIdiom
+      device == UIUserInterfaceIdiomPhone
+
+      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
+    return UIInterfaceOrientationPortrait
+  end
+
   def willAnimateRotationToInterfaceOrientation(orientation, duration:duration)
     view.restyle!(orientation)
   end

data/lib/teacup/z_core_extensions/ui_view_getters.rb

@@ -2,8 +2,9 @@
 # Kinda similar to jQuery-style $().find('stylename')
 class UIView
 
-  # get one stylesheet by stylename
-  # my_view[:button] :button => #<UIButton..>
+  # get one subview by stylename or class
+  # my_view.viewWithStylename :button => #<UIButton..>
+  # my_view.viewWithStylename UIButton => #<UIButton..>
   def viewWithStylename name_or_class
     if name_or_class.is_a? Class
       view = subviews.find { |view| view.is_a? name_or_class }
@@ -21,8 +22,9 @@ class UIView
     nil  # couldn't find it
   end
 
-  # get stylesheets by stylename
-  # my_view.all :button => [#<UIButton..>, #<UIButton...>]
+  # get all subviews by stylename or class
+  # my_view.viewsWithStylename :button => [#<UIButton..>, #<UIButton...>]
+  # my_view.viewsWithStylename UIButton => [#<UIButton..>, #<UIButton...>]
   def viewsWithStylename name_or_class
     r = []
     subviews.each do |view|
@@ -30,10 +32,10 @@ class UIView
         if view.is_a? name_or_class
           r << view
         end
-      else view.stylename == name_or_class
+      elsif view.stylename == name_or_class
         r << view
       end
-      r += view.viewsWithStylename name_or_class
+      r.concat view.viewsWithStylename name_or_class
     end
     r
   end

data/lib/teacup/z_core_extensions/z_handlers.rb

@@ -1,51 +1,71 @@
+module Teacup
+  module_function
+  def calculate(view, dimension, percent)
+    if percent.is_a? Proc
+      view.instance_exec(&percent)
+    elsif percent.is_a? String and percent[-1] == '%'
+      percent = percent[0...-1].to_f / 100.0
+
+      case dimension
+      when :width
+        CGRectGetWidth(view.superview.bounds) * percent
+      when :height
+        CGRectGetHeight(view.superview.bounds) * percent
+      end
+    else
+      percent
+    end
+  end
+end
+
 ##|
 ##|  UIView.frame
 ##|
 Teacup.handler UIView, :left, :x { |x|
   f = self.frame
-  f.origin.x = x
+  f.origin.x = Teacup::calculate(self, :width, x)
   self.frame = f
 }
 
 Teacup.handler UIView, :right { |r|
   f = self.frame
-  f.origin.x = r - f.size.width
+  f.origin.x = Teacup::calculate(self, :width, r) - f.size.width
   self.frame = f
 }
 
 Teacup.handler UIView, :center_x, :middle_x { |x|
   c = self.center
-  c.x = x
+  c.x = Teacup::calculate(self, :width, x)
   self.center = c
 }
 
 Teacup.handler UIView, :top, :y { |y|
   f = self.frame
-  f.origin.y = y
+  f.origin.y = Teacup::calculate(self, :height, y)
   self.frame = f
 }
 
 Teacup.handler UIView, :bottom { |b|
   f = self.frame
-  f.origin.y = b - f.size.height
+  f.origin.y = Teacup::calculate(self, :height, b) - f.size.height
   self.frame = f
 }
 
 Teacup.handler UIView, :center_y, :middle_y { |y|
   c = self.center
-  c.y = y
+  c.y = Teacup::calculate(self, :height, y)
   self.center = c
 }
 
 Teacup.handler UIView, :width { |w|
   f = self.frame
-  f.size.width = w
+  f.size.width = Teacup::calculate(self, :width, w)
   self.frame = f
 }
 
 Teacup.handler UIView, :height { |h|
   f = self.frame
-  f.size.height = h
+  f.size.height = Teacup::calculate(self, :height, h)
   self.frame = f
 }
 
@@ -56,12 +76,15 @@ Teacup.handler UIView, :origin { |origin|
 }
 
 Teacup.handler UIView, :size { |size|
+  # odd... if I changed these to .is_a?, weird errors happen.  Use ===
   if Symbol === size && size == :full
     if self.superview
-      size = Size(self.superview.bounds.size)
+      size = self.superview.bounds.size
     else
       size = self.frame.size
     end
+  elsif Array === size
+    size = [Teacup::calculate(self, :width, size[0]), Teacup::calculate(self, :height, size[1])]
   end
   f = self.frame
   f.size = size
@@ -69,12 +92,23 @@ Teacup.handler UIView, :size { |size|
 }
 
 Teacup.handler UIView, :frame { |frame|
+  # odd... if I changed these to .is_a?, weird errors happen.  Use ===
   if Symbol === frame && frame == :full
     if self.superview
-      frame = Rect(self.superview.bounds)
+      frame = self.superview.bounds
     else
       frame = self.frame
     end
+  elsif Array === frame && frame.length == 4
+    frame = [
+        [Teacup::calculate(self, :width, frame[0]), Teacup::calculate(self, :height, frame[1])],
+        [Teacup::calculate(self, :width, frame[2]), Teacup::calculate(self, :height, frame[3])]
+      ]
+  elsif Array === frame && frame.length == 2
+    frame = [
+        [Teacup::calculate(self, :width, frame[0][0]), Teacup::calculate(self, :height, frame[0][1])],
+        [Teacup::calculate(self, :width, frame[1][0]), Teacup::calculate(self, :height, frame[1][1])]
+      ]
   end
   self.frame = frame
 }
@@ -92,7 +126,7 @@ Teacup.handler UIButton, :titleColor { |color|
 }
 
 
-Teacup.handler UIButton, :titleFont { |font|
+Teacup.handler UIButton, :titleFont, :font { |font|
   font = font.uifont
   self.titleLabel.font = font
 }

data/lib/teacup.rb

@@ -21,4 +21,6 @@ Motion::Project::App.setup do |app|
   Dir.glob(File.join(File.dirname(__FILE__), 'teacup/**/*.rb')).reverse.each do |file|
     app.files.insert(insert_point, file)
   end
+
+  app.vendor_project File.join(File.dirname(__FILE__), '../vendor/TeacupDummy'), :static
 end