sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

data/frameworks/sproutcore/frameworks/runtime/license.js

@@ -0,0 +1,28 @@
+/*! @license
+==========================================================================
+SproutCore Costello -- Property Observing Library
+Copyright ©2006-2009, Sprout Systems, Inc. and contributors.
+Portions copyright ©2008-2009 Apple, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a 
+copy of this software and associated documentation files (the "Software"), 
+to deal in the Software without restriction, including without limitation 
+the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the 
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+DEALINGS IN THE SOFTWARE.
+
+For more information about SproutCore, visit http://www.sproutcore.com
+
+==========================================================================
+@license */

data/frameworks/sproutcore/frameworks/runtime/mixins/array.js

@@ -0,0 +1,403 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+// note: SC.Observable also enhances array.  make sure we are called after
+// SC.Observable so our version of unknownProperty wins.
+sc_require('mixins/observable') ;
+sc_require('mixins/enumerable') ;
+sc_require('system/range_observer');
+
+SC.OUT_OF_RANGE_EXCEPTION = "Index out of range" ;
+
+/**
+  @namespace
+  
+  This module implements Observer-friendly Array-like behavior.  This mixin is 
+  picked up by the Array class as well as other controllers, etc. that want to  
+  appear to be arrays.
+  
+  Unlike SC.Enumerable, this mixin defines methods specifically for 
+  collections that provide index-ordered access to their contents.  When you
+  are designing code that needs to accept any kind of Array-like object, you
+  should use these methods instead of Array primitives because these will 
+  properly notify observers of changes to the array. 
+  
+  Although these methods are efficient, they do add a layer of indirection to
+  your application so it is a good idea to use them only when you need the 
+  flexibility of using both true JavaScript arrays and "virtual" arrays such
+  as controllers and collections.
+  
+  You can use the methods defined in this module to access and modify array 
+  contents in a KVO-friendly way.  You can also be notified whenever the 
+  membership if an array changes by observing the "[]" property.
+
+  To support SC.Array in your own class, you must override two
+  primitives to use it: replace() and objectAt().  
+
+  Note that the SC.Array mixin also incorporates the SC.Enumerable mixin.  All
+  SC.Array-like objects are also enumerable.
+
+  @extends SC.Enumerable
+  @since SproutCore 0.9.0
+*/
+SC.Array = {
+
+/**
+  @field {Number} length
+  
+  Your array must support the length property.  your replace methods should
+  set this property whenever it changes.
+*/
+  // length: 0,
+  
+/**
+  This is one of the primitves you must implement to support SC.Array.  You 
+  should replace amt objects started at idx with the objects in the passed 
+  array.  You should also call this.enumerableContentDidChange() ;
+  
+  @param {Number} idx 
+    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 {Array} objects 
+    An array of zero or more objects that should be inserted into the array at 
+    *idx* 
+*/
+  replace: function(idx, amt, objects) {
+    throw "replace() must be implemented to support SC.Array" ;
+  },
+
+/**
+  This is one of the primitives you must implement to support SC.Array.  
+  Returns the object at the named index.  If your object supports retrieving 
+  the value of an array item using get() (i.e. myArray.get(0)), then you do
+  not need to implement this method yourself.
+  
+  @param {Number} idx
+    The index of the item to return.  If idx exceeds the current length, 
+    return null.
+*/
+  objectAt: function(idx)
+  {
+    if (idx < 0) return undefined ;
+    if (idx >= this.get('length')) return undefined;
+    return this.get(idx);
+  },
+  
+  /**
+    @field []
+
+    This is the handler for the special array content property.  If you get
+    this property, it will return this.  If you set this property it a new 
+    array, it will replace the current content.
+    
+    This property overrides the default property defined in SC.Enumerable.
+  */
+  '[]': function(key, value) {
+    if (value !== undefined) {
+      this.replace(0, this.get('length'), value) ;
+    }  
+    return this ;
+  }.property(),
+  
+/**  
+  This will use the primitive replace() method to insert an object at the 
+  specified index.
+  
+  @param {Number} idx index of insert the object at.
+  @param {Object} object object to insert
+*/
+  insertAt: function(idx, object) {
+    if (idx > this.get('length')) throw SC.OUT_OF_RANGE_EXCEPTION ;
+    this.replace(idx,0,[object]) ;
+    return this ;
+  },
+  
+  /**
+    Remove an object at the specified index using the replace() primitive method.
+  
+    @param {Number} idx index of object to remove
+  */
+  removeAt: function(idx) {
+    if ((idx < 0) || (idx >= this.get('length'))) throw SC.OUT_OF_RANGE_EXCEPTION;
+    var ret = this.objectAt(idx) ;
+    this.replace(idx,1,[]);
+    return ret ;
+  },
+  
+  /**
+    Search the array of this object, removing any occurrences of it.
+    @param {object} obj object to remove
+  */
+  removeObject: function(obj) {
+    var loc = this.get('length') || 0;
+    while(--loc >= 0) {
+      var curObject = this.objectAt(loc) ;
+      if (curObject == obj) this.removeAt(loc) ;
+    }
+    return this ;
+  },
+  
+  /**
+    Push the object onto the end of the array.  Works just like push() but it 
+    is KVO-compliant.
+  */
+  pushObject: function(obj) {
+    this.insertAt(this.get('length'), obj) ;
+    return obj ;
+  },
+  
+  /**
+    Pop object from array or nil if none are left.  Works just like pop() but 
+    it is KVO-compliant.
+  */
+  popObject: function() {
+    var len = this.get('length') ;
+    if (len === 0) return null ;
+    
+    var ret = this.objectAt(len-1) ;
+    this.removeAt(len-1) ;
+    return ret ;
+  },
+  
+  /**
+    Shift an object from start of array or nil if none are left.  Works just 
+    like shift() but it is KVO-compliant.
+  */
+  shiftObject: function() {
+    if (this.get('length') === 0) return null ;
+    var ret = this.objectAt(0) ;
+    this.removeAt(0) ;
+    return ret ;
+  },
+  
+  /**
+    Unshift an object to start of array.  Works just like unshift() but it is 
+    KVO-compliant.
+  */
+  unshiftObject: function(obj) {
+    this.insertAt(0, obj) ;
+    return obj ;
+  },
+  
+  /**  
+    Compares each item in the array.  Returns true if they are equal.
+  */
+  isEqual: function(ary) {
+    if (!ary) return false ;
+    if (ary == this) return true;
+    
+    var loc = ary.get('length') ;
+    if (loc != this.get('length')) return false ;
+
+    while(--loc >= 0) {
+      if (!SC.isEqual(ary.objectAt(loc), this.objectAt(loc))) return false ;
+    }
+    return true ;
+  },
+  
+  /**
+    Generates a new array with the contents of the old array, sans any null
+    values.
+    
+    @returns {Array}
+  */
+  compact: function() { return this.without(null); },
+  
+  /**
+    Generates a new array with the contents of the old array, sans the passed
+    value.
+    
+    @param {Object} value
+    @returns {Array}
+  */
+  without: function(value) {
+    if (this.indexOf(value)<0) return this; // value not present.
+    var ret = [] ;
+    this.forEach(function(k) { 
+      if (k !== value) ret[ret.length] = k; 
+    }) ;
+    return ret ;
+  },
+  
+  /**
+    Generates a new array with only unique values from the contents of the
+    old array.
+    
+    @returns {Array}
+  */
+  uniq: function() {
+    var ret = [] ;
+    this.forEach(function(k){
+      if (ret.indexOf(k)<0) ret[ret.length] = k;
+    });
+    return ret ;
+  },
+  
+  /**
+    SC.CollectionView compatibility. SC.Array does not calculate groups by 
+    default. Use SC.ArrayController and/or SC.ResultSet instead.
+    
+    @type SC.Array
+  */
+  groups: [],
+  
+  rangeObserverClass: SC.RangeObserver,
+  
+  /**
+    Creates a new range observer on the receiver.  The target/method callback
+    you provide will be invoked anytime any property on the objects in the 
+    specified range changes.  It will also be invoked if the objects in the
+    range itself changes also.
+    
+    The callback for a range observer should have the signature:
+    
+    {{{
+      function rangePropertyDidChange(array, objects, key)
+    }}}
+    
+    If the passed key is '[]' it means that the object itself changed.
+    
+    The return value from this method is an opaque reference to the 
+    ranger observer object.  You can use this reference to destroy the 
+    range observer when you are done with it or to update its range.
+  */
+  createRangeObserver: function(start, length, target, method) {
+    var rangeob = this._array_rangeObservers;
+    if (!rangeob) rangeob = this._array_rangeObservers = [] ;
+
+    var C = this.rangeObserverClass ;
+    var ret = C.create(this, start, length, target, method) ;
+    rangeob.push(ret);
+    return ret ;
+  },
+  
+  updateRangeObserver: function(rangeObserver, start, length) {
+    return rangeObserver.update(this, start, length);
+  },
+  
+  destroyRangeObserver: function(rangeObserver) {
+    var ret = rangeObserver.destroy(this);
+    var rangeob = this._array_rangeObservers;
+    if (rangeob) rangeob[rangeob.indexOf(rangeObserver)] = null ; // clear
+    return ret ;
+  },
+  
+  enumerableContentDidChange: function(start, length) {
+    // notify range observers
+    var rangeob = this._array_rangeObservers, len, idx, cur;
+    if (rangeob && (len = rangeob.length)>0) {
+      for(idx=0;idx<len;idx++) { 
+        cur = rangeob[idx];
+        if ((length === undefined) || ((start < (cur.start + cur.length)) && ((start+length) > cur.start))) cur.rangeDidChange();
+      }
+    }
+    
+    this.notifyPropertyChange('[]') ;
+    return this ;
+  }
+  
+} ;
+
+// Add SC.Array to the built-in array before we add SC.Enumerable to SC.Array
+// since built-in Array's are already enumerable.
+SC.mixin(Array.prototype, SC.Array) ; 
+SC.Array = SC.mixin({}, SC.Enumerable, SC.Array) ;
+
+// Add any extra methods to SC.Array that are native to the built-in Array.
+/**
+  Returns a new array that is a slice of the receiver.  This implementation
+  uses the observable array methods to retrieve the objects for the new 
+  slice.
+  
+  @param beginIndex {Integer} (Optional) index to begin slicing from.     
+  @param endIndex {Integer} (Optional) index to end the slice at.
+  @returns {Array} New array with specified slice
+*/
+SC.Array.slice = function(beginIndex, endIndex) {
+  var ret = []; 
+  var length = this.get('length') ;
+  if (SC.none(beginIndex)) beginIndex = 0 ;
+  if (SC.none(endIndex) || (endIndex > length)) endIndex = length ;
+  while(beginIndex < endIndex) ret[ret.length] = this.objectAt(beginIndex++) ;
+  return ret ;
+}  ;
+
+/**
+  Returns the index for a particular object in the index.
+  
+  @param {Object} object the item to search for
+  @returns {Number} index of -1 if not found
+*/
+SC.Array.indexOf = function(object) {
+  var idx, len = this.get('length');
+  for(idx=0;idx<len;idx++) {
+    if (this.objectAt(idx) === object) return idx ;
+  }
+  return -1;
+};
+
+// Some browsers do not support indexOf natively.  Patch if needed
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = SC.Array.indexOf;
+}
+
+// ......................................................
+// ARRAY SUPPORT
+//
+// Implement the same enhancements on Array.  We use specialized methods
+// because working with arrays are so common.
+(function() {
+  SC.mixin(Array.prototype, {
+
+    // primitive for array support.
+    replace: function(idx, amt, objects) {
+      if (!objects || objects.length === 0) {
+        this.splice(idx, amt) ;
+      } else {
+        var args = [idx, amt].concat(objects) ;
+        this.splice.apply(this,args) ;
+      }
+
+      // if we replaced exactly the same number of items, then pass only the
+      // replaced range.  Otherwise, pass the full remaining array length 
+      // since everything has shifted
+      var len = objects ? (objects.get ? objects.get('length') : objects.length) : 0;
+      if (amt !== len) amt = this.length - idx;
+      this.enumerableContentDidChange(idx, amt) ;
+      return this ;
+    },
+  
+    // If you ask for an unknown property, then try to collect the value
+    // from member items.
+    unknownProperty: function(key, value) {
+      var ret = this.reducedProperty(key, value) ;
+      if (ret === undefined) {
+        ret = (value === undefined) ? this.invoke('get', key) : null ;
+      }
+      return ret ;
+    },
+    
+    
+    //indexOf is not implemente in IE for Array
+    indexOf: function(obj) {
+      var len=this.length;
+      for(var i=0; i<len; i++){
+        if(this[i]===obj){
+      	  return i;
+      	}
+      }
+      return -1;
+    }
+  }) ;
+  
+})() ;
+

data/frameworks/sproutcore/frameworks/runtime/mixins/delegate_support.js

@@ -0,0 +1,70 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/**
+  @namespace
+  
+  Support methods for the Delegate design pattern.
+  
+  The Delegate design pattern makes it easy to delegate a portion of your 
+  application logic to another object.  This is most often used in views to 
+  delegate various application-logic decisions to controllers in order to 
+  avoid having to bake application-logic directly into the view itself.
+  
+  The methods provided by this mixin make it easier to implement this pattern
+  but they are not required to support delegates.
+  
+  h2. The Pattern
+  
+  The delegate design pattern typically means that you provide a property,
+  usually ending in "delegate", that can be set to another object in the 
+  system.  
+  
+  When events occur or logic decisions need to be made that you would prefer
+  to delegate, you can call methods on the delegate if it is set.  If the 
+  delegate is not set, you should provide some default functionality instead.
+  
+  Note that typically delegates are not observable, hence it is not necessary
+  to use get() to retrieve the value of the delegate.
+  
+*/
+SC.DelegateSupport = {  
+  
+  /**
+    Invokes the named method on the delegate that you pass.  If no delegate
+    is defined or if the delegate does not implement the method, then a 
+    method of the same name on the receiver will be called instead.  
+    
+    You can pass any arguments you want to pass onto the delegate after the
+    delegate and methodName.
+    
+    @param {Object} delegate a delegate object.  May be null.
+    @param {String} methodName a method name
+    @param {*} args (OPTIONAL) any additional arguments
+    
+    @returns value returned by delegate
+  */
+  invokeDelegateMethod: function(delegate, methodName, args) {
+    args = SC.$A(arguments); args = args.slice(2, args.length) ;
+    if (!delegate || !delegate[methodName]) delegate = this ;
+    
+    var method = delegate[methodName];
+    return method ? method.apply(delegate, args) : null;
+  },
+  
+  /**
+    Gets the named property from the delegate if the delegate exists and it
+    defines the property.  Otherwise, gets the property from the receiver.
+    
+    @param {Object} delegate the delegate or null
+    @param {String} key the property to get.
+  */
+  getDelegateProperty: function(delegate, key) {
+    return (delegate && (delegate[key] !== undefined) && delegate[key]!==null) ? delegate.get(key) : this.get(key) ;
+  }
+  
+};