sproutcore 0.9.4 → 0.9.5

data/frameworks/sproutcore/controllers/array.js

@@ -17,11 +17,25 @@ until you call commitChanges().
 
 @extends SC.Controller
 @extends SC.Array
+@extends SC.SelectionSupport
+@since SproutCore 1.0
 
 */
 SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
 /** @scope SC.ArrayController.prototype */
 {
+  /**
+    If YES the will return controllers for content objects.
+    
+    If you want to use an array controller to edit an array contents directly
+    but you do not want to wrap the values of the array in controller objects
+    then you should set this property to NO.
+    
+    @field
+    @type {Boolean}
+  */
+  useControllersForContent: NO,
+  
   /**
     Provides compatibility with CollectionControllers.
     @field
@@ -45,7 +59,7 @@ SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
     @field
     @type {Boolean}
   */
-  destroyOnRemoval: false,
+  destroyOnRemoval: NO,
     
   /**
     Watches changes to the content property updates the contentClone.
@@ -53,17 +67,46 @@ SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
     @observes content
   */
   _contentObserver: function() {
-    this.beginPropertyChanges();
-    this.contentCloneReset();
-    this.arrayContentDidChange() ;
-    this.notifyPropertyChange('length') ;
-    this.updateSelectionAfterContentChange();
-    this.endPropertyChanges() ;
+    var content = this.get('content') ;
+    if (SC.isEqual(content, this._content)) return ; // nothing to do
+
+    if (!this._boundContentPropertyObserver) {
+      this._boundContentPropertyObserver = this._contentPropertyObserver.bind(this) ;
+    }
+    var func = this._boundContentPropertyObserver ;
+
+    // remove old observer, add new observer, and trigger content property change
+    if (this._content && this._content.removeObserver) this._content.removeObserver('[]', func) ;
+    if (content && content.addObserver) content.addObserver('[]', func) ;
+    this._content = content; //cache
+    this._contentPropertyRevision = null ;
+    
+    var rev = (content) ? content.propertyRevision : -1 ;
+    this._contentPropertyObserver(this, '[]', content, rev) ; 
   }.observes('content'),
 
+  _contentPropertyObserver: function(target, key, value, rev) {  
+      
+    if (!this._updatingContent && (!rev || (rev != this._contentPropertyRevision))) {
+      this._contentPropertyRevision = rev ;
+
+      this._updatingContent = true ;
+
+      this.beginPropertyChanges();
+      this.contentCloneReset();
+      this.arrayContentDidChange() ;
+      this.notifyPropertyChange('length') ;
+      this.updateSelectionAfterContentChange();
+      this.endPropertyChanges() ;
+
+      this._updatingContent = false ;
+
+    }
+  },
+  
   /**
-    The array content that (when committed) will be merged back into the content property.
-    All array methods will take place on this object.
+    The array content that (when committed) will be merged back into the 
+    content property. All array methods will take place on this object.
 
     @field
     @type {SC.Array}
@@ -71,9 +114,9 @@ SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
   contentClone: null,
 
   /**
-  * Clones the content property into the contentClone property.
-  * @private
-  **/
+    Clones the content property into the contentClone property.
+    @private
+  */
   contentCloneReset: function() {
     this._changelog = [];
     this.set('contentClone', null);
@@ -82,17 +125,14 @@ SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
   /**
    SC.Array interface implimentation.
    
-   @param {Number} idx 
-     Starting index in the array to replace.  If idx >= length, then append to 
-     the end of the array.
+   @param idx {Number} Starting index in the array to replace.  If idx >= 
+     length, then append to the end of the array.
    
-   @param {Number} amt 
-     Number of elements that should be removed from the array, starting at 
-     *idx*.
+   @param amt {Number} Number of elements that should be removed from the 
+     array, starting at *idx*.
    
-   @param {Array} objects 
-     An array of zero or more objects that should be inserted into the array at 
-     *idx* 
+   @param objects {Array} An array of zero or more objects that should be 
+     inserted into the array at *idx* 
   */
   replace: function(idx, amt, objects) {
 
@@ -229,6 +269,8 @@ SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
     Returns the object controller for a source value.
   */
   _objectControllerFor: function(obj) {
+    if (!this.useControllersForContent) return obj;
+    
     var controllers = this._objControllers = this._objControllers || {} ;
     var guid = SC.getGUID(obj) ;
     var ret = controllers[guid] ;
@@ -246,6 +288,11 @@ SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
   */
   _sourceObjectFor: function(obj) {
     return (obj && obj.kindOf && obj.kindOf(SC.Controller)) ? obj.get('content') : obj ;
+  },
+  
+  init: function() {
+    arguments.callee.base.apply(this, arguments) ;
+    if (this.get('content')) this._contentObserver() ;
   }
 
 });

data/frameworks/sproutcore/controllers/object.js

@@ -6,8 +6,15 @@
 require('controllers/controller') ;
 
 /** @class
-  An ObjectController gives you a simple way to manage one or more objects
-  as a single object.
+
+  An ObjectController gives you a simple way to manage the editing state of
+  an object.  You can use an ObjectController instance as a "proxy" for your
+  model objects.
+  
+  Any properties you get or set on the object controller, will be passed 
+  through to its content object.  This allows you to setup bindings to your
+  object controller one time for all of your views and then swap out the 
+  content as needed.
   
   @extends SC.Controller
 */
@@ -58,6 +65,18 @@ SC.ObjectController = SC.Controller.extend(
   */
   allowsMultipleContent: true,
   
+  /**
+    Override this method to destroy the selected object. 
+    
+    The default just passes this call onto the content object if it supports
+    it, and then sets the content to null.
+  */
+  destroy: function() {
+    var content = this.get('content') ;
+    if (content && $type(content.destroy) === T_FUNCTION) content.destroy();
+    this.set('content', null) ;  
+  },
+  
   // ...............................
   // INTERNAL SUPPORT
   //

data/frameworks/sproutcore/drag/drag.js

@@ -149,6 +149,17 @@ SC.Drag = SC.Object.extend(
     return [] ; 
   }.property(),
   
+  /**
+    Checks for a named data type in the drag.
+    
+    @param dataType {String} the data type
+    @returns {Boolean} YES if data type is present in dataTypes array.
+  */
+  hasDataType: function(dataType) {
+    var dataTypes = this.get('dataTypes') || [] ;
+    return (dataTypes.indexOf(dataType) >= 0) ;  
+  },
+  
   /**
     Retrieve the data for the specified dataType from the drag source.
   
@@ -286,8 +297,6 @@ SC.Drag = SC.Object.extend(
         op = op & target.dragEntered(this, evt) ;
       } else op = SC.DRAG_NONE ;
 
-      console.log(SC.Drag.inspectOperation(op)) ;
-      
       // if DRAG_NONE, then look for the next parent that is a drop zone.
       if (op == SC.DRAG_NONE) target = this._findNextDropTarget(target) ;
     }
@@ -742,9 +751,9 @@ SC.Drag.mixin(
   */
   inspectOperation: function(op) {
     var ret = [] ;
-    if (op == SC.DRAG_NONE) {
+    if (op === SC.DRAG_NONE) {
       ret = ['DRAG_NONE'];
-    } else if (op == SC.DRAG_ANY) {
+    } else if (op === SC.DRAG_ANY) {
       ret = ['DRAG_ANY'] ;
     } else {
       if (op & SC.DRAG_LINK) {

data/frameworks/sproutcore/drag/drop_target.js

@@ -25,31 +25,37 @@ SC.DropTarget = {
   */  
   isDropTarget: true,
   
-  /** Called when the drag enters the droppable area.
+  /** 
+    Called when the drag enters the droppable area.
   
-    Override this method to return an OR'd mask of the allowed drag operations.  
-    If the user drags over a droppable area within another droppable area, 
-    the drag will latch onto the deepest view that returns one or more available 
-    operations.
+    Override this method to return an OR'd mask of the allowed drag 
+    operations.  If the user drags over a droppable area within another 
+    droppable area, the drag will latch onto the deepest view that returns one 
+    or more available operations.
   
     You can also use this method to perform any one-time changes to your view
-    when a drop enters the area.  If you return anything other than DRAG_NONE on 
-    this method, the dragUpdated() method will also be called immediately.
-  
-    Note that dragEntered may be called frequently during a drag, not just when the 
-    drag first enters your view.  In particular, the Drag object may use this method
-    to determine which nested drop target should receive a drop. 
+    when a drop enters the area.  If you return anything other than DRAG_NONE 
+    on this method, the dragUpdated() method will also be called immediately.
+  
+    Note that dragEntered may be called frequently during a drag, not just 
+    when the drag first enters your view.  In particular, the Drag object may 
+    use this method to determine which nested drop target should receive a 
+    drop.  You should implement this method to determine as quickly as
+    possible all of the possible operations that might be allowed by this 
+    drop target.  You can use dragUpdated to determine the specific operation
+    allowed by the user's current mouse location.
     
-    You should implement your dragEntered method to always return the correct drag
-    operation, but only to perform any one-time setup the first time dragEntered
-    is called after a dragExited.
+    You should implement your dragEntered method to always return the correct 
+    drag operation, but only to perform any one-time setup the first time 
+    dragEntered is called after a dragExited.
     
     The default implementation returns SC.DRAG_NONE
     
-    @param {SC.Drag} drag The current drag object
-    @param {Event}   evt  The most recent mouse move event.  Use to get location 
-
-    @return {DragOps} A mask of all the drag operations allowed or SC.DRAG_NONE
+    @param drag {SC.Drag} The current drag object
+    @param evt {Event} The most recent mouse move event.  Use to get 
+      location 
+    @returns {DragOps} A mask of all the drag operations allowed or 
+      SC.DRAG_NONE
   */
   dragEntered: function(drag, evt) { return SC.DRAG_NONE; },
   
@@ -67,7 +73,8 @@ SC.DropTarget = {
     The default implementation does nothing.
     
     @param {SC.Drag} drag The current drag object
-    @param {Event}   evt  The most recent mouse move event.  Use to get location 
+    @param {Event}   evt  The most recent mouse move event.  Use to get  
+      location 
   */
   dragUpdated: function(drag, evt) {},
 

data/frameworks/sproutcore/english.lproj/core.css

@@ -10,6 +10,10 @@
    These styles are required by various views.  You should keep these in your views even if you write your own theme.
 */
 
+.sc-hide-overflow * {
+  overflow: hidden !important;
+}
+
 /* @group SC.Drag */
 
 .sc-ghost-view {

data/frameworks/sproutcore/english.lproj/strings.js

@@ -10,6 +10,11 @@ Object.extend(String.English,{
   "Invalid.Email(%@)": "%@ is not a valid email address",
   "Invalid.NotEmpty(%@)": "%@ must not be empty",
   "Invalid.Password": "Your passwords do not match.  Please try typing them again.",
+  // "CommentedOut": "String",
+  /*
+     "A bunch of": "Commented out",
+     "Strings": "Do not include",
+  */
   "Invalid.General(%@)": "%@ is invalid.  Please try again.",
   "Invalid.Number(%@)": "%@ is not a number."
 }) ;

data/frameworks/sproutcore/english.lproj/theme.css

@@ -221,6 +221,11 @@ body.sc-theme {
 	background: no-repeat static_url('images/sc-theme-sprite.png') right -69px;
 }
 
+.sc-theme .sc-source-list-view .drop-target {
+  outline: 2px purple solid;
+}
+
+
 /* @end */
 
 /* @group SC.SplitView */

data/frameworks/sproutcore/foundation/application.js

@@ -196,8 +196,6 @@ SC.Application = SC.Responder.extend(
     // keystring is a method name representing the keys pressed (i.e 'alt_shift_escape')
     var keystring = SC.Responder.inputManager.codesForEvent(evt).first();
     
-    //console.log( '[SC.Application#_attemptKeyEquivalent] keystring: %s, evt: %o', keystring, evt );
-
     // inputManager couldn't build a keystring for this key event... nothing to do...
     if (!keystring) return false;
     
@@ -208,6 +206,7 @@ SC.Application = SC.Responder.extend(
     if (mainPane && (mainPane != keyPane) && mainPane.performKeyEquivalent(keystring, evt)) return true;
     return this.performKeyEquivalent(keystring, evt);
   },
+  
   _attemptKeyInterfaceControl: function( evt )
   {
     // keystring is a method name representing the keys pressed (i.e 'alt_shift_escape')

data/frameworks/sproutcore/foundation/set.js

@@ -36,34 +36,53 @@ SC.Set = SC.Object.extend(SC.Array,
     Call this method to test for membership.
   */
   contains: function(obj) {
-    if (obj == null) return false ;
-    return [this._guidFor(obj)] == obj ;
+    if (obj === null) return false ;
+    return this[this._guidFor(obj)] === obj ;
   },
   
   /**
     Call this method to add an object. performs a basic add.
+    
+    If the object is already in the set it will not be added again.
+    
+    @param obj {Object} the object to add
+    @returns {Boolean} YES if the object as added.
   */
   add: function(obj) {
-    if (obj == null) return; // cannot add null to a set.
-    this[this._guidFor(obj)] = obj ;
-    this.incrementProperty('length') ;
-    this.incrementProperty('revision') ;
+    if (obj == null) return NO; // cannot add null to a set.
+    
+    var guid = this._guidFor(obj) ;
+    if (this[guid] == null) {
+      this[this._guidFor(obj)] = obj ;
+      this.incrementProperty('length') ;
+      this.incrementProperty('revision') ;
+      return YES ;
+    } else return NO ;
   },
   
   /**
-    Performs a basic remove
+    Removes the object from the set if it is found.
+    
+    If the object is not in the set, nothing will be changed.
+    
+    @param obj {Object} the object to remove
+    @returns {Boolean} YES if the object was removed.
   */  
   remove: function(obj) {
-    if (obj == null) return ;
-    delete this[this._guidFor(obj)] ; 
-    this.decrementProperty('length') ;
-    this.incrementProperty('revision') ;
+    if (obj == null) return NO ;
+    var guid = this._guidFor(obj);
+    if (this[guid] === obj) {
+      delete this[this._guidFor(obj)] ; 
+      this.decrementProperty('length') ;
+      this.incrementProperty('revision') ;
+      return YES ;
+    } else return NO;
   },
   
   // .......................................
   // PRIVATE 
   _guidFor: function(obj) {
-    return '@' + SC.getGUID(obj);
+    return '@' + SC.guidFor(obj);
   },
   
   _each: function(iterator) {

data/frameworks/sproutcore/foundation/sorted_set.js

@@ -0,0 +1,590 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2008 Sprout Systems, Inc.
+// ========================================================================
+
+require('Core') ;
+require('foundation/object') ;
+
+/**
+  @class
+
+  A sorted set stores objects in a sorted order based on a combination of 
+  sort keys.
+  
+  h2. Usage
+  
+  @extends SC.Object
+  @extends SC.Array
+  @since SproutCore 1.0
+*/
+SC.SortedSet = SC.Object.extend(
+/** @scope SC.SortedSet.prototype */ {
+
+  /**
+    An array of property keys to use when sorting objects.  This should be
+    set when the set is created and not change during the lifetime of the
+    object.
+  */
+  sortBy: [],
+  
+  compareObjects: function(v1, v2) {
+    return (v1 < v2) ? -1 : (v1 > v2) ? 1 : 0 ;
+  },
+  
+  init: function() {
+    arguments.callee.base.call(this) ;
+    this._root      = null;
+    this._cursor    = null;
+    this._ancestors = [];
+  },
+  
+  /** _findNode */
+  _findNode:  function(value, saveAncestors) {
+      if ( saveAncestors == null ) saveAncestors = false;
+
+      var result = this._root;
+
+      if ( saveAncestors ) {
+          this._ancestors = [];
+      }
+
+      while ( result != null ) {
+          var relation = this.compareObjects(value, result._value); 
+
+          if ( relation != 0 ) {
+              if ( saveAncestors ) {
+                  this._ancestors.push(result);
+              }
+              if ( relation < 0 ) {
+                  result = result._left;
+              } else {
+                  result = result._right;
+              }
+          } else {
+              break;
+          }
+      }
+
+      return result;
+  },
+
+  /** _maxNode */
+  _maxNode:  function(node, saveAncestors) {
+      if ( node == null ) node = this._root;
+      if ( saveAncestors == null ) saveAncestors = false;
+
+      if ( node != null ) {
+          while ( node._right != null ) {
+              if ( saveAncestors ) {
+                  this._ancestors.push(node);
+              }
+              node = node._right;
+          }
+      }
+
+      return node;
+  },
+
+  /** _minNode */
+  _minNode:  function(node, saveAncestors) {
+      if ( node == null ) node = this._root;
+      if ( saveAncestors == null ) saveAncestors = false;
+
+      if ( node != null ) {
+          while ( node._left != null ) {
+              if ( saveAncestors ) {
+                  this._ancestors.push(node);
+              }
+              node = node._left;
+          }
+      }
+
+      return node;
+  },
+
+  /** _nextNode */
+  _nextNode:  function(node) {
+      if ( node != null ) {
+          if ( node._right != null ) {
+              this._ancestors.push(node);
+              node = this._minNode(node._right, true);
+          } else {
+              var ancestors = this._ancestors;
+              parent = ancestors.pop();
+
+              while ( parent != null && parent._right === node ) {
+                  node = parent;
+                  parent = ancestors.pop();
+              }
+
+              node = parent;
+          }
+      } else {
+          this._ancestors = [];
+          node = this._minNode(this._root, true);
+      }
+
+      return node;
+  },
+
+  /**   _previousNode */
+  _previousNode:  function(node) {
+      if ( node != null ) {
+          if ( node._left != null ) {
+              this._ancestors.push(node);
+              node = this._maxNode(node._left, true);
+          } else {
+              var ancestors = this._ancestors;
+              parent = ancestors.pop();
+
+              while ( parent != null && parent._left === node ) {
+                  node = parent;
+                  parent = ancestors.pop();
+              }
+
+              node = parent;
+          }
+      } else {
+          this._ancestors = [];
+          node = this._maxNode(this._root, true);
+      }
+
+      return node;
+  },
+
+  /**
+    Adds a new object to the tree.  The object must respond to the 
+    compareMethod.
+  */
+  add:  function(value) {
+      var result;
+
+      if ( this._root == null ) {
+          result = this._root = new SC.RedBlackNode(value, this);
+      } else {
+          var addResult = this._root.add(value);
+
+          this._root = addResult[0];
+          result = addResult[1];
+      }
+
+      return result;
+  },
+
+  
+  find:  function(value) {
+      var node = this._findNode(value);
+
+      return ( node != null ) ? node._value : null;
+  },
+
+  findNext:  function(value) {
+      var current = this._findNode(value, true);
+
+      current = this._nextNode(current);
+
+      return (current != null ) ? current._value : null;
+  },
+
+  findPrevious:  function(value) {
+      var current = this._findNode(value, true);
+
+      current = this._previousNode(current);
+
+      return (current != null ) ? current._value : null;
+  },
+
+  max:  function() {
+      var result = this._maxNode();
+
+      return ( result != null ) ? result._value : null;
+  },
+
+  min:  function() {
+      var result = this._minNode();
+
+      return ( result != null ) ? result._value : null;
+  },
+
+  next:  function() {
+      this._cursor = this._nextNode(this._cursor);
+
+      return ( this._cursor ) ? this._cursor._value : null;
+  },
+
+  previous:  function() {
+      this._cursor = this._previousNode(this._cursor);
+
+      return ( this._cursor ) ? this._cursor._value : null;
+  },
+
+  remove:  function(value) {
+      var result;
+
+      if ( this._root != null ) {
+          var remResult = this._root.remove(value);
+
+          this._root = remResult[0];
+          result = remResult[1];
+      } else {
+          result = null;
+      }
+
+      return result;
+  },
+
+  traverse:  function(func) {
+      if ( this._root != null ) {
+          this._root.traverse(func);
+      }
+  },
+
+  toString:  function() {
+      var lines = [];
+
+      if ( this._root != null ) {
+          var indentText = "  ";
+          var stack = [[this._root, 0, "^"]];
+
+          while ( stack.length > 0 ) {
+              var current = stack.pop();
+              var node    = current[0];
+              var indent  = current[1];
+              var line    = "";
+
+              for ( var i = 0; i < indent; i++ ) {
+                  line += indentText;
+              }
+
+              line += current[2] + "(" + node.toString() + ")";
+              lines.push(line);
+
+              if ( node._right != null ) stack.push([node._right, indent+1, "R"]);
+              if ( node._left  != null ) stack.push([node._left,  indent+1, "L"]);
+          }
+      }
+
+      return lines.join("\n");
+  }
+  
+});
+
+/*****
+*
+*   SC.RedBlackNode.js
+*
+*   copyright 2004, Kevin Lindsey
+*   licensing info available at: http://www.kevlindev.com/license.txt
+*
+*****/
+
+/*****
+*
+*   constructor
+*
+*****/
+SC.RedBlackNode = function(value, owner) {
+    this._owner = owner ;
+    this._left   = null;
+    this._right  = null;
+    this._value  = value;
+    this._height = 1;
+    this._count = 1 ;
+} ;
+
+SC.RedBlackNode.prototype.count = function() {
+  if (!this._count) {
+    this._count = 1 ;
+    this._count += (this._left) ? this._left.count() : 0 ;
+    this._count += (this._right) ? this._right.count() : 0;
+  }
+  return this._count ;
+};
+
+/**
+  Returns the node at the specified index.  Uses counts.
+  
+  Remember: left branch is before the right branch.
+*/
+SC.RedBlackNode.prototype.nodeAt = function(idx) {  
+  var leftCount = (this._left) ? this._left.count() : 0 ;
+  if (idx === leftCount) return this; // its me!
+  
+  // look lower
+  if (idx < leftCount) {
+    return (this._left) ? this._left.nodeAt(idx) : null ;
+    
+  // look higher
+  } else {
+    return (this._right) ? this._right.nodeAt(idx - leftCount) : null;
+  }
+};
+
+/*****
+*
+*   add
+*
+*****/
+SC.RedBlackNode.prototype.add = function(value) {
+    var relation = this._owner.compareObjects(value, this._value);
+    var addResult;
+    var result;
+    var newNode;
+
+    if ( relation != 0 ) {
+        if ( relation < 0 ) {
+            if ( this._left != null ) {
+                addResult = this._left.add(value);
+                this._left = addResult[0];
+                newNode = addResult[1];
+            } else {
+                newNode = this._left = new SC.RedBlackNode(value, this._owner);
+            }
+        } else if ( relation > 0 ) {
+            if ( this._right != null ) {
+                addResult = this._right.add(value);
+                this._right = addResult[0];
+                newNode = addResult[1];
+            } else {
+                newNode = this._right = new SC.RedBlackNode(value, this._owner);
+            }
+        }
+        result = [this.balanceTree(), newNode];
+    } else {
+        result = [this, this];
+    }
+
+    // add to the return 
+    if (result[0]._count != null) result[0]._count = null ;
+    return result;
+};
+
+
+/*****
+*
+*   balanceTree
+*
+*****/
+SC.RedBlackNode.prototype.balanceTree = function() {
+    var leftHeight  = (this._left  != null) ? this._left._height  : 0;
+    var rightHeight = (this._right != null) ? this._right._height : 0;
+    var result;
+
+    if ( leftHeight > rightHeight + 1 ) {
+        result = this.swingRight();
+    } else if ( rightHeight > leftHeight + 1 ) {
+        result = this.swingLeft();
+    } else {
+        this.setHeight();
+        result = this;
+    }
+
+    return result;
+};
+
+
+/*****
+*
+*   join
+*
+*****/
+SC.RedBlackNode.prototype.join = function(that) {
+    var result;
+
+    if ( that == null ) {
+        result = this;
+    } else {
+        var top;
+
+        if ( this._height > that._height ) {
+            top = this;
+            top._right = that.join(top._right);
+        } else {
+            top = that;
+            top._left = this.join(top._left);
+        }
+
+        result = top.balanceTree();
+    }
+
+    return result;
+};
+
+
+/*****
+*
+*   moveLeft
+*
+*****/
+SC.RedBlackNode.prototype.moveLeft = function() {
+    var right = this._right;
+    var rightLeft = right._left;
+    
+    this._right = rightLeft;
+    right._left = this;
+    this.setHeight();
+    right.setHeight();
+
+    return right;
+};
+
+
+/*****
+*
+*   moveRight
+*
+*****/
+SC.RedBlackNode.prototype.moveRight = function() {
+    var left = this._left;
+    var leftRight = left._right;
+    
+    this._left = leftRight;
+    left._right = this;
+    this.setHeight();
+    left.setHeight();
+
+    return left;
+};
+
+
+/*****
+*
+*   remove
+*
+*****/
+SC.RedBlackNode.prototype.remove = function(value) {
+    var relation = this._owner.compareObjects(value, this._value);
+    var remResult;
+    var result;
+    var remNode;
+
+    if ( relation != 0 ) {
+        if ( relation < 0 ) {
+            if ( this._left != null ) {
+                remResult = this._left.remove(value);
+                this._left = remResult[0];
+                remNode = remResult[1];
+            } else {
+                remNode = null;
+            }
+        } else {
+            if ( this._right != null ) {
+                remResult = this._right.remove(value);
+                this._right = remResult[0];
+                remNode = remResult[1];
+            } else {
+                remNode = null;
+            }
+        }
+
+        result = this;
+    } else {
+        remNode = this;
+
+        if ( this._left == null ) {
+            result = this._right;
+        } else if ( this._right == null ) {
+            result = this._left;
+        } else {
+            result = this._left.join(this._right);
+            this._left = null;
+            this._right = null;
+        }
+    }
+
+    if ( remNode != null ) {
+        if ( result != null ) {
+            result = [result.balanceTree(), remNode];
+        } else {
+            result = [result, remNode];
+        }
+    } else {
+        result = [this, null];
+    }
+    
+    if (result[0]._count != null) result[0]._count = null ;
+    return result ;
+};
+
+
+/*****
+*
+*   setHeight
+*
+*****/
+SC.RedBlackNode.prototype.setHeight = function() {
+    var leftHeight  = (this._left  != null) ? this._left._height  : 0;
+    var rightHeight = (this._right != null) ? this._right._height : 0;
+    
+    this._height = (leftHeight < rightHeight) ? rightHeight + 1 : leftHeight + 1;
+};
+
+
+/*****
+*
+*   swingLeft
+*
+*****/
+SC.RedBlackNode.prototype.swingLeft = function() {
+    var right      = this._right;
+    var rightLeft  = right._left;
+    var rightRight = right._right;
+    var left       = this._left;
+
+    var leftHeight       = (left       != null ) ? left._height       : 0;
+    var rightLeftHeight  = (rightLeft  != null ) ? rightLeft._height  : 0;
+    var rightRightHeight = (rightRight != null ) ? rightRight._height : 0;
+
+    if ( rightLeftHeight > rightRightHeight ) {
+        this._right = right.moveRight();
+    }
+
+    return this.moveLeft();
+};
+
+
+/*****
+*
+*   swingRight
+*
+*****/
+SC.RedBlackNode.prototype.swingRight = function() {
+    var left      = this._left;
+    var leftRight = left._right;
+    var leftLeft  = left._left;
+    var right     = this._right;
+
+    var rightHeight     = (right     != null ) ? right._height     : 0;
+    var leftRightHeight = (leftRight != null ) ? leftRight._height : 0;
+    var leftLeftHeight  = (leftLeft  != null ) ? leftLeft._height  : 0;
+
+    if ( leftRightHeight > leftLeftHeight ) {
+        this._left = left.moveLeft();
+    }
+
+    return this.moveRight();
+};
+
+
+/*****
+*
+*   traverse
+*
+*****/
+SC.RedBlackNode.prototype.traverse = function(func) {
+    if ( this._left  != null ) this._left.traverse(func);
+    func(this);
+    if ( this._right != null ) this._right.traverse(func);
+};
+
+
+/*****
+*
+*   toString
+*
+*****/
+SC.RedBlackNode.prototype.toString = function() {
+    return this._value.toString();
+};
+