spade 0.0.1 → 0.0.2

data/sproutcore/frameworks/runtime/system/range_observer.js

@@ -1,270 +0,0 @@
-// ==========================================================================
-// 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)
-// ==========================================================================
-
-
-/** @class
-
-  A RangeObserver is used by Arrays to automatically observe all of the
-  objects in a particular range on the array.  Whenever any property on one
-  of those objects changes, it will notify its delegate.  Likewise, whenever
-  the contents of the array itself changes, it will notify its delegate and
-  possibly update its own registration.
-
-  This implementation uses only SC.Array methods.  It can be used on any
-  object that complies with SC.Array.  You may, however, choose to subclass
-  this object in a way that is more optimized for your particular design.
-
-  @since SproutCore 1.0
-*/
-SC.RangeObserver = {
-
-  /**
-    Walk like a duck.
-
-    @property {Boolean}
-  */
-  isRangeObserver: YES,
-
-  /** @private */
-  toString: function() {
-    var base = this.indexes ? this.indexes.toString() : "SC.IndexSet<..>";
-    return base.replace('IndexSet', 'RangeObserver(%@)'.fmt(SC.guidFor(this)));
-  },
-
-  /**
-    Creates a new range observer owned by the source.  The indexSet you pass
-    must identify the indexes you are interested in observing.  The passed
-    target/method will be invoked whenever the observed range changes.
-
-    Note that changes to a range are buffered until the end of a run loop
-    unless a property on the record itself changes.
-
-    @param {SC.Array} source the source array
-    @param {SC.IndexSet} indexSet set of indexes to observer
-    @param {Object} target the target
-    @param {Function|String} method the method to invoke
-    @param {Object} context optional context to include in callback
-    @param {Boolean} isDeep if YES, observe property changes as well
-    @returns {SC.RangeObserver} instance
-  */
-  create: function(source, indexSet, target, method, context, isDeep) {
-    var ret = SC.beget(this);
-    ret.source = source;
-    ret.indexes = indexSet ? indexSet.frozenCopy() : null;
-    ret.target = target;
-    ret.method = method;
-    ret.context = context ;
-    ret.isDeep  = isDeep || false ;
-    ret.beginObserving();
-    return ret ;
-  },
-
-  /**
-    Create subclasses for the RangeObserver.  Pass one or more attribute
-    hashes.  Use this to create customized RangeObservers if needed for your
-    classes.
-
-    @param {Hash} attrs one or more attribute hashes
-    @returns {SC.RangeObserver} extended range observer class
-  */
-  extend: function(attrs) {
-    var ret = SC.beget(this), args = arguments;
-    for(var i=0, l=args.length; i<l; i++) { SC.mixin(ret, args[i]); }
-    return ret ;
-  },
-
-  /**
-    Destroys an active ranger observer, cleaning up first.
-
-    @param {SC.Array} source the source array
-    @returns {SC.RangeObserver} receiver
-  */
-  destroy: function(source) {
-    this.endObserving();
-    return this;
-  },
-
-  /**
-    Updates the set of indexes the range observer applies to.  This will
-    stop observing the old objects for changes and start observing the
-    new objects instead.
-
-    @param {SC.Array} source the source array
-    @returns {SC.RangeObserver} receiver
-  */
-  update: function(source, indexSet) {
-    if (this.indexes && this.indexes.isEqual(indexSet)) { return this ; }
-
-    this.indexes = indexSet ? indexSet.frozenCopy() : null ;
-    this.endObserving().beginObserving();
-    return this;
-  },
-
-  /**
-    Configures observing for each item in the current range.  Should update
-    the observing array with the list of observed objects so they can be
-    torn down later
-
-    @returns {SC.RangeObserver} receiver
-  */
-  beginObserving: function() {
-    if ( !this.isDeep ) { return this; } // nothing to do
-
-    var observing = this.observing = this.observing || SC.CoreSet.create();
-
-    // cache iterator function to keep things fast
-    var func = this._beginObservingForEach, source = this.source;
-
-    if( !func ) {
-      func = this._beginObservingForEach = function(idx) {
-        var obj = source.objectAt(idx);
-        if (obj && obj.addObserver) {
-          observing.push(obj);
-          obj._kvo_needsRangeObserver = true ;
-        }
-      };
-    }
-
-    this.indexes.forEach(func);
-
-    // add to pending range observers queue so that if any of these objects
-    // change we will have a chance to setup observing on them.
-    this.isObserving = false ;
-    SC.Observers.addPendingRangeObserver(this);
-
-    return this;
-  },
-
-  /** @private
-    Called when an object that appears to need range observers has changed.
-    Check to see if the range observer contains this object in its list.  If
-    it does, go ahead and setup observers on all objects and remove ourself
-    from the queue.
-  */
-  setupPending: function(object) {
-    var observing = this.observing ;
-
-    if ( this.isObserving || !observing || (observing.get('length')===0) ) {
-      return true ;
-    }
-
-    if (observing.contains(object)) {
-      this.isObserving = true ;
-
-      // cache iterator function to keep things fast
-      var func = this._setupPendingForEach;
-      if (!func) {
-        var source = this.source,
-            method = this.objectPropertyDidChange,
-            self   = this;
-
-        func = this._setupPendingForEach = function(idx) {
-          var obj = source.objectAt(idx),
-              guid = SC.guidFor(obj),
-              key ;
-
-          if (obj && obj.addObserver) {
-            observing.push(obj);
-            obj.addObserver('*', self, method);
-
-            // also save idx of object on range observer itself.  If there is
-            // more than one idx, convert to IndexSet.
-            key = self[guid];
-            if ( key == null ) {
-              self[guid] = idx ;
-            } else if (key.isIndexSet) {
-              key.add(idx);
-            } else {
-              self[guid] = SC.IndexSet.create(key).add(idx);
-            }
-
-          }
-        };
-      }
-      this.indexes.forEach(func);
-      return true ;
-    } else {
-      return false ;
-    }
-  },
-
-  /**
-    Remove observers for any objects currently begin observed.  This is
-    called whenever the observed range changes due to an array change or
-    due to destroying the observer.
-
-    @returns {SC.RangeObserver} receiver
-  */
-  endObserving: function() {
-    if ( !this.isDeep ) return this; // nothing to do
-
-    var observing = this.observing;
-
-    if (this.isObserving) {
-      var meth      = this.objectPropertyDidChange,
-          source    = this.source,
-          idx, lim, obj;
-
-      if (observing) {
-        lim = observing.length;
-        for(idx=0;idx<lim;idx++) {
-          obj = observing[idx];
-          obj.removeObserver('*', this, meth);
-          this[SC.guidFor(obj)] = null;
-        }
-        observing.length = 0 ; // reset
-      }
-
-      this.isObserving = false ;
-    }
-
-    if (observing) { observing.clear(); } // empty set.
-    return this ;
-  },
-
-  /**
-    Whenever the actual objects in the range changes, notify the delegate
-    then begin observing again.  Usually this method will be passed an
-    IndexSet with the changed indexes.  The range observer will only notify
-    its delegate if the changed indexes include some of all of the indexes
-    this range observer is monitoring.
-
-    @param {SC.IndexSet} changes optional set of changed indexes
-    @returns {SC.RangeObserver} receiver
-  */
-  rangeDidChange: function(changes) {
-    var indexes = this.indexes;
-    if ( !changes || !indexes || indexes.intersects(changes) ) {
-      this.endObserving(); // remove old observers
-      this.method.call(this.target, this.source, null, '[]', changes, this.context);
-      this.beginObserving(); // setup new ones
-    }
-    return this ;
-  },
-
-  /**
-    Whenever an object changes, notify the delegate
-
-    @param {Object} the object that changed
-    @param {String} key the property that changed
-    @returns {SC.RangeObserver} receiver
-  */
-  objectPropertyDidChange: function(object, key, value, rev) {
-    var context = this.context,
-        method  = this.method,
-        guid    = SC.guidFor(object),
-        index   = this[guid];
-
-    // lazily convert index to IndexSet.
-    if ( index && !index.isIndexSet ) {
-      index = this[guid] = SC.IndexSet.create(index).freeze();
-    }
-
-    method.call(this.target, this.source, object, key, index, context || rev, rev);
-  }
-
-};

data/sproutcore/frameworks/runtime/system/run_loop.js

@@ -1,308 +0,0 @@
-// ==========================================================================
-// 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)
-// ==========================================================================
-
-sc_require('private/observer_set');
-
-/**
-  @class
-
-  The run loop provides a universal system for coordinating events within
-  your application.  The run loop processes timers as well as pending
-  observer notifications within your application.
-
-  To use a RunLoop within your application, you should make sure your event
-  handlers always begin and end with SC.RunLoop.begin() and SC.RunLoop.end()
-
-  The RunLoop is important because bindings do not fire until the end of
-  your run loop is reached.  This improves the performance of your
-  application.
-
-  h2. Example
-
-  This is how you could write your mouseup handler in jQuery:
-
-  {{{
-    $('#okButton').on('click', function() {
-      SC.RunLoop.begin();
-
-      // handle click event...
-
-      SC.RunLoop.end(); // allows bindings to trigger...
-    });
-  }}}
-
-  @extends SC.Object
-  @since SproutCore 1.0
-*/
-SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
-
-  /**
-    Call this method whenver you begin executing code.
-
-    This is typically invoked automatically for you from event handlers and
-    the timeout handler.  If you call setTimeout() or setInterval() yourself,
-    you may need to invoke this yourself.
-
-    @returns {SC.RunLoop} receiver
-  */
-  beginRunLoop: function() {
-    this._start = new Date().getTime() ; // can't use Date.now() in runtime
-    if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
-      SC.Logger.log("-- SC.RunLoop.beginRunLoop at %@".fmt(this._start));
-    }
-    this._runLoopInProgress = YES;
-    return this ;
-  },
-
-  /**
-    YES when a run loop is in progress
-
-    @property {Boolean}
-  */
-  isRunLoopInProgress: function() {
-    return this._runLoopInProgress;
-  }.property(),
-
-  /**
-    Call this method whenever you are done executing code.
-
-    This is typically invoked automatically for you from event handlers and
-    the timeout handler.  If you call setTimeout() or setInterval() yourself
-    you may need to invoke this yourself.
-
-    @returns {SC.RunLoop} receiver
-  */
-  endRunLoop: function() {
-    // at the end of a runloop, flush all the delayed actions we may have
-    // stored up.  Note that if any of these queues actually run, we will
-    // step through all of them again.  This way any changes get flushed
-    // out completely.
-
-    if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
-      SC.Logger.log("-- SC.RunLoop.endRunLoop ~ flushing application queues");
-    } 
-    
-    this.flushAllPending();
-    
-    this._start = null ;
-
-    if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
-      SC.Logger.log("-- SC.RunLoop.endRunLoop ~ End");
-    }
-
-    SC.RunLoop.lastRunLoopEnd = Date.now();
-    this._runLoopInProgress = NO;
-
-    return this ;
-  },
-
-  /**
-    Repeatedly flushes all bindings, observers, and other queued functions until all queues are empty.
-  */
-  flushAllPending: function() {
-    var didChange ;
-    
-    do {
-      didChange = this.flushApplicationQueues() ;
-      if (!didChange) didChange = this._flushinvokeLastQueue() ; 
-    } while(didChange) ;
-  },
-  
-  
-  /**
-    Invokes the passed target/method pair once at the end of the runloop.
-    You can call this method as many times as you like and the method will
-    only be invoked once.
-
-    Usually you will not call this method directly but use invokeOnce()
-    defined on SC.Object.
-
-    Note that in development mode only, the object and method that call this
-    method will be recorded, for help in debugging scheduled code.
-
-    @param {Object} target
-    @param {Function} method
-    @returns {SC.RunLoop} receiver
-  */
-  invokeOnce: function(target, method) {
-    // normalize
-    if (method === undefined) {
-      method = target; target = this ;
-    }
-
-    if (typeof method === "string") method = target[method];
-    if (!this._invokeQueue) this._invokeQueue = SC.ObserverSet.create();
-    if ( method ) this._invokeQueue.add(target, method);
-    return this ;
-  },
-
-  /**
-    Invokes the passed target/method pair at the very end of the run loop,
-    once all other delayed invoke queues have been flushed.  Use this to
-    schedule cleanup methods at the end of the run loop once all other work
-    (including rendering) has finished.
-
-    If you call this with the same target/method pair multiple times it will
-    only invoke the pair only once at the end of the runloop.
-
-    Usually you will not call this method directly but use invokeLast()
-    defined on SC.Object.
-
-    Note that in development mode only, the object and method that call this
-    method will be recorded, for help in debugging scheduled code.
-
-    @param {Object} target
-    @param {Function} method
-    @returns {SC.RunLoop} receiver
-  */
-  invokeLast: function(target, method) {
-    // normalize
-    if (method === undefined) {
-      method = target; target = this ;
-    }
-
-    if (typeof method === "string") method = target[method];
-    if (!this._invokeLastQueue) this._invokeLastQueue = SC.ObserverSet.create();
-    this._invokeLastQueue.add(target, method);
-    return this ;
-  },
-
-  /**
-    Executes any pending events at the end of the run loop.  This method is
-    called automatically at the end of a run loop to flush any pending
-    queue changes.
-
-    The default method will invoke any one time methods and then sync any
-    bindings that might have changed.  You can override this method in a
-    subclass if you like to handle additional cleanup.
-
-    This method must return YES if it found any items pending in its queues
-    to take action on.  endRunLoop will invoke this method repeatedly until
-    the method returns NO.  This way if any if your final executing code
-    causes additional queues to trigger, then can be flushed again.
-
-    @returns {Boolean} YES if items were found in any queue, NO otherwise
-  */
-  flushApplicationQueues: function() {
-    var hadContent = NO,
-        // execute any methods in the invokeQueue.
-        queue = this._invokeQueue;
-    if ( queue && queue.getMembers().length ) {
-      this._invokeQueue = null; // reset so that a new queue will be created
-      hadContent = YES ; // needs to execute again
-      queue.invokeMethods();
-    }
-
-    // flush any pending changed bindings.  This could actually trigger a
-    // lot of code to execute.
-    return SC.Binding.flushPendingChanges() || hadContent ;
-  },
-
-  _flushinvokeLastQueue: function() {
-    var queue = this._invokeLastQueue, hadContent = NO ;
-    if (queue && queue.getMembers().length ) {
-      this._invokeLastQueue = null; // reset queue.
-      hadContent = YES; // has targets!
-      if (hadContent) queue.invokeMethods();
-    }
-    return hadContent ;
-  }
-
-});
-
-/**
-  The current run loop.  This is created automatically the first time you
-  call begin().
-
-  @property {SC.RunLoop}
-*/
-SC.RunLoop.currentRunLoop = null;
-
-/**
-  The default RunLoop class.  If you choose to extend the RunLoop, you can
-  set this property to make sure your class is used instead.
-
-  @property {Class}
-*/
-SC.RunLoop.runLoopClass = SC.RunLoop;
-
-/**
-  Begins a new run loop on the currentRunLoop.  If you are already in a
-  runloop, this method has no effect.
-
-  @returns {SC.RunLoop} receiver
-*/
-SC.RunLoop.begin = function() {
-  var runLoop = this.currentRunLoop;
-  if (!runLoop) runLoop = this.currentRunLoop = this.runLoopClass.create();
-  runLoop.beginRunLoop();
-  return this ;
-};
-
-/**
-  Ends the run loop on the currentRunLoop.  This will deliver any final
-  pending notifications and schedule any additional necessary cleanup.
-
-  @returns {SC.RunLoop} receiver
-*/
-SC.RunLoop.end = function() {
-  var runLoop = this.currentRunLoop;
-  if (!runLoop) {
-    throw "SC.RunLoop.end() called outside of a runloop!";
-  }
-  runLoop.endRunLoop();
-  return this ;
-} ;
-
-/**
-  Returns YES when a run loop is in progress
-
-  @return {Boolean}
-*/
-SC.RunLoop.isRunLoopInProgress = function() {
-  if(this.currentRunLoop) return this.currentRunLoop.get('isRunLoopInProgress');
-  return NO;
-};
-
-/**
-  Executes a passed function in the context of a run loop. If called outside a 
-  runloop, starts and ends one. If called inside an existing runloop, is 
-  simply executes the function unless you force it to create a nested runloop.
-  
-  If an exception is thrown during execution, we give an error catcher the
-  opportunity to handle it before allowing the exception to bubble again.
-  
-  @param {Function} callback callback to execute
-  @param {Object} target context for callback
-  @param {Boolean} if YES, starts/ends a new runloop even if one is already running
-*/
-SC.run = function(callback, target, forceNested) {
-  var alreadyRunning = SC.RunLoop.isRunLoopInProgress();
-
-  // Only use a try/catch block if we have an ExceptionHandler
-  // since in some browsers try/catch causes a loss of the backtrace
-  if (SC.ExceptionHandler && SC.ExceptionHandler.enabled) {
-    try {
-      if(forceNested || !alreadyRunning) SC.RunLoop.begin();
-      if (callback) callback.call(target);
-      if(forceNested || !alreadyRunning) SC.RunLoop.end();
-    } catch (e) {
-      SC.ExceptionHandler.handleException(e);
-
-      // Now that we've handled the exception, throw it again so the browser
-      // can deal with it (and potentially use it for debugging).
-      // (We don't throw it in IE because the user will see two errors)
-      if (!SC.browser.msie) {
-        throw e;
-      }
-    }
-  } else {
-    if(forceNested || !alreadyRunning) SC.RunLoop.begin();
-    if (callback) callback.call(target);
-    if(forceNested || !alreadyRunning) SC.RunLoop.end();
-  }
-};