sproutcore 1.7.1.beta → 1.8.0

data/lib/frameworks/sproutcore/frameworks/core_foundation/controllers/array.js

@@ -223,7 +223,7 @@ SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
   },
 
   /**
-    Removes the passed object from the array.  If the underyling content
+    Removes the passed object from the array.  If the underlying content
     is a single object, then this simply sets the content to null.  Otherwise
     it will call removeObject() on the content.
 
@@ -410,12 +410,12 @@ SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
   },
 
   _scac_arrayContentDidChange: function(start, removed, added) {
+    this._scac_cached = NO;
     this.arrayContentDidChange(start, removed, added);
     if (this._kvo_enumerable_property_chains) {
       var addedObjects = this.slice(start, start+added);
       this.setupEnumerablePropertyChains(addedObjects);
     }
-    this._scac_cached = NO;
     this.updateSelectionAfterContentChange();
   },
 
@@ -524,7 +524,7 @@ SC.ArrayController = SC.Controller.extend(SC.Array, SC.SelectionSupport,
   }.observes('orderBy'),
 
   /** @private
-    Whenver the content "status" property changes, relay out.
+    Whenever the content "status" property changes, relay out.
   */
   _scac_contentStatusDidChange: function() {
     this.notifyPropertyChange('status');

data/lib/frameworks/sproutcore/frameworks/core_foundation/ext/object.js

@@ -39,6 +39,48 @@ SC.mixin(SC.Object.prototype, /** @scope SC.Object.prototype */ {
     // schedule the timer
     return SC.Timer.schedule({ target: this, action: f, interval: interval });
   },
+  
+  /**
+    A convenience method which makes it easy to coalesce invocations to ensure 
+    that the method is only called once. This is useful if you need to schedule 
+    a call but only want it to trigger once after some defined interval has 
+    passed.
+    
+    @param {Function|String} method reference or method name
+    @param {Number} interval
+  */
+  invokeOnceLater: function(method, interval) {
+    if (interval === undefined) { interval = 1 ; }
+
+    var timers = this._sc_invokeOnceLaterTimers,
+        methodGuid, existingTimer, f, newTimer;
+
+    // ensure we always deal with real functions
+    if (SC.typeOf(method) === SC.T_STRING) {
+      method = this[method];
+    }
+    
+    methodGuid = SC.guidFor(method);
+    
+    if(!timers) {
+      this._sc_invokeOnceLaterTimers = timers = {};
+    }
+    
+    existingTimer = timers[methodGuid];
+    if(existingTimer) existingTimer.invalidate();
+    
+    f = function() {
+      // GC assistance for IE
+      delete timers[methodGuid];
+      return method.apply(this, arguments);
+    };
+    
+    // schedule the timer
+    newTimer = SC.Timer.schedule({ target: this, action: f, interval: interval });
+    timers[methodGuid] = newTimer;
+    
+    return newTimer;
+  },
 
   /**
     Lookup the named property path and then invoke the passed function,

data/lib/frameworks/sproutcore/frameworks/core_foundation/ext/run_loop.js

@@ -29,12 +29,12 @@ SC.RunLoop = SC.RunLoop.extend(
 
     Note that timers should fire only once per run loop to avoid the
     situation where a timer might cause an infinite loop by constantly
-    rescheduling itself everytime it is fired.
+    rescheduling itself every time it is fired.
   */
   endRunLoop: function() {
     this.fireExpiredTimers(); // fire them timers!
     var ret = sc_super(); // do everything else
-    this.scheduleNextTimeout(); // schedule a timout if timers remain
+    this.scheduleNextTimeout(); // schedule a timeout if timers remain
     return ret;
   },
 
@@ -161,3 +161,4 @@ SC.RunLoop = SC.RunLoop.extend(
 
 // Recreate the currentRunLoop with the new methods
 SC.RunLoop.currentRunLoop = SC.RunLoop.create();
+SC.RunLoop.runLoopClass = SC.RunLoop;

data/lib/frameworks/sproutcore/frameworks/core_foundation/ext/string.js

@@ -54,6 +54,13 @@ SC.supplement(String.prototype,
     var args = SC.$A(arguments);
     args.unshift(this);
     return SC.String.locWithDefault.apply(SC.String, args);
+  },
+  
+  /**
+    @see SC.String.mult
+  */
+  mult: function(value) {
+    return SC.String.mult(this, value);
   }
 
 });

data/lib/frameworks/sproutcore/frameworks/core_foundation/mixins/action_support.js

@@ -56,7 +56,7 @@ SC.ActionSupport =
   actionContext: null,
 
    /**
-     Perform the action. If an action paramter is not provided, then
+     Perform the action. If an action parameter is not provided, then
      the action defaults to the `action` property.
 
      @param {String} [action] The action to fire.

data/lib/frameworks/sproutcore/frameworks/core_foundation/mixins/delegate_support.js

@@ -99,12 +99,12 @@ SC.DelegateSupport = {
 
     while(idx<len) {
       ret = arguments[idx++];
-      if (ret && ret[key] !== undefined) {
+      if (ret && ret[key] != undefined) {
         return ret.get ? ret.get(key) : ret[key] ;
       }
     }
 
-    return (this[key] !== undefined) ? this.get(key) : undefined ;
+    return (this[key] != undefined) ? this.get(key) : undefined ;
   }
 
 };

data/lib/frameworks/sproutcore/frameworks/core_foundation/mixins/responder_context.js

@@ -183,7 +183,7 @@ SC.ResponderContext = {
   },
 
   _notifyWillLoseFirstResponder: function(responder, cur, root, evt) {
-    if (cur === root) return ; // nothing to do
+    if (!cur || cur === root) return ; // nothing to do
 
     cur.willLoseFirstResponder(responder, evt);
     cur.set('hasFirstResponder', NO);
@@ -193,7 +193,7 @@ SC.ResponderContext = {
   },
 
   _notifyDidBecomeFirstResponder: function(responder, cur, root) {
-    if (cur === root) return ; // nothing to do
+    if (!cur || cur === root) return ; // nothing to do
 
     var next = this.nextResponderFor(cur);
     if (next) this._notifyDidBecomeFirstResponder(responder, next, root);
@@ -220,7 +220,7 @@ SC.ResponderContext = {
 
     @param {String} action name of action
     @param {Object} sender object sending the action
-    @param {Object} context optional additonal context info
+    @param {Object} context optional additional context info
     @returns {SC.Responder} the responder that handled it or null
   */
   sendAction: function(action, sender, context) {

data/lib/frameworks/sproutcore/frameworks/core_foundation/mixins/selection_support.js

@@ -65,7 +65,7 @@ SC.SelectionSupport = {
     have groups or want to otherwise limit the kinds of objects that can be
     selected.
 
-    the default imeplementation returns firstObject property.
+    the default implementation returns firstObject property.
 
     @returns {Object} first selectable object
   */

data/lib/frameworks/sproutcore/frameworks/core_foundation/panes/body_overflow.js

@@ -0,0 +1,63 @@
+/**
+  SC.bodyOverflowArbitrator is a central object responsible for controlling the overflow on the body element.
+  
+  Use it from views that would otherwise set the body overflow style directly; call requestHidden to ask for
+  the body to have overflow:hidden, and call requestVisible to ask for the body to be visible.
+  
+  Call withdrawRequest to register that you no longer have any interest in the body overflow setting. Don't
+  forget to do this, or your object could be affecting the body overflow long after it's no longer relevant.
+  
+  When calling requestHidden, requestVisible, and withdrawRequest, pass your object as the first argument so
+  that its request can be associated with its GUID.
+  
+  When calling requestHidden or requestVisible, you may optionally pass true as a second argument to signify
+  that your desire for hidden or visible overflow is important. An important visible-request will override
+  any other, but an important hidden-request will override a normal visible-request. A normal visible-request
+  will in turn override a normal hidden-request.
+*/
+SC.bodyOverflowArbitrator = SC.Object.create(/**@scope SC.bodyOverflowArbitrator.prototype */{
+  /** Request that the body be given overflow:hidden;. Pass your object, then (optionally) true to confer importance. */
+  requestHidden: function(from,important) { this._makeRequest(from,-1-9*!!important); },
+
+  /** Request that the body be given overflow:visible;. Pass your object, then (optionally) true to confer importance. */
+  requestVisible: function(from,important) { this._makeRequest(from,1+9*!!important); },
+  
+  /** State that your object no longer cares about the body overflow. */
+  withdrawRequest: function(from) {
+    if(!from) return;
+    var guid = SC.guidFor(from);
+    if(this._requests[guid]) delete this._requests[guid];
+    this.setOverflow();
+  },
+  
+  /** Perform the action of setting the overflow depending on what requests are currently registered. Does nothing if there are no requests. */
+  setOverflow: function() {
+    var overflow = this._decideOverflow();
+    if(overflow!==undefined) document.body.style.overflow = overflow ? "auto" : "hidden";
+    // console.log("Body Overflow Arbitrator now decides "+(overflow===undefined?"that overflow is unimportant.":"to use overflow:"+(overflow===true?'visible':"hidden")+";")+" Requests are:",this._requests);
+  },
+  
+  _makeRequest: function(from,value) {
+    if(!from) return;
+    var guid = SC.guidFor(from);
+    this._requests[guid] = value;
+    this.setOverflow();
+  },
+  
+  _requests: {},
+  _decideOverflow: function() {
+    var haveHidden, haveVisible, haveImportantHidden, haveImportantVisible,
+        reqs = this._requests, req;
+    for(var i in reqs) {
+      if((req=reqs[i])<0) haveHidden=YES;
+      if(req<-1) haveImportantHidden=YES;
+      if(req>0) haveVisible=YES;
+      if(req>1) haveImportantVisible=YES;
+    }
+    if(haveImportantVisible) return YES;              //important-visible takes all.
+    if(haveVisible && haveImportantHidden) return NO; //important-hidden beats regular-visible.
+    if(haveVisible) return YES;                       //regular-visible beats regular-hidden
+    if(haveHidden) return NO;                         //if there is a hidden, it can win now.
+    return undefined;                                 //if nobody cared, return undefined to prevent work.
+  }
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/panes/keyboard.js

@@ -41,7 +41,7 @@ SC.Pane.reopen(
     var nextValidKeyView;
 
     // Handle tab key presses if we don't have a first responder already
-    if ((evt.which === 9 || (SC.browser.mozilla && evt.keyCode ===9)) && !this.get('firstResponder')) {
+    if (evt.keyCode === 9 && !this.get('firstResponder')) {
       // Cycle forwards by default, backwards if the shift key is held
       if (evt.shiftKey) {
         nextValidKeyView = this.get('previousValidKeyView');

data/lib/frameworks/sproutcore/frameworks/core_foundation/panes/layout.js

@@ -5,7 +5,6 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 sc_require("panes/pane");
-
 SC.Pane.reopen(
   /** @scope SC.Pane.prototype */ {
 
@@ -37,7 +36,9 @@ SC.Pane.reopen(
       wDim.height = document.body.clientHeight;
 
       // IE7 is the only browser which reports clientHeight _including_ scrollbar.
-      if (SC.browser.isIE && SC.browser.compareVersion("7.0") === 0) {
+      if (SC.browser.name === SC.BROWSER.ie &&
+          SC.browser.compareVersion(SC.browser.version, "7") === 0) {
+
         var scrollbarSize = SC.platform.get('scrollbarSize');
         if (document.body.scrollWidth > wDim.width) {
           wDim.width -= scrollbarSize;
@@ -79,13 +80,47 @@ SC.Pane.reopen(
   */
   windowSizeDidChange: function(oldSize, newSize) {
     this.set('currentWindowSize', newSize) ;
+    this.setBodyOverflowIfNeeded();
     this.parentViewDidResize(); // start notifications.
     return this ;
   },
 
+  /**
+    Changes the body overflow according to whether minWidth or minHeight
+    are present in the layout hash. If there are no minimums, nothing
+    is done unless true is passed as the first argument. If so, then
+    overflow:hidden; will be used.
+
+    It's possible to call this manually and pass YES to remove overflow
+    if setting layout to a hash without minWidth and minHeight, but it's
+    probably not a good idea to do so unless you're doing it from the main
+    pane. There's only one body tag, after all, and if this is called from
+    multiple different panes, the panes could fight over whether it gets
+    an overflow if care isn't taken!
+
+    @param {Boolean} [force] force a style to be set even if there are
+                             no minimums.
+  */
+  setBodyOverflowIfNeeded: function(force) {
+    //Code to get rid of Lion rubberbanding.
+    var layout = this.get('layout'),
+        size = this.get('currentWindowSize');
+    if(!layout || !size || !size.width || !size.height) return;
+    var minW = layout.minWidth,
+        minH = layout.minHeight;
+    if(force===true || minW || minH) {
+      if( (minH && size.height<minH) || (minW && size.width<minW) ) {
+        SC.bodyOverflowArbitrator.requestVisible(this);
+      } else {
+        SC.bodyOverflowArbitrator.requestHidden(this);
+      }
+    }
+  },
+
   /** @private */
   paneLayoutDidChange: function() {
     this.invokeOnce(this.updateLayout);
+    this.setBodyOverflowIfNeeded();
   }.observes('layout'),
 
   recomputeDependentProperties: function(original) {

data/lib/frameworks/sproutcore/frameworks/core_foundation/panes/main.js

@@ -6,6 +6,10 @@
 // ==========================================================================
 
 sc_require('panes/pane');
+sc_require('panes/keyboard');
+sc_require('panes/layout');
+sc_require('panes/manipulation');
+sc_require('panes/visibility');
 
 /** @class
 
@@ -30,10 +34,31 @@ SC.MainPane = SC.Pane.extend({
   /** @private */
   layout: { top: 0, left: 0, bottom: 0, right: 0, minHeight:200, minWidth:200 },
   
+  init:function(){
+    var wDim = {x: 0, y: 0, width: 1000, height: 1000},
+        layout = this.get('layout'), isOverflowing = false;
+    
+    //Initial computation to get ride of Lion rubberbanding.
+    if (document && document.body) {
+      wDim.width = document.body.clientWidth;
+      wDim.height = document.body.clientHeight;
+      
+      if( layout.minHeight || layout.minWidth ) {
+        if( (layout.minHeight && wDim.height<layout.minHeight) || (layout.minWidth && wDim.width<layout.minWidth) ) {
+          SC.bodyOverflowArbitrator.requestVisible(this);
+        } else {
+          // to avoid Lion rubberbanding
+          SC.bodyOverflowArbitrator.requestHidden(this);
+        }
+      }
+    }
+    sc_super();
+  },
+  
   /** @private - extends SC.Pane's method */
   paneDidAttach: function() {
-    var ret = sc_super();
-    var responder = this.rootResponder;
+    var ret = sc_super(),
+        responder = this.rootResponder;
     responder.makeMainPane(this);
     if (!responder.get('keyRootView')) responder.makeKeyPane(this);
     return ret ;
@@ -43,8 +68,5 @@ SC.MainPane = SC.Pane.extend({
   acceptsKeyPane: YES,
 
   /** @private */
-  classNames: ['sc-main'],
-  
-  ariaRole: 'application'
-  
+  classNames: ['sc-main']
 });

data/lib/frameworks/sproutcore/frameworks/core_foundation/panes/pane.js

@@ -6,8 +6,18 @@
 // ==========================================================================
 
 sc_require('views/view');
+sc_require('views/view/acceleration');
+sc_require('views/view/cursor');
+sc_require('views/view/enabled');
+sc_require('views/view/keyboard');
+sc_require('views/view/layout');
+sc_require('views/view/manipulation');
+sc_require('views/view/theming');
+sc_require('views/view/touch');
+sc_require('views/view/visibility');
 sc_require('mixins/responder_context');
 
+
 /**
   Indicates a value has a mixed state of both on and off.
 
@@ -439,9 +449,6 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
     if (dom && dom.parentNode) dom.parentNode.removeChild(dom) ;
     dom = null ;
 
-    // layer is cached by SC.View in this._view_layer, remove it so that the DOM node can be freed
-    this.destroyLayer();
-
     // remove intercept
     this._removeIntercept();
 

data/lib/frameworks/sproutcore/frameworks/core_foundation/protocols/sparse_array_delegate.js

@@ -13,7 +13,7 @@
   array content as needed.
 
   Your object does not need to implement all of these methods, but it should
-  at least implment the sparseArrayDidRequestIndex() method.
+  at least implement the sparseArrayDidRequestIndex() method.
 
   @since SproutCore 1.0
 */
@@ -43,7 +43,7 @@ SC.SparseArrayDelegate = {
   /**
     Invoked when an object requests an index on the sparse array that has not
     yet been set.  You should implement this method to set the object at the
-    index using provideObjectsAtIndex() or provideObjectsInRange() on the
+    index using provideObjectAtIndex() or provideObjectsInRange() on the
     sparse array.  You can call these methods immediately during this handler
     or you can wait and call them at a later time once you have loaded any
     data.

data/lib/frameworks/sproutcore/frameworks/core_foundation/system/browser.js

@@ -5,16 +5,81 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
+
 SC.mixin(SC.browser,
 /** @scope SC.browser */ {
 
   /**
+    Version Strings should not be compared against Numbers.  For example,
+    the version "1.20" is greater than "1.2" and less than "1.200", but as
+    Numbers, they are all 1.2.
+
+    Pass in one of the browser versions: SC.browser.version,
+    SC.browser.engineVersion or SC.browser.osVersion and a String to compare
+    against.  The function will split each version on the decimals and compare
+    the parts numerically.
+
+    Examples:
+
+      SC.browser.compare('1.20', '1.2') == 18
+      SC.browser.compare('1.08', '1.8') == 0
+      SC.browser.compare('1.1.1', '1.1.004') == -3
+
+    @param version {String} One of SC.browser.version, SC.browser.engineVersion or SC.browser.osVersion
+    @param other {String} The version to compare against.
+    @return {Number} The difference between the versions at the first difference.
+  */
+  compare: function(version, other) {
+    var coerce,
+        parts,
+        tests;
+
+    // Ensure that the versions are Strings.
+    if (typeof version === 'number' || typeof other === 'number') {
+      SC.warn('SC.browser.compare(): Versions compared against Numbers may not provide accurate results.  Use a String of decimal separated Numbers instead.')
+      version = String(version);
+      other = String(other);
+    }
+
+    // This function transforms the String to a Number or NaN
+    coerce = function (part) {
+      return Number(part.match(/^[0-9]+/));
+    };
+
+    parts = SC.A(version.split('.')).map(coerce);
+    tests = SC.A(other.split('.')).map(coerce);
+
+    // Test each part stopping when there is a difference.
+    for (var i = 0; i < tests.length; i++) {
+      var check = parts[i] - tests[i];
+      if (isNaN(check)) return 0;
+      if (check !== 0) return check;
+    }
+
+    return 0;
+  },
+
+  /** @deprecated Since 1.7. Use SC.browser.compare(version, otherVersion) instead.
+
     Pass any number of arguments, and this will check them against the browser
     version split on ".".  If any of them are not equal, return the inequality.
     If as many arguments as were passed in are equal, return 0.  If something
     is NaN, return 0.
   */
+
+  // Deprecation Note:
+  //
+  // This function forces the comparison against the value of
+  // SC.browser.version, but the old value of SC.browser.version would
+  // occasionally be the browser's version or the layout engine's version,
+  // which could cause unexpected results.  As well, there was no way to
+  // compare the actual browser version or OS version.
   compareVersion: function () {
+    SC.warn('SC.browser.compareVersion() has been deprecated.  Please ' +
+        'use SC.browser.compare() instead.  Example: ' +
+        'SC.browser.compareVersion(16,0,912) < 0 becomes ' +
+        'SC.browser.compare(SC.browser.engineVersion, \'16.0.912\').');
+
     if (this._versionSplit === undefined) {
       var coerce = function (part) {
         return Number(part.match(/^[0-9]+/));
@@ -28,9 +93,8 @@ SC.mixin(SC.browser,
       if (isNaN(check)) return 0;
       if (check !== 0) return check;
     }
-    
+
     return 0;
   }
 
 });
-