sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

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

@@ -359,12 +359,14 @@ SC.mixin(SC.Object, /** @scope SC.Object @static */ {
 // DEFAULT OBJECT INSTANCE
 // 
 SC.Object.prototype = {
-
+  
+  _kvo_enabled: YES,
+  
   /** @private
     This is the first method invoked on a new instance.  It will first apply
     any added properties to the new instance and then calls the real init()
     method.
-
+    
     @param {Array} extensions an array-like object with hashes to apply.
     @returns {Object} receiver
   */
@@ -374,23 +376,23 @@ SC.Object.prototype = {
     for(idx=0;idx<len;idx++) SC._object_extend(this, extensions[idx]) ;
     SC.generateGuid(this) ; // add guid
     this.init() ; // call real init
-
+    
     // Call 'initMixin' methods to automatically setup modules.
     var inits = this.initMixin; len = (inits) ? inits.length : 0 ;
     for(idx=0;idx < len; idx++) inits[idx].call(this);
-
+    
     return this ; // done!
   },
-
-  /** 
+  
+  /**
     You can call this method on an object to mixin one or more hashes of 
     properties on the receiver object.  In addition to simply copying 
     properties, this method will also prepare the properties for use in 
     bindings, computed properties, etc.
-
+    
     If you plan to use this method, you should call it before you call
     the inherited init method from SC.Object or else your instance may not 
-    function properly.  
+    function properly.
     
     h2. Example
     
@@ -398,7 +400,7 @@ SC.Object.prototype = {
       // dynamically apply a mixin specified in an object property
       var MyClass = SC.Object.extend({
          extraMixin: null,
-
+         
          init: function() {
            this.mixin(this.extraMixin);
            sc_super();
@@ -488,7 +490,7 @@ SC.Object.prototype = {
   respondsTo: function( methodName ) {
     return !!(SC.typeOf(this[methodName]) === SC.T_FUNCTION);
   },
-
+  
   /**
     Attemps to invoked the named method, passing the included two arguments.  
     Returns NO if the method is either not implemented or if the handler 
@@ -597,7 +599,11 @@ SC.Object.prototype = {
   /** @private */
   toString: function() {
     if (!this._object_toString) {
-      this._object_toString = "%@:%@".fmt(SC._object_className(this.constructor), SC.guidFor(this));
+      // only cache the string if the klass name is available
+      var klassName = SC._object_className(this.constructor) ;
+      var string = "%@:%@".fmt(klassName, SC.guidFor(this));
+      if (klassName) this._object_toString = string ;
+      else return string ;
     } 
     return this._object_toString ;
   },
@@ -649,20 +655,20 @@ SC.Object.prototype = {
         var obj = MyRecord.newRecord() ;
         
         // update the collection controller's selection
-        MyApp.myRecordCollectionController.invokeNext( function() {
+        MyApp.myRecordCollectionController.invokeLast( function() {
           this.set('selection', [obj]) ;
         });
       }
     }}}
     
-    You can call invokeNext as many times as you like and the method will
+    You can call invokeLast as many times as you like and the method will
     only be invoked once.
     
     @param {Funciton|String} method method or method name
     @returns {SC.Object} receiver
   */
-  invokeNext: function(method) {
-    SC.RunLoop.currentRunLoop.invokeNext(this, method) ;
+  invokeLast: function(method) {
+    SC.RunLoop.currentRunLoop.invokeLast(this, method) ;
     return this ;
   },
   
@@ -763,6 +769,18 @@ function findClassNames() {
   }*/
 }
 
+/**  
+  Same as the instance method, but lets you check instanceOf without
+  having to first check if instanceOf exists as a method.
+  
+  @param {Object} object the object to check instance of
+  @param {Class} scClass the class
+  @returns {Boolean} if object1 is instance of class
+*/
+SC.instanceOf = function(scObject, scClass) {
+  return (scObject && scObject.constructor === scClass) ;  
+} ;
+
 /** @private
   Returns the name of this class.  If the name is not known, triggers
   a search.  This can be expensive the first time it is called.

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

@@ -6,7 +6,8 @@
 // ==========================================================================
 
 
-/**
+/** @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
@@ -16,34 +17,84 @@
   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 = /** 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.
   
-  create: function(source, start, length, target, method) {
+    @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.start  = start;
-    ret.length = length;
+    ret.indexes = indexSet ? indexSet.frozenCopy() : null;
     ret.target = target;
     ret.method = method;
-    ret.observing = [];
-    
-    this.beginObserving();
+    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 ;
   },
-  
-  destroy: function(source) { this.endObserving(); return this; },
-  
-  update: function(source, start, length) {
-    this.start = start;
-    this.length = length;
-    this.rangeDidChange();
+
+  /**
+    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;
   },
   
@@ -51,49 +102,164 @@ SC.RangeObserver = {
     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() {
-    var observing = this.observing, idx = this.start, source = this.source;
-    var lim = idx + this.length, meth = this.objectPropertyDidChange, obj;
-    for(;idx<lim;idx++) {
-      obj = source.objectAt(idx);
-      if (obj && obj.addObserver) {
-        observing.push(obj);
-        obj.addObserver('*', this, meth);
-      }
+    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() {
-    var idx, observing = this.observing, meth = this.objectPropertyDidChange;
-    var lim = observing.length, source = this.source;
-    for(idx=0;idx<lim;idx++) {
-      observing[idx].removeObserver('*', this, meth);
+    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.
+    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() {
-    this.endObserving(); // remove old observers
-    this.method.call(this.target, this.source, null, '[]');
-    this.beginObserving(); // setup new ones
+  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) {
-    this.method.call(this.target, this.source, object, key);
+  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

@@ -50,8 +50,10 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     @returns {SC.RunLoop} receiver
   */
   beginRunLoop: function() {
-    this._start = new Date().getTime() ; // can't use Date.now() in runtime 
-    this._flushInvokeNextQueue() ; // call any invokeNext methods first
+    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 ; 
   },
   
@@ -65,17 +67,26 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     @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 ; 
   },
   
@@ -103,27 +114,29 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
   },
   
   /**
-    Invokes the passed target/method pair once at the beginning of the next 
-    runloop, before any other methods (including events) are processed.
-    
-    You can call this method as many times as you like and the method will
-    only be invoked once.
+    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 invokeNext() 
+    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
   */
-  invokeNext: function(target, method) {
+  invokeLast: function(target, method) {
     // normalize
     if (method === undefined) { 
       method = target; target = this ;
     }
     if (SC.typeOf(method) === SC.T_STRING) method = target[method];
-    if (!this._invokeNextQueue) this._invokeNextQueue = SC._ObserverSet.create();
-    this._invokeNextQueue.add(target, method);
+    if (!this._invokeLastQueue) this._invokeLastQueue = SC._ObserverSet.create();
+    this._invokeLastQueue.add(target, method);
     return this ;
   },
   
@@ -159,10 +172,10 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     return SC.Binding.flushPendingChanges() || hadContent ;
   },
   
-  _flushInvokeNextQueue: function() {
-    var queue = this._invokeNextQueue, hadContent = NO ;
+  _flushinvokeLastQueue: function() {
+    var queue = this._invokeLastQueue, hadContent = NO ;
     if (queue && queue.targets > 0) {
-      this._invokeNextQueue = null; // reset queue.
+      this._invokeLastQueue = null; // reset queue.
       hadContent = YES; // has targets!
       if (hadContent) queue.invokeMethods();
     }
@@ -211,4 +224,18 @@ SC.RunLoop.end = function() {
   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();
+};
+