sproutcore 1.6.0.rc.2-x86-mingw32 → 1.6.0.1-x86-mingw32

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

@@ -344,9 +344,18 @@ SC.RootResponder = SC.Object.extend(
     (removing sc-blur).  Also notify panes.
   */
   focus: function() {
+    
     if (!this.get('hasFocus')) {
       SC.$('body').addClass('sc-focus').removeClass('sc-blur');
 
+      // If the app is getting focus again set the first responder to the first
+      // valid firstResponder view in the view's tree
+      if(!SC.TABBING_ONLY_INSIDE_DOCUMENT){
+        var mainPane = this.get('mainPane'),
+            nextValidKeyView = mainPane ? mainPane.get('nextValidKeyView') : null;
+        if (nextValidKeyView) mainPane.makeFirstResponder(nextValidKeyView);
+      }
+      
       SC.run(function() {
         this.set('hasFocus', YES);
       }, this);
@@ -689,7 +698,6 @@ SC.RootResponder = SC.Object.extend(
 
     // do some initial set
     this.set('currentWindowSize', this.computeWindowSize()) ;
-    this.focus(); // assume the window is focused when you load.
 
     if (SC.browser.mobileSafari) {
 
@@ -1717,8 +1725,6 @@ SC.RootResponder = SC.Object.extend(
       return YES;
     }
 
-    if(!SC.browser.msie) window.focus();
-
     // First, save the click count. The click count resets if the mouse down
     // event occurs more than 250 ms later than the mouse up event or more
     // than 8 pixels away from the mouse down event.

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

@@ -102,7 +102,7 @@ SC.SparseArray = SC.Object.extend(SC.Observable, SC.Enumerable, SC.Array,
     added as range requests are completed.
   */
   requestedRangeIndex: null,
-  
+
   /**
     Make sure to create the index array during init so that it is not shared
     between all instances.
@@ -110,13 +110,13 @@ SC.SparseArray = SC.Object.extend(SC.Observable, SC.Enumerable, SC.Array,
   init: function() {
     sc_super();
     this.requestedRangeIndex = [];
-    
+
     this._TMP_PROVIDE_ARRAY = [];
     this._TMP_PROVIDE_RANGE = { length: 1 };
     this._TMP_RANGE = {};
   },
-  
-  /** 
+
+  /**
     Returns the object at the specified index.  If the value for the index
     is currently undefined, invokes the didRequestIndex() method to notify
     the delegate.
@@ -124,9 +124,9 @@ SC.SparseArray = SC.Object.extend(SC.Observable, SC.Enumerable, SC.Array,
     The omitMaterializing flag ensures that the object will not be materialized,
     but it simply checks for the presence of an object at the specified index
     and will return YES (or undefined if not found). This is useful in the case
-    of SparseArrays, where you might NOT want to request the index to be loaded, 
+    of SparseArrays, where you might NOT want to request the index to be loaded,
     but simply need a shallow check to see if the position has been filled.
-    
+
     @param {Number} idx the index to get
     @param {Boolean} omitMaterializing
     @return {Object} the object
@@ -251,7 +251,7 @@ SC.SparseArray = SC.Object.extend(SC.Observable, SC.Enumerable, SC.Array,
 
     @param {Range} range the range to apply to
     @param {Array} array the array of objects to insert
-    @returns {SC.SparseArray} reciever
+    @returns {SC.SparseArray} receiver
   */
   provideObjectsInRange: function(range, array) {
     var content = this._sa_content ;
@@ -300,7 +300,7 @@ SC.SparseArray = SC.Object.extend(SC.Observable, SC.Enumerable, SC.Array,
         var start = range.start, loc = Math.min(start + range.length, content.length);
         while (--loc>=start) content[loc] = undefined;
       }
-    }    
+    }
     this.arrayContentDidChange(range.start, range.length, range.length) ; // notify
     return this ;
   },

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

@@ -116,7 +116,7 @@ SC.mixin(SC.String, {
   },
 
   /**
-    Localizes the string.  This will look up the reciever string as a key
+    Localizes the string.  This will look up the receiver string as a key
     in the current Strings hash.  If the key matches, the loc'd value will be
     used.  The resulting string will also be passed through fmt() to insert
     any variables.
@@ -136,12 +136,104 @@ SC.mixin(SC.String, {
 
     var args = SC.$A(arguments);
     args.shift(); // remove str param
-    //to extend String.prototype 
+    //to extend String.prototype
     if(args.length>0 && args[0].isSCArray) args=args[0];
 
     return SC.String.fmt(localized, args);
   },
 
+  /**
+    Returns the localized metric value for the specified key.  A metric is a
+    single value intended to be used in your interface’s layout, such as
+    "Button.Confirm.Width" = 100.
+
+    If you would like to return a set of metrics for use in a layout hash, you
+    may prefer to use the locLayout() method instead.
+
+    @param str {String} key
+    @returns {Number} the localized metric
+  */
+  locMetric: function(key) {
+    var K             = SC.Locale,
+        currentLocale = K.currentLocale;
+
+    if (!currentLocale) {
+      K.createCurrentLocale();
+      currentLocale = K.currentLocale;
+    }
+    return currentLocale.locMetric(key);
+  },
+
+  /**
+    Creates and returns a new hash suitable for use as an SC.View’s 'layout'
+    hash.  This hash will be created by looking for localized metrics following
+    a pattern based on the “base key” you specify.
+
+    For example, if you specify "Button.Confirm", the following metrics will be
+    used if they are defined:
+
+      Button.Confirm.left
+      Button.Confirm.top
+      Button.Confirm.right
+      Button.Confirm.bottom
+      Button.Confirm.width
+      Button.Confirm.height
+      Button.Confirm.midWidth
+      Button.Confirm.minHeight
+      Button.Confirm.centerX
+      Button.Confirm.centerY
+
+    Additionally, you can optionally specify a hash which will be merged on top
+    of the returned hash.  For example, if you wish to allow a button’s width
+    to be configurable per-locale, but always wish for it to be centered
+    vertically and horizontally, you can call:
+
+      locLayout("Button.Confirm", {centerX:0, centerY:0})
+
+    …so that you can combine both localized and non-localized elements in the
+    returned hash.  (An exception will be thrown if there is a locale-specific
+    key that matches a key specific in this hash.)
+
+
+    For example, if your locale defines:
+
+      Button.Confirm.left
+      Button.Confirm.top
+      Button.Confirm.right
+      Button.Confirm.bottom
+
+
+    …then these two code snippets will produce the same result:
+
+      layout: {
+        left:   "Button.Confirm.left".locMetric(),
+        top:    "Button.Confirm.top".locMetric(),
+        right:  "Button.Confirm.right".locMetric(),
+        bottom: "Button.Confirm.bottom".locMetric()
+      }
+
+      layout: "Button.Confirm".locLayout()
+
+    The former is slightly more efficient because it doesn’t have to iterate
+    through the possible localized layout keys, but in virtually all situations
+    you will likely wish to use the latter.
+
+    @param str {String} key
+    @param {str} (optional) additionalHash
+    @param {String} (optional) additionalHash
+    @returns {Number} the localized metric
+  */
+  locLayout: function(key, additionalHash) {
+    var K             = SC.Locale,
+        currentLocale = K.currentLocale;
+
+    if (!currentLocale) {
+      K.createCurrentLocale();
+      currentLocale = K.currentLocale;
+    }
+    return currentLocale.locLayout(key, additionalHash);
+  },
+
   /**
     Works just like loc() except that it will return the passed default
     string if a matching key is not found.
@@ -163,7 +255,7 @@ SC.mixin(SC.String, {
 
     return SC.String.fmt(localized, args);
   },
-  
+
   /**
    Removes any extra whitespace from the edges of the string. This method is
    also aliased as strip().
@@ -214,9 +306,17 @@ if(String.prototype.trim) {
 // We want the version defined here, not in Runtime
 SC.mixin(String.prototype,
 /** @scope String.prototype */ {
-  
+
   loc: function() {
     return SC.String.loc(this.toString(), SC.$A(arguments));
+  },
+
+  locMetric: function() {
+    return SC.String.locMetric(this.toString());
+  },
+
+  locLayout: function(additionalHash) {
+    return SC.String.locLayout(this.toString(), additionalHash);
   }
 
 });

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

@@ -23,21 +23,6 @@
   by SC.View when you name a theme that doesn't actually exist: it creates
   a theme based on the parent theme.
 
-  Renderers
-  ---------------------------
-  Themes are used to keep track of theme class names and, more important,
-  to keep track of renderers.
-
-  Renderers are added to a theme using theme.addRenderer(theRenderer). After
-  this has been done, they may be instantiated using theme.renderer(rendererName).
-
-  Instantiating with renderer() instantiates a version of that renderer
-  specialized for this specific theme-- not any parent themes. The renderer
-  will include all class names for _this_ theme. This means that you can
-  theme controls differently without overriding any renderers: just subclass
-  the original theme that _has_ the renderers, give it its own name, and
-  all renderers will render with that name as a class name.
-
   Locating Child Themes
   ----------------------------
   Locating child themes is relatively simple for the most part: it looks in
@@ -51,7 +36,7 @@
   base classes; if the theme is a global theme, those class names should not
   be included.
 
-  This makes sense logically as well, because when searching for a renderer,
+  This makes sense logically as well, because when searching for a render delegate,
   it will locate it in any base theme that has it, but that doesn't mean
   class names from the derived theme shouldn't be included.
 
@@ -143,10 +128,6 @@ SC.Theme = {
     // method.
     result._privateThemes = {};
 
-    // the theme also specializes all renderers it creates so that they
-    // have the theme's classNames and have their 'theme' property set.
-    result._specializedRenderers = {};
-
     // also, the theme specializes all child themes as they are created
     // to ensure that all of the class names on this theme are included.
     result._specializedThemes = {};
@@ -263,40 +244,6 @@ SC.Theme = {
   */
   addTheme: function(theme) {
     this.themes[theme.name] = theme;
-  },
-
-  /**
-    Adds a renderer to the theme. The renderer's name will be used to
-    keep track of it and identify it later.
-
-    The biggest responsibility of addRenderer is to ensure that renderer()
-    can be used to instantiate that renderer. If a renderer is not instantiated
-    through renderer(), it will not know its theme's classNames.
-  */
-  addRenderer: function(renderer) {
-    this[renderer.name] = renderer;
-  },
-
-   /**
-     Finds the named renderer and instantiates it, returning the result.
-     It also ensures it is using a version of the renderer specialized for
-     this theme. It keeps a cache of specialized versions of the renderer.
-
-     Any arguments after the name are passed on to the instantiated
-     renderer.
-   */
-  renderer: function(name) {
-    var renderer = this._specializedRenderers[name], base = this[name];
-    if (!renderer || renderer._specializedFrom !== base) {
-      if (!base) return null;
-
-      renderer = base.extend({ classNames: this.classNames, theme: this });
-    }
-
-    var args = SC.$A(arguments);
-    args.shift();
-    renderer = renderer.create.apply(renderer, args);
-    return renderer;
   }
 };
 
@@ -304,8 +251,8 @@ SC.Theme = {
 // optimal, but the reasoning is because of test running: the
 // test runner, when running foundation unit tests, cannot load
 // the theme. As such, foundation must include default versions of
-// all of its renderers, and it does so in BaseTheme. All SproutCore
-// controls have renderers in BaseTheme.
+// all of its render delegates, and it does so in BaseTheme. All SproutCore
+// controls have render delegates in BaseTheme.
 SC.BaseTheme = SC.Theme.create({
   name: '' // it is a base class, and doesn't need a class name or such
 });

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

@@ -152,8 +152,10 @@ SC.mixin( /** @scope SC */ {
     return result;
   },
 
-  /** @deprecated
-    Deprecated. SC.offset() is more accurate, more flexible in the value for the element parameter and
+  /**
+    @deprecated Use SC.offset instead.
+
+    SC.offset() is more accurate, more flexible in the value for the element parameter and
     easier to understand.
 
     @param el The DOM element

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/controllers/object/content_destroyed.js

@@ -0,0 +1,59 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+var content, newContent, controller, destroyCount;
+
+// ..........................................................
+// SINGLE OBSERVABLE OBJECT
+// 
+
+SC.TestObject = SC.Object.extend();
+
+SC.TestObject.reopen({
+  destroy: function() {
+    destroyCount = 1;
+  }
+});
+
+module("SC.ObjectController - content destroyed", {
+  setup: function() {
+    content = SC.TestObject.create({ 
+      foo: "foo1", bar: "bar1"
+    });
+    newContent = SC.Object.create({
+      foo: "foo2"
+    });
+    destroyCount = 0;
+    console.log('SSSSS');
+    controller = SC.ObjectController.create({ 
+      destroyContentOnReplace: YES,
+      content: content 
+    });
+  },
+  
+  teardown: function() {
+    controller.destroy();
+  }
+});
+
+test("Setting content should call 'destroy' on old content if destroyContentOnReplace has been set", function() {
+  controller.set('content', newContent);
+  equals(destroyCount, 1, 'destroyCount');
+  equals(controller.getPath('content.foo'), 'foo2');
+});
+
+test("Setting content should NOT call 'destroy' on old content if destroyContentOnReplace has not been set", function() {
+  controller.set('destroyContentOnReplace', NO);
+  controller.set('content', newContent);
+  equals(destroyCount, 0, 'destroyCount');
+  equals(controller.getPath('content.foo'), 'foo2');
+});
+
+test("Setting content should NOT call 'destroy' if set to the same object", function() {
+  controller.set('content', content);
+  equals(destroyCount, 0, 'destroyCount');
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/mixins/string.js

@@ -4,7 +4,7 @@
 //            ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/*global module test equals context ok same */
+/*global module test equals context ok same should_throw*/
 var LocaleObject;
 
 module('SC.Object', {
@@ -26,6 +26,13 @@ module('SC.Object', {
       'Test': '%@',
       'Test.Multiple': '%@ %@'
     });
+
+    SC.metricsFor('English', {
+      'Button.left': 10,
+      'Button.top': 20,
+      'Button.width': 80,
+      'Button.height': 30
+    });
   }
 });
 
@@ -76,3 +83,36 @@ test("Localize a string even if localized version is empty", function() {
   equals("empty".locWithDefault("Empty"), "", "Using String.prototype.locWithDefault");
   equals(SC.String.locWithDefault("empty", "Empty"), "", "Using SC.String.locWithDefault");
 });
+
+test("Access a localized metric", function() {
+  equals(10, "Button.left".locMetric());
+  equals(20, "Button.top".locMetric());
+  equals(undefined, "Button.notThere".locMetric());
+});
+
+test("Access a localized layout hash", function() {
+  // Simple case (if we ever get a full hash comparison function, we should use
+  // it here).
+  var layout = "Button".locLayout();
+  equals(10, layout.left);
+  equals(20, layout.top);
+  equals(80, layout.width);
+  equals(30, layout.height);
+  equals(undefined, layout.right);    // No localized key
+
+
+  // Slightly more involved case:  allow the user to specify an additional hash.
+  layout = "Button".locLayout({right:50});
+  equals(10, layout.left);
+  equals(20, layout.top);
+  equals(80, layout.width);
+  equals(30, layout.height);
+  equals(50, layout.right);    // No localized key
+
+
+  // Sanity-check case:  Since we have both a localized key for 'left' and we'll
+  // pass it in, an exception should be thrown.
+  should_throw(function() {
+    "Button".locLayout({left:10});
+  }, Error, "locLayout():  There is a localized value for the key 'Button.left' but a value for 'left' was also specified in the non-localized hash");
+});