sproutcore 1.4.5-java → 1.5.0-java

data/lib/frameworks/sproutcore/frameworks/core_foundation/ext/handlebars/localization.js

@@ -0,0 +1,5 @@
+sc_require('ext/handlebars');
+
+Handlebars.registerHelper('loc', function(property) {
+  return SC.String.loc(property);
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/ext/handlebars/view.js

@@ -0,0 +1,96 @@
+sc_require('ext/handlebars');
+
+SC.Handlebars.ViewHelper = SC.Object.create({
+  helper: function(thisContext, path, options) {
+    var inverse = options.inverse;
+    var data = options.data;
+    var view = data.view;
+    var fn = options.fn;
+    var hash = options.hash;
+
+    var newView;
+    if (path.isClass || path.isObject) {
+      newView = path;
+      if (!newView) {
+        throw "Null or undefined object was passed to the #view helper. Did you mean to pass a property path string?";
+      }
+    } else {
+      // Path is relative, look it up with this view as the root
+      if (path.charAt(0) === '.') {
+        newView = SC.objectForPropertyPath(path.slice(1), view);
+      } else {
+        // Path is absolute, look up path on global (window) object
+        newView = SC.getPath(thisContext, path);
+        if (!newView) {
+          newView = SC.getPath(path);
+        }
+      }
+      if (!newView) { throw "Unable to find view at path '" + path + "'"; }
+    }
+
+    if (hash.id) { hash.layerId = hash.id; }
+
+    var contextOptions = {
+      'id': hash.id,
+      'class': hash['class'],
+      'classBinding': hash.classBinding
+    };
+    delete hash.id;
+    delete hash['class'];
+    delete hash.classBinding;
+
+    if (newView.isClass) {
+      newView = newView.extend(hash);
+    } else {
+      SC.mixin(newView, hash);
+    }
+
+    var currentView = data.view;
+
+    var childViews = currentView.get('childViews');
+    var childView = currentView.createChildView(newView);
+
+    // Set the template of the view to the passed block if we got one
+    if (fn) { childView.template = fn; }
+
+
+    childViews.pushObject(childView);
+
+    var context = SC.RenderContext(childView.get('tagName'));
+
+    // Add id and class names passed to view helper
+    this.applyAttributes(contextOptions, childView, context);
+
+    childView.applyAttributesToContext(context);
+    // tomdale wants to make SproutCore slow
+    childView.render(context, YES);
+
+    return new Handlebars.SafeString(context.join());
+  },
+
+  applyAttributes: function(options, childView, context) {
+    var id = options.id;
+    var classNames = options['class'];
+
+    if (classNames) {
+      context.addClass(classNames.split(' '));
+    }
+
+    if (id) {
+      childView.set('layerId', id);
+      context.id(id);
+    }
+
+    var classBindings = options.classBinding;
+    if (classBindings) {
+      SC.Handlebars.bindClasses(childView, classBindings, childView).forEach(function(className) {
+        context.setClass(className, YES);
+      });
+    }
+  }
+});
+
+
+Handlebars.registerHelper('view', function(path, options) {
+  return SC.Handlebars.ViewHelper.helper(this, path, options);
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/ext/object.js

@@ -0,0 +1,81 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+// Extensions to the core SC.Object class
+SC.mixin(SC.Object.prototype, /** @scope SC.Object.prototype */ {
+
+  /**
+    Invokes the named method after the specified period of time.
+
+    This is a convenience method that will create a single run timer to
+    invoke a method after a period of time.  The method should have the
+    signature:
+
+        methodName: function(timer)
+
+    If you would prefer to pass your own parameters instead, you can instead
+    call invokeLater() directly on the function object itself.
+
+    @param methodName {String} method name to perform.
+    @param interval {Number} period from current time to schedule.
+    @returns {SC.Timer} scheduled timer.
+  */
+  invokeLater: function(methodName, interval) {
+    if (interval === undefined) { interval = 1 ; }
+    var f = methodName, args, func;
+
+    // if extra arguments were passed - build a function binding.
+    if (arguments.length > 2) {
+      args = SC.$A(arguments).slice(2);
+      if (SC.typeOf(f) === SC.T_STRING) { f = this[methodName] ; }
+      func = f ;
+      f = function() { return func.apply(this, args); } ;
+    }
+
+    // schedule the timer
+    return SC.Timer.schedule({ target: this, action: f, interval: interval });
+  },
+
+  /**
+    Lookup the named property path and then invoke the passed function,
+    passing the resulting value to the function.
+
+    This method is a useful way to handle deferred loading of properties.
+    If you want to defer loading a property, you can override this method.
+    When the method is called, passing a deferred property, you can load the
+    property before invoking the callback method.
+
+    You can even swap out the receiver object.
+
+    The callback method should have the signature:
+
+    function callback(objectAtPath, sourceObject) { ... }
+
+    You may pass either a function itself or a target/method pair.
+
+    @param {String} pathName
+    @param {Object} target target or method
+    @param {Function|String} method
+    @returns {SC.Object} receiver
+  */
+  invokeWith: function(pathName, target, method) {
+    // normalize target/method
+    if (method === undefined) {
+      method = target; target = this;
+    }
+    if (!target) { target = this ; }
+    if (SC.typeOf(method) === SC.T_STRING) { method = target[method]; }
+
+    // get value
+    var v = this.getPath(pathName);
+
+    // invoke method
+    method.call(target, v, this);
+    return this ;
+  }
+
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/ext/run_loop.js

@@ -0,0 +1,163 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+// Create anonymous subclass of SC.RunLoop to add support for processing
+// view queues and Timers.
+SC.RunLoop = SC.RunLoop.extend(
+/** @scope SC.RunLoop.prototype */ {
+
+  /**
+    The time the current run loop began executing.
+
+    All timers scheduled during this run loop will begin executing as if
+    they were scheduled at this time.
+
+    @property {Number}
+  */
+  startTime: function() {
+    if (!this._start) { this._start = Date.now(); }
+    return this._start ;
+  }.property(),
+
+  /*
+
+    Override to fire and reschedule timers once per run loop.
+
+    Note that timers should fire only once per run loop to avoid the
+    situation where a timer might cause an infinite loop by constantly
+    rescheduling itself everytime it is fired.
+  */
+  endRunLoop: function() {
+    this.fireExpiredTimers(); // fire them timers!
+    var ret = sc_super(); // do everything else
+    this.scheduleNextTimeout(); // schedule a timout if timers remain
+    return ret;
+  },
+
+  // ..........................................................
+  // TIMER SUPPORT
+  //
+
+  /**
+    Schedules a timer to execute at the specified runTime.  You will not
+    usually call this method directly.  Instead you should work with SC.Timer,
+    which will manage both creating the timer and scheduling it.
+
+    Calling this method on a timer that is already scheduled will remove it
+    from the existing schedule and reschedule it.
+
+    @param {SC.Timer} timer the timer to schedule
+    @param {Time} runTime the time offset when you want this to run
+    @returns {SC.RunLoop} receiver
+  */
+  scheduleTimer: function(timer, runTime) {
+    // if the timer is already in the schedule, remove it.
+    this._timerQueue = timer.removeFromTimerQueue(this._timerQueue);
+
+    // now, add the timer ot the timeout queue.  This will walk down the
+    // chain of timers to find the right place to insert it.
+    this._timerQueue = timer.scheduleInTimerQueue(this._timerQueue, runTime);
+    return this ;
+  },
+
+  /**
+    Removes the named timer from the timeout queue.  If the timer is not
+    currently scheduled, this method will have no effect.
+
+    @param {SC.Timer} timer the timer to schedule
+    @returns {SC.RunLoop} receiver
+  */
+  cancelTimer: function(timer) {
+    this._timerQueue = timer.removeFromTimerQueue(this._timerQueue) ;
+    return this ;
+  },
+
+  /** @private - shared array used by fireExpiredTimers to avoid memory */
+  TIMER_ARRAY: [],
+
+  /**
+    Invokes any timers that have expired since this method was last called.
+    Usually you will not call this method directly, but it will be invoked
+    automatically at the end of the run loop.
+
+    @returns {Boolean} YES if timers were fired, NO otherwise
+  */
+  fireExpiredTimers: function() {
+    if (!this._timerQueue || this._firing) { return NO; } // nothing to do
+
+    // max time we are allowed to run timers
+    var now = this.get('startTime'),
+        timers = this.TIMER_ARRAY,
+        idx, len, didFire;
+
+    // avoid recursive calls
+    this._firing = YES;
+
+    // collect timers to fire.  we do this one time up front to avoid infinite
+    // loops where firing a timer causes it to schedule itself again, causing
+    // it to fire again, etc.
+    this._timerQueue = this._timerQueue.collectExpiredTimers(timers, now);
+
+    // now step through timers and fire them.
+    len = timers.length;
+    for(idx=0;idx<len;idx++) { timers[idx].fire(); }
+
+    // cleanup
+    didFire = timers.length > 0 ;
+    timers.length = 0 ; // reset for later use...
+    this._firing = NO ;
+    return didFire;
+  },
+
+  /** @private
+    Invoked at the end of a runloop, if there are pending timers, a timeout
+    will be scheduled to fire when the next timer expires.  You will not
+    usually call this method yourself.  It is invoked automatically at the
+    end of a run loop.
+
+    @returns {Boolean} YES if a timeout was scheduled
+  */
+  scheduleNextTimeout: function() {
+    var timer = this._timerQueue ;
+
+    var ret = NO ;
+    // if no timer, and there is an existing timeout, cancel it
+    if (!timer) {
+      if (this._timeout) { clearTimeout(this._timeout); }
+
+    // otherwise, determine if the timeout needs to be rescheduled.
+    } else {
+      var nextTimeoutAt = timer._timerQueueRunTime ;
+      if (this._timeoutAt !== nextTimeoutAt) { // need to reschedule
+        if (this._timeout) { clearTimeout(this._timeout); } // clear existing...
+        // reschedule
+        var delay = Math.max(0, nextTimeoutAt - Date.now());
+        this._timeout = setTimeout(this._timeoutDidFire, delay);
+        this._timeoutAt = nextTimeoutAt ;
+      }
+      ret = YES ;
+    }
+
+    return ret ;
+  },
+
+  /** @private
+    Invoked when a timeout actually fires.  Simply cleanup, then begin and end
+    a runloop. This will fire any expired timers and reschedule.  Note that
+    this function will be called with 'this' set to the global context,
+    hence the need to lookup the current run loop.
+  */
+  _timeoutDidFire: function() {
+    var rl = SC.RunLoop.currentRunLoop;
+    rl._timeout = rl._timeoutAt = null ; // cleanup
+    SC.run();  // begin/end runloop to trigger timers.
+  }
+
+});
+
+// Recreate the currentRunLoop with the new methods
+SC.RunLoop.currentRunLoop = SC.RunLoop.create();

data/lib/frameworks/sproutcore/frameworks/core_foundation/ext/string.js

@@ -0,0 +1,60 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('system/string');
+
+SC.supplement(String.prototype,
+/** @scope String.prototype */ {
+
+  /**
+    @see SC.String.capitalize
+  */
+  capitalize: function() {
+    return SC.String.capitalize(this, arguments);
+  },
+
+  /**
+    @see SC.String.camelize
+  */
+  camelize: function() {
+    return SC.String.camelize(this, arguments);
+  },
+
+  /**
+    @see SC.String.decamelize
+  */
+  decamelize: function() {
+    return SC.String.decamelize(this, arguments);
+  },
+
+  /**
+    @see SC.String.dasherize
+  */
+  dasherize: function() {
+    return SC.String.dasherize(this, arguments);
+  },
+
+  /**
+    @see SC.String.loc
+  */
+  loc: function() {
+    var args = SC.$A(arguments);
+    args.unshift(this);
+    return SC.String.loc.apply(SC.String, args);
+  },
+
+  /**
+    @see SC.String.locWithDefault
+  */
+  locWithDefault: function(def) {
+    var args = SC.$A(arguments);
+    args.unshift(this);
+    return SC.String.locWithDefault.apply(SC.String, args);
+  }
+
+});
+

data/lib/frameworks/sproutcore/frameworks/core_foundation/mixins/delegate_support.js

@@ -0,0 +1,110 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/**
+  @namespace
+
+  Support methods for the Delegate design pattern.
+
+  The Delegate design pattern makes it easy to delegate a portion of your
+  application logic to another object.  This is most often used in views to
+  delegate various application-logic decisions to controllers in order to
+  avoid having to bake application-logic directly into the view itself.
+
+  The methods provided by this mixin make it easier to implement this pattern
+  but they are not required to support delegates.
+
+  h2. The Pattern
+
+  The delegate design pattern typically means that you provide a property,
+  usually ending in "delegate", that can be set to another object in the
+  system.
+
+  When events occur or logic decisions need to be made that you would prefer
+  to delegate, you can call methods on the delegate if it is set.  If the
+  delegate is not set, you should provide some default functionality instead.
+
+  Note that typically delegates are not observable, hence it is not necessary
+  to use get() to retrieve the value of the delegate.
+
+  @since SproutCore 1.0
+
+*/
+SC.DelegateSupport = {
+
+  /**
+    Selects the delegate that implements the specified method name.  Pass one
+    or more delegates.  The receiver is automatically included as a default.
+
+    This can be more efficient than using invokeDelegateMethod() which has
+    to marshall arguments into a delegate call.
+
+    @param {String} methodName
+    @param {Object...} delegate one or more delegate arguments
+    @returns {Object} delegate or null
+  */
+  delegateFor: function(methodName) {
+    var idx = 1,
+        len = arguments.length,
+        ret ;
+
+    while(idx<len) {
+      ret = arguments[idx];
+      if (ret && ret[methodName] !== undefined) return ret ;
+      idx++;
+    }
+
+    return (this[methodName] !== undefined) ? this : null;
+  },
+
+  /**
+    Invokes the named method on the delegate that you pass.  If no delegate
+    is defined or if the delegate does not implement the method, then a
+    method of the same name on the receiver will be called instead.
+
+    You can pass any arguments you want to pass onto the delegate after the
+    delegate and methodName.
+
+    @param {Object} delegate a delegate object.  May be null.
+    @param {String} methodName a method name
+    @param {Object...} args (OPTIONAL) any additional arguments
+
+    @returns {Object} value returned by delegate
+  */
+  invokeDelegateMethod: function(delegate, methodName, args) {
+    args = SC.A(arguments); args = args.slice(2, args.length) ;
+    if (!delegate || !delegate[methodName]) delegate = this ;
+
+    var method = delegate[methodName];
+    return method ? method.apply(delegate, args) : null;
+  },
+
+  /**
+    Search the named delegates for the passed property.  If one is found,
+    gets the property value and returns it.  If none of the passed delegates
+    implement the property, search the receiver for the property as well.
+
+    @param {String} key the property to get.
+    @param {Object} delegate one or more delegate
+    @returns {Object} property value or undefined
+  */
+  getDelegateProperty: function(key, delegate) {
+    var idx = 1,
+        len = arguments.length,
+        ret ;
+
+    while(idx<len) {
+      ret = arguments[idx++];
+      if (ret && ret[key] !== undefined) {
+        return ret.get ? ret.get(key) : ret[key] ;
+      }
+    }
+
+    return (this[key] !== undefined) ? this.get(key) : undefined ;
+  }
+
+};