sproutcore 1.4.5 → 1.5.0.pre.3

data/lib/frameworks/sproutcore/frameworks/amber/mixins/string.js

@@ -0,0 +1,163 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('system/locale');
+
+// These are basic enhancements to the string class used throughout
+// SproutCore.
+/** @private */
+SC.STRING_TITLEIZE_REGEXP = (/([\s|\-|\_|\n])([^\s|\-|\_|\n]?)/g);
+SC.STRING_DECAMELIZE_REGEXP = (/([a-z])([A-Z])/g);
+SC.STRING_DASHERIZE_REGEXP = (/[ _]/g);
+SC.STRING_DASHERIZE_CACHE = {};
+
+/**
+  @namespace
+
+  SproutCore implements a variety of enhancements to the built-in String
+  object that make it easy to perform common substitutions and conversions.
+
+  Most of the utility methods defined here mirror those found in Prototype
+  1.6.
+
+  @since SproutCore 1.0
+*/
+SC.String = {
+  /**
+    Capitalizes a string.
+
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | My favorite items |
+    | css-class-name | Css-class-name |
+    | action_name | Action_name |
+    | innerHTML | InnerHTML |
+
+    @return {String} capitalized string
+  */
+  capitalize: function() {
+    return this.charAt(0).toUpperCase() + this.slice(1) ;
+  },
+
+  /**
+    Camelizes a string.  This will take any words separated by spaces, dashes
+    or underscores and convert them into camelCase.
+
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | myFavoriteItems |
+    | css-class-name | cssClassName |
+    | action_name | actionName |
+    | innerHTML | innerHTML |
+
+    @returns {String} camelized string
+  */
+  camelize: function() {
+    var ret = this.replace(SC.STRING_TITLEIZE_REGEXP,
+      function(str,separater,character) {
+        return (character) ? character.toUpperCase() : '' ;
+      }) ;
+    var first = ret.charAt(0), lower = first.toLowerCase() ;
+    return (first !== lower) ? (lower + ret.slice(1)) : ret ;
+  },
+
+  /**
+    Converts a camelized string into all lower case separated by underscores.
+
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | my favorite items |
+    | css-class-name | css-class-name |
+    | action_name | action_name |
+    | innerHTML | inner_html |
+
+    @returns {String} the decamelized string.
+  */
+  decamelize: function() {
+    return this.replace(SC.STRING_DECAMELIZE_REGEXP,'$1_$2').toLowerCase();
+  },
+
+  /**
+    Converts a camelized string or a string with spaces or underscores into
+    a string with components separated by dashes.
+
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | my-favorite-items |
+    | css-class-name | css-class-name |
+    | action_name | action-name |
+    | innerHTML | inner-html |
+
+    @returns {String} the dasherized string.
+  */
+  dasherize: function() {
+    // Do we have the item in our cache?
+    var cache = SC.STRING_DASHERIZE_CACHE,
+        ret   = cache[this];
+
+    if (ret) {
+      return ret;
+    }
+    else {
+      ret = this.decamelize().replace(SC.STRING_DASHERIZE_REGEXP,'-') ;
+
+      // Add the item to our cache.
+      cache[this] = ret;
+    }
+
+    return ret;
+  },
+
+  /**
+    Localizes the string.  This will look up the reciever 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.
+
+    @param args {Object...} optional arguments to interpolate also
+    @returns {String} the localized and formatted string.
+  */
+  loc: function() {
+    // NB: This could be implemented as a wrapper to locWithDefault() but
+    // it would add some overhead to deal with the arguments and adds stack
+    // frames, so we are keeping the implementation separate.
+    if(!SC.Locale.currentLocale) SC.Locale.createCurrentLocale();
+    var str = SC.Locale.currentLocale.locWithDefault(this);
+    if (SC.typeOf(str) !== SC.T_STRING) str = this;
+    return str.fmt.apply(str,arguments) ;
+  },
+
+  /**
+    Works just like loc() except that it will return the passed default
+    string if a matching key is not found.
+
+    @param {String} def the default to return
+    @param {Object...} args optional formatting arguments
+    @returns {String} localized and formatted string
+  */
+  locWithDefault: function(def) {
+    if(!SC.Locale.currentLocale) SC.Locale.createCurrentLocale();
+    var str = SC.Locale.currentLocale.locWithDefault(this, def);
+    if (SC.typeOf(str) !== SC.T_STRING) str = this;
+    var args = SC.$A(arguments); args.shift(); // remove def param
+    return str.fmt.apply(str,args) ;
+  }
+};
+
+// Apply SC.String mixin to built-in String object
+SC.supplement(String.prototype, SC.String) ;
+
+/** @private */
+String.prototype.loc = SC.String.loc; // Two places define it, and we want the version at SC.String.loc
+
+/** @private */
+SC.String.fmt = String.prototype.fmt; // copy from runtime
+

data/lib/frameworks/sproutcore/frameworks/{foundation → amber}/panes/main.js

@@ -29,7 +29,6 @@ require('panes/pane');
   @since SproutCore 1.0
 */
 SC.MainPane = SC.Pane.extend({
-
   /** @private */
   layout: { top: 0, left: 0, bottom: 0, right: 0, minHeight:200, minWidth:200 },
   
@@ -46,6 +45,8 @@ SC.MainPane = SC.Pane.extend({
   acceptsKeyPane: YES,
 
   /** @private */
-  classNames: ['sc-main']
+  classNames: ['sc-main'],
+  
+  ariaRole: 'application'
   
-});
+});

data/lib/frameworks/sproutcore/frameworks/{foundation → amber}/panes/pane.js

@@ -8,6 +8,13 @@
 sc_require('views/view');
 sc_require('mixins/responder_context');
 
+/** 
+  Indicates a value has a mixed state of both on and off. 
+  
+  @property {String}
+*/
+SC.MIXED_STATE = '__MIXED__' ;
+
 /** @class
   A Pane is like a regular view except that it does not need to live within a 
   parent view.  You usually use a Pane to form the root of a view hierarchy in 
@@ -218,12 +225,33 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
     @returns {Object} object that handled the event
   */
   sendEvent: function(action, evt, target) {
-    var handler ;
+    var handler;
     
     // walk up the responder chain looking for a method to handle the event
     if (!target) target = this.get('firstResponder') ;
-    while(target && !target.tryToPerform(action, evt)) {
-
+    while(target) {
+      if (action === 'touchStart') {
+        // first, we must check that the target is not already touch responder
+        // if it is, we don't want to have "found" it; that kind of recursion is sure to
+        // cause really severe, and even worse, really odd bugs.
+        if (evt.touchResponder === target) {
+          target = null;
+          break;
+        }
+        
+        // now, only pass along if the target does not already have any touches, or is
+        // capable of accepting multitouch.
+        if (!target.get("hasTouch") || target.get("acceptsMultitouch")) {
+          if (target.tryToPerform("touchStart", evt)) break;
+        }
+      } else if (action === 'touchEnd' && !target.get("acceptsMultitouch")) {
+        if (!target.get("hasTouch")) {
+          if (target.tryToPerform("touchEnd", evt)) break;
+        }
+      } else {
+        if (target.tryToPerform(action, evt)) break;
+      }
+      
       // even if someone tries to fill in the nextResponder on the pane, stop
       // searching when we hit the pane.
       target = (target === this) ? null : target.get('nextResponder') ;
@@ -248,6 +276,79 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
     return evt.mouseHandler || target ;
   },
 
+  /**
+    Attempts to send a touch event down the responder chain for this pane. If
+    you pass a target, this method will begin with the target and work up the
+    responder chain. Otherwise, it will begin with the current firstResponder
+    and walk up the chain looking for any responder that implements a handler
+    for the passed method and returns YES or SC.MIXED_STATE when executed.
+
+    This method differs from the sendEvent method by supporting views that
+    return SC.MIXED_STATE. In that case, the event will continue to bubble up
+    the chain until the end is reached or another view returns YES.
+
+    @param {String} action
+    @param {SC.Event} evt
+    @param {Object} target
+    @returns {Array} views an array of views that handled the event
+  */
+  sendTouchEvent: function(action, evt, target) {
+    var handler, response, exclusive = NO, ret = [] ;
+
+    // walk up the responder chain looking for a method to handle the event
+    if (!target) target = this.get('firstResponder') ;
+    while (target) {
+      if (target.respondsTo(action)) {
+        switch (target[action](evt)) {
+          case SC.MIXED_STATE:
+            // The view is interested in events but doesn't want exclusive
+            // control, so keep it in a list of interested views
+            ret.push(target);
+            break;
+          case YES:
+            // The view wants to respond to this event, so we'll stop looking
+            // and give it exclusive control
+            ret = [target];
+            target = null;
+            exclusive = YES;
+            continue;
+        }
+      }
+
+      // even if someone tries to fill in the nextResponder on the pane, stop
+      // searching when we hit the pane.
+      target = (target === this) ? null : target.get('nextResponder') ;
+    }
+
+    // if no handler was found in the responder chain, try the default
+    if (!exclusive && (target = this.get('defaultResponder'))) {
+      if (typeof target === SC.T_STRING) {
+        target = SC.objectForPropertyPath(target);
+      }
+
+      if (target) {
+        // Make sure we merge the return arrays instead of clobbering
+        // our earlier results
+        if (target.isResponderContext) {
+          ret = ret.concat(target.sendTouchAction(action, this, evt));
+        } else {
+          if (target.respondsTo(action)) response = target[action](evt);
+
+          switch (response) {
+            case SC.MIXED_STATE:
+              ret.push(target);
+              break;
+            case YES:
+              ret = [target];
+          }
+        }
+      }
+    }
+
+    target = null;
+    return ret ;
+  },
+
   performKeyEquivalent: function(keystring, evt) {
     var ret = sc_super() ; // try normal view behavior first
     if (!ret) {
@@ -392,7 +493,7 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
     var nextValidKeyView;
 
     // Handle tab key presses if we don't have a first responder already
-    if (evt.which === 9 && !this.get('firstResponder')) {
+    if ((evt.which === 9 || (SC.browser.mozilla && evt.keyCode ===9)) && !this.get('firstResponder')) {
       // Cycle forwards by default, backwards if the shift key is held
       if (evt.shiftKey) {
         nextValidKeyView = this.get('previousValidKeyView');
@@ -723,10 +824,18 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
   isPaneAttached: NO,
   
   /**
-    If YES, a touch itnercept pane will be added above this pane.
+    If YES, a touch intercept pane will be added above this pane when on
+    touch platforms.
   */
-  hasTouchIntercept: NO,
-  
+  wantsTouchIntercept: NO,
+
+  /**
+    Returns YES if wantsTouchIntercept and this is a touch platform.
+  */
+  hasTouchIntercept: function(){
+    return this.get('wantsTouchIntercept') && SC.platform.touch;
+  }.property('wantsTouchIntercept').cacheable(),
+
   /**
     The Z-Index of the pane. Currently, you have to match this in CSS.
     TODO: ALLOW THIS TO AUTOMATICALLY SET THE Z-INDEX OF THE PANE (as an option).
@@ -739,8 +848,7 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
   touchZ: 99,
 
   _addIntercept: function() {
-    if (this.get("hasTouchIntercept") && SC.platform.touch) {
-      this.set("usingTouchIntercept", YES);
+    if (this.get('hasTouchIntercept')) {
       var div = document.createElement("div");
       var divStyle = div.style;
       divStyle.position = "absolute";
@@ -834,6 +942,12 @@ SC.Pane = SC.View.extend(SC.ResponderContext,
 
   /** @private */
   init: function() {
+    // Backwards compatibility
+    if (this.hasTouchIntercept === YES) {
+      console.warn("Do not set hasTouchIntercept directly. Use wantsTouchIntercept instead.");
+      this.hasTouchIntercept = SC.platform.touch;
+    }
+
     // if a layer was set manually then we will just attach to existing 
     // HTML.
     var hasLayer = !!this.get('layer') ;

data/lib/frameworks/sproutcore/frameworks/{runtime → amber}/protocols/observable_protocol.js

@@ -11,21 +11,21 @@
   work.
 */
 SC.ObservableProtocol = {
-  
-  /**  
-    Generic property observer called whenever a property on the receiver 
+
+  /**
+    Generic property observer called whenever a property on the receiver
     changes.
-    
+
     If you need to observe a large number of properties on your object, it
     is sometimes more efficient to implement this observer only and then to
-    handle requests yourself.  Although this observer will be triggered 
+    handle requests yourself.  Although this observer will be triggered
     more often than an observer registered on a specific property, it also
-    does not need to be registered which can make it faster to setup your 
+    does not need to be registered which can make it faster to setup your
     object instance.
-    
+
     You will often implement this observer using a switch statement on the
-    key parameter, taking appropriate action. 
-    
+    key parameter, taking appropriate action.
+
     @param observer {null} no longer used; usually null
     @param target {Object} the target of the change.  usually this
     @param key {String} the name of the property that changed
@@ -34,7 +34,7 @@ SC.ObservableProtocol = {
     @returns {void}
   */
   propertyObserver: function(observer,target,key,value, revision) {
-    
+
   }
-  
+
 };

data/lib/frameworks/sproutcore/frameworks/{runtime → amber}/protocols/sparse_array_delegate.js

@@ -9,105 +9,105 @@
 
   Delegate that provides data for a sparse array.  If you set the delegate for
   a sparse array to an object that implements one or more of these methods,
-  they will be invoked by the sparse array to fetch data or to update the 
+  they will be invoked by the sparse array to fetch data or to update the
   array content as needed.
-  
-  Your object does not need to implement all of these methods, but it should 
+
+  Your object does not need to implement all of these methods, but it should
   at least implment the sparseArrayDidRequestIndex() method.
 
   @since SproutCore 1.0
 */
 SC.SparseArrayDelegate = {
-  
+
   /**
-    Invoked when an object requests the length of the sparse array and the 
-    length has not yet been set.  You can implement this method to update 
+    Invoked when an object requests the length of the sparse array and the
+    length has not yet been set.  You can implement this method to update
     the length property of the sparse array immediately or at a later time
     by calling the provideLength() method on the sparse array.
-    
-    This method will only be called once on your delegate unless you 
+
+    This method will only be called once on your delegate unless you
     subsequently call provideLength(null) on the array, which will effectively
     "empty" the array and cause the array to invoke the delegate again the
     next time its length is request.
-    
+
     If you do not set a length on the sparse array immediately, it will return
     a length of 0 until you provide the length.
-    
+
     @param {SC.SparseArray} sparseArray the array that needs a length.
     @returns {void}
   */
   sparseArrayDidRequestLength: function(sparseArray) {
     // Default does nothing.
   },
-  
+
   /**
     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 provideObjectsAtIndex() 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 
+    or you can wait and call them at a later time once you have loaded any
     data.
-    
+
     This method will only be called when an index is requested on the sparse
     array that has not yet been filled.  If you have filled an index or range
     and you would like to reset it, call the objectsDidChangeInRange() method
     on the sparse array.
-    
+
     Note that if you implement the sparseArrayDidRequestRange() method, that
     method will be invoked instead of this one whenever possible to allow you
     to fill in the array with the most efficiency possible.
-    
+
     @param {SC.SparseArray} sparseArray the sparse array
     @param {Number} index the requested index
     @returns {void}
   */
   sparseArrayDidRequestIndex: function(sparseArray, index) {
-    
+
   },
-  
+
   /**
-    Alternative method invoked when an object requests an index on the 
-    sparse array that has not yet been set.  If you set the 
-    rangeWindowSize property on the Sparse Array, then all object index 
-    requests will be expanded to to nearest range window and then this 
+    Alternative method invoked when an object requests an index on the
+    sparse array that has not yet been set.  If you set the
+    rangeWindowSize property on the Sparse Array, then all object index
+    requests will be expanded to to nearest range window and then this
     method will be called with that range.
-    
+
     You should fill in the passed range by calling the provideObjectsInRange()
     method on the sparse array.
-    
+
     If you do not implement this method but set the rangeWindowSize anyway,
     then the sparseArrayDidRequestIndex() method will be invoked instead.
-  
+
     Note that the passed range is a temporary object.  Be sure to clone it if
     you want to keep the range for later use.
-    
+
     @param {SC.SparseArray} sparseArray the sparse array
     @param {Range} range read only range.
     @returns {void}
   */
   sparseArrayDidRequestRange: function(sparseArray, range) {
-    
+
   },
-  
+
   /**
-    Optional delegate method you can use to determine the index of a 
-    particular object.  If you do not implement this method, then the 
+    Optional delegate method you can use to determine the index of a
+    particular object.  If you do not implement this method, then the
     sparse array will just search the objects it has loaded already.
-    
+
     @param {SC.SparseArray} sparseArray the sparse array
     @param {Object} object the object to find the index of
     @return {Number} the index or -1
     @returns {void}
   */
   sparseArrayDidRequestIndexOf: function(sparseArray, object) {
-    
+
   },
-  
+
   /**
-    Optional delegate method invoked whenever the sparse array attempts to 
-    changes its contents.  If you do not implement this method or if you 
+    Optional delegate method invoked whenever the sparse array attempts to
+    changes its contents.  If you do not implement this method or if you
     return NO from this method, then the edit will not be allowed.
-    
+
     @param {SC.SparseArray} sparseArray the sparse array
     @param {Number} idx the starting index to replace
     @param {Number} amt the number if items to replace
@@ -117,15 +117,15 @@ SC.SparseArrayDelegate = {
   sparseArrayShouldReplace: function(sparseArray, idx, amt, objects) {
     return NO ;
   },
-  
+
   /**
-    Invoked whenever the sparse array is reset.  Resetting a sparse array 
+    Invoked whenever the sparse array is reset.  Resetting a sparse array
     will cause it to flush its content and go back to the delegate for all
     property requests again.
-    
+
     @param {SC.SparseArray} sparseArray the sparse array
     @returns {void}
   */
-  sparseArrayDidReset: function(sparseArray) { 
+  sparseArrayDidReset: function(sparseArray) {
   }
 };