sugarcube 0.11.3 → 0.12

data/lib/sugarcube/timer.rb

@@ -1,4 +1,11 @@
 class Numeric
+  def milliseconds
+    self / 1000.0
+  end
+  alias millisecond milliseconds
+  alias millisecs milliseconds
+  alias millisec milliseconds
+
   def seconds
     self
   end

data/lib/sugarcube/to_s/nslayoutconstraint.rb

@@ -0,0 +1,97 @@
+if defined? NSLayoutConstraint
+class NSLayoutConstraint
+  Relationships = {
+    equal: NSLayoutRelationEqual,
+    lte: NSLayoutRelationLessThanOrEqual,
+    gte: NSLayoutRelationGreaterThanOrEqual,
+  }
+  Attributes = {
+    left: NSLayoutAttributeLeft,
+    right: NSLayoutAttributeRight,
+    top: NSLayoutAttributeTop,
+    bottom: NSLayoutAttributeBottom,
+    leading: NSLayoutAttributeLeading,
+    trailing: NSLayoutAttributeTrailing,
+    width: NSLayoutAttributeWidth,
+    height: NSLayoutAttributeHeight,
+    center_x: NSLayoutAttributeCenterX,
+    center_y: NSLayoutAttributeCenterY,
+    baseline: NSLayoutAttributeBaseline,
+  }
+
+  def to_s
+    target = firstItem
+    relative_to = secondItem
+
+    if firstItem and secondItem
+      if secondItem == firstItem
+        relative_to = :self
+      elsif firstItem.superview and secondItem == firstItem.superview
+        relative_to = :superview
+      elsif secondItem.respond_to?(:stylename) and secondItem.stylename
+        relative_to = secondItem.stylename
+      end
+
+      if secondItem.superview and firstItem == secondItem.superview
+        target = :superview
+      elsif firstItem.respond_to?(:stylename) and firstItem.stylename
+        target = firstItem.stylename
+      end
+    elsif firstItem
+      if firstItem.respond_to?(:stylename) and firstItem.stylename
+        target = firstItem.stylename
+      end
+    elsif secondItem
+      if secondItem.respond_to?(:stylename) and secondItem.stylename
+        target = secondItem.stylename
+      end
+    end
+
+    op = case _to_s_relationship_reverse relation
+         when :equal
+           '=='
+         when :gte
+           '>='
+         when :lte
+           '<='
+         end
+    formula = 'first.'
+    formula << _to_s_attribute_reverse(firstAttribute).to_s
+    formula << ' ' << op << ' '
+    if multiplier != 1
+      formula << multiplier.to_s << ' × '
+    end
+    if secondItem
+      if firstItem == secondItem
+        formula << 'first.'
+      else
+        formula << 'second.'
+      end
+      formula << _to_s_attribute_reverse(secondAttribute).to_s
+    end
+    if constant != 0
+      if secondItem
+        formula << ' + '
+      end
+      formula << constant.to_s
+    end
+
+    return "#<#{self.class}:##{object_id.to_s(16)}" +
+           " firstItem=#{target.inspect}" +
+           " secondItem=#{relative_to.inspect}" +
+           " priority=#{priority.inspect}" +
+           " formula=#{formula.inspect}" +
+           ">"
+  end
+
+private
+  def _to_s_attribute_reverse(attribute)
+    Attributes.key(attribute) || :none
+  end
+
+  def _to_s_relationship_reverse(relationship)
+    Relationships.key(relationship)
+  end
+
+end
+end

data/lib/sugarcube/to_s/uilabel.rb

@@ -1,6 +1,10 @@
 class UILabel
 
   def to_s(options={})
+    text = self.text
+    if text && text.length > 20
+      text = text[0..20] + '...'
+    end
     super options.merge(inner: 'text: ' + text.inspect)
   end
 

data/lib/sugarcube/to_s/uitextfield.rb

@@ -0,0 +1,15 @@
+class UITextField
+
+  def to_s(options={})
+    text = self.text
+    if text && text.length > 20
+      text = text[0..20] + '...'
+    end
+    placeholder = self.placeholder
+    if placeholder && placeholder.length > 20
+      placeholder = placeholder[0..20] + '...'
+    end
+    super options.merge(inner: {text: text, placeholder: placeholder, firstResponder?: firstResponder?})
+  end
+
+end

data/lib/sugarcube/to_s/uiview.rb

@@ -7,8 +7,18 @@ class UIView
     else
       suffix = ''
     end
+    if options[:inner].is_a? Hash
+      inner = ''
+      options[:inner].each do |key, value|
+        inner += ', ' if inner.length > 0
+        inner += "#{key}: #{value.inspect}"
+      end
+    else
+      inner = options[:inner]
+    end
+
     "#{self.class.name}(##{self.object_id.to_s(16)}, #{SugarCube::Adjust::format_frame(self.frame)}" +
-                        (options[:inner] ? ', ' + options[:inner] : '') +
+                        (inner ? ', ' + inner : '') +
                         ')' +
                         (options[:superview] && self.superview ? ", child of #{self.superview.class.name}(##{self.superview.object_id.to_s(16)})" : '') +
                         suffix

data/lib/sugarcube/uiactionsheet.rb

@@ -0,0 +1,86 @@
+class UIActionSheet
+
+  # UIActionSheet.alert("message",
+  #   # The first button is considered the 'cancel' button, for the purposes of
+  #   # whether the cancel or success handler gets called, the second button is
+  #   # the 'destructive' button, and the rest are plain old buttons.
+  #   buttons: %w"Cancel OK No-way",
+  #   cancel: proc{ puts "nevermind" },
+  #   destructive: proc{ puts "OHHH YEAAH!" },
+  #   success: proc{ |pressed| puts "pressed: #{pressed}" },
+  #   )
+  def self.alert(title, options={}, &block)
+    if options.is_a? String
+      options = {message: options}
+    end
+
+    # create the delegate
+    delegate = SugarCube::ActionSheetDelegate.new
+    delegate.on_success = options[:success] || block
+    delegate.on_destructive = options[:destructive] || block
+    delegate.on_cancel = options[:cancel]
+    delegate.send(:retain)
+
+    args = [title]            # initWithTitle:
+    args << options[:message] # message:
+    args << delegate          # delegate:
+
+    buttons = options[:buttons] || []
+    if buttons.empty?
+      # cancelButtonTitle: is first, so check for cancel
+      buttons << "Cancel" if options[:cancel]
+      # destructiveButtonTitle: is first, so check for cancel
+      buttons << "Cancel" if options[:cancel]
+      # otherButtonTitles:
+      buttons << "OK" if options[:success] or buttons.empty?
+    elsif buttons.length == 1 and options[:cancel]
+      raise "If you only have one button, use a :success handler, not :cancel (and definitely not BOTH)"
+    end
+
+    # the button titles.  These are passed to the success handler.
+    delegate.buttons = buttons
+
+    # uses localized buttons in the actual alert
+    args.concat(buttons.map{ |s| s.localized })
+    args << nil  # otherButtonTitles:..., nil
+
+    alert = self.alloc
+    alert.send('initWithTitle:message:delegate:cancelButtonTitle:destructiveButtonTitle:otherButtonTitles:', *args)
+    alert.show
+    alert
+  end
+
+  private
+  def dummy
+    self.initWithTitle(nil, message:nil, delegate:nil, cancelButtonTitle:nil, destructiveButtonTitle:nil, otherButtonTitles:nil)
+  end
+
+end
+
+
+module SugarCube
+  class ActionSheetDelegate
+    attr_accessor :buttons
+    attr_accessor :on_cancel
+    attr_accessor :on_destructive
+    attr_accessor :on_success
+
+    def alertSheet(alert, didDismissWithButtonIndex:index)
+      if index == alert.destructiveButtonIndex && on_destructive
+        on_destructive.call
+      elsif index == alert.cancelButtonIndex && on_cancel
+        on_cancel.call
+      elsif on_success
+        if on_success.arity == 0
+          on_success.call
+        else
+          button = buttons[index]
+          on_success.call(button)
+        end
+      end
+
+      self.send(:autorelease)
+    end
+
+  end
+end

data/lib/sugarcube/uialertview.rb

@@ -61,7 +61,7 @@ module SugarCube
     attr_accessor :on_success
 
     def alertView(alert, didDismissWithButtonIndex:index)
-      if index == 0 && on_cancel
+      if index == alert.cancelButtonIndex && on_cancel
         on_cancel.call
       elsif on_success
         if on_success.arity == 0

data/lib/sugarcube/uicolor.rb

@@ -1,6 +1,6 @@
-
 class UIColor
   def uicolor ; self ; end
+  alias cgcolor CGColor
 
   def red
     _sugarcube_colors[:red]
@@ -24,15 +24,24 @@ private
       red = Pointer.new(:float)
       green = Pointer.new(:float)
       blue = Pointer.new(:float)
+      white = Pointer.new(:float)
       alpha = Pointer.new(:float)
-      self.getRed(red, green:green, blue:blue, alpha:alpha)
-      @color = {
-        red: red[0],
-        green: green[0],
-        blue: blue[0],
-        alpha: alpha[0],
-      }
+      if self.getRed(red, green:green, blue:blue, alpha:alpha)
+        {
+          red: red[0],
+          green: green[0],
+          blue: blue[0],
+          alpha: alpha[0],
+        }
+      elsif self.getWhite(white, alpha:alpha)
+        {
+          red: white[0],
+          green: white[0],
+          blue: white[0],
+          alpha: alpha[0],
+        }
+      end
     end
   end
 
-end
+end

data/lib/sugarcube/uiimage.rb

@@ -1,6 +1,7 @@
 class UIImage
   def uiimage ; self ; end
 
+  # @return [UIColor]
   def uicolor(alpha=nil)
     color = UIColor.colorWithPatternImage(self)
     if not alpha.nil?
@@ -10,19 +11,89 @@ class UIImage
     color
   end
 
+  # @return [UIImageView]
   def uiimageview
-    @uiimageview = UIImageView.alloc.initWithImage(self)
+    UIImageView.alloc.initWithImage(self)
+  end
+
+  # @return [NSData] an NSData object in PNG format
+  def nsdata
+    UIImagePNGRepresentation(self)
   end
 
   ##|
   ##|  REALLY HANDY STUFF!
+  ##|  many of these methods are translated from:
+  ##|  <http://www.catamount.com/blog/uiimage-extensions-for-cutting-scaling-and-rotating-uiimages/>
+  ##|  <http://www.catamount.com/forums/viewtopic.php?f=21&t=967>
   ##|
-  def scale_to new_size
-    UIGraphicsBeginImageContextWithOptions(new_size, false, 0.0)
-    self.drawInRect([[0, 0], new_size])
-    image = UIGraphicsGetImageFromCurrentImageContext()
+  def in_rect(rect)
+    # not necessary, since we don't modify/examine the rect
+    # rect = SugarCube::CoreGraphics::Rect(rect)
+    imageRef = CGImageCreateWithImageInRect(self.CGImage, rect)
+    sub_image = UIImage.imageWithCGImage(imageRef)
+
+    return sub_image
+  end
+
+  def scale_to(new_size)
+    new_size = SugarCube::CoreGraphics::Size(new_size)
+
+    sourceImage = self
+    newImage = nil
+
+    image_size = sourceImage.size
+    width = image_size.width
+    height = image_size.height
+
+    target_width = new_size.width
+    target_height = new_size.height
+
+    scale_factor = 0.0
+    scaled_width = target_width
+    scaled_height = target_height
+
+    thumbnail_point = CGPoint.new(0.0, 0.0)
+
+    unless CGSizeEqualToSize(image_size, new_size)
+      width_factor = target_width / width
+      heightFactor = target_height / height
+
+      if width_factor < heightFactor
+        scale_factor = width_factor
+      else
+        scale_factor = heightFactor
+      end
+
+      scaled_width  = width * scale_factor
+      scaled_height = height * scale_factor
+
+      # center the image
+
+      if width_factor < heightFactor
+        thumbnail_point.y = (target_height - scaled_height) * 0.5
+      elsif width_factor > heightFactor
+        thumbnail_point.x = (target_width - scaled_width) * 0.5
+      end
+    end
+
+    # this is actually the interesting part:
+
+    UIGraphicsBeginImageContext(new_size)
+
+    thumbnail_rect = CGRectZero
+    thumbnail_rect.origin = thumbnail_point
+    thumbnail_rect.size.width  = scaled_width
+    thumbnail_rect.size.height = scaled_height
+
+    sourceImage.drawInRect(thumbnail_rect)
+
+    new_image = UIGraphicsGetImageFromCurrentImageContext()
     UIGraphicsEndImageContext()
-    return image
+
+    raise "could not scale image"  unless new_image
+
+    return new_image
   end
 
   def rounded(corner_radius=5)
@@ -30,18 +101,93 @@ class UIImage
     path = UIBezierPath.bezierPathWithRoundedRect([[0, 0], size], cornerRadius:corner_radius)
     path.addClip
     self.drawInRect([[0, 0], size])
-    image = UIGraphicsGetImageFromCurrentImageContext()
+    new_image = UIGraphicsGetImageFromCurrentImageContext()
+    UIGraphicsEndImageContext()
+    return new_image
+  end
 
+  # Accepts two options: brightness (default: -0.5) and saturation (default: -0.2)
+  # Returns a darkened version of the image.
+  def darken(options={})
+    filter_name = 'CIColorControls'
+    filter_options = {
+      inputBrightness: options[:brightness] || -0.5,
+      inputSaturation: options[:saturation] || -0.2,
+    }
+
+    cg_input_image = CIImage.alloc.initWithImage(self)
+    darken_filter = CIFilter.filterWithName(filter_name)
+    raise Exception.new("Filter not found: #{filter_name}") unless darken_filter
+
+    darken_filter.setDefaults
+    darken_filter.setValue(cg_input_image, forKey:'inputImage')
+    filter_options.each_pair do |key, value|
+      darken_filter.setValue(value, forKey:key)
+    end
+    output = darken_filter.valueForKey('outputImage')
+
+    context = CIContext.contextWithOptions(nil)
+    cg_output_image = context.createCGImage(output, fromRect:output.extent)
+    output_image = UIImage.imageWithCGImage(cg_output_image)
+
+    return output_image
+  end
+
+  ##|
+  ##|  rotate images
+  ##|
+  def rotate(angle_or_direction)
+    case angle_or_direction
+    when :left
+      radian = -90.degrees
+    when :right
+      radian = 90.degrees
+    when :flip
+      radian = 180.degrees
+    when Numeric
+      radian = angle_or_direction
+    else
+      raise "Unknown angle/direction #{angle_or_direction.inspect}"
+    end
+
+    w = (self.size.width * Math.cos(radian)).abs + (self.size.height * Math.sin(radian)).abs
+    h = (self.size.height * Math.cos(radian)).abs + (self.size.width * Math.sin(radian)).abs
+    new_size = CGSize.new(w, h)
+    new_size = self.size
+
+    # Create the bitmap context
+    UIGraphicsBeginImageContext(new_size)
+    bitmap = UIGraphicsGetCurrentContext()
+
+    # Move the origin to the middle of the image so we will rotate and scale around the center.
+    CGContextTranslateCTM(bitmap, new_size.width / 2, new_size.height / 2)
+
+    # Rotate the image context
+    CGContextRotateCTM(bitmap, radian)
+
+    # otherwise it'll be upside down:
+    CGContextScaleCTM(bitmap, 1.0, -1.0)
+    # Now, draw the rotated/scaled image into the context
+    CGContextDrawImage(bitmap, CGRectMake(-new_size.width / 2, -new_size.height / 2, new_size.width, new_size.height), self.CGImage)
+
+    new_image = UIGraphicsGetImageFromCurrentImageContext()
     UIGraphicsEndImageContext()
-    return image
+    return new_image
   end
 
-  def tileable
-    resizableImageWithCapInsets(UIEdgeInsetsZero, resizingMode:UIImageResizingModeTile)
+  ##|
+  ##|  resizableImageWithCapInsets
+  ##|
+  def tileable(insets=UIEdgeInsetsZero)
+    # not necessary, since we don't modify/examine the insets
+    # insets = SugarCube::CoreGraphics::EdgeInsets(insets)
+    resizableImageWithCapInsets(insets, resizingMode:UIImageResizingModeTile)
   end
 
-  def stretchable
-    resizableImageWithCapInsets(UIEdgeInsetsZero, resizingMode:UIImageResizingModeStretch)
+  def stretchable(insets=UIEdgeInsetsZero)
+    # not necessary, since we don't modify/examine the insets
+    # insets = SugarCube::CoreGraphics::EdgeInsets(insets)
+    resizableImageWithCapInsets(insets, resizingMode:UIImageResizingModeStretch)
   end
 
 end