sproutcore 1.9.2 → 1.10.0.rc.1

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

@@ -0,0 +1,50 @@
+sc_require("panes/pane");
+
+/**
+  Adds SC.Pane specific processes.
+
+  While it would be a little nicer to use didAppendToDocument,
+  willRemoveFromDocument and other functions, we cannot because they are public
+  callbacks and if a developer overrides them without knowing to call sc_super()
+  everything will fail.  Instead, it's better to keep our static setup/remove
+  code private.
+  */
+SC.Pane.reopen({
+
+  /** @private */
+  _notifyAttached: function () {
+    // hook into root responder
+    var responder = (this.rootResponder = SC.RootResponder.responder);
+    responder.panes.add(this);
+
+    // Legacy.
+    this.set('isPaneAttached', YES);
+    this.paneDidAttach();
+
+    // Legacy?
+    this.recomputeDependentProperties();
+    this.set('currentWindowSize', responder.currentWindowSize);
+
+    // handle intercept if needed
+    this._addIntercept();
+
+    sc_super();
+  },
+
+  /** @private */
+  _notifyDetached: function () {
+    sc_super();
+
+    // Legacy.
+    this.set('isPaneAttached', NO);
+
+    // remove intercept
+    this._removeIntercept();
+
+    // remove the pane
+    var rootResponder = this.rootResponder;
+    rootResponder.panes.remove(this);
+    this.rootResponder = null;
+  }
+
+});

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

@@ -9,9 +9,9 @@ sc_require("panes/pane");
 SC.Pane.reopen(
   /** @scope SC.Pane.prototype */ {
 
-  recomputeDependentProperties: function(original) {
-    this.recomputeIsVisibleInWindow();
-    original();
-  }.enhance()
+  // recomputeDependentProperties: function(original) {
+  //   this.recomputeIsVisibleInWindow();
+  //   original();
+  // }.enhance()
 
 });

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

@@ -0,0 +1,48 @@
+// ==========================================================================
+// Project:   SproutCore
+// Copyright: @2013 7x7 Software, Inc.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+
+/** @namespace
+  This protocol defines the allowable transition plugin methods.
+
+  SC.View uses transition plugins to setup, execute and cleanup the
+  swapping between views and expects the given transition plugin object
+  to implement the methods in this protocol.
+*/
+SC.ViewTransitionProtocol = {
+
+  /**
+    This optional method is called to set up the entrance transition (i.e.
+    transitionIn or transitionShow).
+
+    Use this method to adjust the layout of the view so that it may be properly
+    animated.  For example, you may need to adjust the content from a flexible
+    layout (i.e. { left: 0, top: 0, right: 0, bottom: 0 }) to a fixed layout
+    (i.e. { left: 0, top: 0, width: 100, height: 200 }) so that it can be
+    moved.
+
+    @param {SC.View} view The view being transitioned.
+    @param {Object} options Options to modify the transition.  As set by transitionShowOptions or transitionInOptions.
+    @param {Boolean} inPlace Whether the transition should start with the current layout of the view, because a previous transition was cancelled in place.
+  */
+  setup: function (view, options, inPlace) {},
+
+  /**
+    This method is called to transition the view in or visible (i.e.
+    transitionIn or transitionShow).
+
+    When the transition completes, this function *must* call `didTransitionIn()`
+    on the view, passing this object and the original options as
+    arguments.
+
+    @param {SC.View} view The view being transitioned.
+    @param {Object} options Options to modify the transition.  As set by transitionShowOptions or transitionInOptions.
+    @param {Object} finalLayout The final layout of the view, which may be different than the starting layout of the view if a previous transition was cancelled in place.
+    @param {Object} finalFrame The final frame of the view, which may be different than the starting frame of the view if a previous transition was cancelled in place.
+  */
+  run: function (view, options, finalLayout, finalFrame) {}
+
+};

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

@@ -9,6 +9,22 @@
 SC.mixin(SC.browser,
 /** @scope SC.browser */ {
 
+  /** @private */
+  _testSupportFor: function (target, propertyName, testValue) {
+    /*jshint eqnull:true*/
+    var ret = target[propertyName] != null,
+      originalValue;
+
+    if (testValue != null) {
+      originalValue = target[propertyName];
+      target[propertyName] = testValue;
+      ret = target[propertyName] === testValue;
+      target[propertyName] = originalValue;
+    }
+
+    return ret;
+  },
+
   /**
     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
@@ -25,18 +41,20 @@ SC.mixin(SC.browser,
       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.
+    @param {String} version One of SC.browser.version, SC.browser.engineVersion or SC.browser.osVersion
+    @param {String} other The version to compare against.
+    @returns {Number} The difference between the versions at the first difference.
   */
-  compare: function(version, other) {
+  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.')
+      //@if(debug)
+      SC.warn('Developer Warning: SC.browser.compare(): Versions compared against Numbers may not provide accurate results.  Use a String of decimal separated Numbers instead.');
+      //@endif
       version = String(version);
       other = String(other);
     }
@@ -59,7 +77,8 @@ SC.mixin(SC.browser,
     return 0;
   },
 
-  /** @deprecated Since 1.7. Use SC.browser.compare(version, otherVersion) instead.
+  /**
+    @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.
@@ -75,10 +94,12 @@ SC.mixin(SC.browser,
   // 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 ' +
+    //@if(debug)
+    SC.warn('Developer Warning: 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\').');
+    //@endif
 
     if (this._versionSplit === undefined) {
       var coerce = function (part) {
@@ -95,6 +116,203 @@ SC.mixin(SC.browser,
     }
 
     return 0;
+  },
+
+
+  /**
+    This simple method allows you to more safely use experimental properties and
+    methods in current and future browsers.
+
+    Using browser specific methods and properties is a risky coding practice.
+    With sufficient testing, you may be able to match prefixes to today's
+    browsers, but this is prone to error and not future proof.  For instance,
+    if a property becomes standard and the browser drops the prefix, your code
+    could suddenly stop working.
+
+    Instead, use SC.browser.experimentalNameFor(target, standardName), which
+    will check the existence of the standard name on the target and if not found
+    will try different camel-cased versions of the name with the current
+    browser's prefix appended.
+
+    If it is still not found, SC.UNSUPPORTED will be returned, allowing
+    you a chance to recover from the lack of browser support.
+
+    Note that `experimentalNameFor` is not really meant for determining browser
+    support, only to ensure that using browser prefixed properties and methods
+    is safe.  Instead, SC.platform provides several properties that can be used
+    to determine support for a certain platform feature, which should be
+    used before calling `experimentalNameFor` to safely use the feature.
+
+    For example,
+
+        // Checks for IndexedDB support first on the current platform.
+        if (SC.platform.supportsIndexedDB) {
+          var db = window.indexedDB,
+            // Example return values: 'getDatabaseNames', 'webkitGetDatabaseNames', 'MozGetDatabaseNames', SC.UNSUPPORTED.
+            getNamesMethod = SC.browser.experimentalNameFor(db, 'getDatabaseNames'),
+            names;
+
+            if (getNamesMethod === SC.UNSUPPORTED) {
+              // Work without it.
+            } else {
+              names = db[getNamesMethod](...);
+            }
+        } else {
+          // Work without it.
+        }
+
+    ## Improving deduction
+    Occasionally a target will appear to support a property, but will fail to
+    actually accept a value.  In order to ensure that the property doesn't just
+    exist but is also usable, you can provide an optional `testValue` that will
+    be temporarily assigned to the target to verify that the detected property
+    is usable.
+
+    @param {Object} target The target for the method.
+    @param {String} standardName The standard name of the property or method we wish to check on the target.
+    @param {String} [testValue] A value to temporarily assign to the property.
+    @returns {string} The name of the property or method on the target or SC.UNSUPPORTED if no method found.
+  */
+  experimentalNameFor: function (target, standardName, testValue) {
+    var cachedNames = this._cachedNames,
+      targetGuid = SC.guidFor(target);
+
+    // Fast path & cache initialization.
+    if (!cachedNames) {
+      cachedNames = this._cachedNames = {};
+      cachedNames[targetGuid] = {};
+    } else if (!cachedNames[targetGuid]) {
+      cachedNames[targetGuid] = {};
+    } else if (cachedNames[targetGuid][standardName]) {
+      return cachedNames[targetGuid][standardName];
+    }
+
+    // Test the property name.
+    var ret = standardName;
+
+    // ex. window.indexedDB.getDatabaseNames
+    if (!this._testSupportFor(target, ret, testValue)) {
+      // ex. window.WebKitCSSMatrix
+      ret = SC.browser.classPrefix + standardName.capitalize();
+      if (!this._testSupportFor(target, ret, testValue)) {
+        // No need to check if the prefix is the same for properties and classes
+        if (SC.browser.domPrefix === SC.browser.classPrefix) {
+          // Always show a warning so that production usage information has a
+          // better chance of filtering back to the developer(s).
+          SC.warn("SC.browser.experimentalNameFor(): target, %@, does not have property `%@` or `%@`.".fmt(target, standardName, ret));
+          ret = SC.UNSUPPORTED;
+        } else {
+          // ex. window.indexedDB.webkitGetDatabaseNames
+          ret = SC.browser.domPrefix + standardName.capitalize();
+          if (!this._testSupportFor(target, ret, testValue)) {
+            // Always show a warning so that production usage information has a
+            // better chance of filtering back to the developer(s).
+            SC.warn("SC.browser.experimentalNameFor(): target, %@, does not have property `%@`, '%@' or `%@`.".fmt(target, standardName, SC.browser.classPrefix + standardName.capitalize(), ret));
+            ret = SC.UNSUPPORTED;
+          }
+        }
+      }
+    }
+
+    // Cache the experimental property name (even SC.UNSUPPORTED) for quick repeat access.
+    cachedNames[targetGuid][standardName] = ret;
+
+    return ret;
+  },
+
+  /**
+    This method returns safe style names for current and future browsers.
+
+    Using browser specific style prefixes is a risky coding practice.  With
+    sufficient testing, you may be able to match styles across today's most
+    popular browsers, but this is a lot of work and not future proof.  For
+    instance, if a browser drops the prefix and supports the standard style
+    name, your code will suddenly stop working.  This happens ALL the time!
+
+    Instead, use SC.browser.experimentalStyleNameFor(standardStyleName), which
+    will test support for the standard style name and if not found will try the
+    prefixed version with the current browser's prefix appended.
+
+    Note: the proper style name is only determined once per standard style
+    name tested and then cached.  Therefore, calling experimentalStyleNameFor
+    repeatedly has no performance detriment.
+
+    For example,
+
+        var boxShadowName = SC.browser.experimentalStyleNameFor('boxShadow'),
+          el = document.createElement('div');
+
+        // `boxShadowName` may be "boxShadow", "WebkitBoxShadow", "msBoxShadow", etc. depending on the browser support.
+        el.style[boxShadowName] = "rgb(0,0,0) 0px 3px 5px";
+
+    ## Improving deduction
+    Occasionally a browser will appear to support a style, but will fail to
+    actually accept a value.  In order to ensure that the style doesn't just
+    exist but is also usable, you can provide an optional `testValue` that will
+    be used to verify that the detected style is usable.
+
+    @param {string} standardStyleName The standard name of the experimental style as it should be un-prefixed.  This is the DOM property name, which is camel-cased (ex. boxShadow)
+    @param {String} [testValue] A value to temporarily assign to the style to ensure support.
+    @returns {string} Future-proof style name for use in the current browser or SC.UNSUPPORTED if no style support found.
+  */
+  experimentalStyleNameFor: function (standardStyleName, testValue) {
+    // Test the style name.
+    var el = this._testEl;
+
+    // Create a test element and cache it for repeated use.
+    if (!el) { el = this._testEl = document.createElement("div"); }
+
+    return this.experimentalNameFor(el.style, standardStyleName, testValue);
+  },
+
+  /**
+    This method returns safe CSS attribute names for current and future browsers.
+
+    Using browser specific CSS prefixes is a risky coding practice.  With
+    sufficient testing, you may be able to match attributes across today's most
+    popular browsers, but this is a lot of work and not future proof.  For
+    instance, if a browser drops the prefix and supports the standard CSS
+    name, your code will suddenly stop working.  This happens ALL the time!
+
+    Instead, use SC.browser.experimentalCSSNameFor(standardCSSName), which
+    will test support for the standard CSS name and if not found will try the
+    prefixed version with the current browser's prefix appended.
+
+    Note: the proper CSS name is only determined once per standard CSS
+    name tested and then cached.  Therefore, calling experimentalCSSNameFor
+    repeatedly has no performance detriment.
+
+    For example,
+
+        var boxShadowCSS = SC.browser.experimentalCSSNameFor('box-shadow'),
+          el = document.createElement('div');
+
+        // `boxShadowCSS` may be "box-shadow", "-webkit-box-shadow", "-ms-box-shadow", etc. depending on the current browser.
+        el.style.cssText = boxShadowCSS + " rgb(0,0,0) 0px 3px 5px";
+
+    ## Improving deduction
+    Occasionally a browser will appear to support a style, but will fail to
+    actually accept a value.  In order to ensure that the style doesn't just
+    exist but is also usable, you can provide an optional `testValue` that will
+    be used to verify that the detected style is usable.
+
+    @param {string} standardCSSName The standard name of the experimental CSS attribute as it should be un-prefixed (ex. box-shadow).
+    @param {String} [testValue] A value to temporarily assign to the style to ensure support.
+    @returns {string} Future-proof CSS name for use in the current browser or SC.UNSUPPORTED if no style support found.
+  */
+  experimentalCSSNameFor: function (standardCSSName, testValue) {
+    var ret = standardCSSName,
+      standardStyleName = standardCSSName.camelize(),
+      styleName = this.experimentalStyleNameFor(standardStyleName, testValue);
+
+    if (styleName === SC.UNSUPPORTED) {
+      ret = SC.UNSUPPORTED;
+    } else if (styleName !== standardStyleName) {
+      // If the DOM property is prefixed, then the CSS name should be prefixed.
+      ret = SC.browser.cssPrefix + standardCSSName;
+    }
+
+    return ret;
   }
 
 });

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

@@ -4,34 +4,39 @@
 //            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-
-sc_require('system/builder') ;
+/*global jQuery*/
+sc_require('system/builder');
 
 // Alias jQuery as SC.$ and SC.CoreQuery for compatibility
-SC.$ = SC.CoreQuery = jQuery ;
+SC.$ = SC.CoreQuery = jQuery;
 
 // Add some plugins to SC.$. jQuery will get these also. -- test in system/core_query/additions
-SC.mixin(SC.$.fn, /** @scope SC.$.prototype */ {
+SC.mixin(SC.$.fn,
+  /** @scope SC.$.prototype */ {
 
   isCoreQuery: YES, // walk like a duck
 
   /** @private - better loggin */
-  toString: function() {
+  toString: function () {
     var values = [],
-        len = this.length, idx=0;
-    for(idx=0;idx<len;idx++) {
+      len = this.length,
+      idx = 0;
+
+    for (idx = 0; idx < len; idx++) {
       values[idx] = '%@: %@'.fmt(idx, this[idx] ? this[idx].toString() : '(null)');
     }
-    return "<$:%@>(%@)".fmt(SC.guidFor(this),values.join(' , '));
+    return "<$:%@>(%@)".fmt(SC.guidFor(this), values.join(' , '));
   },
 
   /**
     Returns YES if all member elements are visible.  This is provided as a
     common test since CoreQuery does not support filtering by
     psuedo-selector.
+
+    @deprecated Version 1.10
   */
-  isVisible: function() {
-    return Array.prototype.every.call(this, function(elem){
+  isVisible: function () {
+    return Array.prototype.every.call(this, function (elem) {
       return SC.$.isVisible(elem);
     });
   },
@@ -43,23 +48,29 @@ SC.mixin(SC.$.fn, /** @scope SC.$.prototype */ {
 
     @returns {Array} array of views or null.
   */
-  view: function() {
-    return this.map(function() {
-      var ret=null, guidKey = SC.viewKey, dom = this, value;
-      while(!ret && dom && (dom !== document)) {
-        if (dom.nodeType===1 && (value = dom.getAttribute('id'))) { ret = SC.View.views[value] ; }
+  view: function () {
+    return this.map(function () {
+      var ret = null,
+        dom = this,
+        value;
+
+      while (!ret && dom && (dom !== document)) {
+        if (dom.nodeType === 1 && (value = dom.getAttribute('id'))) {
+          ret = SC.View.views[value];
+        }
         dom = dom.parentNode;
       }
       dom = null;
-      return ret ;
+
+      return ret;
     });
   },
 
   /**
     Returns YES if any of the matched elements have the passed element or CQ object as a child element.
   */
-  within: function(el) {
-    if( this.filter(el).length ) { return true; }
+  within: function (el) {
+    if (this.filter(el).length) { return true; }
     return !!this.has(el).length;
   }
 
@@ -73,28 +84,28 @@ SC.mixin(SC.$.fn, /** @scope SC.$.prototype */ {
   CoreQuery object inherits this automatically.  jQuery does not extend from
   SC.Builder though, so we reapply SC.Enumerable just to be safe.
 */
-(function() {
+(function () {
   var original = {},
       wrappers = {
 
     // if you call find with a selector, then use the jQuery way.  If you
     // call with a function/target, use Enumerable way
-    find: function(callback,target) {
-      return (target !== undefined) ? SC.Enumerable.find.call(this, callback, target) : original.find.call(this, callback) ;
+    find: function (callback, target) {
+      return (target !== undefined) ? SC.Enumerable.find.call(this, callback, target) : original.find.call(this, callback);
     },
 
     // ditto for filter - execute SC.Enumerable style if a target is passed.
-    filter: function(callback,target) {
+    filter: function (callback, target) {
       return (target !== undefined) ?
         this.pushStack(SC.Enumerable.filter.call(this, callback, target)) :
-        original.filter.call(this, callback) ;
+        original.filter.call(this, callback);
     },
 
     // filterProperty is an SC.Enumerable thing, but it needs to be wrapped
     // in a CoreQuery object.
-    filterProperty: function(key, value) {
+    filterProperty: function (key, value) {
       return this.pushStack(
-        SC.Enumerable.filterProperty.call(this,key,value));
+        SC.Enumerable.filterProperty.call(this, key, value));
     },
 
     // indexOf() is best implemented using the jQuery index()
@@ -103,7 +114,7 @@ SC.mixin(SC.$.fn, /** @scope SC.$.prototype */ {
     // map() is a little tricky because jQuery is non-standard.  If you pass
     // a context object, we will treat it like SC.Enumerable.  Otherwise use
     // jQuery.
-    map: function(callback, target) {
+    map: function (callback, target) {
       return (target !== undefined) ?
         SC.Enumerable.map.call(this, callback, target) :
         original.map.call(this, callback);
@@ -112,15 +123,18 @@ SC.mixin(SC.$.fn, /** @scope SC.$.prototype */ {
 
   // loop through an update some enumerable methods.
   var fn = SC.$.fn,
-      enumerable = SC.Enumerable ,
-      value;
+    enumerable = SC.Enumerable,
+    value;
 
-  for(var key in enumerable) {
+  for (var key in enumerable) {
     if (enumerable.hasOwnProperty(key)) {
       value = enumerable[key];
+
       if (key in wrappers) {
-        original[key] = fn[key]; value = wrappers[key];
+        original[key] = fn[key];
+        value = wrappers[key];
       }
+
       fn[key] = value;
     }
   }
@@ -130,12 +144,18 @@ SC.mixin(SC.$.fn, /** @scope SC.$.prototype */ {
 SC.mixin(SC.$, {
 
   /** @private helper method to determine if an element is visible.  Exposed
-   for use in testing. */
-  isVisible: function(elem) {
+   for use in testing.
+
+    @deprecated Version 1.10
+  */
+  isVisible: function (elem) {
+    //@if(debug)
+    SC.warn("Developer Warning: The isVisible() helper has been deprecated and will be removed in the future.");
+    //@endif
     var CQ = SC.$;
-    return ("hidden"!=elem.type) && (CQ.css(elem,"display")!="none") && (CQ.css(elem,"visibility")!="hidden");
+    return ("hidden" != elem.type) && (CQ.css(elem, "display") != "none") && (CQ.css(elem, "visibility") != "hidden");
   }
 
-}) ;
+});