teacup 1.3.4 → 2.0.0

data/lib/teacup-ios/core_extensions/teacup_handlers.rb

@@ -0,0 +1,183 @@
+##|
+##|  UIView.frame
+##|
+Teacup.handler UIView, :left, :x do |target, x|
+  f = target.frame
+  f.origin.x = Teacup::calculate(target, :width, x)
+  target.frame = f
+end
+
+Teacup.handler UIView, :right do |target, r|
+  f = target.frame
+  f.origin.x = Teacup::calculate(target, :width, r) - f.size.width
+  target.frame = f
+end
+
+Teacup.handler UIView, :center_x, :middle_x do |target, x|
+  c = target.center
+  c.x = Teacup::calculate(target, :width, x)
+  target.center = c
+end
+
+Teacup.handler UIView, :top, :y do |target, y|
+  f = target.frame
+  f.origin.y = Teacup::calculate(target, :height, y)
+  target.frame = f
+end
+
+Teacup.handler UIView, :bottom do |target, b|
+  f = target.frame
+  f.origin.y = Teacup::calculate(target, :height, b) - f.size.height
+  target.frame = f
+end
+
+Teacup.handler UIView, :center_y, :middle_y do |target, y|
+  c = target.center
+  c.y = Teacup::calculate(target, :height, y)
+  target.center = c
+end
+
+Teacup.handler UIView, :width do |target, w|
+  f = target.frame
+  f.size.width = Teacup::calculate(target, :width, w)
+  target.frame = f
+end
+
+Teacup.handler UIView, :height do |target, h|
+  f = target.frame
+  f.size.height = Teacup::calculate(target, :height, h)
+  target.frame = f
+end
+
+Teacup.handler UIView, :size do |target, size|
+  f = target.frame
+  size_x = Teacup::calculate(target, :width, size[0])
+  size_y = Teacup::calculate(target, :height, size[1])
+  f.size = [size_x, size_y]
+  target.frame = f
+end
+
+Teacup.handler UIView, :origin do |target, origin|
+  f = target.frame
+  origin_x = Teacup::calculate(target, :width, origin[0])
+  origin_y = Teacup::calculate(target, :height, origin[1])
+  f.origin = [origin_x, origin_y]
+  target.frame = f
+end
+
+Teacup.handler UIView, :center do |target, center|
+  center_x = Teacup::calculate(target, :width, center[0])
+  center_y = Teacup::calculate(target, :height, center[1])
+  target.center = [center_x, center_y]
+end
+
+Teacup.handler UIView, :size do |target, size|
+  # odd... if I changed these to .is_a?, weird errors happen.  Use ===
+  if Symbol === size && size == :full
+    if target.superview
+      size = target.superview.bounds.size
+    else
+      size = target.frame.size
+    end
+  elsif Array === size
+    size = [Teacup::calculate(target, :width, size[0]), Teacup::calculate(target, :height, size[1])]
+  end
+  f = target.frame
+  f.size = size
+  target.frame = f
+end
+
+Teacup.handler UIView, :frame do |target, frame|
+  # odd... if I changed these to .is_a?, weird errors happen.  Use ===
+  if Symbol === frame && frame == :full
+    if target.superview
+      frame = target.superview.bounds
+    else
+      frame = target.frame
+    end
+  elsif Array === frame && frame.length == 4
+    frame = [
+        [Teacup::calculate(target, :width, frame[0]), Teacup::calculate(target, :height, frame[1])],
+        [Teacup::calculate(target, :width, frame[2]), Teacup::calculate(target, :height, frame[3])]
+      ]
+  elsif (Array === frame && frame.length == 2) || CGRect === frame
+    frame = [
+        [Teacup::calculate(target, :width, frame[0][0]), Teacup::calculate(target, :height, frame[0][1])],
+        [Teacup::calculate(target, :width, frame[1][0]), Teacup::calculate(target, :height, frame[1][1])]
+      ]
+  end
+  target.frame = frame
+end
+
+Teacup.handler UIView, :gradient do |target, gradient|
+  gradient_layer = target.instance_variable_get(:@teacup_gradient_layer) || begin
+    gradient_layer = CAGradientLayer.layer
+    gradient_layer.frame = target.bounds
+    target.layer.insertSublayer(gradient_layer, atIndex:0)
+    gradient_layer
+  end
+
+  gradient.each do |key, value|
+    case key.to_s
+    when 'colors'
+      colors = [value].flatten.collect { |color| color.is_a?(UIColor) ? color.CGColor : color }
+      gradient_layer.colors = colors
+    else
+      gradient_layer.send("#{key}=", value)
+    end
+  end
+
+  target.instance_variable_set(:@teacup_gradient_layer, gradient_layer)
+end
+
+##|
+##|  UIButton
+##|
+Teacup.handler UIButton, :title do |target, title|
+  target.setTitle(title, forState: UIControlStateNormal)
+end
+
+
+Teacup.handler UIButton, :image do |target, image|
+  target.setImage(image, forState: UIControlStateNormal)
+end
+
+
+Teacup.handler UIButton, :backgroundImage do |target, background_image|
+  target.setBackgroundImage(background_image, forState: UIControlStateNormal)
+end
+
+
+Teacup.handler UIButton, :titleColor do |target, color|
+  target.setTitleColor(color, forState: UIControlStateNormal)
+end
+
+
+Teacup.handler UIButton, :titleFont, :font do |target, font|
+  target.titleLabel.font = font
+end
+
+
+##|
+##|  UINavigationBar
+##|
+Teacup.handler UINavigationBar, :backgroundImage do |styles|
+  if styles.is_a?(UIImage)
+    styles = { portrait: styles }
+  end
+
+  styles.each do |metric, image|
+    case metric
+    when UIBarMetricsDefault, :portrait
+      self.setBackgroundImage(image && image.uiimage, forBarMetrics:UIBarMetricsDefault)
+    when UIBarMetricsLandscapePhone, :landscape
+      self.setBackgroundImage(image && image.uiimage, forBarMetrics:UIBarMetricsLandscapePhone)
+    end
+  end
+end
+
+# this handler lyooks redundant, but without it Teacup would treat `attrs` as a
+# stylable-property (the 'nested styling' feature)
+Teacup.handler UINavigationBar, :titleTextAttributes do |view, attrs|
+  view.titleTextAttributes = attrs
+end

data/lib/teacup-ios/core_extensions/ui_view.rb

@@ -0,0 +1,30 @@
+# 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
+  include Teacup::View
+
+  def teacup_animation(options)
+    UIView.beginAnimations(nil, context: nil)
+    UIView.setAnimationDuration(options[:duration]) if options.key?(:duration)
+    UIView.setAnimationCurve(options[:curve]) if options.key?(:curve)
+    UIView.setAnimationDelay(options[:delay]) if options.key?(:delay)
+    yield
+    UIView.commitAnimations
+  end
+
+  def style(properties)
+    super
+
+    self.setNeedsDisplay
+    self.setNeedsLayout
+  end
+
+  def top_level_view
+    self
+  end
+
+end

data/lib/teacup-ios/core_extensions/ui_view_controller.rb

@@ -0,0 +1,110 @@
+class UIViewController
+  include Teacup::Layout
+  include Teacup::Controller
+
+  def viewDidLoad
+    teacupDidLoad
+  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
+
+  def top_level_view
+    view
+  end
+
+end

data/lib/{dummy.rb → teacup-ios/dummy.rb}

@@ -1,9 +1,3 @@
-class TeacupDummy
-  def anyMethodName
-    @anyobject.type = nil
-  end
-end
-
 class DummyView < UIView
 private
   def dummy
@@ -11,6 +5,8 @@ private
     setOpaque(nil)
     setClipsToBounds(nil)
     setUserInteractionEnabled(nil)
+    UIView.appearanceWhenContainedIn(UIView, nil)
+    UIView.appearance
   end
 end
 

data/lib/teacup-ios/handler.rb

@@ -0,0 +1,23 @@
+module Teacup
+  module_function
+
+  def apply_method(target, assign, setter, value)
+    if assign and target.respond_to?(assign)
+      NSLog "Setting #{key} = #{value.inspect}" if target.respond_to? :debug and target.debug
+      target.send(assign, value)
+    elsif target.respondsToSelector(setter)
+      NSLog "Calling target.#{setter}(#{value.inspect})" if target.respond_to? :debug and target.debug
+      target.send(setter, value)
+    elsif target.is_a?(self.AppearanceClass)
+      NSLog "Calling target.#{setter}(#{value.inspect})" if target.respond_to? :debug and target.debug
+      target.send(setter, value)
+    else
+      NSLog "TEACUP WARNING: Can't apply #{setter.inspect}#{assign and " or " + assign.inspect or ""} to #{target.inspect}"
+    end
+  end
+
+  def AppearanceClass
+    @appearance_klass ||= UIView.appearance.class
+  end
+
+end

data/lib/{teacup → teacup-ios}/style.rb

@@ -49,13 +49,11 @@ module Teacup
       end
 
       # first, move orientation settings into properties "base" level.
-      if orientation
-        Overrides[orientation].each do |orientation_key|
-          if override = self[orientation_key]
-            # override is first, so it takes precedence
-            if override.is_a? Hash
-              Teacup::merge_defaults override, properties, properties
-            end
+      Overrides[orientation].each do |orientation_key|
+        if override = self[orientation_key]
+          # override is first, so it takes precedence
+          if override.is_a? Hash
+            Teacup::merge_defaults override, properties, properties
           end
         end
       end
@@ -68,8 +66,9 @@ module Teacup
         properties.delete(orientation_key)
       end
 
-      # now we can merge extends, and importing.  before merging, these will go
-      # through the same process that we just finished on the local style
+      # now we can merge extends, and imported_stylesheets.  before merging,
+      # these will go through the same process that we just finished on the
+      # local style
       if stylesheet && stylesheet.is_a?(Teacup::Stylesheet)
         stylesheet.imported_stylesheets.reverse.each do |stylesheet|
           imported_properties = stylesheet.query(self.stylename, target, rotation_orientation, seen)
@@ -104,7 +103,7 @@ module Teacup
         end
       end
 
-      properties
+      return properties
     end
 
   end

data/lib/teacup-ios/stylesheet_extensions/autoresize.rb

@@ -0,0 +1,169 @@
+# Example:
+#     Teacup::Stylesheet.new :main do
+#       style :root,
+#         # stays centered and grows in height
+#         autoresizingMask: autoresize.flexible_left | autoresize.flexible_right | autoresize.flexible_height
+#         # same, in block form
+#         autoresizingMask: autoresize { flexible_left | flexible_right | flexible_height }
+#     end
+module Teacup
+  class Stylesheet
+
+    def autoresize &block
+      @@autoresize ||= Autoresize.new
+      if block
+        return @@autoresize.instance_exec &block
+      else
+        return @@autoresize
+      end
+    end
+
+    ##|
+    ##|  DEPRECATED
+    ##|
+
+    def flexible_left
+      NSLog("The Stylesheet method `flexible_left` is deprecated, use `autoresize.flexible_left` instead")
+      UIViewAutoresizingFlexibleLeftMargin
+    end
+
+    def flexible_width
+      NSLog("The Stylesheet method `flexible_width` is deprecated, use `autoresize.flexible_width` instead")
+      UIViewAutoresizingFlexibleWidth
+    end
+
+    def flexible_right
+      NSLog("The Stylesheet method `flexible_right` is deprecated, use `autoresize.flexible_right` instead")
+      UIViewAutoresizingFlexibleRightMargin
+    end
+
+    def flexible_top
+      NSLog("The Stylesheet method `flexible_top` is deprecated, use `autoresize.flexible_top` instead")
+      UIViewAutoresizingFlexibleTopMargin
+    end
+
+    def flexible_height
+      NSLog("The Stylesheet method `flexible_height` is deprecated, use `autoresize.flexible_height` instead")
+      UIViewAutoresizingFlexibleHeight
+    end
+
+    def flexible_bottom
+      NSLog("The Stylesheet method `flexible_bottom` is deprecated, use `autoresize.flexible_bottom` instead")
+      UIViewAutoresizingFlexibleBottomMargin
+    end
+
+  end
+
+  class Autoresize
+
+    def none
+      UIViewAutoresizingNone
+    end
+
+    ##|
+    ##|  FLEXIBLE
+    ##|
+
+    def flexible_left
+      UIViewAutoresizingFlexibleLeftMargin
+    end
+
+    def flexible_width
+      UIViewAutoresizingFlexibleWidth
+    end
+
+    def flexible_right
+      UIViewAutoresizingFlexibleRightMargin
+    end
+
+    def flexible_top
+      UIViewAutoresizingFlexibleTopMargin
+    end
+
+    def flexible_height
+      UIViewAutoresizingFlexibleHeight
+    end
+
+    def flexible_bottom
+      UIViewAutoresizingFlexibleBottomMargin
+    end
+
+    ##|
+    ##|  FILL
+    ##|
+
+    def fill
+      flexible_width | flexible_height
+    end
+
+    def fill_top
+      flexible_width | flexible_bottom
+    end
+
+    def fill_bottom
+      flexible_width | flexible_top
+    end
+
+    def fill_left
+      flexible_height | flexible_right
+    end
+
+    def fill_right
+      flexible_height | flexible_left
+    end
+
+    ##|
+    ##|  FIXED
+    ##|
+
+    def fixed_top_left
+      flexible_right | flexible_bottom
+    end
+
+    def fixed_top_middle
+      flexible_left | flexible_right | flexible_bottom
+    end
+
+    def fixed_top_right
+      flexible_left | flexible_bottom
+    end
+
+    def fixed_middle_left
+      flexible_top | flexible_bottom | flexible_right
+    end
+
+    def fixed_middle
+      flexible_top | flexible_bottom | flexible_left | flexible_right
+    end
+
+    def fixed_middle_right
+      flexible_top | flexible_bottom | flexible_left
+    end
+
+    def fixed_bottom_left
+      flexible_right | flexible_top
+    end
+
+    def fixed_bottom_middle
+      flexible_left | flexible_right | flexible_top
+    end
+
+    def fixed_bottom_right
+      flexible_left | flexible_top
+    end
+
+    ##|
+    ##|  FLOAT
+    ##|
+
+    def float_horizontal
+      flexible_left | flexible_right
+    end
+
+    def float_vertical
+      flexible_top | flexible_bottom
+    end
+
+  end
+
+end

data/lib/teacup-osx/core_extensions/ns_view.rb

@@ -0,0 +1,39 @@
+# Teacup's NSView extensions defines some utility functions for NSView 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 NSView
+  include Teacup::Layout
+  include Teacup::View
+
+  class << NSView
+    attr :teacup_is_animating
+  end
+
+  def teacup_animation(options)
+    NSAnimationContext.beginGrouping
+    NSAnimationContext.currentContext.setDuration(options[:duration]) if options.key?(:duration)
+    NSAnimationContext.currentContext.setTimingFunction(options[:timing]) if options.key?(:timing)
+    NSView.teacup_is_animating = true
+    yield
+    NSView.teacup_is_animating = false
+    NSAnimationContext.endGrouping
+  end
+
+  def apply_style_properties(properties)
+    Teacup.apply_hash((NSView.teacup_is_animating ? self.animator : self), properties)
+  end
+
+  def style(properties)
+    super
+
+    self.setNeedsDisplay(true)
+    self.setNeedsLayout(true)
+  end
+
+  def top_level_view
+    self
+  end
+
+end

data/lib/teacup-osx/core_extensions/ns_view_controller.rb

@@ -0,0 +1,21 @@
+class NSViewController
+  include Teacup::Layout
+  include Teacup::Controller
+
+  alias _teacup_loadview loadView
+  def loadView
+    if nibName and nibBundle
+      _teacup_loadview
+    else
+      self.view = NSView.new
+      self.view.autoresizingMask = NSViewWidthSizable|NSViewHeightSizable
+    end
+
+    teacupDidLoad
+  end
+
+  def top_level_view
+    view
+  end
+
+end

data/lib/teacup-osx/core_extensions/ns_window.rb

@@ -0,0 +1,39 @@
+# Teacup's NSWindow extensions defines some utility functions for NSWindow 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 NSWindow
+  include Teacup::Layout
+  include Teacup::View
+
+  class << NSWindow
+    attr :teacup_is_animating
+  end
+
+  def teacup_animation(options)
+    NSAnimationContext.beginGrouping
+    NSAnimationContext.currentContext.setDuration(options[:duration]) if options.key?(:duration)
+    NSAnimationContext.currentContext.setTimingFunction(options[:timing]) if options.key?(:timing)
+    NSWindow.teacup_is_animating = true
+    yield
+    NSWindow.teacup_is_animating = false
+    NSAnimationContext.endGrouping
+  end
+
+  def apply_style_properties(properties)
+    Teacup.apply_hash((NSWindow.teacup_is_animating ? self.animator : self), properties)
+  end
+
+  def style(properties)
+    super
+
+    self.setNeedsDisplay(true)
+    self.setNeedsLayout(true)
+  end
+
+  def top_level_view
+    contentView
+  end
+
+end