sproutcore 1.6.0.beta.3 → 1.6.0.rc.1

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view.js

@@ -1252,9 +1252,9 @@ SC.CoreView.mixin(/** @scope SC.View.prototype */ {
   */
   design: function() {
     if (this.isDesign) {
-      //@ if (debug)
+      // @if (debug)
       SC.Logger.warn("SC.View#design called twice for %@.".fmt(this));
-      //@ endif
+      // @endif
       return this;
     }
 
@@ -1472,7 +1472,8 @@ SC.CoreView.unload = function() {
    2. They act as first responders for incoming keyboard, mouse, and
      touch events.
 
-  ## View Initialization
+  View Initialization
+  ====
 
   When a view is setup, there are several methods you can override that
   will be called at different times depending on how your view is created.

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/enabled.js

@@ -1,6 +1,7 @@
 sc_require("views/view");
 
-SC.View.reopen({
+SC.View.reopen(
+  /** @scope SC.View.prototype */ {
   // ..........................................................
   // IS ENABLED SUPPORT
   //

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/keyboard.js

@@ -1,6 +1,7 @@
 sc_require("views/view");
 
-SC.View.reopen({
+SC.View.reopen(
+  /** @scope SC.View.prototype */ {
   // ..........................................................
   // KEY RESPONDER
   //
@@ -124,100 +125,265 @@ SC.View.reopen({
     return ret ;
   },
 
+  /**
+    The first child of this view for the purposes of tab ordering. If not
+    provided, the first element of childViews is used. Override this if
+    your view displays its child views in an order different from that
+    given in childViews.
+
+    @type SC.View
+    @default null
+  */
+  firstKeyView: null,
+
+  /**
+    @private
+
+    Actually calculates the firstKeyView as described in firstKeyView.
+
+    @returns {SC.View}
+  */
+  _getFirstKeyView: function() {
+    // if first was given, just return it
+    var firstKeyView = this.get('firstKeyView');
+    if(firstKeyView) return firstKeyView;
+
+    // otherwise return the first childView
+    var childViews = this.get('childViews');
+    if(childViews) return childViews[0];
+  },
+
+  /**
+    The last child of this view for the purposes of tab ordering. If not set, can be generated two different ways:
+    1. If firstKeyView is provided, it will be generated by starting from firstKeyView and traversing the childViews nextKeyView properties.
+    2. If firstKeyView is not provided, it will simply return the last element of childViews.
+
+    The first way is not very efficient, so if you provide firstKeyView you should also provide lastKeyView.
+
+    @type SC.View
+    @default null
+  */
+  lastKeyView: null,
+
+  /**
+    @private
+
+    Actually calculates the lastKeyView as described in lastKeyView.
+
+    @returns {SC.View}
+  */
+  _getLastKeyView: function() {
+    // if last was given, just return it
+    var lastKeyView = this.get('lastKeyView');
+    if(lastKeyView) return lastKeyView;
+
+    var view,
+    prev = this.get('firstKeyView');
+
+    // if first was given but not last, build by starting from first and
+    // traversing until we hit the end. this is obviously the least efficient
+    // way
+    if(prev) {
+      while(view = prev._getNextKeyView()) {
+        prev = view;
+      }
+
+      return prev;
+    }
+
+    // if neither was given, it's more efficient to just return the last
+    // childView
+    else {
+      var childViews = this.get('childViews');
+
+      if(childViews) return childViews[childViews.length - 1];
+    }
+  },
+
   /**
     Optionally points to the next key view that should gain focus when tabbing
     through an interface.  If this is not set, then the next key view will
-    be set automatically to the next child.
+    be set automatically to the next sibling as defined by its parent's
+    childViews property.
+
+    If any views define this, all of their siblings should define it as well,
+    otherwise undefined behavior may occur. Their parent view should also define
+    a firstKeyView.
+
+    This may also be set to a view that is not a sibling, but once again all
+    views in the chain must define it or undefined behavior will occur.
+
+    Likewise, any view that sets nextKeyView should also set previousKeyView.
+
+    @type SC.View
+    @default null
+  */
+
+  nextKeyView: undefined,
+
+  /**
+    @private
+
+    Gets the next key view by checking if the user set it and otherwise just
+    getting the next by index in childViews.
+
+    @return {SC.View}
   */
-  nextKeyView: null,
+  _getNextKeyView: function() {
+    var pv = this.get('parentView'),
+    nextKeyView = this.get('nextKeyView');
+
+    // if the parent defines lastKeyView, it takes priority over this views
+    // nextKeyView
+    if(pv && pv.get('lastKeyView') === this) return null;
+
+    // if this view defines a nextKeyView, use it
+    if(nextKeyView !== undefined) return nextKeyView;
+
+    // otherwise generate one based on parent view's childViews
+    if(pv) {
+      var childViews = pv.get('childViews');
+      return childViews[childViews.indexOf(this) + 1];
+    }
+  },
 
   /**
-    Computes the next valid key view, possibly returning the receiver or null.
-    This is the next key view that acceptsFirstResponder.
+    Computes the next valid key view. This is the next key view that
+    acceptsFirstResponder. Computed using depth first search. If the current view
+    is not valid, it will first traverse its children before trying siblings. If
+    the current view is the only valid view, the current view will be returned. Will
+    return null if no valid view can be found.
 
     @property
     @type SC.View
   */
   nextValidKeyView: function() {
-    var seen = [],
-        rootView = this.get('pane'), ret = this.get('nextKeyView');
+    var cur = this, next;
 
-    if(!ret) { ret = rootView._computeNextValidKeyView(this, seen); }
+    while(next !== this) {
+      next = null;
 
-    if(SC.TABBING_ONLY_INSIDE_DOCUMENT && !ret) {
-      ret = rootView._computeNextValidKeyView(rootView, seen);
-    }
+      // only bother to check children if we are visible
+      if(cur.get('isVisibleInWindow')) next = cur._getFirstKeyView();
 
-    return ret ;
-  }.property('nextKeyView'),
+      // if we have no children, check our sibling
+      if(!next) next = cur._getNextKeyView();
 
-  _computeNextValidKeyView: function(currentView, seen) {
-    var ret = this.get('nextKeyView'),
-        children, i, childLen, child;
-    if(this !== currentView && seen.indexOf(currentView)!=-1 &&
-      this.get('acceptsFirstResponder') && this.get('isVisibleInWindow')){
-      return this;
-    }
-    seen.push(this); // avoid cycles
-
-    // find next sibling
-    if (!ret) {
-      children = this.get('childViews');
-      for(i=0, childLen = children.length; i<childLen; i++){
-        child = children[i];
-        if(child._computeNextValidKeyView && child.get('isVisibleInWindow') && child.get('isVisible')){
-          ret = child._computeNextValidKeyView(currentView, seen);
-        }
-        if (ret) { return ret; }
+      // if we have no children or siblings, unroll up closest parent that has a
+      // next sibling
+      if(!next) while(cur = cur.get('parentView')) {
+        if(next = cur._getNextKeyView()) break;
       }
-      ret = null;
+
+      // if no parents have a next sibling, start over from the beginning
+      if(!next) next = this.get('pane');
+
+      // if it's a valid firstResponder, we're done!
+      if(next.get('isVisibleInWindow') && next.get('acceptsFirstResponder')) return next;
+
+      // otherwise keep looking
+      cur = next;
     }
-    return ret ;
-  },
+
+    // this will only happen if no views are visible and accept first responder
+    return null;
+
+  }.property('nextKeyView'),
 
   /**
-    Optionally points to the previous key view that should gain focus when
-    tabbing through the interface. If this is not set then the previous
-    key view will be set automatically to the previous child.
+    Optionally points to the previous key view that should gain focus when tabbing
+    through an interface.  If this is not set, then the previous key view will
+    be set automatically to the previous sibling as defined by its parent's
+    childViews property.
+
+    If any views define this, all of their siblings should define it as well,
+    otherwise undefined behavior may occur. Their parent view should also define
+    a lastKeyView.
+
+    This may also be set to a view that is not a sibling, but once again all
+    views in the chain must define it or undefined behavior will occur.
+
+    Likewise, any view that sets previousKeyView should also set nextKeyView.
+
+    @type SC.View
+    @default null
+  */
+  previousKeyView: undefined,
+
+  /**
+    @private
+
+    Gets the previous key view by checking if the user set it and otherwise just
+    getting the previous by index in childViews.
+
+    @return {SC.View}
   */
-  previousKeyView: null,
+  _getPreviousKeyView: function() {
+    var pv = this.get('parentView'),
+    previousKeyView = this.get('previousKeyView');
+
+    // if the parent defines firstKeyView, it takes priority over this views
+    // previousKeyView
+    if(pv && pv.get('firstKeyView') === this) return null;
+
+    // if this view defines a previousKeyView, use it
+    if(previousKeyView !== undefined) return previousKeyView;
+
+    // otherwise generate one based on parent view's childViews
+    if(pv) {
+      var childViews = pv.get('childViews');
+      return childViews[childViews.indexOf(this) - 1];
+    }
+  },
 
   /**
-    Computes the previous valid key view, possibly returning the receiver or
-    null.  This is the previous key view that acceptsFirstResponder.
+    Computes the previous valid key view. This is the previous key view that
+    acceptsFirstResponder. Traverse views in the opposite order from
+    nextValidKeyView. If the current view is the pane, tries deepest child. If the
+    current view has a previous view, tries its last child. If this view is the
+    first child, tries the parent. Will return null if no valid view can be
+    found.
 
     @property
     @type SC.View
   */
+  // TODO: clean this up
   previousValidKeyView: function() {
-    var seen = [],
-        rootView = this.pane(), ret = this.get('previousKeyView');
-    if(!ret) { ret = rootView._computePreviousValidKeyView(this, seen); }
-    return ret ;
-  }.property('previousKeyView'),
+    var cur = this, prev;
+
+    while(prev !== this) {
+      // normally, just try to get previous view's last child
+      if(cur.get('parentView')) prev = cur._getPreviousKeyView();
+
+      // if we are the pane, get our own last child
+      else prev = cur;
+
+      // loop down to the last valid child
+      if(prev) {
+        do {
+          cur = prev;
+          prev = prev._getLastKeyView();
+        } while(prev && prev.get('isVisibleInWindow'));
+
+        // if we ended on a null, unroll to the last one
+        // we don't unroll if we ended on a hidden view because we need
+        // to traverse to its previous view next iteration
+        if(!prev) prev = cur;
+      }
 
-  _computePreviousValidKeyView: function(currentView, seen) {
-    var ret = this.get('previousKeyView'),
-        children, i, child;
+      // if there is no previous view, traverse to the parent
+      else prev = cur.get('parentView');
 
-    if(this !== currentView && seen.indexOf(currentView)!=-1 &&
-      this.get('acceptsFirstResponder') && this.get('isVisibleInWindow')){
-      return this;
-    }
-    seen.push(this); // avoid cycles
-
-    // find next sibling
-    if (!ret) {
-      children = this.get('childViews');
-      for(i=children.length-1; 0<=i; i--){
-        child = children[i];
-        if(child._computePreviousValidKeyView && child.get('isVisibleInWindow') && child.get('isVisible')){
-          ret = child._computePreviousValidKeyView(currentView, seen);
-        }
-        if (ret) { return ret; }
-      }
-      ret = null;
+      // if the view is valid, return it
+      if(prev.get('isVisibleInWindow') && prev.get('acceptsFirstResponder')) return prev;
+
+      // otherwise, try to find its previous valid keyview
+      cur = prev;
     }
-    return ret ;
-  }
+
+    // if none of the views accept first responder and we make it back to where
+    // we started, just return null
+    return null;
+  }.property('previousKeyView')
 });
+

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/manipulation.js

@@ -1,6 +1,8 @@
 sc_require("views/view");
 
-SC.View.reopen({
+SC.View.reopen(
+  /** @scope SC.View.prototype */{
+
   /**
     This code exists to make it possible to pool SC.Views. We are not going to pool SC.Views in Amber
     */

data/lib/frameworks/sproutcore/frameworks/core_tools/core.js

@@ -15,6 +15,12 @@
 CoreTools = SC.Object.create( /** @scope CoreTools.prototype */ {
 
   NAMESPACE: 'CoreTools',
-  VERSION: '1.0.0'
-  
+  VERSION: '1.0.0',
+
+  attachUrlPrefix: function(url) {
+    if(url && SC.urlPrefix) {
+      url = SC.urlPrefix + url;
+    }
+    return url;
+  }
 }) ;

data/lib/frameworks/sproutcore/frameworks/core_tools/data_source.js

@@ -41,7 +41,7 @@ CoreTools.DataSource = SC.DataSource.extend({
     
     if (!query.get('isRemote')) return NO ; 
     
-    SC.Request.getUrl('/sc/targets.json')
+    SC.Request.getUrl(CoreTools.attachUrlPrefix('/sc/targets.json'))
       .set('isJSON', YES)
       .notify(this, 'fetchTargetsDidComplete', { query: query, store: store })
       .send();

data/lib/frameworks/sproutcore/frameworks/core_tools/models/target.js

@@ -34,7 +34,7 @@ CoreTools.Target = SC.Record.extend(
     URL to use to load the app.  If no an app, returns null
   */
   appUrl: function() {
-    return (this.get('kind') === 'app') ? this.get('name') : null;
+    return (this.get('kind') === 'app') ? CoreTools.attachUrlPrefix(this.get('name')) : null;
   }.property('kind', 'name').cacheable(),
   
   /**

data/lib/frameworks/sproutcore/frameworks/datastore/data_sources/data_source.js

@@ -5,6 +5,12 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
+/**
+  Indicates a value has a mixed state of both on and off.
+
+  @property {String}
+*/
+SC.MIXED_STATE = '__MIXED__';
 
 /** @class
 
@@ -327,20 +333,22 @@ SC.DataSource = SC.Object.extend( /** @scope SC.DataSource.prototype */ {
     @returns {Boolean} YES if data source can handle keys
   */
   commitRecords: function(store, createStoreKeys, updateStoreKeys, destroyStoreKeys, params) {
-    var cret, uret, dret;
+    var uret, dret, ret;
     if (createStoreKeys.length>0) {
-      cret = this.createRecords.call(this, store, createStoreKeys, params);
+      ret = this.createRecords.call(this, store, createStoreKeys, params);
     }
 
     if (updateStoreKeys.length>0) {
       uret = this.updateRecords.call(this, store, updateStoreKeys, params);
+      ret = SC.none(ret) ? uret : (ret === uret) ? ret : SC.MIXED_STATE;
     }
 
     if (destroyStoreKeys.length>0) {
       dret = this.destroyRecords.call(this, store, destroyStoreKeys, params);
+      ret = SC.none(ret) ? dret : (ret === dret) ? ret : SC.MIXED_STATE;
     }
 
-    return ((cret === uret) && (cret === dret)) ? cret : SC.MIXED_STATE;
+    return ret || NO;
   },
 
   /**
@@ -441,13 +449,12 @@ SC.DataSource = SC.Object.extend( /** @scope SC.DataSource.prototype */ {
     invokes the named action for each store key.  returns proper value
   */
   _handleEach: function(store, storeKeys, action, ids, params) {
-    var len = storeKeys.length, idx, ret, cur, lastArg;
-    if(!ids) ids = [];
+    var len = storeKeys.length, idx, ret, cur, idOrParams;
 
     for(idx=0;idx<len;idx++) {
-      lastArg = ids[idx] ? ids[idx] : params;
+      idOrParams = ids ? ids[idx] : params;
 
-      cur = action.call(this, store, storeKeys[idx], lastArg, params);
+      cur = action.call(this, store, storeKeys[idx], idOrParams);
       if (ret === undefined) {
         ret = cur ;
       } else if (ret === YES) {
@@ -456,7 +463,7 @@ SC.DataSource = SC.Object.extend( /** @scope SC.DataSource.prototype */ {
         ret = (cur === NO) ? NO : SC.MIXED_STATE ;
       }
     }
-    return ret ? ret : null ;
+    return !SC.none(ret) ? ret : null ;
   },