sproutcore 1.10.3.1 → 1.11.0.rc1

data/lib/frameworks/sproutcore/frameworks/desktop/tests/views/scroll/integration.js

@@ -3,23 +3,28 @@ module("SC.ScrollView integration");
 test("should work with views that have static layout applied", function() {
   var pane;
   try {
-    pane = SC.MainPane.create({
-      childViews: ['scrollView'],
+    SC.run(function () {
+      pane = SC.MainPane.create({
+        childViews: ['scrollView'],
 
-      scrollView: SC.ScrollView.design({
-        layout: { width: 400, height: 600 },
+        scrollView: SC.ScrollView.design({
+          layout: { width: 400, height: 600 },
 
-        contentView: SC.View.design({
-          useStaticLayout: YES
+          contentView: SC.View.design({
+            useStaticLayout: YES
+          })
         })
-      })
-    });
+      });
 
-    pane.append();
-    SC.RunLoop.begin().end();
+      pane.append();
+    });
 
     ok(true, "displays scroll view without throwing an exception");
   } finally {
-    if (pane) { pane.remove(); }
+    if (pane) {
+      SC.run(function () {
+        pane.remove();
+      });
+    }
   }
 });

data/lib/frameworks/sproutcore/frameworks/desktop/tests/views/scroll/methods.js

@@ -14,21 +14,29 @@ module("SC.ScrollView", {
   setup: function () {
     SC.run(function () {
       pane = SC.MainPane.create({
+        layout: { height: 114, width: 114 }, // Gives us 100x100 container views without worrying about scrollers (or resorting to horrible, counterproductive hacks)
         childViews: [
+          // ScrollView with 4000x4000 contentView. "view" below.
           SC.ScrollView.extend({
-            contentView: SC.ImageView.design({ value: appleURL, layout: { height: 4000, width: 4000 }})
+            contentView: SC.ImageView.design({ value: appleURL, layout: { height: 4000, width: 4000 }}),
+            horizontalAlign: SC.ALIGN_LEFT
           }),
+          // ScrollView with 2000x2000 contentView. "view2" below.
           SC.ScrollView.extend({
-            contentView: SC.ImageView.design({ value: appleURL, layout: { height: 2000, width: 2000 }})
+            contentView: SC.ImageView.design({ value: appleURL, layout: { height: 2000, width: 2000 }}),
+            horizontalAlign: SC.ALIGN_LEFT
           }),
+          // ScrollView (view3 below) with nested ScrollView (view4 below).
           SC.ScrollView.extend({
             layout: { height: 400, width: 400 },
+            horizontalAlign: SC.ALIGN_LEFT,
             contentView: SC.View.design({
               layout: { height: 500, width: 500 },
               childViews: [
                 SC.ScrollView.design({
                   layout: { height: 200, width: 200, centerX: 0, centerY: 0 },
-                  contentView: SC.ImageView.design({ value: appleURL, layout: { height: 300, width: 300 }})
+                  contentView: SC.ImageView.design({ value: appleURL, layout: { height: 300, width: 300 }}),
+                  horizontalAlign: SC.ALIGN_LEFT
                 })
               ]
             })
@@ -72,12 +80,8 @@ module("SC.ScrollView", {
     });
 
     view = pane.childViews[0];
-    view.get('containerView').get('frame').height = 100;
-    view.get('containerView').get('frame').width = 100;
 
     view2 = pane.childViews[1];
-    view2.get('containerView').get('frame').height = 100;
-    view2.get('containerView').get('frame').width = 100;
 
     view3 = pane.childViews[2];
     view4 = view3.get('contentView').get('childViews')[0];
@@ -92,6 +96,9 @@ module("SC.ScrollView", {
 });
 
 
+// ------------------------------------
+// scrollTo, scrollBy
+//
 
 test("Scrolling to a certain co-ordinate of the container view", function () {
   equals(view.get('horizontalScrollOffset'), 0, "Initial horizontal offset must be zero");
@@ -133,6 +140,91 @@ test("Scrolling relative to the current possition of the container view", functi
   });
 });
 
+// ----------------------------------------------
+// scrollToRect, scrollToVisible, scrollDownLine
+//
+
+test("Scrolling to a rectangle", function () {
+  equals(view.get('horizontalScrollOffset'), 0, "Initial horizontal offset must be zero");
+  equals(view.get('verticalScrollOffset'), 0, "Initial vertical offset must be zero");
+
+  SC.run(function () {
+    view.scrollToRect({ x: 100, y: 100, width: 2000, height: 2000 });
+    equals(view.get('horizontalScrollOffset'), 100, "After scrolling to rect, horizontal offset must be 100");
+    equals(view.get('verticalScrollOffset'), 100, "After scrolling to rect, vertical offset must be 100");
+  });
+});
+
+test("Scrolling to a view", function() {
+  var pane = SC.MainPane.create({
+    childViews: ['scrollView'],
+    scrollView: SC.ScrollView.create({
+      layout: { height: 100, width: 100 },
+      canScale: YES,
+      contentView: SC.View.create({
+        layout: { height: 500, width: 500 },
+        childViews: ['innerView1', 'innerView2'],
+        innerView1: SC.View.create({
+          layout: { height: 100, width: 100, top: 150, left: 150 }
+        }),
+        innerView2: SC.View.create({
+          layout: { height: 100, width: 100, top: 200, left: 200 }
+        })
+      })
+    })
+  });
+
+  var scrollView = pane.scrollView,
+    contentView = scrollView.contentView,
+    innerView1 = scrollView.contentView.innerView1,
+    innerView2 = scrollView.contentView.innerView2;
+
+  SC.run(function() { pane.append(); }); // make sure we have a layer...
+
+  // Test scrolling to views.
+  SC.run(function() {
+    scrollView.scrollToVisible(innerView1);
+  });
+  equals(scrollView.get('verticalScrollOffset'), 150, "Scrolling to an inner view at top: 150 should offset the vertical scroll correctly");
+  equals(scrollView.get('horizontalScrollOffset'), 150, "Scrolling to an inner view at left: 150 should offset the horizontal scroll correctly");
+
+  SC.run(function() {
+    scrollView.scrollToVisible(innerView2);
+  });
+  equals(scrollView.get('verticalScrollOffset'), 200, "Scrolling to an inner view at top: 200 should offset the vertical scroll correctly");
+  equals(scrollView.get('horizontalScrollOffset'), 200, "Scrolling to an inner view at left: 200 should offset the horizontal scroll correctly");
+
+  SC.run(function() {
+    scrollView.scrollToVisible(contentView);
+  });
+  ok(!scrollView.get('horizontalScrollOffset') && !scrollView.get('verticalScrollOffset'), "Scrolling to the contentView itself should return to the upper left.");
+
+  // Test scrolling to views with scale.
+  SC.run(function() {
+    scrollView.set('scale', 2);
+  });
+
+  SC.run(function() {
+    scrollView.scrollToVisible(innerView1);
+  });
+  equals(scrollView.get('verticalScrollOffset'), 300, "Scrolling to an inner view at top: 150 with a content scale of 2 should offset the vertical scroll correctly");
+  equals(scrollView.get('horizontalScrollOffset'), 300, "Scrolling to an inner view at left: 150 with a content scale of 2 should offset the horizontal scroll correctly");
+
+  SC.run(function() {
+    scrollView.scrollToVisible(innerView2);
+  });
+  equals(scrollView.get('verticalScrollOffset'), 400, "Scrolling to an inner view at top: 200 with a content scale of 2 should offset the vertical scroll correctly");
+  equals(scrollView.get('horizontalScrollOffset'), 400, "Scrolling to an inner view at left: 200 with a content scale of 2 should offset the horizontal scroll correctly");
+
+  SC.run(function() {
+    scrollView.scrollToVisible(contentView);
+  });
+  ok(!scrollView.get('horizontalScrollOffset') && !scrollView.get('verticalScrollOffset'), "Scrolling to the contentView itself should return to the upper left (regardless of scale).");
+
+  // Cleanup.
+  pane.destroy();
+});
+
 test("Scrolling through line by line", function () {
   var line = 3;
   equals(view.get('horizontalScrollOffset'), 0, "Initial horizontal offset must be zero");
@@ -147,6 +239,10 @@ test("Scrolling through line by line", function () {
   });
 });
 
+// ------------------------------------
+// maximum[Horizontal|Vertical]ScrollOffset
+//
+
 test("maximumHorizontalScrollOffset() returns the maximum horizontal scroll dimension", function () {
   var old_horizontalScrollOffset = 2;
   var old_verticalScrollOffset = 2;
@@ -155,7 +251,7 @@ test("maximumHorizontalScrollOffset() returns the maximum horizontal scroll dime
     view2.set('horizontalScrollOffset', old_horizontalScrollOffset);
     view2.set('verticalScrollOffset', old_verticalScrollOffset);
     view2.scrollBy(5000, 0);
-    equals(view2.get('horizontalScrollOffset'), 1900, 'maximum y coordinate should be 1900');
+    equals(view2.get('horizontalScrollOffset'), 1900, 'maximum x coordinate should be 1900');
   });
 
 
@@ -163,7 +259,7 @@ test("maximumHorizontalScrollOffset() returns the maximum horizontal scroll dime
     view2.set('horizontalScrollOffset', old_horizontalScrollOffset);
     view2.set('verticalScrollOffset', old_verticalScrollOffset);
     view2.scrollBy(-5000, 0);
-    equals(view2.get('horizontalScrollOffset'), 0, 'minimum y coordinate should be 0');
+    equals(view2.get('horizontalScrollOffset'), 0, 'minimum x coordinate should be 0');
   });
 
 });
@@ -176,7 +272,7 @@ test("maximumVerticalScrollOffset() returns the maximum vertical scroll dimensio
     view2.set('horizontalScrollOffset', old_horizontalScrollOffset);
     view2.set('verticalScrollOffset', old_verticalScrollOffset);
     view2.scrollBy(0, 5000);
-    equals(view2.get('verticalScrollOffset'), 1900, 'maximum coordinate should be 1900');
+    equals(view2.get('verticalScrollOffset'), 1900, 'maximum y coordinate should be 1900');
   });
 
   SC.run(function () {
@@ -188,13 +284,15 @@ test("maximumVerticalScrollOffset() returns the maximum vertical scroll dimensio
 
 });
 
+// ------------------------------------
+// mouseWheel events
+//
 
 test("Mouse wheel events should only be captured if the scroll can scroll in the direction (both TOP-LEFT).", function () {
   // FIRST GROUP: everything scrolled all the way to the top left
   SC.run(function () {
     view3.scrollTo(0, 0);
     view4.scrollTo(0, 0);
-  });
 
   // Scrolling further left is not captured by either scroll view
   ok(!view3.mouseWheel({ wheelDeltaX: -10, wheelDeltaY: 0 }), 'The inner scroll view should not capture the mousewheel event since it cannot scroll further.');
@@ -211,13 +309,13 @@ test("Mouse wheel events should only be captured if the scroll can scroll in the
   // Scrolling right is captured by the target scroll view
   ok(view3.mouseWheel({ wheelDeltaX: 0, wheelDeltaY: 10 }), 'The inner scroll view should capture the mousewheel event since it can scroll further.');
   ok(view4.mouseWheel({ wheelDeltaX: 0, wheelDeltaY: 10 }), 'The outer scroll view should capture the mousewheel event since it can scroll further.');
+  });
 });
 
 test("Mouse wheel events should only be captured if the scroll can scroll in the direction (both BOTTOM-RIGHT).", function () {
   SC.run(function () {
     view3.scrollTo(114, 114);
     view4.scrollTo(114, 114);
-  });
 
     // Scrolling further right is not captured by either scroll view
   ok(!view3.mouseWheel({ wheelDeltaX: 10, wheelDeltaY: 0 }), 'The inner scroll view should not capture the mousewheel event since it cannot scroll further.');
@@ -234,6 +332,7 @@ test("Mouse wheel events should only be captured if the scroll can scroll in the
   // Scrolling left is captured by the target scroll view
   ok(view3.mouseWheel({ wheelDeltaX: 0, wheelDeltaY: -10 }), 'The inner scroll view should capture the mousewheel event since it can scroll further.');
   ok(view4.mouseWheel({ wheelDeltaX: 0, wheelDeltaY: -10 }), 'The outer scroll view should capture the mousewheel event since it can scroll further.');
+  });
 });
 
 test("Mouse wheel events not capturable by the inner scroll should bubble to the outer scroll (scroll right).", function () {
@@ -418,3 +517,56 @@ test("Mouse wheel events capturable by the inner scroll should not bubble to the
   }, interval: 200 });
   SC.RunLoop.end();
 });
+
+// ------------------------------------
+// scale
+//
+
+test("Setting scale on ScrollView", function() {
+  // canScale: NO
+  SC.run(function() {
+    view.set('scale', 0.8);
+  });
+  equals(view.get('scale'), 1, "Setting scale on a ScrollView with canScale: NO doesn't change scale.");
+
+  // canScale: YES
+  SC.run(function() {
+    view.set('canScale', YES);
+    view.set('scale', 0.8);
+  });
+  equals(view.get('scale'), 0.8, "Setting scale on a ScrollView with canScale: YES changes scale");
+
+  // Exceeding min
+  SC.run(function() {
+    view.set('scale', -100);
+  });
+  equals(view.get('scale'), view.get('minimumScale'), "Scale is constrained by minimumScale");
+
+  // Exceeding max
+  SC.run(function() {
+    view.set('scale', 100);
+  });
+  equals(view.get('scale'), view.get('maximumScale'), "Scale is constrained by maximumScale");
+
+});
+
+// test("Setting scale on ScrollView with SC.Scalable contentView", function() {
+//   var contentView = view.get('contentView'),
+//       didCall, withScale;
+
+//   // Patch in SC.Scalable support.
+//   contentView.isScalable = YES;
+//   contentView.applyScale = function(scale) {
+//     didCall = YES;
+//     withScale = scale;
+//   };
+
+//   SC.run(function() {
+//     view.set('canScale', YES);
+//     view.set('scale', 0.8);
+//   });
+//   ok(didCall, "Setting scale on ScrollView with SC.Scalable contentView calls contentView.applyScale.");
+//   equals(withScale, 0.8, "Setting scale on ScrollView with SC.Scalable contentView passes the correct scale to contentView.applyScale");
+// });
+
+

data/lib/frameworks/sproutcore/frameworks/desktop/tests/views/scroll/scale.js

@@ -0,0 +1,387 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            portions copyright @2011 Apple Inc.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/*global module, test, equals */
+
+var pane;
+var imageUrl = sc_static('images/sproutcore-512.png'); // 'http://photos4.meetupstatic.com/photos/event/4/6/9/9/600_4518073.jpeg';
+
+var scrollViewOriginalHeight = 100;
+var scrollViewOriginalWidth = 200;
+
+var contentViewOriginalHeight = 400;
+var contentViewOriginalWidth = 400;
+
+var pane = SC.ControlTestPane.design()
+  .add("scrollView with content view of fixed height", SC.ScrollView.design({
+    // ScrollView with overflowing contentView
+    layout: { top: 0, left: 0, height: scrollViewOriginalHeight, width: scrollViewOriginalWidth },
+    contentView: SC.ImageView.design({ value: imageUrl, layout: { height: contentViewOriginalHeight, width: contentViewOriginalWidth }}),
+
+    canScale: YES,
+    minimumScale: 0.01,
+    maximumScale: 100
+  }))
+  .add("scrollview with content view attached to top and bottom", SC.ScrollView.design({
+    // ScrollView with overflowing contentView
+    layout: { top: 0, left: 0, height: scrollViewOriginalHeight, width: scrollViewOriginalWidth },
+    contentView: SC.ImageView.design({ value: imageUrl, layout: { top: 0, bottom: 0, width: contentViewOriginalWidth }}),
+
+    canScale: YES,
+    minimumScale: 0.01,
+    maximumScale: 100
+  }))
+  .add("scrollView with content view of fixed height center-center-aligned", SC.ScrollView.design({
+    // ScrollView with overflowing contentView
+    layout: { top: 0, left: 0, height: scrollViewOriginalHeight, width: scrollViewOriginalWidth },
+    contentView: SC.ImageView.design({ value: imageUrl, layout: { height: contentViewOriginalHeight, width: contentViewOriginalWidth }}),
+
+    canScale: YES,
+    minimumScale: 0.01,
+    maximumScale: 100,
+
+    horizontalAlign: SC.ALIGN_CENTER,
+    verticalAlign: SC.ALIGN_MIDDLE
+  }))
+  .add("scrollView with content view of fixed height bottom-right-aligned", SC.ScrollView.design({
+    // ScrollView with overflowing contentView
+    layout: { top: 0, left: 0, height: scrollViewOriginalHeight, width: scrollViewOriginalWidth },
+    contentView: SC.ImageView.design({ value: imageUrl, layout: { height: contentViewOriginalHeight, width: contentViewOriginalWidth }}),
+
+    canScale: YES,
+    minimumScale: 0.01,
+    maximumScale: 100,
+
+    horizontalAlign: SC.ALIGN_RIGHT,
+    verticalAlign: SC.ALIGN_BOTTOM
+  }))
+  .add("scrollView with content view of fixed height and bottom-right initial alignment", SC.ScrollView.design({
+    // ScrollView with overflowing contentView
+    layout: { top: 0, left: 0, height: scrollViewOriginalHeight, width: scrollViewOriginalWidth },
+    contentView: SC.ImageView.design({ value: imageUrl, layout: { height: contentViewOriginalHeight, width: contentViewOriginalWidth }}),
+
+    canScale: YES,
+    minimumScale: 0.01,
+    maximumScale: 100,
+
+    horizontalAlign: SC.ALIGN_LEFT,
+    verticalAlign: SC.ALIGN_TOP,
+    initialHorizontalAlign: SC.ALIGN_RIGHT,
+    initialVerticalAlign: SC.ALIGN_BOTTOM
+  }));
+
+module("SC.ScrollView", {
+  setup: function () {
+    pane.standardSetup().setup();
+  },
+
+  teardown: function () {
+    pane.standardSetup().teardown();
+  }
+});
+
+// ------------------------------
+// BASIC
+//
+
+test('Initial values of scale and horizontal offsets are good', function () {
+  var scrollView = pane.view('scrollView with content view of fixed height');
+
+  equals(scrollView.get('scale'), 1, 'Initial scale is 1');
+
+  equals(scrollView.get('horizontalScrollOffset'), 107, 'Initial horizontal offset must be half the maximumHorizontalScrollOffset');
+  equals(scrollView.get('verticalScrollOffset'), 0, 'Initial vertical offset must be zero');
+});
+
+test("Content view is scaled based on scroll view's scale property", function() {
+  var scrollView = pane.view('scrollView with content view of fixed height'),
+    contentView = scrollView.get('contentView');
+
+  SC.run(function() {
+    scrollView.set('scale', 0.1);
+  });
+
+  equals(scrollView.get('scale'), 0.1, 'Scale has been updated to 0.1');
+
+  equals(contentView.getPath('frame.width'), 0.1 * contentViewOriginalWidth, "Content view's width is scaled smaller based on scroll view's scale");
+  equals(contentView.getPath('frame.height'), 0.1 * contentViewOriginalHeight, "Content view's height is scaled smaller based on scroll view's scale");
+
+  SC.run(function() {
+    scrollView.set('scale', 10);
+  });
+
+  equals(scrollView.get('scale'), 10, 'Scale has been updated to 10');
+
+  equals(contentView.getPath('frame.width'), 10 * contentViewOriginalWidth, "Content view's width is scaled larger based on scroll view's scale");
+  equals(contentView.getPath('frame.height'), 10 * contentViewOriginalHeight, "Content view's height is scaled larger based on scroll view's scale");
+
+});
+
+// ------------------------------
+// Fully visible - static
+//
+
+test('When contentView is fully visible, it is positioned according to horizontalAlign', function() {
+  var scrollView = pane.view('scrollView with content view of fixed height'),
+    containerView = scrollView.get('containerView'),
+    contentView = scrollView.get('contentView');
+
+  SC.run(function() {
+    scrollView.set('scale', 0.1);
+  });
+
+  SC.run(function() {
+    scrollView.set('horizontalAlign', SC.ALIGN_LEFT);
+  });
+
+  equals(contentView.getPath('frame.x'), 0, "Content view's x offset is 0 when horizontalAlign is set to SC.ALIGN_LEFT");
+
+  SC.run(function() {
+    scrollView.set('horizontalAlign', SC.ALIGN_CENTER);
+  });
+
+  var expectedContentViewOffsetX = (containerView.getPath('frame.width') - contentView.getPath('frame.width')) / 2;
+  expectedContentViewOffsetX = Math.round(expectedContentViewOffsetX);
+  equals(contentView.getPath('frame.x'), expectedContentViewOffsetX, "Content view is centered when horizontalAlign is set to SC.ALIGN_CENTER");
+
+  SC.run(function() {
+    scrollView.set('horizontalAlign', SC.ALIGN_RIGHT);
+  });
+
+  expectedContentViewOffsetX = containerView.getPath('frame.width') - contentView.getPath('frame.width');
+  expectedContentViewOffsetX = Math.round(expectedContentViewOffsetX);
+
+  equals(contentView.getPath('frame.x'), expectedContentViewOffsetX, "Content view is aligned right when horizontalAlign is set to SC.ALIGN_RIGHT");
+});
+
+test('When contentView is fully visible, it is positioned according to verticalAlign', function() {
+  var scrollView = pane.view('scrollView with content view of fixed height'),
+    containerView = scrollView.get('containerView'),
+    contentView = scrollView.get('contentView');
+
+  SC.run(function() {
+    scrollView.set('scale', 0.1);
+  });
+
+  SC.run(function() {
+    scrollView.set('verticalAlign', SC.ALIGN_TOP);
+  });
+
+  equals(contentView.getPath('frame.y'), 0, "Content view's y offset is 0 when verticalAlign is set to SC.ALIGN_TOP");
+
+  SC.run(function() {
+    scrollView.set('verticalAlign', SC.ALIGN_MIDDLE);
+  });
+
+  var expectedContentViewOffsetX = (containerView.getPath('frame.height') - contentView.getPath('frame.height')) / 2;
+  expectedContentViewOffsetX = Math.round(expectedContentViewOffsetX);
+
+  equals(contentView.getPath('frame.y'), expectedContentViewOffsetX, "Content view is centered when verticalAlign is set to SC.ALIGN_MIDDLE");
+
+  SC.run(function() {
+    scrollView.set('verticalAlign', SC.ALIGN_BOTTOM);
+  });
+
+  expectedContentViewOffsetX = containerView.getPath('frame.height') - contentView.getPath('frame.height');
+  expectedContentViewOffsetX = Math.round(expectedContentViewOffsetX);
+
+  equals(contentView.getPath('frame.y'), expectedContentViewOffsetX, "Content view is aligned to the bottom when verticalAlign is set to SC.ALIGN_BOTTOM");
+});
+
+// ------------------------------
+// Zoomed in - static
+//
+
+test('When zoomed into the contentView, the content view should remain centered around visible center', function() {
+  var scrollView = pane.view('scrollView with content view of fixed height'),
+    containerFrame = scrollView.getPath('containerView.frame');
+
+  // The percentage offsets for horizontal: ALIGN_CENTER & vertical: ALIGN_TOP for the given content and container size.
+  var hPct = 0.5,
+      vPct = 0.1075;
+
+  SC.run(function() {
+    // Note: Before any scrolling occurs, scale changes adhere to initial alignments.
+    scrollView.set('horizontalScrollOffset', scrollView.get('horizontalScrollOffset'));
+    scrollView.set('verticalScrollOffset', scrollView.get('verticalScrollOffset'));
+
+    scrollView.set('scale', 10);
+  });
+
+  var newOffsets = {
+    h: hPct * (scrollView.get('maximumHorizontalScrollOffset') + containerFrame.width) - (containerFrame.width / 2),
+    v: vPct * (scrollView.get('maximumVerticalScrollOffset') + containerFrame.height) - (containerFrame.height / 2)
+  };
+
+  equals(scrollView.get('horizontalScrollOffset'), newOffsets.h, "Content view left offset remains centered to visible center when zoomed into contentView");
+  equals(scrollView.get('verticalScrollOffset'), newOffsets.v, "Content view top offset remains centered to visible center when zoomed into contentView");
+});
+
+// ------------------------------
+// Zooming in
+//
+
+/*
+  The following tests ensure that the content sticks to minimums or maximums when scaling. However, this seems like the incorrect
+  behavior. Instead zooming should respect the content's visible center (e.g. OS X Preview zooming behavior).
+  */
+// test('When zoomed into the contentView, the horizontal offset should stick to minimum if it was previously set to minimum', function() {
+//   var scrollView = pane.view('scrollView with content view of fixed height'),
+//     containerFrame = scrollView.getPath('containerView.frame');
+
+//   // first, zoom in a bit and set the horizontal offset to minimum
+//   SC.run(function() {
+//     scrollView.set('scale', 10);
+//     scrollView.set('horizontalScrollOffset', scrollView.get('minimumHorizontalScrollOffset'));
+//   });
+
+//   // verify that the horizontal offset is minimum
+
+//   equals(scrollView.get('horizontalScrollOffset'), scrollView.get('minimumHorizontalScrollOffset'), 'Horizontal offset is at minimum after setting it to be thus');
+
+//   // now, zoom in a bit more and make sure it's still minimum
+
+//   // The percentage offsets for horizontal: 0 @ scale of 10 & vertical: ALIGN_TOP for the given content and container size.
+//   var hPct = (0 + (containerFrame.width / 2)) / (scrollView.get('maximumHorizontalScrollOffset') + containerFrame.width),
+//       vPct = 0.125;
+
+//   SC.run(function() {
+//     scrollView.set('scale', 11);
+//   });
+
+//   var newOffsets = {
+//     h: hPct * (scrollView.get('maximumHorizontalScrollOffset') + containerFrame.width) - (containerFrame.width / 2),
+//     v: vPct * (scrollView.get('maximumVerticalScrollOffset') + containerFrame.height) - (containerFrame.height / 2)
+//   };
+
+//   equals(scrollView.get('horizontalScrollOffset'), newOffsets.h, 'Horizontal offset is still at minimum after scaling');
+// });
+
+// test('When zoomed into the contentView, the horizontal offset should stick to maximum if it was previously set to maximum', function() {
+//   var scrollView = pane.view('scrollView with content view of fixed height');
+
+//   // first, zoom in a bit and set the horizontal offset to maximum
+//   SC.run(function() {
+//     scrollView.set('scale', 10);
+//     scrollView.scrollTo(scrollView.get('maximumHorizontalScrollOffset'));
+//   });
+
+//   // verify that the horizontal offset is maximum
+
+//   equals(scrollView.get('horizontalScrollOffset'), scrollView.get('maximumHorizontalScrollOffset'), 'Horizontal offset is at maximum after setting it to be thus');
+
+//   // now, zoom in a bit more and make sure it's still maximum
+
+//   SC.run(function() {
+//     scrollView.set('scale', 11);
+//   });
+
+//   equals(scrollView.get('horizontalScrollOffset'), scrollView.get('maximumHorizontalScrollOffset'), 'Horizontal offset is still at maximum after scaling');
+// });
+
+// test('When zoomed into the contentView, the vertical offset should stick to minimum if it was previously set to minimum', function() {
+//   var scrollView = pane.view('scrollView with content view of fixed height');
+
+//   // first, zoom in a bit and set the vertical offset to minimum
+//   SC.run(function() {
+//     scrollView.set('scale', 10);
+//     scrollView.scrollTo(null, scrollView.get('minimumVerticalScrollOffset'));
+//   });
+
+//   // verify that the vertical offset is minimum
+
+//   equals(scrollView.get('verticalScrollOffset'), scrollView.get('minimumVerticalScrollOffset'), 'Vertical offset is at minimum after setting it to be thus');
+
+//   // now, zoom in a bit more and make sure it's still minimum
+
+//   SC.run(function() {
+//     scrollView.set('scale', 11);
+//   });
+
+//   equals(scrollView.get('verticalScrollOffset'), scrollView.get('minimumVerticalScrollOffset'), 'Vertical offset is still at minimum after scaling');
+// });
+
+// test('When zoomed into the contentView, the vertical offset should stick to maximum if it was previously set to maximum', function() {
+//   var scrollView = pane.view('scrollView with content view of fixed height');
+
+//   // first, zoom in a bit and set the vertical offset to maximum
+//   SC.run(function() {
+//     scrollView.set('scale', 10);
+//     scrollView.scrollTo(null, scrollView.get('maximumVerticalScrollOffset'));
+//   });
+
+//   // verify that the vertical offset is maximum
+
+//   equals(scrollView.get('verticalScrollOffset'), scrollView.get('maximumVerticalScrollOffset'), 'Vertical offset is at maximum after setting it to be thus');
+
+//   // now, zoom in a bit more and make sure it's still maximum
+
+//   SC.run(function() {
+//     scrollView.set('scale', 11);
+//   });
+
+//   equals(scrollView.get('verticalScrollOffset'), scrollView.get('maximumVerticalScrollOffset'), 'Vertical offset is still at maximum after scaling');
+// });
+
+// ---------------------------------------------------
+// Zooming in from fully-visible with fresh view
+//
+
+// test("Zooming from fully-visible to clipped with different alignments", function() {
+
+//   // TOP & LEFT
+//   var scrollView = pane.view('scrollView with content view of fixed height');
+
+//   SC.run(function() {
+//     scrollView.set('scale', 0.1);
+//   });
+//   SC.run(function() {
+//     scrollView.set('scale', 1);
+//   });
+//   equals(scrollView.get('horizontalScrollOffset'), 0, "Scaling a fresh left-aligned view in from fully-visible aligns it to the left");
+//   equals(scrollView.get('verticalScrollOffset'), 0, "Scaling a fresh top-aligned view in from fully-visible aligns it to the top");
+
+//   // CENTER
+//   scrollView = pane.view('scrollView with content view of fixed height center-center-aligned');
+
+//   SC.run(function() {
+//     scrollView.set('scale', 0.1);
+//   });
+//   SC.run(function() {
+//     scrollView.set('scale', 1);
+//   });
+//   equals(scrollView.get('horizontalScrollOffset'), (scrollView.get('maximumHorizontalScrollOffset')) / 2, "Scaling a fresh horizontally-center-aligned view in from fully-visible aligns it to the center");
+//   equals(scrollView.get('verticalScrollOffset'), (scrollView.get('maximumVerticalScrollOffset')) / 2, "Scaling a fresh vertically-middle-aligned view in from fully-visible aligns it to the center");
+
+//   // BOTTOM & RIGHT
+//   scrollView = pane.view('scrollView with content view of fixed height bottom-right-aligned');
+
+//   SC.run(function() {
+//     scrollView.set('scale', 0.1);
+//   });
+//   SC.run(function() {
+//     scrollView.set('scale', 1);
+//   });
+//   equals(scrollView.get('horizontalScrollOffset'), scrollView.get('maximumHorizontalScrollOffset'), "Scaling a fresh right-aligned view in from fully-visible aligns it to the right");
+//   equals(scrollView.get('verticalScrollOffset'), scrollView.get('maximumVerticalScrollOffset'), "Scaling a fresh bottom-aligned view in from fully-visible aligns it to the bottom");
+// });
+
+test("Initial alignments different than alignments", function() {
+  // This view is aligned top-left but with initial position at bottom-right. It should start at maximum offsets; when
+  // scaled out it should instead pin to the minimum offsets.
+  var view = pane.view('scrollView with content view of fixed height and bottom-right initial alignment');
+  equals(view.get('horizontalScrollOffset'), view.get('maximumHorizontalScrollOffset'), "initialHorizontalAlign correctly informs initial position when not scaled out");
+  equals(view.get('verticalScrollOffset'), view.get('maximumVerticalScrollOffset'), "initialVerticalAlign correctly informs initial position when not scaled out");
+
+  SC.run(function() {
+    view.set('scale', 0.1);
+  });
+
+  equals(view.get('horizontalScrollOffset'), 0, "horizontalAlign correctly takes over from initialHorizontalAlign when scaled out");
+  equals(view.get('verticalScrollOffset'), 0, "verticalAlign correctly takes over from initialVerticalAlign when scaled out");
+
+});