sproutcore 1.5.0.pre.3 → 1.5.0.pre.4

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

@@ -0,0 +1,68 @@
+sc_require("panes/pane");
+
+SC.Pane.reopen(
+  /** @scope SC.Pane.prototype */ {
+
+  performKeyEquivalent: function(keystring, evt) {
+    var ret = sc_super() ; // try normal view behavior first
+    if (!ret) {
+      var defaultResponder = this.get('defaultResponder') ;
+      if (defaultResponder) {
+        // try default responder's own performKeyEquivalent method,
+        // if it has one...
+        if (defaultResponder.performKeyEquivalent) {
+          ret = defaultResponder.performKeyEquivalent(keystring, evt) ;
+        }
+
+        // even if it does have one, if it doesn't handle the event, give
+        // methodName-style key equivalent handling a try
+        if (!ret && defaultResponder.tryToPerform) {
+          ret = defaultResponder.tryToPerform(keystring, evt) ;
+        }
+      }
+    }
+    return ret ;
+  },
+
+  /** @private
+    If the user presses the tab key and the pane does not have a first
+    responder, try to give it to the next eligible responder.
+
+    If the keyDown event reaches the pane, we can assume that no responders in
+    the responder chain, nor the default responder, handled the event.
+  */
+  keyDown: function(evt) {
+    var nextValidKeyView;
+
+    // Handle tab key presses if we don't have a first responder already
+    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');
+      } else {
+        nextValidKeyView = this.get('nextValidKeyView');
+      }
+
+      if (nextValidKeyView) {
+        this.makeFirstResponder(nextValidKeyView);
+        return YES;
+      }
+    }
+
+    return NO;
+  },
+
+  /** @private method forwards status changes in a generic way. */
+  _forwardKeyChange: function(shouldForward, methodName, pane, isKey) {
+    var keyView, responder, newKeyView;
+    if (shouldForward && (responder = this.get('firstResponder'))) {
+      newKeyView = (pane) ? pane.get('firstResponder') : null ;
+      keyView = this.get('firstResponder') ;
+      if (keyView && keyView[methodName]) { keyView[methodName](newKeyView); }
+
+      if ((isKey !== undefined) && responder) {
+        responder.set('isKeyResponder', isKey);
+      }
+    }
+  }
+});

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

@@ -0,0 +1,108 @@
+sc_require("panes/pane");
+
+SC.Pane.reopen(
+  /** @scope SC.Pane.prototype */ {
+
+  /**
+    Last known window size.
+
+    @property {Rect}
+  */
+  currentWindowSize: null,
+
+  /**
+    The parent dimensions are always the last known window size.
+
+    @returns {Rect} current window size
+  */
+  computeParentDimensions: function(frame) {
+    if(this.get('designer') && SC.suppressMain) { return sc_super(); }
+
+    var wframe = this.get('currentWindowSize'),
+        wDim = {x: 0, y: 0, width: 1000, height: 1000},
+        layout = this.get('layout');
+
+    if (wframe){
+      wDim.width = wframe.width;
+      wDim.height = wframe.height;
+    }
+    // Call the RootResponder instance...
+    else if (SC.RootResponder.responder) {
+      var wSize = SC.RootResponder.responder.get('currentWindowSize');
+      if (wSize){
+        wDim.width = wSize.width;
+        wDim.height = wSize.height;
+      }
+    }
+    // If all else fails then we need to Calculate it from the window size and DOM
+    else {
+      var size, body, docElement;
+      if(!this._bod || !this._docElement){
+        body = document.body;
+        docElement = document.documentElement;
+        this._body=body;
+        this._docElement=docElement;
+      }else{
+        body = this._body;
+        docElement = this._docElement;
+      }
+
+      if (window.innerHeight) {
+        wDim.width = window.innerWidth;
+        wDim.height = window.innerHeight;
+      } else if (docElement && docElement.clientHeight) {
+        wDim.width = docElement.clientWidth;
+        wDim.height = docElement.clientHeight;
+      } else if (body) {
+        wDim.width = body.clientWidth;
+        wDim.height = body.clientHeight;
+      }
+      this.windowSizeDidChange(null, wDim);
+    }
+
+
+    // If there is a minWidth or minHeight set on the pane, take that
+    // into account when calculating dimensions.
+
+    if (layout.minHeight || layout.minWidth) {
+      if (layout.minHeight) {
+        wDim.height = Math.max(wDim.height, layout.minHeight);
+      }
+      if (layout.minWidth) {
+        wDim.width = Math.max(wDim.width, layout.minWidth);
+      }
+    }
+    return wDim;
+  },
+
+  /** @private Disable caching due to an known bug in SC. */
+  frame: function() {
+    if(this.get('designer') && SC.suppressMain) { return sc_super(); }
+    return this.computeFrameWithParentFrame(null) ;
+  }.property(),
+
+  /**
+    Invoked by the root responder whenever the window resizes.  This should
+    simply begin the process of notifying children that the view size has
+    changed, if needed.
+
+    @param {Rect} oldSize the old window size
+    @param {Rect} newSize the new window size
+    @returns {SC.Pane} receiver
+  */
+  windowSizeDidChange: function(oldSize, newSize) {
+    this.set('currentWindowSize', newSize) ;
+    this.parentViewDidResize(); // start notifications.
+    return this ;
+  },
+
+  /** @private */
+  paneLayoutDidChange: function() {
+    this.invokeOnce(this.updateLayout);
+  }.observes('layout'),
+
+  recomputeDependentProperties: function(original) {
+    this.set('currentWindowSize', this.rootResponder.computeWindowSize()) ;
+    original();
+  }.enhance()
+});

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

@@ -5,7 +5,7 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-require('panes/pane');
+sc_require('panes/pane');
 
 /** @class
 
@@ -49,4 +49,4 @@ SC.MainPane = SC.Pane.extend({
   
   ariaRole: 'application'
   
-});
+});

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

@@ -0,0 +1,27 @@
+sc_require("panes/pane");
+
+SC.Pane.reopen(
+  /** @scope SC.Pane.prototype */ {
+
+  /**
+    Inserts the pane's layer as the first child of the passed element.
+
+    @param {DOMElement|jQuery|String} elem the element to prepend the pane's layer to.
+      This is passed to `jQuery()`, so any value supported by `jQuery()` will work.
+    @returns {SC.Pane} receiver
+  */
+  prependTo: function(elem) {
+    return this.insert(function(layer) {
+      jQuery(elem).prepend(layer);
+    });
+  },
+
+  /**
+    This method has no effect in the pane.  Instead use remove().
+
+    @returns {void}
+  */
+  removeFromParent: function() {
+    throw SC.Error.desc("SC.Pane cannot be removed from its parent, since it's the root. Did you mean remove()?");
+  }
+});