spade 0.0.1

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

@@ -0,0 +1,83 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 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/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-2010 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/sproutcore/frameworks/core_foundation/mixins/delegate_support.js

@@ -0,0 +1,110 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 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 ;
+  }
+
+};

data/sproutcore/frameworks/core_foundation/mixins/responder_context.js

@@ -0,0 +1,269 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('system/responder');
+
+/** @namespace
+
+  The root object for a responder chain.  A responder context can dispatch
+  actions directly to a first responder; walking up the responder chain until
+  it finds a responder that can handle the action.
+
+  If no responder can be found to handle the action, it will attempt to send
+  the action to the defaultResponder.
+
+  You can have as many ResponderContext's as you want within your application.
+  Every SC.Pane and SC.Application automatically implements this mixin.
+
+  Note that to implement this, you should mix SC.ResponderContext into an
+  SC.Responder or SC.Responder subclass.
+
+  @since SproutCore 1.0
+*/
+SC.ResponderContext = {
+
+  // ..........................................................
+  // PROPERTIES
+  //
+
+  isResponderContext: YES,
+
+  /** @property
+
+    When set to YES, logs tracing information about all actions sent and
+    responder changes.
+  */
+  trace: NO,
+
+  /** @property
+    The default responder.  Set this to point to a responder object that can
+    respond to events when no other view in the hierarchy handles them.
+
+    @type SC.Responder
+  */
+  defaultResponder: null,
+
+  /** @property
+    The next responder for an app is always its defaultResponder.
+  */
+  nextResponder: function() {
+    return this.get('defaultResponder');
+  }.property('defaultResponder').cacheable(),
+
+  /** @property
+    The first responder.  This is the first responder that should receive
+    actions.
+  */
+  firstResponder: null,
+
+  // ..........................................................
+  // METHODS
+  //
+
+  /**
+    Finds the next responder for the passed responder based on the responder's
+    nextResponder property.  If the property is a string, then lookup the path
+    in the receiver.
+  */
+  nextResponderFor: function(responder) {
+    var next = responder.get('nextResponder');
+    if (typeof next === SC.T_STRING) {
+      next = SC.objectForPropertyPath(next, this);
+    } else if (!next && (responder !== this)) next = this ;
+    return next ;
+  },
+
+  /**
+    Finds the responder name by searching the responders one time.
+  */
+  responderNameFor: function(responder) {
+    if (!responder) return "(No Responder)";
+    else if (responder._scrc_name) return responder._scrc_name;
+
+    // none found, let's go hunting...look three levels deep
+    var n = this.NAMESPACE;
+    this._findResponderNamesFor(this, 3, n ? [this.NAMESPACE] : []);
+
+    return responder._scrc_name || responder.toString(); // try again
+  },
+
+  _findResponderNamesFor: function(responder, level, path) {
+    var key, value;
+
+    for(key in responder) {
+      if (key === 'nextResponder') continue ;
+      value = responder[key];
+      if (value && value.isResponder) {
+        if (value._scrc_name) continue ;
+        path.push(key);
+        value._scrc_name = path.join('.');
+        if (level>0) this._findResponderNamesFor(value, level-1, path);
+        path.pop();
+      }
+    }
+  },
+
+  /**
+    Makes the passed responder into the new firstResponder for this
+    responder context.  This will cause the current first responder to lose
+    its responder status and possibly keyResponder status as well.
+
+    When you change the first responder, this will send callbacks to
+    responders up the chain until you reach a shared responder, at which point
+    it will stop notifying.
+
+    @param {SC.Responder} responder
+    @param {Event} evt that cause this to become first responder
+    @returns {SC.ResponderContext} receiver
+  */
+  makeFirstResponder: function(responder, evt) {
+    var current = this.get('firstResponder'),
+        last    = this.get('nextResponder'),
+        trace   = this.get('trace'),
+        common ;
+
+    if (this._locked) {
+      if (trace) {
+        SC.Logger.log('%@: AFTER ACTION: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
+      }
+
+      this._pendingResponder = responder;
+      return ;
+    }
+
+    if (trace) {
+      SC.Logger.log('%@: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
+    }
+
+    if (responder) responder.set("becomingFirstResponder", YES);
+
+    this._locked = YES;
+    this._pendingResponder = null;
+
+    // Find the nearest common responder in the responder chain for the new
+    // responder.  If there are no common responders, use last responder.
+    // Note: start at the responder itself: it could be the common responder.
+    common = responder ? responder : null;
+    while (common) {
+      if (common.get('hasFirstResponder')) break;
+      common = (common===last) ? null : this.nextResponderFor(common);
+    }
+    if (!common) common = last;
+
+    // Cleanup old first responder
+    this._notifyWillLoseFirstResponder(current, current, common, evt);
+    if (current) current.set('isFirstResponder', NO);
+
+    // Set new first responder.  If new firstResponder does not have its
+    // responderContext property set, then set it.
+
+    // but, don't tell anyone until we have _also_ updated the hasFirstResponder state.
+    this.beginPropertyChanges();
+
+    this.set('firstResponder', responder) ;
+    if (responder) responder.set('isFirstResponder', YES);
+
+    this._notifyDidBecomeFirstResponder(responder, responder, common);
+
+    // now, tell everyone the good news!
+    this.endPropertyChanges();
+
+    this._locked = NO ;
+    if (this._pendingResponder) {
+      this.makeFirstResponder(this._pendingResponder);
+      this._pendingResponder = null;
+    }
+
+    if (responder) responder.set("becomingFirstResponder", NO);
+
+    return this ;
+  },
+
+  _notifyWillLoseFirstResponder: function(responder, cur, root, evt) {
+    if (cur === root) return ; // nothing to do
+
+    cur.willLoseFirstResponder(responder, evt);
+    cur.set('hasFirstResponder', NO);
+
+    var next = this.nextResponderFor(cur);
+    if (next) this._notifyWillLoseFirstResponder(responder, next, root);
+  },
+
+  _notifyDidBecomeFirstResponder: function(responder, cur, root) {
+    if (cur === root) return ; // nothing to do
+
+    var next = this.nextResponderFor(cur);
+    if (next) this._notifyDidBecomeFirstResponder(responder, next, root);
+
+    cur.set('hasFirstResponder', YES);
+    cur.didBecomeFirstResponder(responder);
+  },
+
+  /**
+    Re-enters the current responder (calling willLoseFirstResponder and didBecomeFirstResponder).
+  */
+  resetFirstResponder: function() {
+    var current = this.get('firstResponder');
+    if (!current) return;
+    current.willLoseFirstResponder();
+    current.didBecomeFirstResponder();
+  },
+
+  /**
+    Send the passed action down the responder chain, starting with the
+    current first responder.  This will look for the first responder that
+    actually implements the action method and returns YES or no value when
+    called.
+
+    @param {String} action name of action
+    @param {Object} sender object sending the action
+    @param {Object} context optional additonal context info
+    @returns {SC.Responder} the responder that handled it or null
+  */
+  sendAction: function(action, sender, context) {
+    var working = this.get('firstResponder'),
+        last    = this.get('nextResponder'),
+        trace   = this.get('trace'),
+        handled = NO,
+        responder;
+
+    this._locked = YES;
+    if (trace) {
+      SC.Logger.log("%@: begin action '%@' (%@, %@)".fmt(this, action, sender, context));
+    }
+
+    if (!handled && !working && this.tryToPerform) {
+      handled = this.tryToPerform(action, sender, context);
+    }
+
+    while (!handled && working) {
+      if (working.tryToPerform) {
+        handled = working.tryToPerform(action, sender, context);
+      }
+
+      if (!handled) {
+        working = (working===last) ? null : this.nextResponderFor(working);
+      }
+    }
+
+    if (trace) {
+      if (!handled) SC.Logger.log("%@:  action '%@' NOT HANDLED".fmt(this,action));
+      else SC.Logger.log("%@: action '%@' handled by %@".fmt(this, action, this.responderNameFor(working)));
+    }
+
+    this._locked = NO ;
+
+    if (responder = this._pendingResponder) {
+      this._pendingResponder= null ;
+      this.makeFirstResponder(responder);
+    }
+
+
+    return working ;
+  }
+
+};