sproutcore 1.4.5-java → 1.5.0-java

data/lib/frameworks/sproutcore/frameworks/foundation/mixins/static_layout.js

@@ -1,16 +1,19 @@
 // ==========================================================================
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 /**
   @namespace 
+  @deprecated
 
-  __NOTE:__ SC.StaticLayout is now built in to SC.View.  You do not need to 
+  SC.StaticLayout is now built in to SC.View.  You do not need to 
   apply this mixin to use static layout.  Just set useStaticLayout to YES.
   
+  
+  
   Normally, SproutCore views use absolute positioning to display themselves
   on the screen.  While this is both the fastest and most efficient way to 
   display content in the web browser, sometimes your user interface might need
@@ -26,7 +29,7 @@
   Normally, if you are allowing the browser to manage the size and positioning
   of your view, these feature will not be useful to your code anyway.
   
-  h2. Using StaticLayout
+  ## Using StaticLayout
   
   To enable static layout on your view, just include this mixin on the view.
   SproutCore's builtin views that are capable of being used in static 
@@ -36,31 +39,26 @@
   You can then use CSS or the render() method on your view to setup the 
   positioning on your view using any browser layout mechanism you want.
   
-  h2. Example
+  ## Example
   
-  {{{
+      // JavaScript
     
-    // JavaScript
+      MyApp.CommentView = SC.View.extend(SC.StaticLayout, {
     
-    MyApp.CommentView = SC.View.extend(SC.StaticLayout, {
-    
-      classNames: ['comment-view'],
+        classNames: ['comment-view'],
       
-      useStaticLayout: YES,
+        useStaticLayout: YES,
 
-      ...
-    });
-    
-    // CSS
+        ...
+      });
     
-    .comment-view {
-      display: block;
-      position: relative;
-    }
+      // CSS
     
-  }}}
+      .comment-view {
+        display: block;
+        position: relative;
+      }
   
-  @deprecated
   @since SproutCore 1.0
 */
 SC.StaticLayout = {
@@ -70,7 +68,8 @@ SC.StaticLayout = {
     Note that a view that hasStaticLayout still may not actually use static
     layout unless useStaticLayout is also set to YES.
     
-    @property {Boolean}
+    @type Boolean
+    @default YES
   */
   hasStaticLayout: YES
   

data/lib/frameworks/sproutcore/frameworks/foundation/mixins/tree_item_content.js

@@ -1,88 +1,92 @@
 // ==========================================================================
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 /**
   @namespace
 
-  A tree item is a model object that acts as a node in a tree-like data 
-  structure such as a hierarchy of folders or outline of items.  This mixin 
+  A tree item is a model object that acts as a node in a tree-like data
+  structure such as a hierarchy of folders or outline of items.  This mixin
   can be applied to tree item model objects to customize the way the tree
   information is extracted from the object.
 
-  h2. Basic Implementation
-  
+  ## Basic Implementation
+
   If you add this mixin, you must implement the treeItemChildren property so
   that it returns the current array of child tree items for the receiver.  If
   you do not implement this property the tree item will not function.
-  
-  h2. Optimizing Branches
-  
+
+  ## Optimizing Branches
+
   The most common use of this mixin is to override the treeItemBranchIndexes
   property to return an index set of child items that are themselves branches
   in the tree.  Normally the TreeController will need to walk every item in
-  your list to determine these branch items.  However by implementing this 
+  your list to determine these branch items.  However by implementing this
   method yourself, you can provide a result faster.
-  
+
   If none of your child items are branches, override this property to return
   null or an empty index set.
-  
+
   @since SproutCore 1.0
 */
 SC.TreeItemContent = {
 
-  /** 
-    Walk like a duck. 
-    
-    @property {Boolean}
+  /**
+    Walk like a duck.
+
+    @type Boolean
+    @default YES
   */
   isTreeItemContent: YES,
-  
+
   /**
-    Property returns the children for this tree item.  The default simply 
-    returns null.  If you implement this mixin, you MUST implement this 
+    Property returns the children for this tree item.  The default simply
+    returns null.  If you implement this mixin, you MUST implement this
     property to return the actual tree item children for the item.
-   
-    @property {SC.Array}
+
+    @type SC.Array
+    @default null
   */
   treeItemChildren: null,
 
   /**
     The default property used to determine if the tree item is expanded.  You
     can implement you model object to update this property or you can override
-    treeItemDisclosureState() to compute the disclosure state however you 
+    treeItemDisclosureState() to compute the disclosure state however you
     want.
-    
-    @property {Boolean}
+
+    @type Boolean
+    @default YES
   */
   treeItemIsExpanded: YES,
-  
+
   /**
-    Indicates whether the tree item should be rendered as a group or not. 
+    Indicates whether the tree item should be rendered as a group or not.
     This property is only useful on the root item in your tree.  Setting it to
     YES on any other item will be ignored.
-    
-    @property {Boolean}
+
+    @type Boolean
+    @default NO
   */
   treeItemIsGrouped: NO,
-  
+
   /**
-    Returns the disclosure state for the tree item, which appears at the 
-    index of the parent's treeItemChildren array.  The response must be one of 
+    Returns the disclosure state for the tree item, which appears at the
+    index of the parent's treeItemChildren array.  The response must be one of
     SC.BRANCH_OPEN, SC.BRANCH_CLOSED or SC.LEAF_NODE.
-     
-    If the parent parameter is null, then this item is part of the root 
+
+    If the parent parameter is null, then this item is part of the root
     children array.
-    
+
     This method will only be called for tree items that have children.  Tree
     items with no children are assumed to be leaf nodes.
 
-    The default implementation uses the treeItemIsExpanded property to 
+    The default implementation uses the treeItemIsExpanded property to
     determine if the item should be open or closed.
-    
+
     @param {Object} parent the parent item containing this item
     @param {Number} idx the index of the item in the parent
     @returns {Number} branch state
@@ -90,52 +94,52 @@ SC.TreeItemContent = {
   treeItemDisclosureState: function(parent, idx) {
     return this.get('treeItemIsExpanded') ? SC.BRANCH_OPEN : SC.BRANCH_CLOSED;
   },
-  
+
   /**
-    Collapse the tree item.  The default implementation will change the 
+    Collapse the tree item.  The default implementation will change the
     treeItemIsExpanded property, but you can override this method to handle
     collapsing anyway you like.
-    
+
     @param {Object} parent the parent item containing this item
     @param {Number} idx the index of the item in the parent
     @returns {void}
   */
   treeItemCollapse: function(parent, idx) {
-    this.setIfChanged('treeItemIsExpanded', NO);    
+    this.setIfChanged('treeItemIsExpanded', NO);
   },
 
   /**
-    Expand the tree item.  The default implementation will change the 
+    Expand the tree item.  The default implementation will change the
     treeItemIsExpanded property, but you can override this method to handle
     collapsing anyway you like.
-    
+
     @param {Object} parent the parent item containing this item
     @param {Number} idx the index of the item in the parent
     @returns {void}
   */
   treeItemExpand: function(parent, idx) {
-    this.setIfChanged('treeItemIsExpanded', YES);    
+    this.setIfChanged('treeItemIsExpanded', YES);
   },
-  
+
   /**
-    Returns an index set containing the child indexes of the item that are 
+    Returns an index set containing the child indexes of the item that are
     themselves branches.  This will only be called on tree items with a branch
     disclosure state.
 
-    If the passed parent and index are both null, then the receiver is the 
+    If the passed parent and index are both null, then the receiver is the
     root node in the tree.
-    
+
     The default implementation iterates over the item's children to get the
     disclosure state of each one.  Child items with a branch disclosure state
-    will have their index added to the return index set.  
-    
-    You may want to override this method to provide a more efficient 
+    will have their index added to the return index set.
+
+    You may want to override this method to provide a more efficient
     implementation if you are working with large data sets and can infer which
     children are branches without iterating over each one.
 
     If you know for sure that all of the child items for this item are leaf
     nodes and not branches, simply override this method to return null.
-    
+
     @param {Object} parent the parent item containing this item
     @param {Number} index the index of the item in the parent
     @returns {SC.IndexSet} branch indexes
@@ -143,9 +147,9 @@ SC.TreeItemContent = {
   treeItemBranchIndexes: function(parent, index) {
     var children = this.get('treeItemChildren'),
         ret, lim, idx, item;
-        
+
     if (!children) return null ; // nothing to do
-    
+
     ret = SC.IndexSet.create();
     lim = children.get('length');
     for(idx=0;idx<lim;idx++) {
@@ -156,5 +160,5 @@ SC.TreeItemContent = {
 
     return ret.get('length')>0 ? ret : null;
   }
-  
+
 };

data/lib/frameworks/sproutcore/frameworks/foundation/mixins/validatable.js

@@ -1,7 +1,7 @@
 // ==========================================================================
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
@@ -25,7 +25,8 @@ SC.Validatable = {
     Set to a validator class or instance.  If this points to a class, it will 
     be instantiated when the validator is first used.
     
-    @property {SC.Validator}
+    @type SC.Validator
+    @default null
   */
   validator: null,
 
@@ -38,7 +39,8 @@ SC.Validatable = {
     You can return a loc string here if you like.  It will be localized when
     it is placed into the error string.
     
-    @property {String}
+    @type String
+    @default null
   */
   errorLabel: null,
 
@@ -49,7 +51,9 @@ SC.Validatable = {
     this property if you want to use some other method to calculate the
     current valid state.
     
-    @property {Boolean}
+    @field
+    @type Boolean
+    @default YES
   */
   isValid: function() { 
     return SC.typeOf(this.get('value')) !== SC.T_ERROR; 
@@ -60,7 +64,8 @@ SC.Validatable = {
     belong to a form.  This property is usually set automatically by an 
     owner form view.
     
-    @property {SC.View}
+    @type SC.View
+    @default null
   */
   ownerForm: null,
   
@@ -122,7 +127,8 @@ SC.Validatable = {
   /**
     Returns the validator object, if one has been created.
     
-    @property {SC.Validator}
+    @field
+    @type SC.Validator
   */
   validatorObject: function() {
     return this._validator;
@@ -135,7 +141,7 @@ SC.Validatable = {
     The default implementation simply calls performValidateSubmit() and 
     returns that value.
     
-    @property {Boolean}
+    @type Boolean
   */
   validateSubmit: function() { return this.performValidateSubmit(); },
   
@@ -164,6 +170,7 @@ SC.Validatable = {
     return this._validator ? this._validator.fieldValueForObject(object, this.get('ownerForm'), this) : object ;
   },
   
+  /** @private */
   _validatable_displayObserver: function() {
     this.displayDidChange();
   }.observes('isValid'),
@@ -173,7 +180,9 @@ SC.Validatable = {
     context.setClass('invalid', !this.get('isValid'));
   },
 
-  // invoked whenever the attached validator changes.
+  /** @private
+    Invoked whenever the attached validator changes.
+  */
   _validatable_validatorDidChange: function() {
     var form = this.get('ownerForm') ;
     var val = SC.Validator.findFor(form, this, this.get('validator')) ;
@@ -185,5 +194,5 @@ SC.Validatable = {
       this.propertyDidChange('validatorObject');
     }  
   }.observes('validator', 'ownerForm')
-      
+
 };

data/lib/frameworks/sproutcore/frameworks/foundation/private/tree_item_observer.js

@@ -1,26 +1,26 @@
 // ==========================================================================
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 sc_require('mixins/tree_item_content');
 sc_require('mixins/collection_content');
 
-/** 
+/**
   @ignore
   @class
-  
+
   A TreeNode is an internal class that will manage a single item in a tree
-  when trying to display the item in a hierarchy. 
-  
-  When displaying a tree of objects, a tree item object will be nested to 
+  when trying to display the item in a hierarchy.
+
+  When displaying a tree of objects, a tree item object will be nested to
   cover every object that might have child views.
-  
-  TreeNode stores an array which contains either a number pointing to the 
+
+  TreeNode stores an array which contains either a number pointing to the
   next place in the array there is a child item or it contains a child item.
-  
+
   @extends SC.Object
   @extends SC.Array
   @extends SC.CollectionContent
@@ -36,82 +36,82 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
   item: null,
 
   /**
-    The controller delegate.  If the item does not implement the 
+    The controller delegate.  If the item does not implement the
     TreeItemContent method, delegate properties will be used to determine how
     to access the content.  Set automatically when a tree item is created.
-    
+
     If you are creating an observer manually, you must set this to a non-null
     value.
   */
   delegate: null,
-  
+
   // ..........................................................
   // FOR NESTED OBSERVERS
-  // 
-  
+  //
+
   /**
     The parent TreeItemObserver for this observer.  Must be set on create.
   */
   parentObserver: null,
 
   /**
-    The parent item for the observer item.  Computed automatically from the 
+    The parent item for the observer item.  Computed automatically from the
     parent.  If the value of this is null, then this is the root of the tree.
   */
   parentItem: function() {
     var p = this.get('parentObserver');
     return p ? p.get('item') : null;
   }.property('parentObserver').cacheable(),
-  
+
   /**
     Index location in parent's children array.  If this is the root item
     in the tree, should be null.
   */
   index: null,
-  
-  outlineLevel: 0, 
-  
+
+  outlineLevel: 0,
+
   // ..........................................................
   // EXTRACTED FROM ITEM
-  // 
-  
+  //
+
   /**
     Array of child tree items.  Extracted from the item automatically on init.
   */
   children: null,
-  
+
   /**
     Disclosure state of this item.  Must be SC.BRANCH_OPEN or SC.BRANCH_CLOSED
     If this is the root of a item tree, the observer will have children but
     no parent or parent item.  IN this case the disclosure state is always
     SC.BRANCH_OPEN.
-    
+
     @property
     @type Number
   */
   disclosureState: SC.BRANCH_OPEN,
 
   /**
-    IndexSet of children with branches.  This will ask the delegate to name 
+    IndexSet of children with branches.  This will ask the delegate to name
     these indexes.  The default implementation will iterate over the children
     of the item but a more optimized version could avoid touching each item.
-    
+
     @property
     @type SC.IndexSet
   */
   branchIndexes: function() {
-    var item = this.get('item'), 
+    var item = this.get('item'),
         len, pitem, idx, children, ret;
-    
+
     // no item - no branches
     if (!item) return SC.IndexSet.EMPTY;
-    
+
     // if item is treeItemContent then ask it directly
     else if (item.isTreeItemContent) {
       pitem  = this.get('parentItem');
       idx    = this.get('index') ;
       return item.treeItemBranchIndexes(pitem, idx);
-      
+
     // otherwise, loop over children and determine disclosure state for each
     } else {
       children = this.get('children');
@@ -119,10 +119,10 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
       ret = SC.IndexSet.create();
       len = children.get('length');
       pitem = item ; // save parent
-      
+
       for(idx=0;idx<len;idx++) {
         if (!(item = children.objectAt(idx))) continue ;
-        if (!this._computeChildren(item, pitem, idx)) continue; // no chil'en
+        if (!this._computeChildren(item, pitem, idx)) continue; // no children
         if (this._computeDisclosureState(item, pitem, idx) !== SC.LEAF_NODE) {
           ret.add(idx);
         }
@@ -131,7 +131,7 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
       return ret.get('length')>0 ? ret : null;
     }
   }.property('children').cacheable(),
-  
+
   /**
     Returns YES if the item itself should be shown, NO if only its children
     should be shown.  Normally returns YES unless the parentObject is null.
@@ -139,46 +139,50 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
   isHeaderVisible: function() {
     return !!this.get('parentObserver');
   }.property('parentObserver').cacheable(),
-  
+
   /**
     Get the current length of the tree item including any of its children.
   */
   length: 0,
-  
+
   // ..........................................................
   // SC.ARRAY SUPPORT
-  // 
-  
+  //
+
   /**
     Get the object at the specified index.  This will talk the tree info
-    to determine the proper place.  The offset should be relative to the 
+    to determine the proper place.  The offset should be relative to the
     start of this tree item.  Calls recursively down the tree.
-    
+
     This should only be called with an index you know is in the range of item
     or its children based on looking at the length.
+
+    @param {Number} index
+    @param {Boolean} omitMaterializing
+    @returns {Object}
   */
-  objectAt: function(index) {
+  objectAt: function(index, omitMaterializing) {
     var len   = this.get('length'),
-        item  = this.get('item'), 
+        item  = this.get('item'),
         cache = this._objectAtCache,
         cur   = index,
         loc   = 0,
         indexes, children;
-     
+
     if (index >= len) return undefined;
     if (this.get('isHeaderVisible')) {
       if (index === 0) return item;
       else cur--;
     }
-    item = null; 
+    item = null;
 
     if (!cache) cache = this._objectAtCache = [];
     if ((item = cache[index]) !== undefined) return item ;
 
     children = this.get('children');
     if (!children) return undefined; // no children - nothing to get
-    
-    // loop through branch indexes, reducing the offset until it matches 
+
+    // loop through branch indexes, reducing the offset until it matches
     // something we might actually return.
     if (indexes = this.get('branchIndexes')) {
       indexes.forEach(function(i) {
@@ -191,16 +195,16 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
         // otherwise, just remove len from cur.
         len = observer.get('length') ;
         if (i+len > cur) {
-          item = observer.objectAt(cur-i);
+          item = observer.objectAt(cur-i, omitMaterializing);
           cur  = -1;
         } else cur -= len-1 ;
-        
+
       },this);
     }
-    
-    if (cur>=0) item = children.objectAt(cur); // get internal if needed
-    cache[index] = item ; // save in cache 
-    
+
+    if (cur>=0) item = children.objectAt(cur, omitMaterializing); // get internal if needed
+    cache[index] = item ; // save in cache
+
     return item ;
   },
 
@@ -208,27 +212,27 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
     Implements SC.Array.replace() primitive.  For this method to succeed, the
     range you replace must lie entirely within the same parent item, otherwise
     this will raise an exception.
-    
+
     h3. The Operation Parameter
-    
+
     Note that this replace method accepts an additional parameter "operation"
-    which is used when you try to insert an item on a boundary between 
+    which is used when you try to insert an item on a boundary between
     branches whether it should be inserted at the end of the previous group
-    after the group.  If you don't pass operation, the default is 
+    after the group.  If you don't pass operation, the default is
     SC.DROP_BEFORE, which is the expected behavior.
-    
+
     Even if the operation is SC.DROP_AFTER, you should still pass the actual
     index where you expect the item to be inserted.  For example, if you want
     to insert AFTER the last index of an 3-item array, you would still call:
-    
+
     {{{
       observer.replace(3, 0, [object1 .. objectN], SC.DROP_AFTER)
     }}}
-    
+
     The operation is simply used to disambiguate whether the insertion is
     intended to be AFTER the previous item or BEFORE the items you are
     replacing.
-    
+
     @param {Number} start the starting index
     @param {Number} amt the number of items to replace
     @param {SC.Array} objects array of objects to insert
@@ -240,12 +244,12 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
     var cur      = start,
         observer = null,
         indexes, len, max;
-        
+
     if (operation === undefined) operation = SC.DROP_BEFORE;
-    
+
     // adjust the start location based on branches, possibly passing on to an
     // observer.
-    if (this.get('isHeaderVisible')) cur--; // exclude my own header item 
+    if (this.get('isHeaderVisible')) cur--; // exclude my own header item
     if (cur < 0) throw "Tree Item cannot replace itself";
 
     // remove branch lengths.  If the adjusted start location lands inside of
@@ -255,8 +259,8 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
         if (observer || (i>=cur)) return ; // nothing to do
         if (!(observer = this.branchObserverAt(i))) return; // nothing to do
         len = observer.get('length');
-        
-        // if this branch range is before the start loc, just remove it and 
+
+        // if this branch range is before the start loc, just remove it and
         // go on.  If cur is somewhere inside of the range, then save to pass
         // on.  Note use of operation to determine the abiguous end op.
         if ((i+len === cur) && operation === SC.DROP_AFTER) cur -= i;
@@ -264,15 +268,15 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
         else {
           cur -= len-1; observer = null ;
         }
-      }, this);      
+      }, this);
     }
-      
+
     // if an observer was saved, pass on call.
     if (observer) {
       observer.replace(cur, amt, objects, operation);
       return this;
     }
-    
+
     // no observer was saved, which means cur points to an index inside of
     // our own range.  Now amt just needs to be adjusted to remove any
     // visible branches as well.
@@ -285,11 +289,11 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
         max -= len-1;
       }, this);
     }
-    
+
     // get amt back out.  if amt is negative, it means that the range passed
     // was not cleanly inside of this range.  raise an exception.
-    amt = max-cur; 
-    
+    amt = max-cur;
+
     // ok, now that we are adjusted, get the children and forward the replace
     // call on.  if there are no children, bad news...
     var children = this.get('children');
@@ -300,43 +304,43 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
     }
 
     children.replace(cur, amt, objects, operation);
-    
+
     // don't call enumerableContentDidChange() here because, as an observer,
     // we should be notified by the children array itself.
-    
+
     return this;
   },
-  
+
   /**
     Called whenever the content for the passed observer has changed.  Default
     version notifies the parent if it exists and updates the length.
-    
+
     The start, amt and delta params should reflect changes to the children
     array, not to the expanded range for the wrapper.
   */
   observerContentDidChange: function(start, amt, delta) {
-    
+
     // clear caches
     this.invalidateBranchObserversAt(start);
     this._objectAtCache = this._outlineLevelCache = null;
     this._disclosureStateCache = null;
     this._contentGroupIndexes = NO;
     this.notifyPropertyChange('branchIndexes');
-    
+
     var oldlen = this.get('length'),
         newlen = this._computeLength(),
         parent = this.get('parentObserver'), set;
-    
+
     // update length if needed
     if (oldlen !== newlen) this.set('length', newlen);
-    
+
     // if we have a parent, notify that parent that we have changed.
     if (!this._notifyParent) return this; // nothing more to do
-    
+
     if (parent) {
       set = SC.IndexSet.create(this.get('index'));
       parent._childrenRangeDidChange(parent.get('children'), null, '[]', set);
-      
+
     // otherwise, note the enumerable content has changed.  note that we need
     // to convert the passed change to reflect the computed range
     } else {
@@ -345,14 +349,16 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
         start = this.expandChildIndex(start);
         amt = amt - start ;
         delta = 0 ;
-        
+
       } else {
         start = this.expandChildIndex(start);
         amt   = newlen - start;
         delta = newlen - oldlen ;
       }
 
-      this.enumerableContentDidChange(start, amt, delta);
+      var removedCount = amt;
+      var addedCount = delta + removedCount;
+      this.arrayContentDidChange(start, removedCount, addedCount);
     }
   },
 
@@ -360,31 +366,31 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
     Accepts a child index and expands it to reflect any nested groups.
   */
   expandChildIndex: function(index) {
-    
+
     var ret = index;
     if (this.get('isHeaderVisible')) index++;
 
     // fast path
     var branches = this.get('branchIndexes');
     if (!branches || branches.get('length')===0) return ret;
-    
+
     // we have branches, adjust for their length
     branches.forEachIn(0, index, function(idx) {
       ret += this.branchObserverAt(idx).get('length')-1;
     }, this);
-    
+
     return ret; // add 1 for item header
   },
-  
+
   // ..........................................................
   // SC.COLLECTION CONTENT SUPPORT
-  // 
+  //
 
   _contentGroupIndexes: NO,
-  
+
   /**
-    Called by the collection view to return any group indexes.  The default 
-    implementation will compute the indexes one time based on the delegate 
+    Called by the collection view to return any group indexes.  The default
+    implementation will compute the indexes one time based on the delegate
     treeItemIsGrouped
   */
   contentGroupIndexes: function(view, content) {
@@ -392,71 +398,73 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
 
     var ret = this._contentGroupIndexes;
     if (ret !== NO) return ret ;
-    
-    // if this is not the root item, never do grouping
+
+    // If this is not the root item, never do grouping
     if (this.get('parentObserver')) return null;
-    
-    var item = this.get('item'), group, indexes, len, cur, loc, children;
-    
+
+    var item = this.get('item'), group, indexes, cur, padding;
+
     if (item && item.isTreeItemContent) group = item.get('treeItemIsGrouped');
     else group = !!this.delegate.get('treeItemIsGrouped');
-    
-    // if grouping is enabled, build an index set with all of our local 
-    // groups.
+
+    // If grouping is enabled, build an index set with all of our local groups.
     if (group) {
       ret      = SC.IndexSet.create();
       indexes  = this.get('branchIndexes');
-      children = this.get('children');
-      len      = children ? children.get('length') : 0;
-      cur = loc = 0;
-      
+
       if (indexes) {
+        // Start at the minimum index, which is equal for the tree and flat array
+        cur = indexes.min();
+
+        // Padding is the difference between the tree index and array index for the current tree index
+        padding = 0;
         indexes.forEach(function(i) {
-          ret.add(cur, (i+1)-loc); // add loc -> i to set
-          cur += (i+1)-loc;
-          loc = i+1 ;
-          
-          var observer = this.branchObserverAt(i);
-          if (observer) cur += observer.get('length')-1;
-        }, this);
+          ret.add(i + padding, 1);
+
+            var observer = this.branchObserverAt(i);
+            if (observer) {
+              padding += observer.get('length') - 1;
+              cur += padding;
+            }
+          }, this);
       }
+    } else {
+      ret = null;
+    }
 
-      if (loc<len) ret.add(cur, len-loc);
-    } else ret = null;
-    
     this._contentGroupIndexes = ret ;
     return ret;
   },
-  
+
   contentIndexIsGroup: function(view, content, idx) {
     var indexes = this.contentGroupIndexes(view, content);
     return indexes ? indexes.contains(idx) : NO ;
   },
-  
+
   /**
     Returns the outline level for the specified index.
   */
   contentIndexOutlineLevel: function(view, content, index) {
     if (content !== this) return -1; // only care about us
-    
+
     var cache = this._outlineLevelCache;
     if (cache && (cache[index] !== undefined)) return cache[index];
     if (!cache) cache = this._outlineLevelCache = [];
-    
+
     var len   = this.get('length'),
         cur   = index,
         loc   = 0,
         ret   = null,
         indexes, children, observer;
-    
+
     if (index >= len) return -1;
-     
+
     if (this.get('isHeaderVisible')) {
       if (index === 0) return cache[0] = this.get('outlineLevel')-1;
       else cur--;
     }
 
-    // loop through branch indexes, reducing the offset until it matches 
+    // loop through branch indexes, reducing the offset until it matches
     // something we might actually return.
     if (indexes = this.get('branchIndexes')) {
       indexes.forEach(function(i) {
@@ -472,12 +480,12 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
           ret  = observer.contentIndexOutlineLevel(view, observer, cur-i);
           cur  = -1;
         } else cur -= len-1 ;
-        
+
       },this);
     }
-    
+
     if (cur>=0) ret = this.get('outlineLevel'); // get internal if needed
-    cache[index] = ret ; // save in cache 
+    cache[index] = ret ; // save in cache
     return ret ;
   },
 
@@ -486,25 +494,25 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
   */
   contentIndexDisclosureState: function(view, content, index) {
     if (content !== this) return -1; // only care about us
-    
+
     var cache = this._disclosureStateCache;
     if (cache && (cache[index] !== undefined)) return cache[index];
     if (!cache) cache = this._disclosureStateCache = [];
-    
+
     var len   = this.get('length'),
         cur   = index,
         loc   = 0,
         ret   = null,
         indexes, children, observer;
-    
+
     if (index >= len) return SC.LEAF_NODE;
-     
+
     if (this.get('isHeaderVisible')) {
       if (index === 0) return cache[0] = this.get('disclosureState');
       else cur--;
     }
 
-    // loop through branch indexes, reducing the offset until it matches 
+    // loop through branch indexes, reducing the offset until it matches
     // something we might actually return.
     if (indexes = this.get('branchIndexes')) {
       indexes.forEach(function(i) {
@@ -520,12 +528,12 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
           ret  = observer.contentIndexDisclosureState(view, observer, cur-i);
           cur  = -1;
         } else cur -= len-1 ;
-        
+
       },this);
     }
-    
+
     if (cur>=0) ret = SC.LEAF_NODE; // otherwise its a leaf node
-    cache[index] = ret ; // save in cache 
+    cache[index] = ret ; // save in cache
     return ret ;
   },
 
@@ -537,42 +545,42 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
   contentIndexExpand: function(view, content, idx) {
 
     var indexes, cur = idx, children, item;
-    
+
     if (content !== this) return; // only care about us
     if (this.get('isHeaderVisible')) {
       if (idx===0) {
         this._expand(this.get('item'));
         return;
       } else cur--;
-    } 
-    
+    }
+
     if (indexes = this.get('branchIndexes')) {
       indexes.forEach(function(i) {
         if (i >= cur) return; // past end - nothing to do
         var observer = this.branchObserverAt(i), len;
-        if (!observer) return ; 
-        
+        if (!observer) return ;
+
         len = observer.get('length');
         if (i+len > cur) {
           observer.contentIndexExpand(view, observer, cur-i);
           cur = -1 ; //done
         } else cur -= len-1;
-        
-      }, this);  
+
+      }, this);
     }
-    
+
     // if we are still inside of the range then maybe pass on to a child item
     if (cur>=0) {
-      children = this.get('children');  
+      children = this.get('children');
       item     = children ? children.objectAt(cur) : null;
       if (item) this._expand(item, this.get('item'), cur);
     }
   },
-  
+
   /**
-    Called to collapse a content index item if it is currently in an open 
-    disclosure state.  The default implementation does nothing.  
-    
+    Called to collapse a content index item if it is currently in an open
+    disclosure state.  The default implementation does nothing.
+
     @param {SC.CollectionView} view the collection view
     @param {SC.Array} content the content object
     @param {Number} idx the content index
@@ -581,42 +589,42 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
   contentIndexCollapse: function(view, content, idx) {
 
     var indexes, children, item, cur = idx;
-        
+
     if (content !== this) return; // only care about us
     if (this.get('isHeaderVisible')) {
       if (idx===0) {
         this._collapse(this.get('item'));
         return;
       } else cur--;
-    } 
-    
-    
+    }
+
+
     if (indexes = this.get('branchIndexes')) {
       indexes.forEach(function(i) {
         if (i >= cur) return; // past end - nothing to do
         var observer = this.branchObserverAt(i), len;
-        if (!observer) return ; 
-        
+        if (!observer) return ;
+
         len = observer.get('length');
         if (i+len > cur) {
           observer.contentIndexCollapse(view, observer, cur-i);
           cur = -1 ; //done
         } else cur -= len-1;
-        
-      }, this);  
+
+      }, this);
     }
 
     // if we are still inside of the range then maybe pass on to a child item
     if (cur>=0) {
-      children = this.get('children');  
+      children = this.get('children');
       item     = children ? children.objectAt(cur) : null;
       if (item) this._collapse(item, this.get('item'), cur);
     }
   },
-  
+
   // ..........................................................
   // BRANCH NODES
-  //   
+  //
 
   /**
     Returns the branch item for the specified index.  If none exists yet, it
@@ -626,7 +634,7 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
     var byIndex = this._branchObserversByIndex,
         indexes = this._branchObserverIndexes,
         ret, parent, pitem, item, children, guid, del ;
-        
+
     if (!byIndex) byIndex = this._branchObserversByIndex = [];
     if (!indexes) {
       indexes = this._branchObserverIndexes = SC.IndexSet.create();
@@ -638,7 +646,7 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
     children = this.get('children');
     item   = children ? children.objectAt(index) : null ;
     if (!item) return null ; // can't create an observer for a null item
-    
+
     byIndex[index] = ret = SC.TreeItemObserver.create({
       item:     item,
       delegate: this.get('delegate'),
@@ -650,7 +658,7 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
     indexes.add(index); // save for later invalidation
     return ret ;
   },
-  
+
   /**
     Invalidates any branch observers on or after the specified index range.
   */
@@ -660,57 +668,60 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
 
     if (!byIndex || byIndex.length<=index) return this ; // nothing to do
     if (index < 0) index = 0 ;
-    
+
     // destroy any observer on or after the range
     indexes.forEachIn(index, indexes.get('max')-index, function(i) {
       var observer = byIndex[i];
       if (observer) observer.destroy();
     }, this);
-    
+
     byIndex.length = index; // truncate to dump extra indexes
-    
+
     return this;
   },
-  
+
   // ..........................................................
   // INTERNAL METHODS
-  // 
-  
+  //
+
   init: function() {
     sc_super();
-    
+
     // begin all properties on item if there is one.  This will allow us to
     // track important property changes.
     var item = this.get('item');
     if (!item) throw "SC.TreeItemObserver.item cannot be null";
-    
+
     item.addObserver('*', this, this._itemPropertyDidChange);
     this._itemPropertyDidChange(item, '*');
     this._notifyParent = YES ; // avoid infinite loops
   },
-  
+
   /**
-    Called just before a branch observer is removed.  Should stop any 
+    Called just before a branch observer is removed.  Should stop any
     observering and invalidate any child observers.
   */
   destroy: function() {
     this.invalidateBranchObserversAt(0);
     this._objectAtCache = null ;
-    
+    this._notifyParent = NO ; // parent doesn't care anymore
+
     // cleanup observing
     var item = this.get('item');
     if (item) item.removeObserver('*', this, this._itemPropertyDidChange);
-    
+
     var children = this._children,
         ro = this._childrenRangeObserver;
     if (children && ro) children.removeRangeObserver(ro);
-    
+
+    this.set('length', 0);
+
     sc_super();
   },
-  
+
   /**
     Called whenever a property changes on the item.  Determines if either the
-    children array or the disclosure state has changed and then notifies as 
+    children array or the disclosure state has changed and then notifies as
     necessary..
   */
   _itemPropertyDidChange: function(target, key) {
@@ -718,18 +729,18 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
         state    = this.get('disclosureState'),
         item     = this.get('item'),
         next ;
-        
+
     this.beginPropertyChanges();
-    
+
     next = this._computeDisclosureState(item);
     if (state !== next) this.set('disclosureState', next);
-    
+
     next = this._computeChildren(item);
     if (children !== next) this.set('children', next);
-    
+
     this.endPropertyChanges();
   },
-  
+
   /**
     Called whenever the children or disclosure state changes.  Begins or ends
     observing on the children array so that changes can propogate outward.
@@ -739,21 +750,21 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
         cur   = state === SC.BRANCH_OPEN ? this.get('children') : null,
         last  = this._children,
         ro    = this._childrenRangeObserver;
-        
+
     if (last === cur) return this; //nothing to do
     if (ro) last.removeRangeObserver(ro);
     if (cur) {
-      this._childrenRangeObserver = 
+      this._childrenRangeObserver =
           cur.addRangeObserver(null, this, this._childrenRangeDidChange);
     } else this._childrenRangeObserver = null;
-    
+
     this._children = cur ;
     this._childrenRangeDidChange(cur, null, '[]', null);
-    
+
   }.observes("children", "disclosureState"),
 
   /**
-    Called anytime the actual content of the children has changed.  If this 
+    Called anytime the actual content of the children has changed.  If this
     changes the length property, then notifies the parent that the content
     might have changed.
   */
@@ -763,14 +774,14 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
         min = indexes ? indexes.get('min') : 0,
         max = indexes ? indexes.get('max') : len,
         old = this._childrenLen || 0;
-        
+
     this._childrenLen = len; // save for future calls
     this.observerContentDidChange(min, max-min, len-old);
   },
-  
+
   /**
-    Computes the current disclosure state of the item by asking the item or 
-    the delegate.  If no pitem or index is passed, the parentItem and idex 
+    Computes the current disclosure state of the item by asking the item or
+    the delegate.  If no pitem or index is passed, the parentItem and idex
     will be used.
   */
   _computeDisclosureState: function(item, pitem, index) {
@@ -778,13 +789,13 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
 
     // no item - assume leaf node
     if (!item || !this._computeChildren(item)) return SC.LEAF_NODE;
-    
+
     // item implement TreeItemContent - call directly
     else if (item.isTreeItemContent) {
       if (pitem === undefined) pitem = this.get('parentItem');
       if (index === undefined) index = this.get('index');
       return item.treeItemDisclosureState(pitem, index);
-      
+
     // otherwise get treeItemDisclosureStateKey from delegate
     } else {
       key = this._treeItemIsExpandedKey ;
@@ -796,9 +807,9 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
       return item.get(key) ? SC.BRANCH_OPEN : SC.BRANCH_CLOSED;
     }
   },
-  
+
   /**
-    Collapse the item at the specified index.  This will either directly 
+    Collapse the item at the specified index.  This will either directly
     modify the property on the item or call the treeItemCollapse() method.
   */
   _collapse: function(item, pitem, index) {
@@ -806,13 +817,13 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
 
     // no item - assume leaf node
     if (!item || !this._computeChildren(item)) return this;
-    
+
     // item implement TreeItemContent - call directly
     else if (item.isTreeItemContent) {
       if (pitem === undefined) pitem = this.get('parentItem');
       if (index === undefined) index = this.get('index');
       item.treeItemCollapse(pitem, index);
-      
+
     // otherwise get treeItemDisclosureStateKey from delegate
     } else {
       key = this._treeItemIsExpandedKey ;
@@ -823,12 +834,12 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
       }
       item.setIfChanged(key, NO);
     }
-    
+
     return this ;
   },
 
   /**
-    Expand the item at the specified index.  This will either directly 
+    Expand the item at the specified index.  This will either directly
     modify the property on the item or call the treeItemExpand() method.
   */
   _expand: function(item, pitem, index) {
@@ -836,13 +847,13 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
 
     // no item - assume leaf node
     if (!item || !this._computeChildren(item)) return this;
-    
+
     // item implement TreeItemContent - call directly
     else if (item.isTreeItemContent) {
       if (pitem === undefined) pitem = this.get('parentItem');
       if (index === undefined) index = this.get('index');
       item.treeItemExpand(pitem, index);
-      
+
     // otherwise get treeItemDisclosureStateKey from delegate
     } else {
       key = this._treeItemIsExpandedKey ;
@@ -853,22 +864,22 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
       }
       item.setIfChanged(key, YES);
     }
-    
+
     return this ;
   },
-  
+
   /**
     Computes the children for the passed item.
   */
   _computeChildren: function(item) {
     var del, key;
-    
+
     // no item - no children
     if (!item) return null;
-    
+
     // item implement TreeItemContent - call directly
     else if (item.isTreeItemContent) return item.get('treeItemChildren');
-          
+
     // otherwise get treeItemChildrenKey from delegate
     else {
       key = this._treeItemChildrenKey ;
@@ -880,7 +891,7 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
       return item.get(key);
     }
   },
-  
+
   /**
     Computes the length of the array by looking at children.
   */
@@ -899,9 +910,9 @@ SC.TreeItemObserver = SC.Object.extend(SC.Array, SC.CollectionContent, {
           ret += observer.get('length')-1;
         }, this);
       }
-    } 
+    }
     return ret ;
   }
-    
+
 });