sproutcore 1.6.0.beta.3-java → 1.6.0-java

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

@@ -52,6 +52,8 @@ SC.Pane.reopen(
       if (nextValidKeyView) {
         this.makeFirstResponder(nextValidKeyView);
         return YES;
+      }else if(!SC.TABBING_ONLY_INSIDE_DOCUMENT){
+        evt.allowDefault();
       }
     }
 

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

@@ -249,44 +249,48 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
     @param {Event} evt that cause this to become first responder
     @returns {SC.Pane} receiver
   */
-  makeFirstResponder: function(view, evt) {
+  makeFirstResponder: function(original, view, evt) {
+    // firstResponder should never be null
+    if(!view) view = this;
+
     var current=this.get('firstResponder'), isKeyPane=this.get('isKeyPane');
     if (current === view) return this ; // nothing to do
     if (SC.platform.touch && view && view.kindOf(SC.TextFieldView) && !view.get('focused')) return this;
 
-    // notify current of firstResponder change
-    if (current) current.willLoseFirstResponder(current, evt);
-
     // if we are currently key pane, then notify key views of change also
     if (isKeyPane) {
       if (current) { current.tryToPerform('willLoseKeyResponderTo', view); }
-      if (view) { view.tryToPerform('willBecomeKeyResponderFrom', current); }
+      if (view) { 
+        view.tryToPerform('willBecomeKeyResponderFrom', current); 
+      }
     }
 
-    // change setting
     if (current) {
-      current.beginPropertyChanges()
-        .set('isFirstResponder', NO).set('isKeyResponder', NO)
-      .endPropertyChanges();
+      current.beginPropertyChanges();
+      current.set('isKeyResponder', NO);
     }
 
-    this.set('firstResponder', view) ;
-
     if (view) {
-      view.beginPropertyChanges()
-        .set('isFirstResponder', YES).set('isKeyResponder', isKeyPane)
-      .endPropertyChanges();
+      view.beginPropertyChanges();
+      view.set('isKeyResponder', isKeyPane);
     }
 
+    original(view, evt);
+
+    if(current) current.endPropertyChanges();
+    if(view) view.endPropertyChanges();
+
     // and notify again if needed.
     if (isKeyPane) {
-      if (view) { view.tryToPerform('didBecomeKeyResponderFrom', current); }
-      if (current) { current.tryToPerform('didLoseKeyResponderTo', view); }
+      if (view) { 
+        view.tryToPerform('didBecomeKeyResponderFrom', current); }
+      if (current) { 
+        current.tryToPerform('didLoseKeyResponderTo', view); 
+      }
     }
 
-    if (view) view.didBecomeFirstResponder(view);
     return this ;
-  },
+  }.enhance(),
 
   /**
     Called just before the pane loses it's keyPane status.  This will notify
@@ -294,7 +298,7 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
     giving it one last opportunity to save its state.
 
     @param {SC.Pane} pane
-    @returns {SC.Pane} reciever
+    @returns {SC.Pane} receiver
   */
   willLoseKeyPaneTo: function(pane) {
     this._forwardKeyChange(this.get('isKeyPane'), 'willLoseKeyResponderTo', pane, NO);
@@ -316,13 +320,15 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
   },
 
 
+  didBecomeKeyResponderFrom: function(responder) {},
+
   /**
     Called just after the pane has lost its keyPane status.  Notifies the
     current keyView of the change.  The keyView can use this method to do any
     final cleanup and changes its own display value if needed.
 
     @param {SC.Pane} pane
-    @returns {SC.Pane} reciever
+    @returns {SC.Pane} receiver
   */
   didLoseKeyPaneTo: function(pane) {
     var isKeyPane = this.get('isKeyPane');

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

@@ -5,39 +5,55 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-/**
+/** @class
+
   SC.TemplatePane is a helper that will create a new pane based on
   a single root TemplateView.
 
-  function main() {
-    MyApp.mainPane = SC.TemplatePane.append({
-      layerId: 'my-root-id',
-      templateName: 'app'
-    })
-  }
+      function main() {
+        MyApp.mainPane = SC.TemplatePane.append({
+          layerId: 'my-root-id',
+          templateName: 'app'
+        })
+      }
+
+  @extends SC.Object
+  @since SproutCore 1.5
 */
-SC.TemplatePane = SC.Object.extend({
-  touchStart: function(touch) {
-    touch.allowDefault();
-  },
+SC.TemplatePane = SC.Object.extend({});
 
-  touchesDragged: function(evt, touches) {
-    evt.allowDefault();
-  },
+SC.TemplatePane.mixin( /** @scope SC.TemplatePane */ {
 
-  touchEnd: function(touch) {
-    touch.allowDefault();
-  }
-});
+  /**
+    Creates a new pane with a single TemplateView.
 
-SC.mixin(SC.TemplatePane, {
+    @param {Object} attrs describes the pane to create
+    @returns {SC.MainPane} the created pane
+  */
   append: function(attrs) {
     var pane = SC.MainPane.extend({
       childViews: ['contentView'],
 
-      contentView: SC.TemplateView.design(attrs)
+      contentView: SC.TemplateView.design(attrs),
+
+      touchStart: function(touch) {
+        touch.allowDefault();
+      },
+
+      touchesDragged: function(evt, touches) {
+        evt.allowDefault();
+      },
+
+      touchEnd: function(touch) {
+        touch.allowDefault();
+      }
     });
 
-    return pane.create().append();
+    pane = pane.create().append();
+
+    // Normally the awake process is started in the Page, but we don't have a Page
+    pane.awake();
+
+    return pane;
   }
 });

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

@@ -7,8 +7,8 @@
 
 /** @class
 
-  The root object for a SproutCore application.  Usually you will create a
-  single SC.Application instance as your root namespace.  SC.Application is
+  The root object for a SproutCore application. Usually you will create a
+  single SC.Application instance as your root namespace. SC.Application is
   required if you intend to use SC.Responder to route events.
 
   ## Example
@@ -19,11 +19,6 @@
         // add other useful properties here
       });
 
-  ## Sending Events
-
-  You can send actions and events down an application-level responder chain
-  by
-
   @extends SC.ResponderContext
   @since SproutCore 1.0
 */

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

@@ -76,14 +76,14 @@ SC.Event = function(originalEvent) {
   if (!this.which && this.button) {
     this.which = ((this.button & 1) ? 1 : ((this.button & 2) ? 3 : ( (this.button & 4) ? 2 : 0 ) ));
   }
-  
+
   // Normalize wheel delta values for mousewheel events
   if (this.type === 'mousewheel' || this.type === 'DOMMouseScroll' || this.type === 'MozMousePixelScroll') {
     var deltaMultiplier = SC.Event.MOUSE_WHEEL_MULTIPLIER,
         version = parseFloat(SC.browser.version);
 
     // normalize wheelDelta, wheelDeltaX, & wheelDeltaY for Safari
-    if (SC.browser.webkit && originalEvent.wheelDelta!==undefined) {
+    if (SC.browser.webkit && originalEvent.wheelDelta !== undefined) {
       this.wheelDelta = 0-(originalEvent.wheelDeltaY || originalEvent.wheelDeltaX);
       this.wheelDeltaY = 0-(originalEvent.wheelDeltaY||0);
       this.wheelDeltaX = 0-(originalEvent.wheelDeltaX||0);
@@ -102,7 +102,7 @@ SC.Event = function(originalEvent) {
 
     // handle all other legacy browser
     } else {
-      this.wheelDelta = this.wheelDeltaY = SC.browser.msie ? 0-originalEvent.wheelDelta : originalEvent.wheelDelta ;
+      this.wheelDelta = this.wheelDeltaY = SC.browser.msie || SC.browser.opera ? 0-originalEvent.wheelDelta : originalEvent.wheelDelta ;
       this.wheelDeltaX = 0 ;
     }
 
@@ -287,7 +287,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     // Get the handlers queue for this element/eventType.  If the queue does
     // not exist yet, create it and also setup the shared listener for this
     // eventType.
-    var events = SC.data(elem, "events") || SC.data(elem, "events", {}) ,
+    var events = SC.data(elem, "sc_events") || SC.data(elem, "sc_events", {}) ,
         handlers = events[eventType]; 
     if (!handlers) {
       handlers = events[eventType] = {} ;
@@ -351,7 +351,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     // around, causing it to be cloned in the process
     if (SC.browser.msie && elem.setInterval) elem = window;
 
-    var handlers, key, events = SC.data(elem, "events") ;
+    var handlers, key, events = SC.data(elem, "sc_events") ;
     if (!events) return this ; // nothing to do if no events are registered
 
     // if no type is provided, remove all types for this element.
@@ -396,7 +396,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
       key = null ;
       for(key in events) break;
       if(!key) {
-        SC.removeData(elem, "events") ;
+        SC.removeData(elem, "sc_events") ;
         delete this._elements[SC.guidFor(elem)]; // important to avoid leaks
       }
       
@@ -546,7 +546,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     args[0] = event = SC.Event.normalizeEvent(event || window.event);
 
     // get the handlers for this event type
-    handlers = (SC.data(this, "events") || {})[event.type];
+    handlers = (SC.data(this, "sc_events") || {})[event.type];
     if (!handlers) return NO ; // nothing to do
     
     // invoke all handlers

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

@@ -66,6 +66,12 @@ SC.Locale = SC.Object.extend({
   /** The strings hash for this locale. */
   strings: {},
   
+  /**
+    The metrics for this locale.  A metric is a singular value that is usually
+    used in a user interface layout, such as "width of the OK button".
+  */
+  metrics: {},
+
   toString: function() {
     if (!this.language) SC.Locale._assignLocales() ;
     return "SC.Locale["+this.language+"]"+SC.guidFor(this) ;
@@ -86,9 +92,107 @@ SC.Locale = SC.Object.extend({
     if (SC.typeOf(ret) === SC.T_STRING) return ret;
     else if (SC.typeOf(def) === SC.T_STRING) return def;
     return string;
+  },
+
+  /**
+    Returns the localized value of the metric for the specified key, or
+    undefined if no match is found.
+
+    @param {String} key
+    @returns {Number} ret
+  */
+  locMetric: function(key) {
+    var ret = this.metrics[key];
+    if (SC.typeOf(ret) === SC.T_NUMBER) {
+      return ret;
+    }
+    else if (ret === undefined) {
+      SC.warn("No localized metric found for key \"" + key + "\"");
+      return undefined;
+    }
+    else {
+      SC.warn("Unexpected metric type for key \"" + key + "\"");
+      return undefined;
+    }
+  },
+
+  /**
+    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.)
+
+    @param {String} baseKey
+    @param {String} (optional) additionalHash
+    @returns {Hash}
+  */
+  locLayout: function(baseKey, additionalHash) {
+    // Note:  In this method we'll directly access this.metrics rather than
+    //        going through locMetric() for performance and to avoid
+    //        locMetric()'s sanity checks.
+
+    var i, len, layoutKey, key, value,
+        layoutKeys = SC.Locale.layoutKeys,
+        metrics    = this.metrics,
+
+        // Cache, to avoid repeated lookups
+        typeOfFunc = SC.typeOf,
+        numberType = SC.T_NUMBER,
+
+        ret        = {};
+
+
+    // Start off by mixing in the additionalHash; we'll look for collisions with
+    // the localized values in the loop below.
+    if (additionalHash) SC.mixin(ret, additionalHash);
+
+
+    // For each possible key that can be included in a layout hash, see whether
+    // we have a localized value.
+    for (i = 0, len = layoutKeys.length;  i < len;  ++i) {
+      layoutKey = layoutKeys[i];
+      key       = baseKey + "." + layoutKey;
+      value     = metrics[key];
+
+      if (typeOfFunc(value) === numberType) {
+        // We have a localized value!  As a sanity check, if the caller
+        // specified an additional hash and it has the same key, we'll throw an
+        // error.
+        if (additionalHash  &&  additionalHash[layoutKey]) {
+          throw "locLayout():  There is a localized value for the key '" + key + "' but a value for '" + layoutKey + "' was also specified in the non-localized hash";
+        }
+
+        ret[layoutKey] = value;
+      }
+    }
+
+    return ret;
   }
-  
-  
+
 }) ;
 
 SC.Locale.mixin(/** @scope SC.Locale */ {
@@ -98,12 +202,19 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     preferred one.
   */
   useAutodetectedLanguage: NO,
-  
+
   /**
     This property is set by the build tools to the current build language.
   */
   preferredLanguage: null,
-  
+
+  /**
+    This property holds all attributes name which can be used for a layout hash
+    (for an SC.View).  These are what we support inside the layoutFor() method.
+  */
+  layoutKeys: ['left', 'top', 'right', 'bottom', 'width', 'height',
+               'minWidth', 'minHeight', 'centerX', 'centerY'],
+
   /** 
     Invoked at the start of SproutCore's document onready handler to setup 
     the currentLocale.  This will use the language properties you have set on
@@ -211,7 +322,37 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     this.prototype.hasStrings = YES ;
     return this;
   },
-  
+
+  /**
+    Adds the passed hash of metrics to the locale's metrics table, much as
+    addStrings() is used to add in strings.   Note that if the receiver locale
+    inherits its metrics from its parent, then the metrics table will be cloned
+    first.
+
+    @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)) {
+        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;
+  },
+
   _map: { english: 'en', french: 'fr', german: 'de', japanese: 'ja', jp: 'ja', spanish: 'es' },
   
   /**
@@ -286,4 +427,15 @@ SC.stringsFor = function(languageCode, strings) {
   return this ;
 } ;
 
+/**
+  Just like SC.stringsFor, but for metrics.
 
+  @param {String} languageCode
+  @param {Hash} metrics
+  @returns {Object} receiver
+*/
+SC.metricsFor = function(languageCode, metrics) {
+  var locale = SC.Locale.localeClassFor(languageCode);
+  locale.addMetrics(metrics);
+  return this;
+};