Merge branch 'open940b' into open929

Merge in Fixed Position updates to reconcile conflicts
related to generalization of selection mechanism, WTD-929.

Conflicts:
	platform/features/layout/src/FixedController.js
	platform/features/layout/test/FixedControllerSpec.js

platform/features/layout/test/FixedControllerSpec.js

@@ -170,6 +170,20 @@ define(
                     .toHaveBeenCalledWith(elements[1]);
             });
 
+            it("allows selection retrieval", function () {
+                // selected with no arguments should give the current
+                // selection
+                var elements;
+
+                testModel.modified = 1;
+                findWatch("model.modified")(testModel.modified);
+
+                elements = controller.getElements();
+                controller.select(elements[1]);
+                mockScope.selection.get.andReturn(elements[1]);
+                expect(controller.selected()).toEqual(elements[1]);
+            });
+
             it("allows selections to be cleared", function () {
                 var elements;
 
@@ -303,6 +317,69 @@ define(
                     jasmine.any(Object)
                 );
             });
+
+            it("exposes drag handles", function () {
+                var handles;
+
+                // Select something so that drag handles are expected
+                testModel.modified = 1;
+                findWatch("model.modified")(testModel.modified);
+                controller.select(controller.getElements()[1]);
+
+                // Should have a non-empty array of handles
+                handles = controller.handles();
+                expect(handles).toEqual(jasmine.any(Array));
+                expect(handles.length).not.toEqual(0);
+
+                // And they should have start/continue/end drag methods
+                handles.forEach(function (handle) {
+                    expect(handle.startDrag).toEqual(jasmine.any(Function));
+                    expect(handle.continueDrag).toEqual(jasmine.any(Function));
+                    expect(handle.endDrag).toEqual(jasmine.any(Function));
+                });
+            });
+
+            it("exposes a move handle", function () {
+                var handle;
+
+                // Select something so that drag handles are expected
+                testModel.modified = 1;
+                findWatch("model.modified")(testModel.modified);
+                controller.select(controller.getElements()[1]);
+
+                // Should have a move handle
+                handle = controller.moveHandle();
+
+                // And it should have start/continue/end drag methods
+                expect(handle.startDrag).toEqual(jasmine.any(Function));
+                expect(handle.continueDrag).toEqual(jasmine.any(Function));
+                expect(handle.endDrag).toEqual(jasmine.any(Function));
+            });
+
+            it("updates selection style during drag", function () {
+                var oldStyle;
+
+                // Select something so that drag handles are expected
+                testModel.modified = 1;
+                findWatch("model.modified")(testModel.modified);
+                controller.select(controller.getElements()[1]);
+                mockScope.selection.get.andReturn(controller.getElements()[1]);
+
+                // Get style
+                oldStyle = controller.selected().style;
+
+                // Start a drag gesture
+                controller.moveHandle().startDrag();
+
+                // Haven't moved yet; style shouldn't have updated yet
+                expect(controller.selected().style).toEqual(oldStyle);
+
+                // Drag a little
+                controller.moveHandle().continueDrag([ 1000, 100 ]);
+
+                // Style should have been updated
+                expect(controller.selected().style).not.toEqual(oldStyle);
+            });
         });
     }
 );

platform/features/layout/test/FixedDragHandleSpec.js

@@ -0,0 +1,68 @@
+/*global define,describe,it,expect,beforeEach,jasmine,xit*/
+
+define(
+    ['../src/FixedDragHandle'],
+    function (FixedDragHandle) {
+        "use strict";
+
+        var TEST_GRID_SIZE = [ 13, 33 ];
+
+        describe("A fixed position drag handle", function () {
+            var mockElementHandle,
+                mockUpdate,
+                mockCommit,
+                handle;
+
+            beforeEach(function () {
+                mockElementHandle = jasmine.createSpyObj(
+                    'elementHandle',
+                    [ 'x', 'y' ]
+                );
+                mockUpdate = jasmine.createSpy('update');
+                mockCommit = jasmine.createSpy('commit');
+
+                mockElementHandle.x.andReturn(6);
+                mockElementHandle.y.andReturn(8);
+
+                handle = new FixedDragHandle(
+                    mockElementHandle,
+                    TEST_GRID_SIZE,
+                    mockUpdate,
+                    mockCommit
+                );
+            });
+
+            it("provides a style for positioning", function () {
+                var style = handle.style();
+                // 6 grid coords * 13 pixels - 3 pixels for centering
+                expect(style.left).toEqual('75px');
+                // 8 grid coords * 33 pixels - 3 pixels for centering
+                expect(style.top).toEqual('261px');
+            });
+
+            it("allows handles to be dragged", function () {
+                handle.startDrag();
+                handle.continueDrag([ 16, 8 ]);
+
+                // Should update x/y, snapped to grid
+                expect(mockElementHandle.x).toHaveBeenCalledWith(7);
+                expect(mockElementHandle.y).toHaveBeenCalledWith(8);
+
+                handle.continueDrag([ -16, -35 ]);
+
+                // Should have interpreted relative to initial state
+                expect(mockElementHandle.x).toHaveBeenCalledWith(5);
+                expect(mockElementHandle.y).toHaveBeenCalledWith(7);
+
+                // Should have called update once per continueDrag
+                expect(mockUpdate.calls.length).toEqual(2);
+
+                // Finally, ending drag should commit
+                expect(mockCommit).not.toHaveBeenCalled();
+                handle.endDrag();
+                expect(mockCommit).toHaveBeenCalled();
+            });
+
+        });
+    }
+);

platform/features/layout/test/elements/ElementProxySpec.js

@@ -47,6 +47,13 @@ define(
                 proxy.order("top");
                 expect(testElements).toEqual([{}, {}, {}, testElement]);
             });
+
+            it("ensures x/y values are non-negative", function () {
+                proxy.x(-1);
+                proxy.y(-400);
+                expect(proxy.x()).toEqual(0);
+                expect(proxy.y()).toEqual(0);
+            });
         });
     }
 );

platform/features/layout/test/elements/LineHandleSpec.js

@@ -0,0 +1,54 @@
+/*global define,describe,it,expect,beforeEach,jasmine,xit*/
+
+define(
+    ['../../src/elements/LineHandle'],
+    function (LineHandle) {
+        "use strict";
+
+        describe("A fixed position drag handle", function () {
+            var testElement,
+                handle;
+
+            beforeEach(function () {
+                testElement = {
+                    x: 3,
+                    y: 42,
+                    x2: 8,
+                    y2: 11
+                };
+
+                handle = new LineHandle(testElement, 'x', 'y', 'x2', 'y2');
+            });
+
+            it("provides x/y grid coordinates for its corner", function () {
+                expect(handle.x()).toEqual(3);
+                expect(handle.y()).toEqual(42);
+            });
+
+            it("changes x and y positions", function () {
+                handle.x(30);
+                expect(testElement.x).toEqual(30);
+                handle.y(40);
+                expect(testElement.y).toEqual(40);
+            });
+
+            it("disallows values less than zero", function () {
+                handle.x(-1);
+                handle.y(-400);
+                expect(testElement.x).toEqual(0);
+                expect(testElement.y).toEqual(0);
+            });
+
+            it("ensures that end points remain different", function () {
+                handle.x(testElement.x2);
+                handle.y(testElement.y2);
+                // First change should have been fine, because y was different
+                expect(testElement.x).toEqual(testElement.x2);
+                // Second change should have been rejected
+                expect(testElement.y).not.toEqual(testElement.y2);
+            });
+
+
+        });
+    }
+);

platform/features/layout/test/elements/LineProxySpec.js

@@ -67,6 +67,10 @@ define(
                 expect(proxy.y2()).toEqual(0);
             });
 
+            it("provides handles for both ends", function () {
+                expect(new LineProxy(diagonal).handles().length).toEqual(2);
+            });
+
         });
     }
 );

platform/features/layout/test/elements/ResizeHandleSpec.js

@@ -0,0 +1,59 @@
+/*global define,describe,it,expect,beforeEach,jasmine,xit*/
+
+define(
+    ['../../src/elements/ResizeHandle'],
+    function (ResizeHandle) {
+        "use strict";
+
+        var TEST_MIN_WIDTH = 4, TEST_MIN_HEIGHT = 2;
+
+        describe("A fixed position drag handle", function () {
+            var testElement,
+                handle;
+
+            beforeEach(function () {
+                testElement = {
+                    x: 3,
+                    y: 42,
+                    width: 30,
+                    height: 36
+                };
+
+                handle = new ResizeHandle(
+                    testElement,
+                    TEST_MIN_WIDTH,
+                    TEST_MIN_HEIGHT
+                );
+            });
+
+            it("provides x/y grid coordinates for lower-right corner", function () {
+                expect(handle.x()).toEqual(33);
+                expect(handle.y()).toEqual(78);
+            });
+
+            it("changes width of an element", function () {
+                handle.x(30);
+                // Should change width, not x
+                expect(testElement.x).toEqual(3);
+                expect(testElement.width).toEqual(27);
+            });
+
+            it("changes height of an element", function () {
+                handle.y(60);
+                // Should change height, not y
+                expect(testElement.y).toEqual(42);
+                expect(testElement.height).toEqual(18);
+            });
+
+            it("enforces minimum width/height", function () {
+                handle.x(testElement.x);
+                handle.y(testElement.y);
+                expect(testElement.x).toEqual(3);
+                expect(testElement.y).toEqual(42);
+                expect(testElement.width).toEqual(TEST_MIN_WIDTH);
+                expect(testElement.height).toEqual(TEST_MIN_HEIGHT);
+            });
+
+        });
+    }
+);

platform/features/layout/test/suite.json

@@ -1,5 +1,6 @@
 [
     "FixedController",
+    "FixedDragHandle",
     "FixedProxy",
     "LayoutController",
     "LayoutDrag",
@@ -9,6 +10,7 @@
     "elements/ElementProxies",
     "elements/ElementProxy",
     "elements/LineProxy",
+    "elements/ResizeHandle",
     "elements/TelemetryProxy",
     "elements/TextProxy"
 ]