sproutit-sproutcore 1.0.203 → 1.0.20090721145236

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

@@ -1,265 +0,0 @@
-// ==========================================================================
-// Project:   SproutCore Costello - Property Observing Library
-// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
-//            Portions ©2008-2009 Apple, Inc. All rights reserved.
-// License:   Licened 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 = /** SC.RangeObserver.prototype */ {
-
-  isRangeObserver: YES,
-  
-  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 || NO ;
-    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, len = args.length, idx;
-    for(idx=0;idx<len;idx++) SC.mixin(ret, args[idx]);
-    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;
-    if (!observing) observing = this.observing = SC.CoreSet.create();
-    
-    // cache iterator function to keep things fast
-    var func = this._beginObservingForEach;
-    if (!func) {
-      func = this._beginObservingForEach = function(idx) {
-        var obj = this.source.objectAt(idx);
-        if (obj && obj.addObserver) {
-          observing.push(obj);
-          obj._kvo_needsRangeObserver = YES ;
-        }
-      };
-    }
-    this.indexes.forEach(func,this);
-
-    // 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 = NO ;
-    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 YES ;
-    } 
-    
-    if (observing.contains(object)) {
-      this.isObserving = YES ;
-
-      // cache iterator function to keep things fast
-      var func = this._setupPendingForEach;
-      if (!func) {
-        var source = this.source,
-            method = this.objectPropertyDidChange;
-
-        func = this._setupPendingForEach = function(idx) {
-          var obj = this.source.objectAt(idx),
-              guid = SC.guidFor(obj),
-              key ;
-              
-          if (obj && obj.addObserver) {
-            observing.push(obj);
-            obj.addObserver('*', this, method);
-            
-            // also save idx of object on range observer itself.  If there is
-            // more than one idx, convert to IndexSet.
-            key = this[guid];
-            if (key === undefined || key === null) {
-              this[guid] = idx ;
-            } else if (key.isIndexSet) {
-              key.add(idx);
-            } else {
-              key = this[guid] = SC.IndexSet.create(key).add(idx);
-            }
-            
-          }
-        };
-      }
-      this.indexes.forEach(func,this);
-      return YES ;
-      
-    } else return NO ;
-  },
-  
-  /**
-    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 = NO ;
-    }
-    
-    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();
-    }
-    
-    if (context) {
-      method.call(this.target, this.source, object, key, index, context, rev);
-    } else {
-      method.call(this.target, this.source, object, key, index, rev);
-    }
-  }
-  
-};

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

@@ -1,241 +0,0 @@
-// ==========================================================================
-// Project:   SproutCore Costello - Property Observing Library
-// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
-//            Portions ©2008-2009 Apple, Inc. All rights reserved.
-// License:   Licened 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) {
-      console.log("-- SC.RunLoop.beginRunLoop at %@".fmt(this._start));
-    } 
-    return this ; 
-  },
-  
-  /**
-    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.
-    var didChange ;
-
-    if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
-      console.log("-- SC.RunLoop.endRunLoop ~ flushing application queues");
-    } 
-    
-    do {
-      didChange = this.flushApplicationQueues() ;
-      if (!didChange) didChange = this._flushinvokeLastQueue() ; 
-    } while(didChange) ;
-    this._start = null ;
-
-    if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
-      console.log("-- SC.RunLoop.endRunLoop ~ End");
-    } 
-    
-    return this ; 
-  },
-  
-  /**
-    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.
-    
-    @param {Object} target
-    @param {Function} method
-    @returns {SC.RunLoop} receiver
-  */
-  invokeOnce: function(target, method) {
-    // normalize
-    if (method === undefined) { 
-      method = target; target = this ;
-    }
-    if (SC.typeOf(method) === SC.T_STRING) method = target[method];
-    if (!this._invokeQueue) this._invokeQueue = SC._ObserverSet.create();
-    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.
-    
-    @param {Object} target
-    @param {Function} method
-    @returns {SC.RunLoop} receiver
-  */
-  invokeLast: function(target, method) {
-    // normalize
-    if (method === undefined) { 
-      method = target; target = this ;
-    }
-    if (SC.typeOf(method) === SC.T_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.
-    var queue = this._invokeQueue;
-    if (queue && queue.targets > 0) {
-      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.targets > 0) {
-      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(). 
-*/
-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.
-*/
-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 ;
-} ;
-
-/**
-  Helper method executes the passed function inside of a runloop.  Normally
-  not needed but useful for testing.
-  
-  @param {Function} callback callback to execute
-  @param {Object} target context for callback
-  @returns {SC} receiver
-*/
-SC.run = function(callback, target) {
-  SC.RunLoop.begin();
-  callback.call(target);
-  SC.RunLoop.end();
-};
-
-