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

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

@@ -0,0 +1,151 @@
+// ==========================================================================
+// 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)
+// ==========================================================================
+
+// These are helpful utility functions for calculating range and rect values
+sc_require('system/browser');
+
+SC.mixin( /** @scope SC */ {
+
+  /**
+    Takes a URL of any type and normalizes it into a fully qualified URL with
+    hostname.  For example:
+
+    {{{
+      "some/path" => "http://localhost:4020/some/path"
+      "/some/path" => "http://localhost:4020/some/path"
+      "http://localhost:4020/some/path" => "http://localhost:4020/some/path"
+    }}}
+
+    @param url {String} the URL
+    @returns {String} the normalized URL
+  */
+  normalizeURL: function(url) {
+    if (url.slice(0,1) == '/') {
+      url = window.location.protocol + '//' + window.location.host + url ;
+    } else if ((url.slice(0,5) == 'http:') || (url.slice(0,6) == 'https:')) {
+      // no change
+    } else {
+      url = window.location.href + '/' + url ;
+    }
+    return url ;
+  },
+
+  /** Return true if the number is between 0 and 1 */
+  isPercentage: function(val){
+    return (val<1 && val>0);
+  },
+
+  /** Return the left edge of the frame */
+  minX: function(frame) {
+    return frame.x || 0;
+  },
+
+  /** Return the right edge of the frame. */
+  maxX: function(frame) {
+    return (frame.x || 0) + (frame.width || 0);
+  },
+
+  /** Return the midpoint of the frame. */
+  midX: function(frame) {
+    return (frame.x || 0) + ((frame.width || 0) / 2) ;
+  },
+
+  /** Return the top edge of the frame */
+  minY: function(frame) {
+    return frame.y || 0 ;
+  },
+
+  /** Return the bottom edge of the frame */
+  maxY: function(frame) {
+    return (frame.y || 0) + (frame.height || 0) ;
+  },
+
+  /** Return the midpoint of the frame */
+  midY: function(frame) {
+    return (frame.y || 0) + ((frame.height || 0) / 2) ;
+  },
+
+  /** Returns the point that will center the frame X within the passed frame. */
+  centerX: function(innerFrame, outerFrame) {
+    return (outerFrame.width - innerFrame.width) / 2 ;
+  },
+
+  /** Return the point that will center the frame Y within the passed frame. */
+  centerY: function(innerFrame, outerFrame) {
+    return (outerFrame.height - innerFrame.height) /2  ;
+  },
+
+  /**
+    The offset of an element.
+
+    This function returns the left and top offset of an element with respect to either the document, the
+    viewport or the element's parent element.  In standard SproutCore applications, the coordinates of the
+    viewport are equivalent to the document, but a HTML5 application that wishes to use this component
+    of SproutCore might need to properly distinguish between the two.
+
+    For a useful discussion on the concepts of offsets and coordinates, see:
+    http://www.quirksmode.org/mobile/viewports.html.
+
+    @param {DOMElement|jQuery|String} elem the element to find the offset of.
+      This is passed to `jQuery()`, so any value supported by `jQuery()` will work.
+    @param {String} relativeToFlag flag to determine which relative element to determine offset by.
+      One of either: 'document', 'viewport' or 'parent' (default: 'document').
+    @returns {Object} the offset of the element as an Object (ie. Hash) in the form { left: value, top: value }.
+   */
+  offset: function(elem, relativeToFlag) {
+    var userAgent,
+        index,
+        mobileBuildNumber,
+        result;
+
+    relativeToFlag = relativeToFlag || 'document';
+
+    if (relativeToFlag === 'parent') {
+      result = jQuery(elem).position();
+    } else {
+      result = jQuery(elem).offset();
+
+      // jQuery does not workaround a problem with Mobile Safari versions prior to 4.1 that add the scroll
+      // offset to the results of getBoundingClientRect.
+      //
+      // See http://dev.jquery.it/ticket/6446
+      if (SC.browser.mobileSafari) {
+        userAgent = navigator.userAgent;
+        index = userAgent.indexOf('Mobile/');
+        mobileBuildNumber = userAgent.substring(index + 7, index + 9);
+
+        if (parseInt(SC.browser.mobileSafari, 0) <= 532 || (mobileBuildNumber <= "8A")) {
+          result.left = result.left - window.pageXOffset;
+          result.top = result.top - window.pageYOffset;
+        }
+      }
+
+      // Subtract the scroll offset for viewport coordinates
+      if (relativeToFlag === 'viewport') {
+        result.left = result.left - window.pageXOffset;
+        result.top = result.top - window.pageYOffset;
+      }
+    }
+
+    return result;
+  },
+
+  /** @deprecated
+    Deprecated. SC.offset() is more accurate, more flexible in the value for the element parameter and
+    easier to understand.
+
+    @param el The DOM element
+    @returns {Point} A hash with x, y offsets.
+  */
+  viewportOffset: function(el) {
+    console.warn("SC.viewportOffset() has been deprecated in favor of SC.offset().  Please use SC.offset() from here on.");
+    var result = SC.offset(el, 'viewport');
+
+    return {x: result.left, y: result.top};
+  }
+
+}) ;

data/lib/frameworks/sproutcore/frameworks/{amber → core_foundation}/tests/controllers/array/selection_support.js

@@ -316,3 +316,29 @@ function() {
   equals(selectionSet.get('length'), 0, 'selection set should have length 0');
   ok(indexSet === null, 'selection set should not still have an indexSet');
 });
+
+test("replacing content in an ArrayController propagates changes to bound arrangedObjects", function() {
+  equals(controller.getPath('arrangedObjects.length'), 5, "precond - controller has 5 items");
+
+  var obj, listChanged = 0;
+
+  SC.run(function() {
+    obj = SC.Object.create({
+      testController: controller,
+      listBinding: ".testController.arrangedObjects",
+      listDidChange: function() {
+        listChanged++;
+      }.observes('list')
+    });
+  });
+
+  equals(obj.getPath('list.length'), 5, "precond - binding has 5 items");
+
+  SC.run(function() {
+    controller.set('content', []);
+  });
+
+  equals(controller.getPath('arrangedObjects.length'), 0, "precond - controller has 5 items");
+  equals(obj.getPath('list.length'), 0, "binding has 0 items");
+  equals(listChanged, 1, "listDidChange was called");
+});

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

@@ -0,0 +1,14 @@
+module("Template Panes");
+
+test("Template panes append a main pane to the document body", function() {
+  var pane = SC.TemplatePane.append({
+    layerId: 'template-panes-are-so-cool',
+
+    template: SC.Handlebars.compile('<h1>foo bar baz</h1>')
+  });
+
+  ok(pane.get('layer'), "creates a layer for the pane");
+  equals(pane.$('#template-panes-are-so-cool').length, 1, "creates a view with the passed id");
+
+  pane.remove();
+});

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

@@ -0,0 +1,268 @@
+// ========================================================================
+// SC Miscellaneous Utils Tests - documentOffset
+// ========================================================================
+
+/*global module test htmlbody ok equals same */
+
+var pane, view1, view2, view3, view4;
+
+htmlbody('<style> body { height: 1500px; width: 1500px; } </style>');
+
+
+module("SC.offset", {
+
+  setup: function() {
+    var viewportEl;
+
+    SC.RunLoop.begin();
+
+    // Even though a full SC app doesn't really allow the viewport to be scaled or scrolled by default (thus
+    // the offset by viewport will always equal offset by document), we simulate an app that uses a
+    // scrollable viewport to test the validity of the functions.
+    if (SC.browser.mobileSafari) {
+      viewportEl = $("[name='viewport']")[0];
+
+      viewportEl.setAttribute('content','initial-scale=0.9, minimum-scale=0.5, maximum-scale=1.2, user-scalable=yes, width=device-height');
+    }
+
+    pane = SC.MainPane.create({
+      childViews: [
+        SC.View.extend({
+          classNames: 'upper'.w(),
+          layout: { top: 20, left: 20, width: 100, height: 100 },
+          childViews: [
+            SC.View.extend({
+              classNames: 'upper-inner'.w(),
+              layout: { top: 10, left: 10, width: 20, height: 20 }
+            })]
+        }),
+        SC.View.extend({
+          classNames: 'lower'.w(),
+          layout: { top: 1200, left: 20, width: 100, height: 100 },
+          childViews: [
+            SC.View.extend({
+              classNames: 'lower-inner'.w(),
+              layout: { top: 10, left: 10, width: 20, height: 20 }
+            })]
+        })]
+
+      // Useful for debugging in iOS
+      // /** Allow default touch events */
+      //  touchStart: function(touch) {
+      //    if (SC.browser.mobileSafari) touch.allowDefault();
+      //  },
+      //
+      //  touchesDragged: function(evt, touches) {
+      //    if (SC.browser.mobileSafari) evt.allowDefault();
+      //  },
+      //
+      //  touchEnd: function(touch) {
+      //    if (SC.browser.mobileSafari) touch.allowDefault();
+      //  }
+    });
+    pane.append();
+    SC.RunLoop.end();
+
+    view1 = pane.childViews[0];
+    view2 = pane.childViews[1];
+    view3 = view1.childViews[0];
+    view4 = view2.childViews[0];
+  },
+
+  teardown: function() {
+    // Useful for debugging in iOS
+    // if (!SC.browser.mobileSafari) {
+      pane.remove();
+      pane = view1 = view2 = view3 = view4 = null;
+    // }
+  }
+});
+
+
+function checkDocumentOffset(element, top, left) {
+  var docOffset = SC.offset(element, 'document');
+
+  equals(docOffset.top, top, '%@ document offset top'.fmt(element[0].className));
+  equals(docOffset.left, left, '%@ document offset left'.fmt(element[0].className));
+}
+
+function checkViewportOffset(element, top, left) {
+  var viewOffset = SC.offset(element, 'viewport');
+
+  equals(viewOffset.top, top, '%@ viewport offset top'.fmt(element[0].className));
+  equals(viewOffset.left, left, '%@ viewport offset left'.fmt(element[0].className));
+}
+
+function checkParentOffset(element, top, left) {
+  var parentOffset = SC.offset(element, 'parent');
+
+  equals(parentOffset.top, top, '%@ parent offset top'.fmt(element[0].className));
+  equals(parentOffset.left, left, '%@ parent offset left'.fmt(element[0].className));
+}
+
+test("Regular views", function() {
+  var element;
+
+  element = view1.$();
+  checkDocumentOffset(element, 20, 20);
+  checkViewportOffset(element, 20, 20);
+  checkParentOffset(element, 20, 20);
+
+  element = view3.$();
+  checkDocumentOffset(element, 30, 30);
+  checkViewportOffset(element, 30, 30);
+  checkParentOffset(element, 10, 10);
+});
+
+test("A regular view not visible within the visual viewport", function() {
+  var element;
+
+  element = view2.$();
+  checkDocumentOffset(element, 1200, 20);
+  checkViewportOffset(element, 1200, 20);
+  checkParentOffset(element, 1200, 20);
+
+  element = view4.$();
+  checkDocumentOffset(element, 1210, 30);
+  checkViewportOffset(element, 1210, 30);
+  checkParentOffset(element, 10, 10);
+});
+
+function testPosition4(element1, element2, element3, element4) {
+  checkDocumentOffset(element1, 20, 20);
+  checkViewportOffset(element1, -80, -80);
+  checkParentOffset(element1, 20, 20);
+
+  checkDocumentOffset(element3, 30, 30);
+  checkViewportOffset(element3, -70, -70);
+  checkParentOffset(element3, 10, 10);
+
+  checkDocumentOffset(element2, 1200, 20);
+  checkViewportOffset(element2, 1100, -80);
+  checkParentOffset(element2, 1200, 20);
+
+  checkDocumentOffset(element4, 1210, 30);
+  checkViewportOffset(element4, 1110, -70);
+  checkParentOffset(element4, 10, 10);
+
+  window.start(); // continue the tests
+}
+
+function testPosition3(element1, element2, element3, element4) {
+  checkDocumentOffset(element1, 20, 20);
+  checkViewportOffset(element1, -80, 10);
+  checkParentOffset(element1, 20, 20);
+
+  checkDocumentOffset(element3, 30, 30);
+  checkViewportOffset(element3, -70, 20);
+  checkParentOffset(element3, 10, 10);
+
+  checkDocumentOffset(element2, 1200, 20);
+  checkViewportOffset(element2, 1100, 10);
+  checkParentOffset(element2, 1200, 20);
+
+  checkDocumentOffset(element4, 1210, 30);
+  checkViewportOffset(element4, 1110, 20);
+  checkParentOffset(element4, 10, 10);
+
+  window.start();
+}
+
+function testPosition2(element1, element2, element3, element4) {
+  checkDocumentOffset(element1, 20, 20);
+  checkViewportOffset(element1, 10, 10);
+  checkParentOffset(element1, 20, 20);
+
+  checkDocumentOffset(element3, 30, 30);
+  checkViewportOffset(element3, 20, 20);
+  checkParentOffset(element3, 10, 10);
+
+  checkDocumentOffset(element2, 1200, 20);
+  checkViewportOffset(element2, 1190, 10);
+  checkParentOffset(element2, 1200, 20);
+
+  checkDocumentOffset(element4, 1210, 30);
+  checkViewportOffset(element4, 1200, 20);
+  checkParentOffset(element4, 10, 10);
+
+  window.start();
+}
+
+function testPosition1(element1, element2, element3, element4) {
+  // For some reason, the scroll jumps back to 0,0 if we don't set it here
+  window.scrollTo(0, 10);
+
+  checkDocumentOffset(element1, 20, 20);
+  checkViewportOffset(element1, 10, 20);
+  checkParentOffset(element1, 20, 20);
+
+  checkDocumentOffset(element3, 30, 30);
+  checkViewportOffset(element3, 20, 30);
+  checkParentOffset(element3, 10, 10);
+
+  checkDocumentOffset(element2, 1200, 20);
+  checkViewportOffset(element2, 1190, 20);
+  checkParentOffset(element2, 1200, 20);
+
+  checkDocumentOffset(element4, 1210, 30);
+  checkViewportOffset(element4, 1200, 30);
+  checkParentOffset(element4, 10, 10);
+
+  window.start();
+}
+
+test("A regular view with window scroll offset top:10", function() {
+  var element1 = view1.$(),
+      element2 = view2.$(),
+      element3 = view3.$(),
+      element4 = view4.$();
+
+  window.stop();
+
+  window.scrollTo(0, 10);
+  SC.RunLoop.begin();
+  SC.Timer.schedule({ target: this, action: function() { return testPosition1(element1, element2, element3, element4); }, interval: 200 });
+  SC.RunLoop.end();
+});
+
+test("A regular view with window scroll offset top:10, left: 10", function() {
+  var element1 = view1.$(),
+      element2 = view2.$(),
+      element3 = view3.$(),
+      element4 = view4.$();
+
+  window.stop();
+
+  window.scrollTo(10, 10);
+  SC.RunLoop.begin();
+  SC.Timer.schedule({ target: this, action: function() { return testPosition2(element1, element2, element3, element4); }, interval: 200 });
+  SC.RunLoop.end();
+});
+
+test("A regular view with window scroll offset top:100, left: 10", function() {
+  var element1 = view1.$(),
+      element2 = view2.$(),
+      element3 = view3.$(),
+      element4 = view4.$();
+
+  window.stop();
+
+  window.scrollTo(10, 100);
+  SC.RunLoop.begin();
+  SC.Timer.schedule({ target: this, action: function() { return testPosition3(element1, element2, element3, element4); }, interval: 200 });
+  SC.RunLoop.end();
+});
+
+test("A regular view with window scroll offset top:100, left: 100", function() {
+  var element1 = view1.$(),
+      element2 = view2.$(),
+      element3 = view3.$(),
+      element4 = view4.$();
+
+  window.stop();
+
+  window.scrollTo(100, 100);
+  SC.RunLoop.begin();
+  SC.Timer.schedule({ target: this, action: function() { return testPosition4(element1, element2, element3, element4); }, interval: 200 });
+  SC.RunLoop.end();
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/main_pane.js

@@ -0,0 +1,43 @@
+// ========================================================================
+// MainPane Unit Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+// ..........................................................
+// BASE TESTS
+// 
+// These tests exercise the API.  See below for tests that cover edge 
+// conditions.  If you find a bug, we recommend that you add a test in the 
+// edge case section.
+
+(function() {
+  var FRAME = { x: 10, y: 10, width: 30, height: 30 } ;
+
+  var pane, view ; // test globals
+
+  module('SC.MainPane', {
+    setup: function() {
+      pane = SC.MainPane.create();
+    },
+
+    teardown: function() {
+      pane.remove();
+    }
+  });
+
+  test("should not be attached before calling append()", function() {
+    equals(pane.get('isPaneAttached'), NO) ;
+  });
+
+  test("should attach when calling append()", function() {
+    pane.append() ;
+    equals(pane.get('isPaneAttached'), YES) ;
+  });
+
+  test("appending should make pane main & key", function() {
+    pane.append();
+    var r = pane.get('rootResponder');
+    equals(r.get('mainPane'), pane, 'should become mainPane');
+    equals(r.get('keyPane'), pane, 'should become keyPane');
+  });
+})();