teacup 1.3.4 → 2.0.0

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

@@ -0,0 +1,29 @@
+class NSWindowController
+  include Teacup::Layout
+  include Teacup::Controller
+
+  def windowDidLoad
+    teacupDidLoad
+  end
+
+  def top_level_view
+    window.contentView
+  end
+
+end
+
+
+class TeacupWindowController < NSWindowController
+
+  def self.new
+    alloc.initWithWindowNibName(self.class.name)
+  end
+
+  def loadWindow
+    self.window = NSWindow.alloc.initWithContentRect([[240, 180], [480, 360]],
+      styleMask: NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask|NSResizableWindowMask,
+      backing: NSBackingStoreBuffered,
+      defer: false)
+  end
+
+end

data/lib/{teacup/z_core_extensions/z_handlers.rb → teacup-osx/core_extensions/teacup_handlers.rb}

@@ -1,77 +1,77 @@
 ##|
-##|  UIView.frame
+##|  NSView.frame
 ##|
-Teacup.handler UIView, :left, :x { |target, x|
+Teacup.handler NSView, :left, :x do |target, x|
   f = target.frame
   f.origin.x = Teacup::calculate(target, :width, x)
   target.frame = f
-}
+end
 
-Teacup.handler UIView, :right { |target, r|
+Teacup.handler NSView, :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 { |target, x|
+Teacup.handler NSView, :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 { |target, y|
+Teacup.handler NSView, :top, :y do |target, y|
   f = target.frame
   f.origin.y = Teacup::calculate(target, :height, y)
   target.frame = f
-}
+end
 
-Teacup.handler UIView, :bottom { |target, b|
+Teacup.handler NSView, :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 { |target, y|
+Teacup.handler NSView, :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 { |target, w|
+Teacup.handler NSView, :width do |target, w|
   f = target.frame
   f.size.width = Teacup::calculate(target, :width, w)
   target.frame = f
-}
+end
 
-Teacup.handler UIView, :height { |target, h|
+Teacup.handler NSView, :height do |target, h|
   f = target.frame
   f.size.height = Teacup::calculate(target, :height, h)
   target.frame = f
-}
+end
 
-Teacup.handler UIView, :size { |target, size|
+Teacup.handler NSView, :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 { |target, origin|
+Teacup.handler NSView, :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 { |target, center|
+Teacup.handler NSView, :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 { |target, size|
+Teacup.handler NSView, :size do |target, size|
   # odd... if I changed these to .is_a?, weird errors happen.  Use ===
   if Symbol === size && size == :full
     if target.superview
@@ -85,9 +85,9 @@ Teacup.handler UIView, :size { |target, size|
   f = target.frame
   f.size = size
   target.frame = f
-}
+end
 
-Teacup.handler UIView, :frame { |target, frame|
+Teacup.handler NSView, :frame do |target, frame|
   # odd... if I changed these to .is_a?, weird errors happen.  Use ===
   if Symbol === frame && frame == :full
     if target.superview
@@ -100,16 +100,16 @@ Teacup.handler UIView, :frame { |target, 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
+  elsif (Array === frame && frame.length == 2) || NSRect === 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 { |target, gradient|
+Teacup.handler NSView, :gradient do |target, gradient|
   gradient_layer = target.instance_variable_get(:@teacup_gradient_layer) || begin
     gradient_layer = CAGradientLayer.layer
     gradient_layer.frame = target.bounds
@@ -128,21 +128,4 @@ Teacup.handler UIView, :gradient { |target, gradient|
   end
 
   target.instance_variable_set(:@teacup_gradient_layer, gradient_layer)
-}
-
-##|
-##|  UIButton
-##|
-Teacup.handler UIButton, :title { |target, title|
-  target.setTitle(title, forState: UIControlStateNormal)
-}
-
-
-Teacup.handler UIButton, :titleColor { |target, color|
-  target.setTitleColor(color, forState: UIControlStateNormal)
-}
-
-
-Teacup.handler UIButton, :titleFont, :font { |target, font|
-  target.titleLabel.font = font
-}
+end

data/lib/teacup-osx/dummy.rb

@@ -0,0 +1,80 @@
+class DummyView < NSView
+private
+  def dummy
+    setFrame(nil)
+    setOpaque(nil)
+    setClipsToBounds(nil)
+    setUserInteractionEnabled(nil)
+    setAutoresizingMask(nil)
+    NSView.appearanceWhenContainedIn(NSView, nil)
+    NSView.appearance
+  end
+end
+
+class DummyTableView < NSTableView
+private
+ def dummy
+   setAllowSelection(value)
+ end
+end
+
+class DummyTableColumn < NSTableColumn
+private
+  def dummy
+    setEditable(nil)
+  end
+end
+
+class DummyButton < NSButton
+private
+  def dummy
+    setTitleEdgeInsets(nil)
+    setTarget(nil)
+    setAction(nil)
+    setBezelStyle(nil)
+  end
+end
+
+class DummyScrollView < NSScrollView
+private
+  def dummy
+    setScrollEnabled(nil)
+    setHasVerticalScroller(nil)
+    setHasHorizontalScroller(nil)
+  end
+end
+
+class DummyTextField < NSTextField
+private
+  def dummy
+    setAdjustsFontSizeToFitWidth(nil)
+  end
+end
+
+class DummyTextView < NSTextView
+private
+  def dummy
+    setSecureTextEntry(nil)
+    setReturnKeyType(nil)
+    setAutocapitalizationType(nil)
+    setAutocorrectionType(nil)
+    setSpellCheckingType(nil)
+  end
+end
+
+class DummyLayer < CALayer
+private
+  def dummy
+    setCornerRadius(nil)
+    setTransform(nil)
+    setMasksToBounds(nil)
+    setShadowOffset(nil)
+    setShadowOpacity(nil)
+    setShadowRadius(nil)
+    setShadowOffset(nil)
+    setShadowColor(nil)
+    setShadowPath(nil)
+    setOpaque(nil)
+    setTranslucent(nil)
+  end
+end

data/lib/teacup-osx/handler.rb

@@ -0,0 +1,16 @@
+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)
+    else
+      NSLog "TEACUP WARNING: Can't apply #{setter.inspect}#{assign and " or " + assign.inspect or ""} to #{target.inspect}"
+    end
+  end
+
+end

data/lib/teacup-osx/style.rb

@@ -0,0 +1,83 @@
+module Teacup
+  # The Style class is where the precedence rules are applied.  A Style can
+  # query the Stylesheet that created it to look up other styles (for
+  # `extends:`) and to import other Stylesheets.  If it is handed a target (e.g.
+  # a `UIView` instance) and orientation, it will merge those in appropriately
+  # as well.
+  class Style < Hash
+    attr_accessor :stylename
+    attr_accessor :stylesheet
+
+    # A hash of orientation => true/false.  true means the orientation is
+    # supported.
+    def supports
+      @supports ||= {}
+    end
+
+    # returns the value - `nil` has special meaning when querying :portrait or :upside_up
+    def supports? orientation_key
+      false
+    end
+
+    def build(target=nil, rotation_orientation=nil, seen={})
+      properties = Style.new
+      properties.stylename = self.stylename
+      properties.stylesheet = self.stylesheet
+
+      # if we have an orientation, only apply those styles.  otherwise apply the
+      # entire style, including the current orientation.
+      if rotation_orientation
+        # in order to preserve the "local-first" override, we need to *delete*
+        # the keys in imported_stylesheets and extended_properties that are
+        # present in this style - even though we don't ultimately *apply* the
+        # styles
+        delete_keys = self.keys
+        orientation = rotation_orientation
+      else
+        delete_keys = []
+        properties.update(self)
+        orientation = nil
+      end
+
+      # 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)
+          delete_keys.each do |key|
+            imported_properties.delete(key)
+          end
+          Teacup::merge_defaults! properties, imported_properties
+        end
+
+        if also_includes = self[:extends]
+          also_includes = [also_includes] unless also_includes.is_a? Array
+
+          # turn style names into Hashes by querying them on the stylesheet
+          # (this does not pass `seen`, because this is a new query)
+          also_includes.each do |also_include|
+            extended_properties = stylesheet.query(also_include, target, rotation_orientation)
+            delete_keys.each do |key|
+              extended_properties.delete(key)
+            end
+            Teacup::merge_defaults! properties, extended_properties
+          end
+        end
+        properties.delete(:extends)
+
+        # if we know the class of the target, we can apply styles via class
+        # inheritance.  We do not pass `target` in this case.
+        if target
+          target.class.ancestors.each do |ancestor|
+            extended_properties = stylesheet.query(ancestor, nil, rotation_orientation)
+            Teacup::merge_defaults!(properties, extended_properties)
+          end
+        end
+      end
+
+      return properties
+    end
+
+  end
+end

data/lib/teacup-osx/style_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")
+      NSViewMinXMargin
+    end
+
+    def flexible_width
+      NSLog("The Stylesheet method `flexible_width` is deprecated, use `autoresize.flexible_width` instead")
+      NSViewWidthSizable
+    end
+
+    def flexible_right
+      NSLog("The Stylesheet method `flexible_right` is deprecated, use `autoresize.flexible_right` instead")
+      NSViewMaxXMargin
+    end
+
+    def flexible_top
+      NSLog("The Stylesheet method `flexible_top` is deprecated, use `autoresize.flexible_top` instead")
+      NSViewMaxYMargin
+    end
+
+    def flexible_height
+      NSLog("The Stylesheet method `flexible_height` is deprecated, use `autoresize.flexible_height` instead")
+      NSViewHeightSizable
+    end
+
+    def flexible_bottom
+      NSLog("The Stylesheet method `flexible_bottom` is deprecated, use `autoresize.flexible_bottom` instead")
+      NSViewMinYMargin
+    end
+
+  end
+
+  class Autoresize
+
+    def none
+      NSViewNotSizable
+    end
+
+    ##|
+    ##|  FLEXIBLE
+    ##|
+
+    def flexible_left
+      NSViewMinXMargin
+    end
+
+    def flexible_width
+      NSViewWidthSizable
+    end
+
+    def flexible_right
+      NSViewMaxXMargin
+    end
+
+    def flexible_top
+      NSViewMaxYMargin
+    end
+
+    def flexible_height
+      NSViewHeightSizable
+    end
+
+    def flexible_bottom
+      NSViewMinYMargin
+    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.rb

@@ -4,21 +4,22 @@ end
 
 
 Motion::Project::App.setup do |app|
+  teacup_lib = File.join(File.dirname(__FILE__), 'teacup')
+  platform = app.respond_to?(:template) ? app.template : :ios
+  teacup_platform_lib = File.join(File.dirname(__FILE__), "teacup-#{platform}")
+  unless File.exists? teacup_platform_lib
+    raise "Sorry, the platform #{platform.inspect} is not supported by teacup"
+  end
+
   # scans app.files until it finds app/ (the default)
   # if found, it inserts just before those files, otherwise it will insert to
   # the end of the list
-  insert_point = 0
-  app.files.each_index do |index|
-    file = app.files[index]
-    if file =~ /^(?:\.\/)?app\//
-      # found app/, so stop looking
-      break
-    end
-    insert_point = index + 1
-  end
+  insert_point = app.files.find_index { |file| file =~ /^(?:\.\/)?app\// } || 0
 
-  app.files.insert(insert_point, File.join(File.dirname(__FILE__), 'dummy.rb'))
-  Dir.glob(File.join(File.dirname(__FILE__), 'teacup/**/*.rb')).reverse.each do |file|
+  Dir.glob(File.join(teacup_platform_lib, '**/*.rb')).reverse.each do |file|
+    app.files.insert(insert_point, file)
+  end
+  Dir.glob(File.join(teacup_lib, '**/*.rb')).reverse.each do |file|
     app.files.insert(insert_point, file)
   end
 end

data/samples/Tweets/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'teacup', :path => '../..'

data/samples/Tweets/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: ../..
+  specs:
+    teacup (2.0.0pre)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.0.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  teacup!

data/samples/Tweets/README

@@ -0,0 +1,7 @@
+Tweets.app
+
+This sample demonstrates the following concepts: NSTableView, NSImageCell,
+JSON parsing and Grand Central Dispatch.
+
+The data_parser.rb, tweet.rb and json_parser.rb files are exactly the same
+as in the ios/Tweets sample.

data/samples/Tweets/Rakefile

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project/template/osx'
+require 'teacup'
+
+Motion::Project::App.setup do |app|
+  # Use `rake config' to see complete project settings.
+  app.name = 'Tweets'
+end

data/samples/Tweets/app/app_delegate.rb

@@ -0,0 +1,18 @@
+class AppDelegate
+  def applicationDidFinishLaunching(notification)
+    buildMenu
+    buildWindow
+  end
+
+  def buildWindow
+    @controller = MainController.new
+    @mainWindow = @controller.window
+    # @mainWindow = NSWindow.alloc.initWithContentRect([[240, 180], [480, 360]],
+    #   styleMask: NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask|NSResizableWindowMask,
+    #   backing: NSBackingStoreBuffered,
+    #   defer: false)
+    @mainWindow.title = NSBundle.mainBundle.infoDictionary['CFBundleName']
+    @mainWindow.orderFrontRegardless
+  end
+
+end

data/samples/Tweets/app/data_parser.rb

@@ -0,0 +1,10 @@
+class DataParser
+  def self.parse(url)
+    error_ptr = Pointer.new(:object)
+    data = NSData.alloc.initWithContentsOfURL(NSURL.URLWithString(url), options:NSDataReadingUncached, error:error_ptr)
+    unless data
+      raise error_ptr[0]
+    end
+    data
+  end
+end

data/samples/Tweets/app/json_parser.rb

@@ -0,0 +1,12 @@
+class JSONParser
+  def self.parse_from_url(url)
+    data = DataParser.parse(url)
+    
+    error_ptr = Pointer.new(:object)
+    json = NSJSONSerialization.JSONObjectWithData(data, options:0, error:error_ptr)
+    unless json
+      raise error_ptr[0]
+    end
+    json
+  end
+end