sproutcore 1.10.3.1 → 1.11.0.rc1

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

@@ -47,23 +47,15 @@ SC.mixin(SC.$.fn,
     it finds an element managed by a view.
 
     @returns {Array} array of views or null.
+    @deprecated Version 1.10
   */
   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;
+    //@if(debug)
+    // Deprecation warning.
+    SC.warn("Developer Warning: SC.$.view() has been deprecated and will be removed in the future. Please use SC.viewFor(element) instead.");
+    //@endif
 
-      return ret;
-    });
+    return SC.viewFor(this[0]);
   },
 
   /**

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

@@ -40,14 +40,13 @@ SC.NO_ORIENTATION = 'desktop'; // value 'desktop' for backwards compatibility
 SC.device = SC.Object.create({
 
   /**
-    Sets the orientation for touch devices, either SC.LANDSCAPE_ORIENTATION
-    or SC.PORTRAIT_ORIENTATION. Will be SC.NO_ORIENTATION in the case of
-    non-touch devices that are also not simulating touch events.
+    Sets the orientation for devices, either SC.LANDSCAPE_ORIENTATION
+    or SC.PORTRAIT_ORIENTATION.
 
     @type String
-    @default SC.NO_ORIENTATION
+    @default SC.PORTRAIT_ORIENTATION
   */
-  orientation: SC.NO_ORIENTATION,
+  orientation: SC.PORTRAIT_ORIENTATION,
 
   /**
     Indicates whether the device is currently online or offline. For browsers
@@ -127,30 +126,12 @@ SC.device = SC.Object.create({
   */
   windowSizeDidChange: function(newSize) {
     if (SC.platform.windowSizeDeterminesOrientation) {
-      if (!SC.browser.iOS) {
-        // in any browser other than iOS, use height vs. width test
-        SC.run(function() {
-          if (SC.platform.touch) {
-            if (newSize.height >= newSize.width) {
-              SC.device.set('orientation', SC.PORTRAIT_ORIENTATION);
-            } else {
-              SC.device.set('orientation', SC.LANDSCAPE_ORIENTATION);
-            }
-          } else {
-            SC.device.set('orientation', SC.NO_ORIENTATION);
-          }
-        });
+      if (newSize.height >= newSize.width) {
+        SC.device.set('orientation', SC.PORTRAIT_ORIENTATION);
       } else {
-        // in mobile safari, because some of its chrome can make the
-        // above match landscape falsely, we compare to screen.width
-        SC.run(function() {
-          if (newSize.width === window.screen.width) {
-            SC.device.set('orientation', SC.PORTRAIT_ORIENTATION);
-          } else {
-            SC.device.set('orientation', SC.LANDSCAPE_ORIENTATION);
-          }
-        });
+        SC.device.set('orientation', SC.LANDSCAPE_ORIENTATION);
       }
+
       return YES;
     }
     return NO;
@@ -169,20 +150,21 @@ SC.device = SC.Object.create({
     });
   },
 
-  orientationObserver: function(){
+  /** @private */
+  orientationObserver: function () {
     var body = SC.$(document.body),
         orientation = this.get('orientation');
 
     if (orientation === SC.PORTRAIT_ORIENTATION) {
-      body.addClass('portrait');
+      body.addClass('sc-portrait');
     } else {
-      body.removeClass('portrait');
+      body.removeClass('sc-portrait');
     }
 
     if (orientation === SC.LANDSCAPE_ORIENTATION) {
-      body.addClass('landscape');
+      body.addClass('sc-landscape');
     } else {
-      body.removeClass('landscape');
+      body.removeClass('sc-landscape');
     }
   }.observes('orientation'),
 
@@ -192,11 +174,15 @@ SC.device = SC.Object.create({
   //
 
   online: function(evt) {
-    this.set('isOffline', NO);
+    SC.run(function () {
+      this.set('isOffline', NO);
+    }, this);
   },
 
   offline: function(evt) {
-    this.set('isOffline', YES);
+    SC.run(function () {
+      this.set('isOffline', YES);
+    }, this);
   }
 
 });
@@ -206,5 +192,5 @@ SC.device = SC.Object.create({
   an instance and sets up event listeners as needed.
 */
 SC.ready(function() {
-  SC.device.setup() ;
+  SC.device.setup();
 });

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

@@ -345,10 +345,10 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
 
     // if no type is provided, remove all types for this element.
     if (eventType === undefined) {
-      for(eventType in events) this.remove(elem, eventType) ;
+      for (var anEventType in events) this.remove(elem, anEventType) ;
 
     // otherwise, remove the handler for this specific eventType if found
-    } else if (handlers = events[eventType]) {
+    } else if ((handlers = events[eventType])) {
 
       var cleanupHandlers = NO ;
 
@@ -530,7 +530,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     if ((typeof SC === "undefined") || SC.Event.triggered) return YES ;
 
     // returned undefined or NO
-    var val, ret, namespace, all, handlers, args, key, handler, method, target;
+    var val, ret, handlers, args, key, handler, method, target;
 
     // normalize event across browsers.  The new event will actually wrap the
     // real event with a normalized API.
@@ -657,6 +657,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
   KEY_TAB:       9,
   KEY_RETURN:   13,
   KEY_ESC:      27,
+  KEY_SPACE:    32,
   KEY_LEFT:     37,
   KEY_UP:       38,
   KEY_RIGHT:    39,
@@ -846,7 +847,7 @@ SC.Event.prototype = {
     var evt = this.originalEvent ;
     if (evt) {
       if (evt.preventDefault) evt.preventDefault() ;
-      evt.returnValue = NO ; // IE
+      else evt.returnValue = NO ; // IE8
     }
     this.hasCustomEventHandling = YES ;
     return this ;
@@ -902,8 +903,8 @@ SC.Event.prototype = {
     if(SC.browser.name === SC.BROWSER.ie &&
         SC.browser.compare(SC.browser.version, '9.0') < 0) {
       // Return an empty String for backspace, tab, left, right, up or down.
-      if(this.keyCode == 8 || this.keyCode == 9 ||
-          (this.keyCode >= 37 && this.keyCode<=40)) {
+      if(this.keyCode === 8 || this.keyCode === 9 ||
+          (this.keyCode >= 37 && this.keyCode <= 40)) {
         return String.fromCharCode(0);
       } else {
         // This will only be accurate if the event is a keypress event.
@@ -915,47 +916,82 @@ SC.Event.prototype = {
   },
 
   /**
-    Returns character codes for the event.  The first value is the normalized
-    code string, with any shift or ctrl characters added to the begining.
-    The second value is the char string by itself.
+    Returns characters with command codes for the event.
+
+    The first value is a normalized command code identifying the modifier keys that are pressed in
+    combination with a character key. Command codes can be used to map key combinations to an action
+    in the application. A basic example of a normalized command code would be `ctrl_x`, which
+    corresponds to the combination of the `command` key with the `x` key being pressed on OS X or
+    the `ctrl` key with the `x` key in Windows.
+
+    The second value is the character string by itself. So for `ctrl_x`, this would be simply `x`. However,
+    for `alt_x` it would be `≈` and for `alt_shift_x`, it would be `˛`.
+
+    ## Considerations for Different OS's
+
+    At this time, the meta (command) key in OS X is mapped to the `ctrl_` command code prefix. This
+    means that on OS X, command + s, and on Windows, ctrl + s, both become the same command code, `ctrl_s`.
+
+    Note that the order of command code prefixes is important and goes in the order: `ctrl_`, `alt_`,
+    `shift_`. The following are examples of command codes:
+
+    * ctrl_x
+    * alt_x
+    * ctrl_shift_x
+    * ctrl_alt_shift_x
+    * alt_shift_x
 
     @returns {Array}
   */
-  commandCodes: function() {
-    var code=this.keyCode, ret=null, key=null, modifiers='', lowercase ;
-
-    // handle function keys.
-    // WebKit browsers have equal values for keyCode and charCode on keypress event
-    if (code && code !== this.charCode) {
-      ret = SC.FUNCTION_KEYS[code] ;
-      if (!ret && (this.altKey || this.ctrlKey || this.metaKey)) {
-        ret = SC.PRINTABLE_KEYS[code];
-      }
+  commandCodes: function () {
+    var charCode = this.charCode,
+      keyCode = this.keyCode,
+      charString = null,
+      commandCode = null,
+      baseKeyName;
+
+    // WebKit browsers have equal values for `keyCode` and `charCode` on the keypress event. For example,
+    // the letter `r` and the function `f3` both have a `keyCode` of 114. But the `r` also has a `charCode`
+    // of 114.
+    // If there is a keyCode and no matching charCode it is a function key.
+    if (keyCode && keyCode !== charCode) {
+      commandCode = SC.FUNCTION_KEYS[keyCode];
+    }
 
-      if (ret) {
-        if (this.altKey) modifiers += 'alt_' ;
-        if (this.ctrlKey || this.metaKey) modifiers += 'ctrl_' ;
-        if (this.shiftKey) modifiers += 'shift_' ;
-      }
+    // Use the function name as the key name in the command code (ex. `down` could become `shift_down`).
+    if (commandCode) {
+      baseKeyName = commandCode;
+
+    // Find the base character for the key (i.e. `alt` + `a` becomes `å`, but we really want the key name, `a`).
+    } else {
+      baseKeyName = SC.PRINTABLE_KEYS[keyCode];
     }
 
-    // otherwise just go get the right key.
-    if (!ret) {
-      code = this.which ;
-      key = ret = String.fromCharCode(code) ;
-      lowercase = ret.toLowerCase() ;
-      if (this.metaKey) {
-        modifiers = 'meta_' ;
-        ret = lowercase;
+    // If there is a base key name, append any modifiers to generate the command code.
+    if (baseKeyName) {
+      var modifiers = '';
+
+      // Append the pressed modifier keys into a name used to identify command codes.
+      // For example, holding the keys: shift, command & x, will map to the name "ctrl_shift_x".
+      if (this.ctrlKey || this.metaKey) modifiers += 'ctrl_';
+      // UNUSED. In a future version we should scrap ctrl vs. meta for the proper intent depending on the current OS.
+      // if (this.ctrlKey) modifiers += 'ctrl_';
+      // In OS X at least, when the ctrl key is pressed, both ctrlKey & metaKey are true. This makes it impossible to identify
+      // ctrl + meta vs. just ctrl. We can identify just meta though.
+      // else if (this.metaKey) modifiers += 'meta_';
 
-      } else ret = null ;
+      if (this.altKey) modifiers += 'alt_';
+      if (this.shiftKey) modifiers += 'shift_';
+
+      commandCode = modifiers + baseKeyName;
     }
 
-    if (ret) ret = modifiers + ret ;
-    return [ret, key] ;
+    charString = this.getCharString();  // A character string or null.
+
+    return [commandCode, charString];
   }
 
-} ;
+};
 
 // Also provide a Prototype-like API so that people can use either one.
 

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

@@ -72,6 +72,19 @@ SC.Locale = SC.Object.extend({
   */
   metrics: {},
 
+  /**
+    The inflection constants for this locale.
+  */
+  inflectionConstants: {},
+
+  /**
+    The method used to compute the ordinal of a number for this locale.
+  */
+  ordinalForNumber: function(number) { 
+    return '';
+  },
+
+
   toString: function() {
     if (!this.language) SC.Locale._assignLocales() ;
     return "SC.Locale["+this.language+"]"+SC.guidFor(this) ;
@@ -226,10 +239,10 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     var autodetect = (String.useAutodetectedLanguage !== undefined) ? String.useAutodetectedLanguage : this.useAutodetectedLanguage;
     var preferred = (String.preferredLanguage !== undefined) ? String.preferredLanguage : this.preferredLanguage ;
 
+
     // determine the language
     var lang = ((autodetect) ? SC.browser.language : null) || preferred || SC.browser.language || 'en';
     lang = SC.Locale.normalizeLanguage(lang) ;
-
     // get the locale class.  If a class cannot be found, fall back to generic
     // language then to english.
     var klass = this.localeClassFor(lang) ;
@@ -300,6 +313,45 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
   */
   options: function() { return this.prototype; },
 
+  /**
+    Adds the passed hash to the locale's given property name.  Note that
+    if the receiver locale inherits its hashes from its parent, then the
+    property table will be cloned first.
+
+    @param {String} name
+    @param {Hash} hash
+    @returns {Object} receiver
+  */
+  addHashes: function(name, hash) {
+    // make sure the target hash exists and belongs to the locale
+    var currentHash = this.prototype[name];
+    if (currentHash) {
+      if (!this.prototype.hasOwnProperty(currentHash)) {
+        currentHash = this.prototype[name] = SC.clone(currentHash);
+      }
+    }
+    else {
+      currentHash = this.prototype[name] = {};
+    }
+
+    // add hash
+    if (hash) this.prototype[name] = SC.mixin(currentHash, hash);
+
+    return this;
+  },
+
+  /**
+    Adds the passed method to the locale's given property name. 
+
+    @param {String} name
+    @param {Function} method
+    @returns {Object} receiver
+  */
+  addMethod: function(name, method) {
+    this.prototype[name] = method;
+    return this;
+  },
+
   /**
     Adds the passed hash of strings to the locale's strings table.  Note that
     if the receiver locale inherits its strings from its parent, then the
@@ -308,18 +360,14 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     @returns {Object} receiver
   */
   addStrings: function(stringsHash) {
-    // make sure the target strings hash exists and belongs to the locale
-    var strings = this.prototype.strings ;
-    if (strings) {
-      if (!this.prototype.hasOwnProperty('strings')) {
-        strings = this.prototype.strings = SC.clone(strings) ;
-      }
-    } else strings = this.prototype.strings = {} ;
+    var ret = this.addHashes('strings', stringsHash);
 
-    // add strings hash
-    if (stringsHash)  this.prototype.strings = SC.mixin(strings, stringsHash) ;
-    this.prototype.hasStrings = YES ;
-    return this;
+    // Note:  We don't need the equivalent of this.hasStrings here, because we
+    //        are not burdened by an older API to look for like the strings
+    //        support is.
+    this.prototype.hasStrings = YES;
+
+    return ret;
   },
 
   /**
@@ -331,25 +379,7 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     @returns {Object} receiver
   */
   addMetrics: function(metricsHash) {
-    // make sure the target metrics hash exists and belongs to the locale
-    var metrics = this.prototype.metrics;
-    if (metrics) {
-      if (!this.prototype.hasOwnProperty(metrics)) {
-        metrics = this.prototype.metrics = SC.clone(metrics) ;
-      }
-    }
-    else {
-      metrics = this.prototype.metrics = {} ;
-    }
-
-    // add metrics hash
-    if (metricsHash) this.prototype.metrics = SC.mixin(metrics, metricsHash);
-
-    // Note:  We don't need the equivalent of this.hasStrings here, because we
-    //        are not burdened by an older API to look for like the strings
-    //        support is.
-
-    return this;
+    return this.addHashes('metrics', metricsHash);
   },
 
   _map: { english: 'en', french: 'fr', german: 'de', japanese: 'ja', jp: 'ja', spanish: 'es' },
@@ -404,10 +434,36 @@ SC.Locale.locales = {
   de: SC.Locale.extend({ _deprecatedLanguageCodes: ['German'] }),
   ja: SC.Locale.extend({ _deprecatedLanguageCodes: ['Japanese', 'jp'] }),
   es: SC.Locale.extend({ _deprecatedLanguageCodes: ['Spanish'] })
-} ;
+};
 
+/**
+  This special helper will store the propertyName / hashes pair you pass 
+  in the locale matching the language code.  If a locale is not defined 
+  from the language code you specify, then one will be created for you 
+  with the english locale as the parent.
 
+  @param {String} languageCode
+  @param {String} propertyName
+  @param {Hash} hashes
+  @returns {void}
+*/
+SC.hashesForLocale = function(languageCode, propertyName, hashes) {
+  var locale = SC.Locale.localeClassFor(languageCode);
+  locale.addHashes(propertyName, hashes);
+};
 
+/**
+  Just like SC.hashesForLocale, but for methods.
+
+  @param {String} languageCode
+  @param {String} propertyName
+  @param {Function} method
+  @returns {void}
+*/
+SC.methodForLocale = function(languageCode, propertyName, method) {
+  var locale = SC.Locale.localeClassFor(languageCode);
+  locale.addMethod(propertyName, method);
+};
 
 /**
   This special helper will store the strings you pass in the locale matching
@@ -422,9 +478,9 @@ SC.Locale.locales = {
 SC.stringsFor = function(languageCode, strings) {
   // get the locale, creating one if needed.
   var locale = SC.Locale.localeClassFor(languageCode);
-  locale.addStrings(strings) ;
+  locale.addStrings(strings);
   return this ;
-} ;
+};
 
 /**
   Just like SC.stringsFor, but for metrics.