sproutcore 1.4.5 → 1.5.0.pre.3

data/lib/frameworks/sproutcore/frameworks/{runtime → amber}/mixins/delegate_support.js

@@ -7,42 +7,42 @@
 
 /**
   @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 
+
+  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.  
-  
+  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 
+  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.
-  
+
   @since SproutCore 1.0
-  
+
 */
-SC.DelegateSupport = {  
-  
+SC.DelegateSupport = {
+
   /**
     Selects the delegate that implements the specified method name.  Pass one
     or more delegates.  The receiver is automatically included as a default.
-    
+
     This can be more efficient than using invokeDelegateMethod() which has
     to marshall arguments into a delegate call.
-    
+
     @param {String} methodName
     @param {Object...} delegate one or more delegate arguments
     @returns {Object} delegate or null
@@ -51,43 +51,43 @@ SC.DelegateSupport = {
     var idx = 1,
         len = arguments.length,
         ret ;
-        
+
     while(idx<len) {
       ret = arguments[idx];
       if (ret && ret[methodName] !== undefined) return ret ;
-      idx++;      
+      idx++;
     }
-    
+
     return (this[methodName] !== undefined) ? this : null;
   },
-  
+
   /**
     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.  
-    
+    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 {Object...} args (OPTIONAL) any additional arguments
-    
+
     @returns {Object} 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;
   },
-  
+
   /**
-    Search the named delegates for the passed property.  If one is found, 
-    gets the property value and returns it.  If none of the passed delegates 
+    Search the named delegates for the passed property.  If one is found,
+    gets the property value and returns it.  If none of the passed delegates
     implement the property, search the receiver for the property as well.
-    
+
     @param {String} key the property to get.
     @param {Object} delegate one or more delegate
     @returns {Object} property value or undefined
@@ -96,15 +96,15 @@ SC.DelegateSupport = {
     var idx = 1,
         len = arguments.length,
         ret ;
-        
+
     while(idx<len) {
       ret = arguments[idx++];
       if (ret && ret[key] !== undefined) {
         return ret.get ? ret.get(key) : ret[key] ;
       }
     }
-    
+
     return (this[key] !== undefined) ? this.get(key) : undefined ;
   }
-  
+
 };

data/lib/frameworks/sproutcore/frameworks/{foundation → amber}/mixins/responder_context.js

@@ -11,14 +11,14 @@ sc_require('system/responder');
 
   The root object for a responder chain.  A responder context can dispatch
   actions directly to a first responder; walking up the responder chain until
-  it finds a responder that can handle the action.  
-  
+  it finds a responder that can handle the action.
+
   If no responder can be found to handle the action, it will attempt to send
   the action to the defaultResponder.
-  
+
   You can have as many ResponderContext's as you want within your application.
   Every SC.Pane and SC.Application automatically implements this mixin.
-  
+
   Note that to implement this, you should mix SC.ResponderContext into an
   SC.Responder or SC.Responder subclass.
 
@@ -28,41 +28,41 @@ SC.ResponderContext = {
 
   // ..........................................................
   // PROPERTIES
-  // 
-  
+  //
+
   isResponderContext: YES,
-  
+
   /** @property
-  
-    When set to YES, logs tracing information about all actions sent and 
+
+    When set to YES, logs tracing information about all actions sent and
     responder changes.
   */
   trace: NO,
-  
+
   /** @property
-    The default responder.  Set this to point to a responder object that can 
+    The default responder.  Set this to point to a responder object that can
     respond to events when no other view in the hierarchy handles them.
-    
+
     @type SC.Responder
   */
   defaultResponder: null,
-  
+
   /** @property
     The next responder for an app is always its defaultResponder.
   */
   nextResponder: function() {
     return this.get('defaultResponder');
   }.property('defaultResponder').cacheable(),
-  
+
   /** @property
-    The first responder.  This is the first responder that should receive 
+    The first responder.  This is the first responder that should receive
     actions.
   */
   firstResponder: null,
 
   // ..........................................................
   // METHODS
-  // 
+  //
 
   /**
     Finds the next responder for the passed responder based on the responder's
@@ -74,7 +74,7 @@ SC.ResponderContext = {
     if (typeof next === SC.T_STRING) {
       next = SC.objectForPropertyPath(next, this);
     } else if (!next && (responder !== this)) next = this ;
-    return next ;  
+    return next ;
   },
 
   /**
@@ -83,17 +83,17 @@ SC.ResponderContext = {
   responderNameFor: function(responder) {
     if (!responder) return "(No Responder)";
     else if (responder._scrc_name) return responder._scrc_name;
-    
+
     // none found, let's go hunting...look three levels deep
     var n = this.NAMESPACE;
     this._findResponderNamesFor(this, 3, n ? [this.NAMESPACE] : []);
-    
+
     return responder._scrc_name || responder.toString(); // try again
   },
-  
+
   _findResponderNamesFor: function(responder, level, path) {
     var key, value;
-    
+
     for(key in responder) {
       if (key === 'nextResponder') continue ;
       value = responder[key];
@@ -106,22 +106,22 @@ SC.ResponderContext = {
       }
     }
   },
-  
+
   /**
-    Makes the passed responder into the new firstResponder for this 
-    responder context.  This will cause the current first responder to lose 
+    Makes the passed responder into the new firstResponder for this
+    responder context.  This will cause the current first responder to lose
     its responder status and possibly keyResponder status as well.
-    
-    When you change the first responder, this will send callbacks to 
+
+    When you change the first responder, this will send callbacks to
     responders up the chain until you reach a shared responder, at which point
     it will stop notifying.
-    
+
     @param {SC.Responder} responder
     @param {Event} evt that cause this to become first responder
     @returns {SC.ResponderContext} receiver
   */
   makeFirstResponder: function(responder, evt) {
-    var current = this.get('firstResponder'), 
+    var current = this.get('firstResponder'),
         last    = this.get('nextResponder'),
         trace   = this.get('trace'),
         common ;
@@ -134,16 +134,16 @@ SC.ResponderContext = {
       this._pendingResponder = responder;
       return ;
     }
-    
+
     if (trace) {
       console.log('%@: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
     }
-    
+
     if (responder) responder.set("becomingFirstResponder", YES);
-    
+
     this._locked = YES;
     this._pendingResponder = null;
-    
+
     // Find the nearest common responder in the responder chain for the new
     // responder.  If there are no common responders, use last responder.
     // Note: start at the responder itself: it could be the common responder.
@@ -153,56 +153,56 @@ SC.ResponderContext = {
       common = (common===last) ? null : this.nextResponderFor(common);
     }
     if (!common) common = last;
-    
+
     // Cleanup old first responder
     this._notifyWillLoseFirstResponder(current, current, common, evt);
     if (current) current.set('isFirstResponder', NO);
 
-    // Set new first responder.  If new firstResponder does not have its 
+    // Set new first responder.  If new firstResponder does not have its
     // responderContext property set, then set it.
-    
+
     // but, don't tell anyone until we have _also_ updated the hasFirstResponder state.
     this.beginPropertyChanges();
-    
+
     this.set('firstResponder', responder) ;
     if (responder) responder.set('isFirstResponder', YES);
-    
+
     this._notifyDidBecomeFirstResponder(responder, responder, common);
-    
+
     // now, tell everyone the good news!
     this.endPropertyChanges();
-    
+
     this._locked = NO ;
     if (this._pendingResponder) {
       this.makeFirstResponder(this._pendingResponder);
       this._pendingResponder = null;
     }
-    
+
     if (responder) responder.set("becomingFirstResponder", NO);
-    
+
     return this ;
   },
 
   _notifyWillLoseFirstResponder: function(responder, cur, root, evt) {
     if (cur === root) return ; // nothing to do
 
-    cur.willLoseFirstResponder(responder, evt);  
+    cur.willLoseFirstResponder(responder, evt);
     cur.set('hasFirstResponder', NO);
 
     var next = this.nextResponderFor(cur);
     if (next) this._notifyWillLoseFirstResponder(responder, next, root);
   },
-  
+
   _notifyDidBecomeFirstResponder: function(responder, cur, root) {
     if (cur === root) return ; // nothing to do
 
     var next = this.nextResponderFor(cur);
     if (next) this._notifyDidBecomeFirstResponder(responder, next, root);
-    
+
     cur.set('hasFirstResponder', YES);
-    cur.didBecomeFirstResponder(responder);  
+    cur.didBecomeFirstResponder(responder);
   },
-  
+
   /**
     Re-enters the current responder (calling willLoseFirstResponder and didBecomeFirstResponder).
   */
@@ -212,13 +212,13 @@ SC.ResponderContext = {
     current.willLoseFirstResponder();
     current.didBecomeFirstResponder();
   },
-  
+
   /**
-    Send the passed action down the responder chain, starting with the 
-    current first responder.  This will look for the first responder that 
-    actually implements the action method and returns YES or no value when 
+    Send the passed action down the responder chain, starting with the
+    current first responder.  This will look for the first responder that
+    actually implements the action method and returns YES or no value when
     called.
-    
+
     @param {String} action name of action
     @param {Object} sender object sending the action
     @param {Object} context optional additonal context info
@@ -254,15 +254,15 @@ SC.ResponderContext = {
       if (!handled) console.log("%@:  action '%@' NOT HANDLED".fmt(this,action));
       else console.log("%@: action '%@' handled by %@".fmt(this, action, this.responderNameFor(working)));
     }
-    
+
     this._locked = NO ;
-    
+
     if (responder = this._pendingResponder) {
       this._pendingResponder= null ;
       this.makeFirstResponder(responder);
     }
-    
-    
+
+
     return working ;
   }
 

data/lib/frameworks/sproutcore/frameworks/{foundation → amber}/mixins/selection_support.js

@@ -6,67 +6,67 @@
 // ==========================================================================
 /**
   @namespace
-  
+
   Implements common selection management properties for controllers.
-  
+
   Selection can be managed by any controller in your applications.  This
   mixin provides some common management features you might want such as
   disabling selection, or restricting empty or multiple selections.
-  
-  To use this mixin, simply add it to any controller you want to manage 
+
+  To use this mixin, simply add it to any controller you want to manage
   selection and call updateSelectionAfterContentChange()
   whenever your source content changes.  You can also override the properties
-  defined below to configure how the selection management will treat your 
+  defined below to configure how the selection management will treat your
   content.
-  
-  This mixin assumes the arrangedObjects property will return an SC.Array of 
+
+  This mixin assumes the arrangedObjects property will return an SC.Array of
   content you want the selection to reflect.
-  
-  Add this mixin to any controller you want to manage selection.  It is 
+
+  Add this mixin to any controller you want to manage selection.  It is
   already applied to the CollectionController and ArrayController.
-  
+
   @since SproutCore 1.0
 */
 SC.SelectionSupport = {
 
   // ..........................................................
   // PROPERTIES
-  // 
+  //
   /**
     Walk like a duck.
-    
+
     @property {Boolean}
   */
   hasSelectionSupport: YES,
 
   /**
     If YES, selection is allowed. Default is YES.
-    
+
     @property {Boolean}
   */
   allowsSelection: YES,
 
   /**
     If YES, multiple selection is allowed. Default is YES.
-    
+
     @property {Boolean}
   */
   allowsMultipleSelection: YES,
 
   /**
     If YES, allow empty selection Default is YES.
-    
+
     @property {Boolean}
   */
   allowsEmptySelection: YES,
 
   /**
-    Override to return the first selectable object.  For example, if you 
+    Override to return the first selectable object.  For example, if you
     have groups or want to otherwise limit the kinds of objects that can be
     selected.
-    
+
     the default imeplementation returns firstObject property.
-    
+
     @returns {Object} first selectable object
   */
   firstSelectableObject: function() {
@@ -77,7 +77,7 @@ SC.SelectionSupport = {
     This is the current selection.  You can make this selection and another
     controller's selection work in concert by binding them together. You
     generally have a master selection that relays changes TO all the others.
-    
+
     @property {SC.SelectionSet}
   */
   selection: function(key, value) {
@@ -91,10 +91,10 @@ SC.SelectionSupport = {
     // whenever we have to recompute selection, reapply all the conditions to
     // the selection.  This ensures that changing the conditions immediately
     // updates the selection.
-    // 
+    //
     // Note also if we don't allowSelection, we don't clear the old selection;
     // we just don't allow it to be changed.
-    if ((value === undefined) || !this.get('allowsSelection')) value = old;
+    if ((value === undefined) || !this.get('allowsSelection')) { value = old; }
 
     len = (value && value.isEnumerable) ? value.get('length') : 0;
 
@@ -110,13 +110,13 @@ SC.SelectionSupport = {
       }
     }
 
-    // if we don't allow empty selection, block that also.  select first 
+    // if we don't allow empty selection, block that also.  select first
     // selectable item if necessary.
     if ((len === 0) && !this.get('allowsEmptySelection')) {
       if (oldlen === 0) {
         value = this.get('firstSelectableObject');
-        if (value) value = SC.SelectionSet.create().addObject(value).freeze();
-        else value = SC.SelectionSet.EMPTY;
+        if (value) { value = SC.SelectionSet.create().addObject(value).freeze(); }
+        else { value = SC.SelectionSet.EMPTY; }
         len = value.get('length');
 
       } else {
@@ -126,7 +126,7 @@ SC.SelectionSupport = {
     }
 
     // if value is empty or is not enumerable, then use empty set
-    if (len === 0) value = SC.SelectionSet.EMPTY;
+    if (len === 0) { value = SC.SelectionSet.EMPTY; }
 
     // always use a frozen copy...
     value = value.frozenCopy();
@@ -138,7 +138,7 @@ SC.SelectionSupport = {
 
   /**
     YES if the receiver currently has a non-zero selection.
-    
+
     @property {Boolean}
   */
   hasSelection: function() {
@@ -148,11 +148,11 @@ SC.SelectionSupport = {
 
   // ..........................................................
   // METHODS
-  // 
+  //
   /**
     Selects the passed objects in your content.  If you set "extend" to YES,
     then this will attempt to extend your selection as well.
-  
+
     @param {SC.Enumerable} objects objects to select
     @param {Boolean} extend optionally set to YES to extend selection
     @returns {Object} receiver
@@ -161,13 +161,13 @@ SC.SelectionSupport = {
 
     // handle passing an empty array
     if (!objects || objects.get('length') === 0) {
-      if (!extend) this.set('selection', SC.SelectionSet.EMPTY);
+      if (!extend) { this.set('selection', SC.SelectionSet.EMPTY); }
       return this;
     }
 
     var sel = this.get('selection');
-    if (extend && sel) sel = sel.copy();
-    else sel = SC.SelectionSet.create();
+    if (extend && sel) { sel = sel.copy(); }
+    else { sel = SC.SelectionSet.create(); }
 
     sel.addObjects(objects).freeze();
     this.set('selection', sel);
@@ -175,32 +175,32 @@ SC.SelectionSupport = {
   },
 
   /**
-    Selects a single passed object in your content.  If you set "extend" to 
+    Selects a single passed object in your content.  If you set "extend" to
     YES then this will attempt to extend your selection as well.
-    
+
     @param {Object} object object to select
     @param {Boolean} extend optionally set to YES to extend selection
     @returns {Object} receiver
   */
   selectObject: function(object, extend) {
     if (object === null) {
-      if (!extend) this.set('selection', null);
+      if (!extend) { this.set('selection', null); }
       return this;
 
-    } else return this.selectObjects([object], extend);
+    } else { return this.selectObjects([object], extend); }
   },
 
   /**
     Deselects the passed objects in your content.
-    
+
     @param {SC.Enumerable} objects objects to select
     @returns {Object} receiver
   */
   deselectObjects: function(objects) {
 
-    if (!objects || objects.get('length') === 0) return this; // nothing to do
+    if (!objects || objects.get('length') === 0) { return this; } // nothing to do
     var sel = this.get('selection');
-    if (!sel || sel.get('length') === 0) return this; // nothing to do
+    if (!sel || sel.get('length') === 0) { return this; } // nothing to do
     // find index for each and remove it
     sel = sel.copy().removeObjects(objects).freeze();
     this.set('selection', sel.freeze());
@@ -209,19 +209,19 @@ SC.SelectionSupport = {
 
   /**
     Deselects the passed object in your content.
-    
+
     @param {SC.Object} object single object to select
     @returns {Object} receiver
   */
   deselectObject: function(object) {
-    if (!object) return this; // nothing to do
-    else return this.deselectObjects([object]);
+    if (!object) { return this; } // nothing to do
+    else { return this.deselectObjects([object]); }
   },
 
   /**
-    Call this method whenever your source content changes to ensure the 
+    Call this method whenever your source content changes to ensure the
     selection always remains up-to-date and valid.
-    
+
     @returns {Object}
   */
   updateSelectionAfterContentChange: function() {
@@ -231,14 +231,14 @@ SC.SelectionSupport = {
     var indexSet; // Selection index set for arranged objects
 
     // If we don't have any selection, there's nothing to update
-    if (!selectionSet) return this;
+    if (!selectionSet) { return this; }
     // Remove any selection set objects that are no longer in the content
     indexSet = selectionSet.indexSetForSource(arrangedObjects);
     if ((indexSet && (indexSet.get('length') !== selectionSet.get('length'))) || (!indexSet && (selectionSet.get('length') > 0))) { // then the selection content has changed
       selectionSet = selectionSet.copy().constrain(arrangedObjects).freeze();
       this.set('selection', selectionSet);
     }
-    
+
     // Reselect an object if required (if content length > 0)
     if ((selectionSet.get('length') === 0) && arrangedObjects && (arrangedObjects.get('length') > 0) && !allowsEmptySelection) {
       this.selectObject(this.get('firstSelectableObject'), NO);