From 20f8f8a852840331d960856e832182193c3d8b0f Mon Sep 17 00:00:00 2001
From: Hristo Hristov <hristo.hristov@telerik.com>
Date: Tue, 19 Jan 2016 10:34:33 +0200
Subject: [PATCH 1/3] Fixed bug in GridLayout Added tests for GridLayout

---
 apps/tests/layouts/grid-layout-tests.ts       |  235 ++--
 apps/tests/layouts/layout-helper.android.ts   |  242 ++--
 apps/tests/layouts/layout-helper.d.ts         |   79 +-
 apps/tests/layouts/layout-helper.ios.ts       |  232 ++--
 apps/tests/layouts/stack-layout-tests.ts      |    8 +-
 .../xml-declaration/xml-declaration-tests.ts  |    3 +-
 ui/layouts/grid-layout/grid-layout-common.ts  |   44 +-
 ui/layouts/grid-layout/grid-layout.ios.ts     | 1068 ++++++++++-------
 8 files changed, 1140 insertions(+), 771 deletions(-)

diff --git a/apps/tests/layouts/grid-layout-tests.ts b/apps/tests/layouts/grid-layout-tests.ts
index c8b085f8b..f1226a2f2 100644
--- a/apps/tests/layouts/grid-layout-tests.ts
+++ b/apps/tests/layouts/grid-layout-tests.ts
@@ -1,8 +1,7 @@
-import page = require("ui/page");
-import layout = require("ui/layouts/grid-layout");
+import {Page} from "ui/page";
+import {GridLayout, ItemSpec, GridUnitType} from "ui/layouts/grid-layout";
 import {Button} from "ui/button";
 import TKUnit = require("../TKUnit");
-import helper = require("./layout-helper");
 import view = require("ui/core/view");
 import navHelper = require("../ui/helper");
 import utils = require("utils/utils");
@@ -15,69 +14,46 @@ import commonTests = require("./common-layout-tests");
 
 var DELTA = 1;
 
-export class MyGridLayout extends layout.GridLayout {
-    public measureCount: number = 0;
-    public layoutCount: number = 0;
+export class GridLayoutTest extends testModule.UITest<GridLayout> {
 
-    public get measured(): boolean {
-        return this.measureCount > 0;
-    }
-
-    public get layouted(): boolean {
-        return this.layoutCount > 0;
-    }
-
-    public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
-        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
-        this.measureCount++;
-    }
-
-    public onLayout(left: number, top: number, right: number, bottom: number): void {
-        super.onLayout(left, top, right, bottom);
-        this.layoutCount++;
-    }
-}
-
-export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
-
-    public create(): layout.GridLayout {
-        return new MyGridLayout();
+    public create(): GridLayout {
+        return new GridLayout();
     }
 
     private row(view: view.View): number {
-        return layout.GridLayout.getRow(view);
+        return GridLayout.getRow(view);
     }
 
     private rowSpan(view: view.View): number {
-        return layout.GridLayout.getRowSpan(view);
+        return GridLayout.getRowSpan(view);
     }
 
     private col(view: view.View): number {
-        return layout.GridLayout.getColumn(view);
+        return GridLayout.getColumn(view);
     }
 
     private colSpan(view: view.View): number {
-        return layout.GridLayout.getColumnSpan(view);
+        return GridLayout.getColumnSpan(view);
     }
 
     private prepareGridLayout(wait?: boolean) {
 
-        this.testView.addRow(new layout.ItemSpec(1, layout.GridUnitType.star));
-        this.testView.addRow(new layout.ItemSpec(2, layout.GridUnitType.star));
-        this.testView.addRow(new layout.ItemSpec(layoutHelper.dp(50), layout.GridUnitType.pixel));
-        this.testView.addRow(new layout.ItemSpec(50, layout.GridUnitType.auto));
+        this.testView.addRow(new ItemSpec(1, GridUnitType.star));
+        this.testView.addRow(new ItemSpec(2, GridUnitType.star));
+        this.testView.addRow(new ItemSpec(layoutHelper.dp(50), GridUnitType.pixel));
+        this.testView.addRow(new ItemSpec(50, GridUnitType.auto));
 
-        this.testView.addColumn(new layout.ItemSpec(1, layout.GridUnitType.star));
-        this.testView.addColumn(new layout.ItemSpec(2, layout.GridUnitType.star));
-        this.testView.addColumn(new layout.ItemSpec(layoutHelper.dp(50), layout.GridUnitType.pixel));
-        this.testView.addColumn(new layout.ItemSpec(50, layout.GridUnitType.auto));
+        this.testView.addColumn(new ItemSpec(1, GridUnitType.star));
+        this.testView.addColumn(new ItemSpec(2, GridUnitType.star));
+        this.testView.addColumn(new ItemSpec(layoutHelper.dp(50), GridUnitType.pixel));
+        this.testView.addColumn(new ItemSpec(50, GridUnitType.auto));
 
         for (var r = 0; r < 4; r++) {
             for (var c = 0; c < 4; c++) {
-                var btn = new helper.MyButton();
+                var btn = new layoutHelper.MyButton();
                 btn.text = "R" + r + "C" + c;
-                layout.GridLayout.setColumn(btn, c);
-                layout.GridLayout.setRow(btn, r);
+                GridLayout.setColumn(btn, c);
+                GridLayout.setRow(btn, r);
                 if (c === 3) {
                     btn.width = layoutHelper.dp(100); // Auto column should take 100px for this test.
                 }
@@ -124,73 +100,73 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
 
     public test_getRow_shouldThrow_onNullValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.getRow(null);
+            GridLayout.getRow(null);
         }, "getRow called with null should throw exception");
     }
 
     public test_getRowSpan_shouldThrow_onNullValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.getRowSpan(null);
+            GridLayout.getRowSpan(null);
         }, "getRowSpan called with null should throw exception");
     }
 
     public test_getColumn_shouldThrow_onNullValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.getColumn(null);
+            GridLayout.getColumn(null);
         }, "getColumn called with null should throw exception");
     }
 
     public test_getColumnSpan_shouldThrow_onNullValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.getColumnSpan(null);
+            GridLayout.getColumnSpan(null);
         }, "getColumnSpan called with null should throw exception");
     }
 
     public test_setRow_shouldThrow_onNullValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.setRow(null, 1);
+            GridLayout.setRow(null, 1);
         }, "setRow called with null should throw exception");
     }
 
     public test_setRowSpan_shouldThrow_onNullValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.setRowSpan(null, 1);
+            GridLayout.setRowSpan(null, 1);
         }, "setRowSpan called with null should throw exception");
     }
 
     public test_setColumn_shouldThrow_onNullValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.setColumn(null, 1);
+            GridLayout.setColumn(null, 1);
         }, "setColumn called with null should throw exception")
     }
 
     public test_setColumnSpan_shouldThrow_onNullValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.setColumnSpan(null, 1);
+            GridLayout.setColumnSpan(null, 1);
         }, "setColumnSpan called with null should throw exception");
     }
 
     public test_setRow_shouldThrow_onNegativeValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.setRow(new Button(), -1);
+            GridLayout.setRow(new Button(), -1);
         }, "setRow should throw when value < 0");
     }
 
     public test_setRowSpan_shouldThrow_onNotPositiveValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.setRowSpan(new Button(), 0);
+            GridLayout.setRowSpan(new Button(), 0);
         }, "setRowSpan should throw when value <= 0");
     }
 
     public test_setColumn_shouldThrow_onNegativeValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.setColumn(new Button(), -1);
+            GridLayout.setColumn(new Button(), -1);
         }, "setColumn should when value < 0");
     }
 
     public test_setColumnSpan_shouldThrow_onNotPositiveValues() {
         TKUnit.assertThrows(() => {
-            layout.GridLayout.setColumnSpan(new Button(), 0);
+            GridLayout.setColumnSpan(new Button(), 0);
         }, "setColumnSpan should throw when value <= 0");
     }
 
@@ -253,13 +229,13 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
 
     public test_measuredWidth_when_not_stretched_two_columns() {
         this.testView.horizontalAlignment = enums.HorizontalAlignment.center;
-        this.testView.addColumn(new layout.ItemSpec(layoutHelper.dp(80), layout.GridUnitType.pixel));
-        this.testView.addColumn(new layout.ItemSpec(1, layout.GridUnitType.star));
+        this.testView.addColumn(new ItemSpec(layoutHelper.dp(80), GridUnitType.pixel));
+        this.testView.addColumn(new ItemSpec(1, GridUnitType.star));
 
         let btn = new Button();
         btn.text = "A";
         btn.width = layoutHelper.dp(100);
-        MyGridLayout.setColumnSpan(btn, 2);
+        GridLayout.setColumnSpan(btn, 2);
         this.testView.addChild(btn);
 
         this.waitUntilTestElementLayoutIsValid();
@@ -272,22 +248,22 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
 
     public test_measuredWidth_when_not_stretched_three_columns() {
         this.testView.horizontalAlignment = enums.HorizontalAlignment.center;
-        this.testView.addColumn(new layout.ItemSpec(layoutHelper.dp(80), layout.GridUnitType.pixel));
-        this.testView.addColumn(new layout.ItemSpec(1, layout.GridUnitType.star));
-        this.testView.addColumn(new layout.ItemSpec(1, layout.GridUnitType.auto));
+        this.testView.addColumn(new ItemSpec(layoutHelper.dp(80), GridUnitType.pixel));
+        this.testView.addColumn(new ItemSpec(1, GridUnitType.star));
+        this.testView.addColumn(new ItemSpec(1, GridUnitType.auto));
 
         for (let i = 1; i < 4; i++) {
             let btn = new Button();
             btn.text = "A";
             btn.width = layoutHelper.dp(i * 20);
-            MyGridLayout.setColumn(btn, i - 1);
+            GridLayout.setColumn(btn, i - 1);
             this.testView.addChild(btn);
         }
 
         let btn = new Button();
         btn.text = "B";
         btn.width = layoutHelper.dp(100);
-        MyGridLayout.setColumnSpan(btn, 3);
+        GridLayout.setColumnSpan(btn, 3);
         this.testView.addChild(btn);
 
         this.waitUntilTestElementLayoutIsValid();
@@ -310,21 +286,21 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
     }
 
     public test_ItemSpec_actualLength_defaultValue() {
-        var def = new layout.ItemSpec(1, layout.GridUnitType.auto);
+        var def = new ItemSpec(1, GridUnitType.auto);
         TKUnit.assertEqual(def.actualLength, 0, "'actualLength' property default value should be 0.");
     }
 
     public test_ItemSpec_constructor_throws_onNegativeValue() {
         TKUnit.assertThrows(() => {
-            new layout.ItemSpec(-1, layout.GridUnitType.auto);
+            new ItemSpec(-1, GridUnitType.auto);
         }, "'value' should be positive number.");
     }
 
     public test_ItemSpec_constructor_doesnt_throw_onCorrectType() {
         try {
-            new layout.ItemSpec(1, layout.GridUnitType.auto);
-            new layout.ItemSpec(1, layout.GridUnitType.star);
-            new layout.ItemSpec(1, layout.GridUnitType.pixel);
+            new ItemSpec(1, GridUnitType.auto);
+            new ItemSpec(1, GridUnitType.star);
+            new ItemSpec(1, GridUnitType.pixel);
         }
         catch (ex) {
             TKUnit.assert(false, "ItemSpec type should support auto, star and pixel.");
@@ -333,13 +309,13 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
 
     public test_ItemSpec_constructor_throws_onWrongType() {
         TKUnit.assertThrows(() => {
-            new layout.ItemSpec(1, "unsupported");
+            new ItemSpec(1, "unsupported");
         }, "'ItemSpec type' incorrect value.");
     }
 
     public test_ItemSpec_auto() {
-        var w = new layout.ItemSpec(1, layout.GridUnitType.auto);
-        TKUnit.assertEqual(w.gridUnitType, layout.GridUnitType.auto, "'gridUnitType' property default value should be 'auto'");
+        var w = new ItemSpec(1, GridUnitType.auto);
+        TKUnit.assertEqual(w.gridUnitType, GridUnitType.auto, "'gridUnitType' property default value should be 'auto'");
         TKUnit.assertEqual(w.isAbsolute, false, "'isAbsolute' property default value should be 'false'");
         TKUnit.assertEqual(w.isAuto, true, "'isAuto' property default value should be 'false'");
         TKUnit.assertEqual(w.isStar, false, "'isAuto' property default value should be 'true'");
@@ -347,8 +323,8 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
     }
 
     public test_ItemSpec_unitType_pixel() {
-        var w = new layout.ItemSpec(6, layout.GridUnitType.pixel);
-        TKUnit.assertEqual(w.gridUnitType, layout.GridUnitType.pixel, "'gridUnitType' property default value should be 'pixel'");
+        var w = new ItemSpec(6, GridUnitType.pixel);
+        TKUnit.assertEqual(w.gridUnitType, GridUnitType.pixel, "'gridUnitType' property default value should be 'pixel'");
         TKUnit.assertEqual(w.isAbsolute, true, "'isAbsolute' property default value should be 'false'");
         TKUnit.assertEqual(w.isAuto, false, "'isAuto' property default value should be 'false'");
         TKUnit.assertEqual(w.isStar, false, "'isAuto' property default value should be 'true'");
@@ -356,8 +332,8 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
     }
 
     public test_ItemSpec_unitType() {
-        var w = new layout.ItemSpec(2, layout.GridUnitType.star);
-        TKUnit.assertEqual(w.gridUnitType, layout.GridUnitType.star, "'gridUnitType' property default value should be 'star'");
+        var w = new ItemSpec(2, GridUnitType.star);
+        TKUnit.assertEqual(w.gridUnitType, GridUnitType.star, "'gridUnitType' property default value should be 'star'");
         TKUnit.assertEqual(w.isAbsolute, false, "'isAbsolute' property default value should be 'false'");
         TKUnit.assertEqual(w.isAuto, false, "'isAuto' property default value should be 'false'");
         TKUnit.assertEqual(w.isStar, true, "'isAuto' property default value should be 'true'");
@@ -384,9 +360,9 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
             width = 0;
             height = 0;
             for (var c = 0; c < 4; c++) {
-                var btn = <helper.MyButton>this.testView.getChildAt(i++);
+                var btn = <layoutHelper.MyButton>this.testView.getChildAt(i++);
                 if (cols[c].isAbsolute) {
-                    width += helper.dip(cols[c].actualLength);
+                    width += layoutHelper.dip(cols[c].actualLength);
                 }
                 else {
                     width += btn.getMeasuredWidth();
@@ -398,7 +374,7 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
             maxWidth = Math.max(maxWidth, width);
 
             if (rows[r].isAbsolute) {
-                maxHeight += helper.dip(rows[r].actualLength);
+                maxHeight += layoutHelper.dip(rows[r].actualLength);
             }
             else {
                 maxHeight += height;
@@ -442,7 +418,7 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
         for (var r = 0; r < 4; r++) {
 
             for (var c = 0; c < 4; c++) {
-                var btn = <helper.MyButton>this.testView.getChildAt(i++);
+                var btn = <layoutHelper.MyButton>this.testView.getChildAt(i++);
                 var col = cols[c];
                 var row = rows[r];
 
@@ -479,10 +455,10 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
     public test_ColumnWidth_when_4stars_and_width_110() {
 
         this.testView.width = layoutHelper.dp(110);
-        this.testView.addColumn(new layout.ItemSpec(1, layout.GridUnitType.star));
-        this.testView.addColumn(new layout.ItemSpec(1, layout.GridUnitType.star));
-        this.testView.addColumn(new layout.ItemSpec(1, layout.GridUnitType.star));
-        this.testView.addColumn(new layout.ItemSpec(1, layout.GridUnitType.star));
+        this.testView.addColumn(new ItemSpec(1, GridUnitType.star));
+        this.testView.addColumn(new ItemSpec(1, GridUnitType.star));
+        this.testView.addColumn(new ItemSpec(1, GridUnitType.star));
+        this.testView.addColumn(new ItemSpec(1, GridUnitType.star));
 
         this.waitUntilTestElementLayoutIsValid();
 
@@ -498,7 +474,7 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
 
         this.testView.height = layoutHelper.dp(200);
         this.testView.width = layoutHelper.dp(200);
-        var btn = new helper.MyButton();
+        var btn = new layoutHelper.MyButton();
         btn.text = "btn";
         btn.height = layoutHelper.dp(100);
         btn.width = layoutHelper.dp(100);
@@ -513,19 +489,19 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
     }
 
     public test_set_columns_in_XML_comma_separator() {
-        var p = <page.Page>builder.parse("<Page><GridLayout columns=\"auto, *, 10*, 100 \"><Button/></GridLayout></Page>");
-        var grid = <layout.GridLayout>p.content;
+        var p = <Page>builder.parse("<Page><GridLayout columns=\"auto, *, 10*, 100 \"><Button/></GridLayout></Page>");
+        var grid = <GridLayout>p.content;
         this.assertColumns(grid);
     }
 
     public test_set_columns_in_XML_space_separator() {
-        var p = <page.Page>builder.parse("<Page><GridLayout columns=\"auto * 10* 100 \"><Button/></GridLayout></Page>");
-        var grid = <layout.GridLayout>p.content;
+        var p = <Page>builder.parse("<Page><GridLayout columns=\"auto * 10* 100 \"><Button/></GridLayout></Page>");
+        var grid = <GridLayout>p.content;
         this.assertColumns(grid);
     }
 
-    private assertColumns(grid: layout.GridLayout) {
-        var columns: Array<layout.ItemSpec> = grid.getColumns();
+    private assertColumns(grid: GridLayout) {
+        var columns: Array<ItemSpec> = grid.getColumns();
 
         TKUnit.assertEqual(columns.length, 4, "columns.length");
         TKUnit.assert(columns[0].isAuto, "columns[0].isAuto");
@@ -541,19 +517,20 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
     }
 
     public test_set_rows_in_XML_comma_separator() {
-        var p = <page.Page>builder.parse("<Page><GridLayout rows=\"auto, *, 10*, 100 \"><Button/></GridLayout></Page>");
-        var grid = <layout.GridLayout>p.content;
-        this.assertRows(grid);
-    }
-    public test_set_rows_in_XML_space_separator() {
-        var p = <page.Page>builder.parse("<Page><GridLayout rows=\"auto * 10* 100 \"><Button/></GridLayout></Page>");
-        var grid = <layout.GridLayout>p.content;
+        var p = <Page>builder.parse("<Page><GridLayout rows=\"auto, *, 10*, 100 \"><Button/></GridLayout></Page>");
+        var grid = <GridLayout>p.content;
         this.assertRows(grid);
     }
 
-    private assertRows(grid: layout.GridLayout) {
-        var columns: Array<layout.ItemSpec> = grid.getColumns();
-        var rows: Array<layout.ItemSpec> = grid.getRows();
+    public test_set_rows_in_XML_space_separator() {
+        var p = <Page>builder.parse("<Page><GridLayout rows=\"auto * 10* 100 \"><Button/></GridLayout></Page>");
+        var grid = <GridLayout>p.content;
+        this.assertRows(grid);
+    }
+
+    private assertRows(grid: GridLayout) {
+        var columns: Array<ItemSpec> = grid.getColumns();
+        var rows: Array<ItemSpec> = grid.getRows();
 
         TKUnit.assertEqual(rows.length, 4, "rows.length");
         TKUnit.assert(rows[0].isAuto, "rows[0].isAuto");
@@ -577,13 +554,13 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
         this.testView.width = layoutHelper.dp(300);
         this.testView.height = layoutHelper.dp(300);
 
-        var btn = new helper.MyButton();
+        var btn = new layoutHelper.MyButton();
         this.testView.addChild(btn);
 
         this.waitUntilTestElementLayoutIsValid();
 
-        helper.assertMeasure(btn, 260, 240);
-        helper.assertLayout(btn, 10, 20, 260, 240);
+        layoutHelper.assertMeasure(btn, 260, 240);
+        layoutHelper.assertLayout(btn, 10, 20, 260, 240);
     }
 
     public test_codesnippets = function () {
@@ -592,7 +569,7 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
         // ### Creating Grid Layout via code.
         // ``` JavaScript
         //var layout = require("ui/layouts/grid-layout");
-        var gridLayout = new layout.GridLayout();
+        var gridLayout = new GridLayout();
         //  ```
 
         // ### Create grid layout with an xml declaration
@@ -620,34 +597,34 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
 
         // ### Set column property on views - btn1 in first column, btn2 is second and btn3 in third
         // ``` JavaScript
-        layout.GridLayout.setColumn(btn1, 0);
-        layout.GridLayout.setColumn(btn2, 1);
-        layout.GridLayout.setColumn(btn3, 2);
+        GridLayout.setColumn(btn1, 0);
+        GridLayout.setColumn(btn2, 1);
+        GridLayout.setColumn(btn3, 2);
         // ```
 
         // ### Set row property on btn4.
         // ``` JavaScript
-        layout.GridLayout.setRow(btn4, 1);
+        GridLayout.setRow(btn4, 1);
         // ```
 
         // ### Set columnSpan property on btn4 to stretch into all columns
         // ``` JavaScript
-        layout.GridLayout.setColumnSpan(btn4, 3);
+        GridLayout.setColumnSpan(btn4, 3);
         // ```
 
         // ### Create ItemSpec for columns and rows 3 columns - 80px, *, auto size and 2 rows - 100px and auto size
         // ``` JavaScript
         //// ItemSpec modes of the column refers to its width.
         //// Absolute size of the column
-        var firstColumn = new layout.ItemSpec(80, layout.GridUnitType.pixel);
+        var firstColumn = new ItemSpec(80, GridUnitType.pixel);
         //// Star width means that this column will expand to fill the gap left from other columns
-        var secondColumn = new layout.ItemSpec(1, layout.GridUnitType.star);
+        var secondColumn = new ItemSpec(1, GridUnitType.star);
         //// Auto size means that column will expand or shrink in order to give enough place for all child UI elements.
-        var thirdColumn = new layout.ItemSpec(1, layout.GridUnitType.auto);
+        var thirdColumn = new ItemSpec(1, GridUnitType.auto);
 
         //// Star and Auto modes for rows behave like corresponding setting for columns but refer to row height.
-        var firstRow = new layout.ItemSpec(1, layout.GridUnitType.auto);
-        var secondRow = new layout.ItemSpec(1, layout.GridUnitType.star);
+        var firstRow = new ItemSpec(1, GridUnitType.auto);
+        var secondRow = new ItemSpec(1, GridUnitType.star);
         // ```
 
         // ### Add columns and rows to GridLayout
@@ -668,6 +645,34 @@ export class GridLayoutTest extends testModule.UITest<layout.GridLayout> {
     public test_percent_support_nativeLayoutParams_are_correct() {
         commonTests.percent_support_nativeLayoutParams_are_correct(this);
     }
+
+    public test_layout_correctnes() {
+        this.testView.width = layoutHelper.dp(300);
+        this.testView.height = layoutHelper.dp(300);
+
+        let grid = new layoutHelper.MyGridLayout();
+        grid.width = layoutHelper.dp(150);
+        grid.height = layoutHelper.dp(150);
+        grid.horizontalAlignment = enums.HorizontalAlignment.right;
+        grid.verticalAlignment = enums.VerticalAlignment.bottom;
+
+        this.testView.addChild(grid);
+
+        let btn = new layoutHelper.MyButton();
+        btn.width = layoutHelper.dp(75);
+        btn.height = layoutHelper.dp(75);
+        btn.horizontalAlignment = enums.HorizontalAlignment.left;
+        btn.verticalAlignment = enums.VerticalAlignment.bottom;
+        grid.addChild(btn);
+
+        this.waitUntilTestElementLayoutIsValid();
+
+        layoutHelper.assertMeasure(grid, 150, 150);
+        layoutHelper.assertLayout(grid, 150, 150, 150, 150);
+
+        layoutHelper.assertMeasure(btn, 75, 75);
+        layoutHelper.assertLayout(btn, 0, 75, 75, 75);
+    }
 }
 
 export function createTestCase(): GridLayoutTest {
diff --git a/apps/tests/layouts/layout-helper.android.ts b/apps/tests/layouts/layout-helper.android.ts
index 5ef196e8f..44f03c8af 100644
--- a/apps/tests/layouts/layout-helper.android.ts
+++ b/apps/tests/layouts/layout-helper.android.ts
@@ -1,16 +1,18 @@
-import button = require("ui/button");
+import {View} from "ui/core/view";
+import {Button} from "ui/button";
 import {StackLayout} from "ui/layouts/stack-layout";
+import {GridLayout} from "ui/layouts/grid-layout";
+
 import utils = require("utils/utils");
 import TKUnit = require("../TKUnit");
 import def = require("./layout-helper");
 
 var DELTA = 0.1;
 
-export class NativeButton extends android.widget.Button {
-    
-    private owner: MyButton;
+class NativeButton extends android.widget.Button {    
+    private owner: def.MeasuredView;
 
-    constructor(context: android.content.Context, owner: MyButton) {
+    constructor(context: android.content.Context, owner: def.MeasuredView) {
         super(context);
         this.owner = owner;
         return global.__native(this);
@@ -18,33 +20,69 @@ export class NativeButton extends android.widget.Button {
 
     protected onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
-        this.owner._oldWidthMeasureSpec = widthMeasureSpec;
-        this.owner._oldHeightMeasureSpec = heightMeasureSpec;
-
-        this.owner._measureWidth = utils.layout.getMeasureSpecSize(widthMeasureSpec);
-        this.owner._measureHeight = utils.layout.getMeasureSpecSize(heightMeasureSpec);
+        this.owner.widthMeasureSpec = widthMeasureSpec;
+        this.owner.heightMeasureSpec = heightMeasureSpec;
         this.owner.measureCount++;
     }
 
     protected onLayout(changed: boolean, left: number, top: number, right: number, bottom: number): void {
-        this.owner._layoutLeft = left;
-        this.owner._layoutTop = top;
-        this.owner._layoutWidth = right - left;
-        this.owner._layoutHeight = bottom - top;
-
         super.onLayout(changed, left, top, right, bottom);
         this.owner.arrangeCount++;
     }
 }
 
-export class MyButton extends button.Button implements def.MyButton {
-    private _layout: NativeButton;
+class NativeStackLayout extends org.nativescript.widgets.StackLayout {
+    private owner: def.MeasuredView;
 
-    get android(): NativeButton {
+    constructor(context: android.content.Context, owner: def.MeasuredView) {
+        super(context);
+        this.owner = owner;
+        return global.__native(this);
+    }
+
+    protected onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        this.owner.widthMeasureSpec = widthMeasureSpec;
+        this.owner.heightMeasureSpec = heightMeasureSpec;
+        this.owner.measureCount++;
+    }
+
+    protected onLayout(changed: boolean, left: number, top: number, right: number, bottom: number): void {
+        super.onLayout(changed, left, top, right, bottom);
+        this.owner.arrangeCount++;
+    }
+}
+
+class NativeGridLayout extends org.nativescript.widgets.GridLayout {
+    private owner: def.MeasuredView;
+
+    constructor(context: android.content.Context, owner: def.MeasuredView) {
+        super(context);
+        this.owner = owner;
+        return global.__native(this);
+    }
+
+    protected onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        this.owner.widthMeasureSpec = widthMeasureSpec;
+        this.owner.heightMeasureSpec = heightMeasureSpec;
+        this.owner.measureCount++;
+    }
+
+    protected onLayout(changed: boolean, left: number, top: number, right: number, bottom: number): void {
+        super.onLayout(changed, left, top, right, bottom);
+        this.owner.arrangeCount++;
+    }
+}
+
+export class MyButton extends Button implements def.MyButton {
+    private _layout: android.view.View;
+
+    get android(): android.view.View {
         return this._layout;
     }
 
-    get _nativeView(): NativeButton {
+    get _nativeView(): android.view.View {
         return this._layout;
     }
 
@@ -55,16 +93,15 @@ export class MyButton extends button.Button implements def.MyButton {
     public measureCount: number = 0;
     public arrangeCount: number = 0;
 
-    _oldWidthMeasureSpec: number = Number.NaN;
-    _oldHeightMeasureSpec: number = Number.NaN;
+    public widthMeasureSpec: number = Number.NaN;
+    public heightMeasureSpec: number = Number.NaN;
 
-    _layoutLeft;
-    _layoutTop;
-    _layoutWidth;
-    _layoutHeight;
-
-    _measureWidth;
-    _measureHeight;
+    public get measureWidth() {
+        return utils.layout.getMeasureSpecSize(this.widthMeasureSpec);
+    }
+    public get measureHeight() {
+        return utils.layout.getMeasureSpecSize(this.heightMeasureSpec);
+    }
 
     public get measured(): boolean {
         return this.measureCount > 0;
@@ -74,67 +111,31 @@ export class MyButton extends button.Button implements def.MyButton {
         return this.arrangeCount > 0;
     }
 
-    get measureHeight(): number {
-        return this._measureHeight;
-    }
-
-    get measureWidth(): number {
-        return this._measureWidth;
-    }
-
     get layoutWidth(): number {
-        return this._layoutWidth;
+        return this._layout.getWidth();
     }
 
     get layoutHeight(): number {
-        return this._layoutHeight;
+        return this._layout.getHeight();
     }
-    
+
     get layoutLeft(): number {
-        return this._layoutLeft;
+        return this._layout.getLeft();
     }
 
     get layoutTop(): number {
-        return this._layoutTop;
-    }
-
-    _getCurrentMeasureSpecs(): { widthMeasureSpec: number; heightMeasureSpec: number } {
-        return {
-            widthMeasureSpec: this._oldWidthMeasureSpec,
-            heightMeasureSpec: this._oldHeightMeasureSpec
-        };
-    }
-}
-
-export class NativeStackLayout extends org.nativescript.widgets.StackLayout {
- 
-    private owner: MyStackLayout;
-
-    constructor(context: android.content.Context, owner: MyStackLayout) {
-        super(context);
-        this.owner = owner;
-        return global.__native(this);
-    }
-
-    protected onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
-        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
-        this.owner.measureCount++;
-    }
-
-    protected onLayout(changed: boolean, left: number, top: number, right: number, bottom: number): void {
-        super.onLayout(changed, left, top, right, bottom);
-        this.owner.arrangeCount++;
+        return this._layout.getTop();
     }
 }
 
 export class MyStackLayout extends StackLayout implements def.MyStackLayout {
-    private _layout: NativeStackLayout;
+    private _layout: android.view.View;
 
-    get android(): NativeStackLayout {
+    get android(): android.view.View {
         return this._layout;
     }
 
-    get _nativeView(): NativeStackLayout {
+    get _nativeView(): android.view.View {
         return this._layout;
     }
 
@@ -145,6 +146,16 @@ export class MyStackLayout extends StackLayout implements def.MyStackLayout {
     public measureCount: number = 0;
     public arrangeCount: number = 0;
 
+    public widthMeasureSpec: number = Number.NaN;
+    public heightMeasureSpec: number = Number.NaN;
+
+    public get measureWidth() {
+        return utils.layout.getMeasureSpecSize(this.widthMeasureSpec);
+    }
+    public get measureHeight() {
+        return utils.layout.getMeasureSpecSize(this.heightMeasureSpec);
+    }
+
     public get measured(): boolean {
         return this.measureCount > 0;
     }
@@ -152,22 +163,91 @@ export class MyStackLayout extends StackLayout implements def.MyStackLayout {
     public get arranged(): boolean {
         return this.arrangeCount > 0;
     }
+
+    get layoutWidth(): number {
+        return this._layout.getWidth();
+    }
+
+    get layoutHeight(): number {
+        return this._layout.getHeight();
+    }
+
+    get layoutLeft(): number {
+        return this._layout.getLeft();
+    }
+
+    get layoutTop(): number {
+        return this._layout.getTop();
+    }
 }
 
-export function assertMeasure(btn: MyButton, width: number, height: number, name?: string) {
-    name = name ? "[" + name + "]" : "";
+export class MyGridLayout extends GridLayout implements def.MyGridLayout {
+    private _layout: android.view.View;
 
-    TKUnit.assertAreClose(btn.measureWidth, width, DELTA, name + "width");
-    TKUnit.assertAreClose(btn.measureHeight, height, DELTA, name + "height");
+    get android(): android.view.View {
+        return this._layout;
+    }
+
+    get _nativeView(): android.view.View {
+        return this._layout;
+    }
+
+    public _createUI() {
+        this._layout = new NativeGridLayout(this._context, this);
+    }
+
+    public measureCount: number = 0;
+    public arrangeCount: number = 0;
+
+    public widthMeasureSpec: number = Number.NaN;
+    public heightMeasureSpec: number = Number.NaN;
+
+    public get measureWidth() {
+        return utils.layout.getMeasureSpecSize(this.widthMeasureSpec);
+    }
+    public get measureHeight() {
+        return utils.layout.getMeasureSpecSize(this.heightMeasureSpec);
+    }
+
+    public get measured(): boolean {
+        return this.measureCount > 0;
+    }
+
+    public get arranged(): boolean {
+        return this.arrangeCount > 0;
+    }
+
+    get layoutWidth(): number {
+        return this._layout.getWidth();
+    }
+
+    get layoutHeight(): number {
+        return this._layout.getHeight();
+    }
+
+    get layoutLeft(): number {
+        return this._layout.getLeft();
+    }
+
+    get layoutTop(): number {
+        return this._layout.getTop();
+    }
 }
 
-export function assertLayout(btn: MyButton, left: number, top: number, width: number, height: number, name?: string): void {
+export function assertMeasure(view: def.MeasuredView, width: number, height: number, name?: string) {
     name = name ? "[" + name + "]" : "";
 
-    TKUnit.assertAreClose(btn.layoutLeft, left, DELTA, name + "left");
-    TKUnit.assertAreClose(btn.layoutTop, top, DELTA, name + "top");
-    TKUnit.assertAreClose(btn.layoutWidth, width, DELTA, name + "width");
-    TKUnit.assertAreClose(btn.layoutHeight, height, DELTA, name + "height");
+    TKUnit.assertAreClose(view.measureWidth, width, DELTA, name + "width");
+    TKUnit.assertAreClose(view.measureHeight, height, DELTA, name + "height");
+}
+
+export function assertLayout(view: def.MeasuredView, left: number, top: number, width: number, height: number, name?: string): void {
+    name = name ? "[" + name + "]" : "";
+
+    TKUnit.assertAreClose(view.layoutLeft, left, DELTA, name + "left");
+    TKUnit.assertAreClose(view.layoutTop, top, DELTA, name + "top");
+    TKUnit.assertAreClose(view.layoutWidth, width, DELTA, name + "width");
+    TKUnit.assertAreClose(view.layoutHeight, height, DELTA, name + "height");
 }
 
 export function dp(value: number): number {
diff --git a/apps/tests/layouts/layout-helper.d.ts b/apps/tests/layouts/layout-helper.d.ts
index 17ef67905..bf8f1c70a 100644
--- a/apps/tests/layouts/layout-helper.d.ts
+++ b/apps/tests/layouts/layout-helper.d.ts
@@ -1,32 +1,85 @@
-import button = require("ui/button");
+import {View} from "ui/core/view";
+import {Button} from "ui/button";
 import {StackLayout} from "ui/layouts/stack-layout";
+import {GridLayout} from "ui/layouts/grid-layout";
 
-export class MyButton extends button.Button {
-    public measureCount: number;
-    public arrangeCount: number;
+export interface MeasuredView {
+    measureCount: number;
+    arrangeCount: number;
 
     measured: boolean;
     arranged: boolean;
 
     measureHeight: number;
     measureWidth: number;
+
+    widthMeasureSpec: number;
+    heightMeasureSpec: number;
+
     layoutWidth: number;
     layoutHeight: number;
     layoutLeft: number;
     layoutTop: number;
-
-    _getCurrentMeasureSpecs(): { widthMeasureSpec: number; heightMeasureSpec: number };
 }
 
-export class MyStackLayout extends StackLayout {
-    public measureCount: number;
-    public arrangeCount: number;
+export class MyButton extends Button implements MeasuredView {
+    measureCount: number;
+    arrangeCount: number;
 
-    public measured: boolean;
-    public arranged: boolean;
+    measured: boolean;
+    arranged: boolean;
+
+    measureHeight: number;
+    measureWidth: number;
+
+    widthMeasureSpec: number;
+    heightMeasureSpec: number;
+
+    layoutWidth: number;
+    layoutHeight: number;
+    layoutLeft: number;
+    layoutTop: number;
 }
 
-export function assertMeasure(btn: MyButton, width: number, height: number, name?: string);
-export function assertLayout(btn: MyButton, left: number, top: number, width: number, height: number, name?: string): void;
+export class MyStackLayout extends StackLayout implements MeasuredView {
+    measureCount: number;
+    arrangeCount: number;
+
+    measured: boolean;
+    arranged: boolean;
+
+    measureHeight: number;
+    measureWidth: number;
+
+    widthMeasureSpec: number;
+    heightMeasureSpec: number;
+
+    layoutWidth: number;
+    layoutHeight: number;
+    layoutLeft: number;
+    layoutTop: number;
+}
+
+export class MyGridLayout extends GridLayout implements MeasuredView {
+    measureCount: number;
+    arrangeCount: number;
+
+    measured: boolean;
+    arranged: boolean;
+
+    measureHeight: number;
+    measureWidth: number;
+
+    widthMeasureSpec: number;
+    heightMeasureSpec: number;
+
+    layoutWidth: number;
+    layoutHeight: number;
+    layoutLeft: number;
+    layoutTop: number;
+}
+
+export function assertMeasure(view: MeasuredView, width: number, height: number, name?: string);
+export function assertLayout(view: MeasuredView, left: number, top: number, width: number, height: number, name?: string): void;
 export function dip(value: number): number;
 export function dp(value: number): number;
\ No newline at end of file
diff --git a/apps/tests/layouts/layout-helper.ios.ts b/apps/tests/layouts/layout-helper.ios.ts
index 2d2e17e20..ad399eb7b 100644
--- a/apps/tests/layouts/layout-helper.ios.ts
+++ b/apps/tests/layouts/layout-helper.ios.ts
@@ -1,14 +1,31 @@
-import button = require("ui/button");
+import {Button} from "ui/button";
+import {StackLayout} from "ui/layouts/stack-layout";
+import {GridLayout} from "ui/layouts/grid-layout";
 import utils = require("utils/utils");
 import TKUnit = require("../TKUnit");
-import {StackLayout} from "ui/layouts/stack-layout";
+import def = require("./layout-helper");
 
 var DELTA = 0.1;
 
-export class MyStackLayout extends StackLayout {
+export class MyGridLayout extends GridLayout implements def.MyGridLayout {
     public measureCount: number = 0;
     public arrangeCount: number = 0;
 
+    public widthMeasureSpec: number = Number.NaN;
+    public heightMeasureSpec: number = Number.NaN;
+
+    public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        this.widthMeasureSpec = widthMeasureSpec;
+        this.heightMeasureSpec = heightMeasureSpec;
+        this.measureCount++;
+    }
+
+    public onLayout(left: number, top: number, right: number, bottom: number): void {
+        super.onLayout(left, top, right, bottom);
+        this.arrangeCount++;
+    }
+
     public get measured(): boolean {
         return this.measureCount > 0;
     }
@@ -17,106 +34,161 @@ export class MyStackLayout extends StackLayout {
         return this.arrangeCount > 0;
     }
 
-    public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
-        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
-        this.measureCount++;
+    public get measureWidth() {
+        return utils.layout.getMeasureSpecSize(this.widthMeasureSpec);
     }
 
-    public onLayout(left: number, top: number, right: number, bottom: number): void {
-        super.onLayout(left, top, right, bottom);
-        this.arrangeCount++;
-    }
-}
-
-export class MyButton extends button.Button {
-    public measureCount: number = 0;
-    public arrangeCount: number = 0;
-
-    private _layoutLeft;
-    private _layoutTop;
-    private _layoutWidth;
-    private _layoutHeight;
-
-    private _measureWidth;
-    private _measureHeight;
-
-    public get measured(): boolean {
-        return this.measureCount > 0;
-    }
-
-    public get arranged(): boolean {
-        return this.arrangeCount > 0;
-    }
-
-    public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
-        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
-        this._measureWidth = utils.layout.getMeasureSpecSize(widthMeasureSpec);
-        this._measureHeight = utils.layout.getMeasureSpecSize(heightMeasureSpec);
-        this.measureCount++;
-    }
-
-    public onLayout(left: number, top: number, right: number, bottom: number): void {
-        this._layoutLeft = left;
-        this._layoutTop = top;
-        this._layoutWidth = right - left;
-        this._layoutHeight = bottom - top;
-
-        super.onLayout(left, top, right, bottom);
-        this.arrangeCount++;
-    }
-
-    get measureHeight(): number {
-        return this._measureHeight;
-    }
-
-    get measureWidth(): number {
-        return this._measureWidth;
+    public get measureHeight() {
+        return utils.layout.getMeasureSpecSize(this.heightMeasureSpec);
     }
 
     get layoutWidth(): number {
-        return this._layoutWidth;
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.right - bounds.left;
     }
 
     get layoutHeight(): number {
-        return this._layoutHeight;
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.bottom - bounds.top;
     }
-    
+
     get layoutLeft(): number {
-        return this._layoutLeft;
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.left;
     }
 
     get layoutTop(): number {
-        return this._layoutTop;
-    }
-
-    _getCurrentMeasureSpecs(): { widthMeasureSpec: number; heightMeasureSpec: number } {
-        return {
-            widthMeasureSpec: (<any>this)._oldWidthMeasureSpec,
-            heightMeasureSpec: (<any>this)._oldHeightMeasureSpec
-        };
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.top;
     }
 }
 
-export function assertMeasure(btn: MyButton, width: number, height: number, name?: string) {
-    var density = utils.layout.getDisplayDensity();
+export class MyStackLayout extends StackLayout implements def.MyStackLayout {
+    public measureCount: number = 0;
+    public arrangeCount: number = 0;
 
-    var delta = Math.floor(density) !== density ? 1.1 : DELTA;
-    name = name ? "[" + name + "]" : "";
+    public widthMeasureSpec: number = Number.NaN;
+    public heightMeasureSpec: number = Number.NaN;
 
-    TKUnit.assertAreClose(Math.floor(btn.measureWidth / density), width, delta, name + "width");
-    TKUnit.assertAreClose(Math.floor(btn.measureHeight / density), height, delta, name + "height");
+    public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        this.widthMeasureSpec = widthMeasureSpec;
+        this.heightMeasureSpec = heightMeasureSpec;
+        this.measureCount++;
+    }
+
+    public onLayout(left: number, top: number, right: number, bottom: number): void {
+        super.onLayout(left, top, right, bottom);
+        this.arrangeCount++;
+    }
+
+    public get measured(): boolean {
+        return this.measureCount > 0;
+    }
+
+    public get arranged(): boolean {
+        return this.arrangeCount > 0;
+    }
+
+    public get measureWidth() {
+        return utils.layout.getMeasureSpecSize(this.widthMeasureSpec);
+    }
+
+    public get measureHeight() {
+        return utils.layout.getMeasureSpecSize(this.heightMeasureSpec);
+    }
+
+    get layoutWidth(): number {
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.right - bounds.left;
+    }
+
+    get layoutHeight(): number {
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.bottom - bounds.top;
+    }
+
+    get layoutLeft(): number {
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.left;
+    }
+
+    get layoutTop(): number {
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.top;
+    }
 }
 
-export function assertLayout(btn: MyButton, left: number, top: number, width: number, height: number, name?: string): void {
-    var density = utils.layout.getDisplayDensity();
+export class MyButton extends Button implements def.MyButton {
+    public measureCount: number = 0;
+    public arrangeCount: number = 0;
 
-    var delta = Math.floor(density) !== density ? 1.1 : DELTA;
+    public widthMeasureSpec: number = Number.NaN;
+    public heightMeasureSpec: number = Number.NaN;
+
+    public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        this.widthMeasureSpec = widthMeasureSpec;
+        this.heightMeasureSpec = heightMeasureSpec;
+        this.measureCount++;
+    }
+
+    public onLayout(left: number, top: number, right: number, bottom: number): void {
+        super.onLayout(left, top, right, bottom);
+        this.arrangeCount++;
+    }
+
+    public get measured(): boolean {
+        return this.measureCount > 0;
+    }
+
+    public get arranged(): boolean {
+        return this.arrangeCount > 0;
+    }
+
+    public get measureWidth() {
+        return utils.layout.getMeasureSpecSize(this.widthMeasureSpec);
+    }
+
+    public get measureHeight() {
+        return utils.layout.getMeasureSpecSize(this.heightMeasureSpec);
+    }
+
+    get layoutWidth(): number {
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.right - bounds.left;
+    }
+
+    get layoutHeight(): number {
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.bottom - bounds.top;
+    }
+    
+    get layoutLeft(): number {
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.left;
+    }
+
+    get layoutTop(): number {
+        let bounds = this._getCurrentLayoutBounds();
+        return bounds.top;
+    }
+}
+
+export function assertMeasure(view: def.MeasuredView, width: number, height: number, name?: string) {
     name = name ? "[" + name + "]" : "";
 
-    TKUnit.assertAreClose(Math.floor(btn.layoutLeft / density), left, delta, name + "left");
-    TKUnit.assertAreClose(Math.floor(btn.layoutTop / density), top, delta, name + "top");
-    TKUnit.assertAreClose(Math.floor(btn.layoutWidth / density), width, delta, name + "width");
-    TKUnit.assertAreClose(Math.floor(btn.layoutHeight / density), height, delta, name + "height");
+    TKUnit.assertAreClose(view.measureWidth, width, DELTA, name + "width");
+    TKUnit.assertAreClose(view.measureHeight, height, DELTA, name + "height");
+}
+
+export function assertLayout(view: def.MeasuredView, left: number, top: number, width: number, height: number, name?: string): void {
+    name = name ? "[" + name + "]" : "";
+
+    TKUnit.assertAreClose(view.layoutLeft, left, DELTA, name + "left");
+    TKUnit.assertAreClose(view.layoutTop, top, DELTA, name + "top");
+    TKUnit.assertAreClose(view.layoutWidth, width, DELTA, name + "width");
+    TKUnit.assertAreClose(view.layoutHeight, height, DELTA, name + "height");
 }
 
 export function dp(value: number): number {
diff --git a/apps/tests/layouts/stack-layout-tests.ts b/apps/tests/layouts/stack-layout-tests.ts
index 2cfc12eed..28369ef25 100644
--- a/apps/tests/layouts/stack-layout-tests.ts
+++ b/apps/tests/layouts/stack-layout-tests.ts
@@ -56,9 +56,7 @@ export class StackLayoutTest extends testModule.UITest<StackLayout> {
         TKUnit.assertTrue(this.rootLayout.measured, "Layout should be measured.");
         TKUnit.assertTrue(this.rootLayout.arranged, "Layout should be arranged.");
 
-        var specs = this.btn1._getCurrentMeasureSpecs();
-
-        TKUnit.assertEqual(utils.layout.getMeasureSpecMode(specs.heightMeasureSpec), utils.layout.AT_MOST, "Layout should measure child with AT_MOST Height in vertical orientation.");
+        TKUnit.assertEqual(utils.layout.getMeasureSpecMode(this.btn1.heightMeasureSpec), utils.layout.AT_MOST, "Layout should measure child with AT_MOST Height in vertical orientation.");
     }
 
     public test_ShouldMeasureWith_AtMost_OnHorizontal() {
@@ -70,9 +68,7 @@ export class StackLayoutTest extends testModule.UITest<StackLayout> {
         TKUnit.assert(this.rootLayout.measured, "Layout should be measured.");
         TKUnit.assert(this.rootLayout.arranged, "Layout should be arranged.");
 
-        var specs = this.btn1._getCurrentMeasureSpecs();
-
-        TKUnit.assertEqual(utils.layout.getMeasureSpecMode(specs.widthMeasureSpec), utils.layout.AT_MOST, "Layout should measure child with AT_MOST Width in horizontal orientation.");
+        TKUnit.assertEqual(utils.layout.getMeasureSpecMode(this.btn1.widthMeasureSpec), utils.layout.AT_MOST, "Layout should measure child with AT_MOST Width in horizontal orientation.");
     }
 
     public test_DesiredSize_Vertical() {
diff --git a/apps/tests/xml-declaration/xml-declaration-tests.ts b/apps/tests/xml-declaration/xml-declaration-tests.ts
index 6d4634128..d26c50091 100644
--- a/apps/tests/xml-declaration/xml-declaration-tests.ts
+++ b/apps/tests/xml-declaration/xml-declaration-tests.ts
@@ -50,7 +50,8 @@ export function test_loadWithOptionsNoXML() {
     var v = builder.load({
         path: "~/xml-declaration/mymodule",
         name: "MyControl",
-        exports: exports
+        exports: exports,
+        page: new Page()
     });
 
     TKUnit.assert(v instanceof view.View, "Expected result: View; Actual result: " + v + ";");
diff --git a/ui/layouts/grid-layout/grid-layout-common.ts b/ui/layouts/grid-layout/grid-layout-common.ts
index 3c03b8ed9..0859de9f4 100644
--- a/ui/layouts/grid-layout/grid-layout-common.ts
+++ b/ui/layouts/grid-layout/grid-layout-common.ts
@@ -107,8 +107,6 @@ export class ItemSpec extends bindable.Bindable implements definition.ItemSpec {
 export class GridLayout extends layouts.LayoutBase implements definition.GridLayout, view.ApplyXmlAttributes {
     private _rows: Array<ItemSpec> = new Array<ItemSpec>();
     private _cols: Array<ItemSpec> = new Array<ItemSpec>();
-    protected _singleRow: ItemSpec = new ItemSpec();
-    protected _singleColumn: ItemSpec = new ItemSpec();
 
     public static columnProperty = new dependencyObservable.Property("Column", "GridLayout",
         new proxy.PropertyMetadata(0, dependencyObservable.PropertyMetadataSettings.None, GridLayout.onColumnPropertyChanged, numberUtils.notNegative));
@@ -154,12 +152,6 @@ export class GridLayout extends layouts.LayoutBase implements definition.GridLay
         validateArgs(element)._setValue(GridLayout.rowSpanProperty, value);
     }
 
-    constructor() {
-        super();
-        this._singleRow.index = 0
-        this._singleColumn.index = 0;
-    }
-
     public addRow(itemSpec: ItemSpec) {
         GridLayout.validateItemSpec(itemSpec);
         itemSpec.owner = this;
@@ -260,40 +252,14 @@ export class GridLayout extends layouts.LayoutBase implements definition.GridLay
         return this._rows.slice();
     }
 
-    protected getColumn(view: view.View): ItemSpec {
-        if (this._cols.length === 0) {
-            return this._singleColumn;
-        }
-
-        var columnIndex = Math.min(GridLayout.getColumn(view), this._cols.length - 1);
-        return this._cols[columnIndex];
+    protected get columnsInternal(): Array<ItemSpec> {
+        return this._cols;
     }
 
-    protected getRow(view: view.View): ItemSpec {
-        if (this._rows.length === 0) {
-            return this._singleRow;
-        }
-
-        var columnIndex = Math.min(GridLayout.getRow(view), this._rows.length - 1);
-        return this._rows[columnIndex];
+    protected get rowsInternal(): Array<ItemSpec> {
+        return this._rows;
     }
-
-    protected getColumnSpan(view: view.View, columnIndex: number): number {
-        if (this._cols.length === 0) {
-            return 1;
-        }
-
-        return Math.min(GridLayout.getColumnSpan(view), this._cols.length - columnIndex);
-    }
-
-    protected getRowSpan(view: view.View, rowIndex: number): number {
-        if (this._rows.length === 0) {
-            return 1;
-        }
-
-        return Math.min(GridLayout.getRowSpan(view), this._rows.length - rowIndex);
-    }
-
+    
     protected invalidate(): void {
         //
     }
diff --git a/ui/layouts/grid-layout/grid-layout.ios.ts b/ui/layouts/grid-layout/grid-layout.ios.ts
index 091615591..9b431e185 100644
--- a/ui/layouts/grid-layout/grid-layout.ios.ts
+++ b/ui/layouts/grid-layout/grid-layout.ios.ts
@@ -7,23 +7,35 @@ import {CommonLayoutParams} from "ui/styling/style";
 global.moduleMerge(common, exports);
 
 export class GridLayout extends common.GridLayout {
-
-    private _isValid: boolean = false;
     private helper: MeasureHelper;
+    private columnOffsets = new Array<number>();
+    private rowOffsets = new Array<number>();
+    private map = new Map<View, MeasureSpecs>();
+
+    constructor() {
+        super();
+        this.helper = new MeasureHelper(this);
+    }
 
     protected onRowAdded(itemSpec: common.ItemSpec) {
+        this.helper.rows.push(new ItemGroup(itemSpec));
         this.invalidate();
     }
 
     protected onColumnAdded(itemSpec: common.ItemSpec) {
+        this.helper.columns.push(new ItemGroup(itemSpec));
         this.invalidate();
     }
 
     protected onRowRemoved(itemSpec: common.ItemSpec, index: number) {
+        this.helper.rows[index].children.length = 0;
+        this.helper.rows.splice(index, 1);
         this.invalidate();
     }
 
     protected onColumnRemoved(itemSpec: common.ItemSpec, index: number) {
+        this.helper.columns[index].children.length = 0;
+        this.helper.columns.splice(index, 1);
         this.invalidate();
     }
 
@@ -44,14 +56,94 @@ export class GridLayout extends common.GridLayout {
     }
 
     protected invalidate(): void {
-        this._isValid = false;
         this.requestLayout();
     }
 
+    public addChild(child: View): void {
+        super.addChild(child);
+        this.addToMap(child);
+    }
+
+    public insertChild(child: View, atIndex: number): void {
+        super.insertChild(child, atIndex);
+        this.addToMap(child);
+    }
+
+    public removeChild(child: View): void {
+        this.removeFromMap(child);
+        super.removeChild(child);
+    }
+
+    public removeChildren(): void {
+        this.map.clear();
+        super.removeChildren();
+    }
+
+    private getColumnIndex(view: View): number {
+        return Math.max(0, Math.min(GridLayout.getColumn(view), this.columnsInternal.length - 1));
+    }
+
+    private getRowIndex(view: View): number {
+        return Math.max(0, Math.min(GridLayout.getRow(view), this.rowsInternal.length - 1));
+    }
+
+    private getColumnSpan(view: View, columnIndex: number): number {
+        return Math.max(1, Math.min(GridLayout.getColumnSpan(view), this.columnsInternal.length - columnIndex));
+    }
+
+    private getRowSpan(view: View, rowIndex: number): number {
+        return Math.max(1, Math.min(GridLayout.getRowSpan(view), this.rowsInternal.length - rowIndex));
+    }
+
+    private getColumnSpec(view: View): common.ItemSpec {
+        return this.columnsInternal[this.getColumnIndex(view)] || this.helper.singleColumn;
+    }
+
+    private getRowSpec(view: View): common.ItemSpec {
+        return this.rowsInternal[this.getRowIndex(view)] || this.helper.singleRow;
+    }
+
+    private updateMeasureSpecs(child: View, measureSpec: MeasureSpecs): void {
+        let column = this.getColumnSpec(child);
+        let columnIndex = this.getColumnIndex(child);
+        let columnSpan = this.getColumnSpan(child, columnIndex);
+
+        let row = this.getRowSpec(child);
+        let rowIndex = this.getRowIndex(child);
+        let rowSpan = this.getRowSpan(child, rowIndex);
+
+        measureSpec.setColumn(column);
+        measureSpec.setColumnIndex(columnIndex);
+        measureSpec.setColumnSpan(columnSpan);
+
+        measureSpec.setRow(row);
+        measureSpec.setRowIndex(rowIndex);
+        measureSpec.setRowSpan(rowSpan);
+
+        measureSpec.autoColumnsCount = 0;
+        measureSpec.autoRowsCount = 0;
+        measureSpec.measured = false;
+        measureSpec.pixelHeight = 0;
+        measureSpec.pixelWidth = 0;
+        measureSpec.starColumnsCount = 0;
+        measureSpec.starRowsCount = 0;
+    }
+
+    private addToMap(child: View): void {
+        this.map.set(child, new MeasureSpecs(child));
+    }
+
+    private removeFromMap(child: View): void {
+        this.map.delete(child);
+    }
+
     public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
         GridLayout.adjustChildrenLayoutParams(this, widthMeasureSpec, heightMeasureSpec);
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
 
+        let measureWidth = 0;
+        let measureHeight = 0;
+
         let width = utils.layout.getMeasureSpecSize(widthMeasureSpec);
         let widthMode = utils.layout.getMeasureSpecMode(widthMeasureSpec);
 
@@ -59,84 +151,49 @@ export class GridLayout extends common.GridLayout {
         let heightMode = utils.layout.getMeasureSpecMode(heightMeasureSpec);
 
         let density = utils.layout.getDisplayDensity();
+        let verticalPadding = (this.paddingTop + this.paddingBottom) * density;
+        let horizontalPadding = (this.paddingLeft + this.paddingRight) * density;
+
         let infinityWidth = widthMode === utils.layout.UNSPECIFIED;
         let infinityHeight = heightMode === utils.layout.UNSPECIFIED;
 
-        let rows = this.getRows();
-        let cols = this.getColumns();
-        if (!this._isValid) {
+        this.helper.width = Math.max(0, width - horizontalPadding);
+        this.helper.height = Math.max(0, height - verticalPadding);
 
-            rows.forEach((value: common.ItemSpec, index: number, array: common.ItemSpec[]) => {
-                value.index = index;
-            });
+        this.helper.stretchedHorizontally = widthMode === utils.layout.EXACTLY || (this.horizontalAlignment === HorizontalAlignment.stretch && !infinityWidth);
+        this.helper.stretchedVertically = heightMode === utils.layout.EXACTLY || (this.verticalAlignment === VerticalAlignment.stretch && !infinityHeight);
 
-            cols.forEach((value: common.ItemSpec, index: number, array: common.ItemSpec[]) => {
-                value.index = index;
-            });
+        this.helper.setInfinityWidth(infinityWidth);
+        this.helper.setInfinityHeight(infinityHeight);
 
-            this.helper = new MeasureHelper();
-            this.helper.grid = this;
-            this.helper.width = width - (this.paddingLeft + this.paddingRight) * density;
-            this.helper.height = height - (this.paddingTop + this.paddingBottom) * density;
-            this.helper.infinityWidth = infinityWidth;
-            this.helper.infinityHeight = infinityHeight;
+        this.helper.clearMeasureSpecs();
+        this.helper.init();
 
-            for (let i = 0; i < cols.length; i++) {
-                let column = cols[i];
-                let columnGroup = new ColumnGroup(column, this.helper);
-                this.helper.columns.push(columnGroup);
-                if (column.isAbsolute) {
-                    columnGroup.width = column.value * density;
-                }
-            }
-
-            for (let i = 0; i < rows.length; i++) {
-                let row = rows[i];
-                let rowGroup = new RowGroup(row, this.helper);
-                this.helper.rows.push(rowGroup);
-                if (row.isAbsolute) {
-                    rowGroup.height = row.value * density;
-                }
-            }
-
-            if (rows.length === 0) {
-                this.helper.rows.push(new RowGroup(this._singleRow, this.helper));
-            }
-
-            if (cols.length === 0) {
-                this.helper.columns.push(new ColumnGroup(this._singleColumn, this.helper));
-            }
-        }
-
-        let childrenCount = this.getChildrenCount();
-        for (let i = 0; i < childrenCount; i++) {
+        for (let i = 0, count = this.getChildrenCount(); i < count; i++) {
             let child = this.getChildAt(i);
             if (!child._isVisible) {
                 continue;
             }
 
-            let column = this.getColumn(child);
-            let row = this.getRow(child);
-            let columnSpan = this.getColumnSpan(child, column.index);
-            let rowSpan = this.getRowSpan(child, row.index);
-
-            let measureSpec = new MeasureSpecs(child, column, row, columnSpan, rowSpan);
-
-            this.helper.addMeasureSpec(measureSpec, density);
+            let measureSpecs = this.map.get(child);
+            this.updateMeasureSpecs(child, measureSpecs);
+            this.helper.addMeasureSpec(measureSpecs);
         }
 
         this.helper.measure();
 
-        let measureWidth = this.helper.measuredWidth + (this.paddingLeft + this.paddingRight) * density;
-        let measureHeight = this.helper.measuredHeight + (this.paddingTop + this.paddingBottom) * density;
+        // Add in our padding
+        measureWidth = this.helper.measuredWidth + horizontalPadding;
+        measureHeight = this.helper.measuredHeight + verticalPadding;
 
+        // Check against our minimum sizes
         measureWidth = Math.max(measureWidth, this.minWidth * density);
         measureHeight = Math.max(measureHeight, this.minHeight * density);
 
-        let widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
-        let heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
+        let widthSizeAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
+        let heightSizeAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
 
-        this.setMeasuredDimension(widthAndState, heightAndState);
+        this.setMeasuredDimension(widthSizeAndState, heightSizeAndState);
     }
 
     public onLayout(left: number, top: number, right: number, bottom: number): void {
@@ -144,52 +201,59 @@ export class GridLayout extends common.GridLayout {
 
         let density = utils.layout.getDisplayDensity();
 
-        let columnOffsets = new Array<number>();
-        columnOffsets.push(this.paddingLeft * density);
+        let paddingLeft = this.paddingLeft * density;
+        let paddingTop = this.paddingTop * density;
 
-        let rowOffsets = new Array<number>();
-        rowOffsets.push(this.paddingTop * density);
+        this.columnOffsets.length = 0;
+        this.rowOffsets.length = 0;
 
-        let offset = columnOffsets[0];
-        let roundedOffset: number = this.paddingLeft;
-        let roundedLength: number = 0;
-        let actualLength: number = 0;
-        for (let i = 0; i < this.helper.columns.length; i++) {
+        this.columnOffsets.push(paddingLeft);
+        this.rowOffsets.push(paddingTop);
+
+        let offset = this.columnOffsets[0];
+        let roundedOffset = paddingLeft;
+        let roundedLength = 0;
+        let actualLength = 0;
+
+        for (let i = 0, size = this.helper.columns.length; i < size; i++) {
             let columnGroup = this.helper.columns[i];
-            offset += columnGroup.width;
-            columnOffsets.push(offset);
+            offset += columnGroup.length;
 
-            actualLength = offset / density - roundedOffset;
+            actualLength = offset - roundedOffset;
             roundedLength = Math.round(actualLength);
-            columnGroup.column._actualLength = roundedLength;
+            columnGroup.rowOrColumn._actualLength = roundedLength;
             roundedOffset += roundedLength;
+
+            this.columnOffsets.push(roundedOffset);
         }
 
-        offset = rowOffsets[0];
-        roundedOffset = this.paddingTop;
+        offset = this.rowOffsets[0];
+        roundedOffset = paddingTop;
         roundedLength = 0;
         actualLength = 0;
-        for (let i = 0; i < this.helper.rows.length; i++) {
-            let rowGroup = this.helper.rows[i];
-            offset += rowGroup.height;
-            rowOffsets.push(offset);
 
-            actualLength = offset / density - roundedOffset;
+        for (let i = 0, size = this.helper.rows.length; i < size; i++) {
+            let rowGroup = this.helper.rows[i];
+            offset += rowGroup.length;
+
+            actualLength = offset - roundedOffset;
             roundedLength = Math.round(actualLength);
-            rowGroup.row._actualLength = roundedLength;
+            rowGroup.rowOrColumn._actualLength = roundedLength;
             roundedOffset += roundedLength;
+
+            this.rowOffsets.push(roundedOffset);
         }
 
-        for (let i = 0; i < this.helper.columns.length; i++) {
+        for (let i = 0, columns = this.helper.columns.length; i < columns; i++) {
             let columnGroup = this.helper.columns[i];
-            for (let j = 0; j < columnGroup.children.length; j++) {
+            for (let j = 0, children = columnGroup.children.length; j < children; j++) {
 
                 let measureSpec = columnGroup.children[j];
-                let childLeft = columnOffsets[measureSpec.columnIndex];
-                let childRight = columnOffsets[measureSpec.columnIndex + measureSpec.columnSpan];
-                let childTop = rowOffsets[measureSpec.rowIndex];
-                let childBottom = rowOffsets[measureSpec.rowIndex + measureSpec.rowSpan];
-
+                let childLeft = this.columnOffsets[measureSpec.getColumnIndex()];
+                let childRight = this.columnOffsets[measureSpec.getColumnIndex() + measureSpec.getColumnSpan()];
+                let childTop = this.rowOffsets[measureSpec.getRowIndex()];
+                let childBottom = this.rowOffsets[measureSpec.getRowIndex() + measureSpec.getRowSpan()];
+	
                 // No need to include margins in the width, height
                 View.layoutChild(this, measureSpec.child, childLeft, childTop, childRight, childBottom);
             }
@@ -200,315 +264,392 @@ export class GridLayout extends common.GridLayout {
 }
 
 class MeasureSpecs {
+    private _columnSpan = 1;
+    private _rowSpan = 1;
 
-    private _columnSpan: number = 1;
-    private _rowSpan: number = 1;
+    public pixelWidth = 0;
+    public pixelHeight = 0;
 
-    public pixelWidth: number = 0;
-    public pixelHeight: number = 0;
+    public starColumnsCount = 0;
+    public starRowsCount = 0;
 
-    public starColumnsCount: number = 0;
-    public starRowsCount: number = 0;
+    public autoColumnsCount = 0;
+    public autoRowsCount = 0;
 
-    public autoColumnsCount: number = 0;
-    public autoRowsCount: number = 0;
+    public measured = false;
 
-    public measured: boolean = false;
+    public child: View;
+    private column: common.ItemSpec;
+    private row: common.ItemSpec
+    private columnIndex: number;
+    private rowIndex: number;
 
-    constructor(
-        public child: View,
-        public column: common.ItemSpec,
-        public row: common.ItemSpec,
-        columnSpan?: number,
-        rowSpan?: number) {
-        // cannot have zero colSpan.
-        if (columnSpan) {
-            this._columnSpan = columnSpan;
-        }
-
-        // cannot have zero rowSpan.
-        if (rowSpan) {
-            this._rowSpan = rowSpan;
-        }
+    constructor(child: View) {
+        this.child = child;
     }
 
-    get columnIndex(): number {
-        return this.column.index;
-    }
-
-    get rowIndex(): number {
-        return this.row.index;
-    }
-
-    get spanned(): boolean {
+    public getSpanned(): boolean {
         return this._columnSpan > 1 || this._rowSpan > 1;
     }
 
-    get columnSpan(): number {
+    public getIsStar(): boolean {
+        return this.starRowsCount > 0 || this.starColumnsCount > 0;
+    }
+
+    public getColumnSpan(): number {
         return this._columnSpan;
     }
 
-    get rowSpan(): number {
+    public getRowSpan(): number {
         return this._rowSpan;
     }
 
-    get isStar(): boolean {
-        return this.starRowsCount > 0 || this.starColumnsCount > 0;
+    public setRowSpan(value: number): void {
+        // cannot have zero rowSpan.
+        this._rowSpan = Math.max(1, value);
+    }
+
+    public setColumnSpan(value: number): void {
+        // cannot have zero colSpan.
+        this._columnSpan = Math.max(1, value);
+    }
+
+    public getRowIndex(): number {
+        return this.rowIndex;
+    }
+
+    public getColumnIndex(): number {
+        return this.columnIndex;
+    }
+
+    public setRowIndex(value: number): void {
+        this.rowIndex = value;
+    }
+
+    public setColumnIndex(value: number): void {
+        this.columnIndex = value;
+    }
+
+    public getRow(): common.ItemSpec {
+        return this.row;
+    }
+
+    public getColumn(): common.ItemSpec {
+        return this.column;
+    }
+
+    public setRow(value: common.ItemSpec): void {
+        this.row = value;
+    }
+
+    public setColumn(value: common.ItemSpec): void {
+        this.column = value;
     }
 }
 
-class ColumnGroup {
-    width: number = 0;
-    measuredCount = 0;
-    column: common.ItemSpec;
-    children: Array<MeasureSpecs> = new Array<MeasureSpecs>();
-    owner: MeasureHelper;
+class ItemGroup {
+    public length = 0;
+    public measuredCount = 0;
+    public rowOrColumn: common.ItemSpec;
+    public children: Array<MeasureSpecs> = new Array<MeasureSpecs>();
 
-    public measureToFix: number = 0;
-    public currentMeasureToFixCount: number = 0;
+    public measureToFix = 0;
+    public currentMeasureToFixCount = 0;
+    private infinityLength = false;
 
-    constructor(column: common.ItemSpec, owner: MeasureHelper) {
-        this.owner = owner;
-        this.column = column;
+    constructor(spec: common.ItemSpec) {
+        this.rowOrColumn = spec;
     }
 
-    init() {
+    public setIsLengthInfinity(infinityLength: boolean): void {
+        this.infinityLength = infinityLength;
+    }
+
+    public init(density): void {
         this.measuredCount = 0;
         this.currentMeasureToFixCount = 0;
+        this.length = this.rowOrColumn.isAbsolute ? this.rowOrColumn.value * density : 0;
     }
 
-    get allMeasured(): boolean {
+    public getAllMeasured(): boolean {
         return this.measuredCount === this.children.length;
     }
 
-    get isAuto(): boolean {
-        return this.column.isAuto || (this.column.isStar && this.owner.infinityWidth);
-    }
-
-    get isStar(): boolean {
-        return this.column.isStar && !this.owner.infinityWidth;
-    }
-
-    get isAbsolute(): boolean {
-        return this.column.isAbsolute;
-    }
-
-    get canBeFixed(): boolean {
+    public getCanBeFixed(): boolean {
         return this.currentMeasureToFixCount === this.measureToFix;
     }
-}
 
-class RowGroup {
-    height: number = 0;
-    measuredCount = 0;
-    row: common.ItemSpec;
-    children: Array<MeasureSpecs> = new Array<MeasureSpecs>();
-    owner: MeasureHelper;
-
-    public measureToFix: number = 0;
-    public currentMeasureToFixCount: number = 0;
-
-    constructor(row: common.ItemSpec, owner: MeasureHelper) {
-        this.row = row;
-        this.owner = owner;
+    public getIsAuto(): boolean {
+        return this.rowOrColumn.isAuto || (this.rowOrColumn.isStar && this.infinityLength);
     }
 
-    init() {
-        this.measuredCount = 0;
-        this.currentMeasureToFixCount = 0;
+    public getIsStar(): boolean {
+        return this.rowOrColumn.isStar && !this.infinityLength;
     }
 
-    get allMeasured(): boolean {
-        return this.measuredCount === this.children.length;
-    }
-
-    get canBeFixed(): boolean {
-        return this.measuredCount === this.measureToFix;
-    }
-
-    get isAuto(): boolean {
-        return this.row.isAuto || (this.row.isStar && this.owner.infinityHeight);
-    }
-
-    get isStar(): boolean {
-        return this.row.isStar && !this.owner.infinityHeight;
-    }
-
-    get isAbsolute(): boolean {
-        return this.row.isAbsolute;
+    public getIsAbsolute(): boolean {
+        return this.rowOrColumn.isAbsolute;
     }
 }
 
 class MeasureHelper {
-    infinity: number = utils.layout.makeMeasureSpec(0, utils.layout.UNSPECIFIED);
-    rows: Array<RowGroup> = new Array<RowGroup>();
-    columns: Array<ColumnGroup> = new Array<ColumnGroup>();
+    singleRow: common.ItemSpec;
+    singleColumn: common.ItemSpec;
     grid: GridLayout;
-    width: number;
-    height: number;
-    infinityWidth: boolean;
-    infinityHeight: boolean;
-    measuredWidth: number;
-    measuredHeight: number;
 
-    columnStarValue: number;
-    rowStarValue: number;
+    infinity: number = utils.layout.makeMeasureSpec(0, utils.layout.UNSPECIFIED);
+    rows: Array<ItemGroup> = new Array<ItemGroup>();
+    columns: Array<ItemGroup> = new Array<ItemGroup>();
 
-    get horizontalStretch(): boolean {
-        return this.grid.horizontalAlignment === HorizontalAlignment.stretch && !this.infinityWidth;
+    width: number = 0;
+    height: number = 0;
+    stretchedHorizontally: boolean = false;
+    stretchedVertically: boolean = false;
+
+    infinityWidth: boolean = false;
+    infinityHeight: boolean = false;
+
+    measuredWidth: number = 0;
+    measuredHeight: number = 0;
+
+    private columnStarValue: number;
+    private rowStarValue: number;
+
+    private fakeRowAdded: boolean = false;
+    private fakeColumnAdded: boolean = false;
+
+    private singleRowGroup: ItemGroup;
+    private singleColumnGroup: ItemGroup;
+
+    constructor(grid: GridLayout) {
+        this.grid = grid;
+        this.singleRow = new common.ItemSpec();
+        this.singleColumn = new common.ItemSpec();
+        this.singleRowGroup = new ItemGroup(this.singleRow);
+        this.singleColumnGroup = new ItemGroup(this.singleColumn);
     }
 
-    get verticalStretch(): boolean {
-        return this.grid.verticalAlignment === VerticalAlignment.stretch && !this.infinityHeight;
+    public getColumnsFixed(): boolean {
+        return this.columnStarValue >= 0;
     }
 
-    get columnsFixed(): boolean {
-        return !isNaN(this.columnStarValue);
+    public setInfinityWidth(value: boolean): void {
+        if (this.infinityWidth !== value) {
+            this.infinityWidth = value;
+
+            for (let i = 0, size = this.columns.length; i < size; i++) {
+                let columnGroup: ItemGroup = this.columns[i];
+                columnGroup.setIsLengthInfinity(value);
+            }
+        }
     }
 
-    public addMeasureSpec(measureSpec: MeasureSpecs, density: number) {
+    public setInfinityHeight(value: boolean): void {
+        if (this.infinityHeight !== value) {
+            this.infinityHeight = value;
+
+            for (let i = 0, size = this.rows.length; i < size; i++) {
+                let rowGroup: ItemGroup = this.rows[i];
+                rowGroup.setIsLengthInfinity(value);
+            }
+        }
+    }
+
+    public addMeasureSpec(measureSpec: MeasureSpecs): void {
         // Get column stats
-        for (let i = measureSpec.columnIndex; i < measureSpec.columnIndex + measureSpec.columnSpan; i++) {
-            let columnGroup = this.columns[i];
-            if (columnGroup.isAuto) {
+        let size = measureSpec.getColumnIndex() + measureSpec.getColumnSpan();
+        for (let i = measureSpec.getColumnIndex(); i < size; i++) {
+            let columnGroup: ItemGroup = this.columns[i];
+            if (columnGroup.getIsAuto()) {
                 measureSpec.autoColumnsCount++;
             }
-            else if (columnGroup.isStar) {
-                measureSpec.starColumnsCount += columnGroup.column.value;
+            else if (columnGroup.getIsStar()) {
+                measureSpec.starColumnsCount += columnGroup.rowOrColumn.value;
             }
-            else if (columnGroup.isAbsolute) {
-                measureSpec.pixelWidth += columnGroup.column.value * density;
+            else if (columnGroup.getIsAbsolute()) {
+                measureSpec.pixelWidth += columnGroup.rowOrColumn.value;
             }
         }
 
         if (measureSpec.autoColumnsCount > 0 && measureSpec.starColumnsCount === 0) {
             // Determine which auto columns are affected by this element
-            for (let i = measureSpec.columnIndex; i < measureSpec.columnIndex + measureSpec.columnSpan; i++) {
-                let columnGroup = this.columns[i];
-                if (columnGroup.isAuto) {
+            for (let i = measureSpec.getColumnIndex(); i < size; i++) {
+                let columnGroup: ItemGroup = this.columns[i];
+                if (columnGroup.getIsAuto()) {
                     columnGroup.measureToFix++;
                 }
             }
         }
 
         // Get row stats
-        for (let i = measureSpec.rowIndex; i < measureSpec.rowIndex + measureSpec.rowSpan; i++) {
-            let rowGroup = this.rows[i];
-            if (rowGroup.isAuto) {
+        size = measureSpec.getRowIndex() + measureSpec.getRowSpan();
+        for (let i = measureSpec.getRowIndex(); i < size; i++) {
+            let rowGroup: ItemGroup = this.rows[i];
+            if (rowGroup.getIsAuto()) {
                 measureSpec.autoRowsCount++;
             }
-            else if (rowGroup.isStar) {
-                measureSpec.starRowsCount += rowGroup.row.value;
+            else if (rowGroup.getIsStar()) {
+                measureSpec.starRowsCount += rowGroup.rowOrColumn.value;
             }
-            else if (rowGroup.isAbsolute) {
-                measureSpec.pixelHeight += rowGroup.row.value * density;
+            else if (rowGroup.getIsAbsolute()) {
+                measureSpec.pixelHeight += rowGroup.rowOrColumn.value;
             }
         }
 
         if (measureSpec.autoRowsCount > 0 && measureSpec.starRowsCount === 0) {
             // Determine which auto rows are affected by this element
-            for (let i = measureSpec.rowIndex; i < measureSpec.rowIndex + measureSpec.rowSpan; i++) {
-                let rowGroup = this.rows[i];
-                if (rowGroup.isAuto) {
+            for (let i = measureSpec.getRowIndex(); i < size; i++) {
+                let rowGroup: ItemGroup = this.rows[i];
+                if (rowGroup.getIsAuto()) {
                     rowGroup.measureToFix++;
                 }
             }
         }
 
-        this.columns[measureSpec.columnIndex].children.push(measureSpec);
-        this.rows[measureSpec.rowIndex].children.push(measureSpec);
+        this.columns[measureSpec.getColumnIndex()].children.push(measureSpec);
+        this.rows[measureSpec.getRowIndex()].children.push(measureSpec);
     }
 
-    private init() {
-        this.rows.forEach((row, i, a) => row.init());
-        this.columns.forEach((col, i, a) => col.init());
+    public clearMeasureSpecs(): void {
+        for (let i = 0, size = this.columns.length; i < size; i++) {
+            this.columns[i].children.length = 0;
+        }
 
-        this.columnStarValue = Number.NaN;
-        this.rowStarValue = Number.NaN;
+        for (let i = 0, size = this.rows.length; i < size; i++) {
+            this.rows[i].children.length = 0;
+        }
     }
 
-    private itemMeasured(measureSpec: MeasureSpecs, isFakeMeasure: boolean = false) {
+    private static initList(list: Array<ItemGroup>): void {
+        let density = utils.layout.getDisplayDensity();
+        for (let i = 0, size = list.length; i < size; i++) {
+            let item: ItemGroup = list[i];
+            item.init(density);
+        }
+    }
+
+    init(): void {
+
+        let rows = this.rows.length;
+        if (rows === 0) {
+            this.singleRowGroup.setIsLengthInfinity(this.infinityHeight);
+            this.rows.push(this.singleRowGroup);
+            this.fakeRowAdded = true;
+        } else if (rows > 1 && this.fakeRowAdded) {
+            this.rows.splice(0, 1);
+            this.fakeRowAdded = false;
+        }
+
+        let cols = this.columns.length;
+        if (cols === 0) {
+            this.fakeColumnAdded = true;
+            this.singleColumnGroup.setIsLengthInfinity(this.infinityWidth);
+            this.columns.push(this.singleColumnGroup);
+        }
+        else if (cols > 1 && this.fakeColumnAdded) {
+            this.columns.splice(0, 1);
+            this.fakeColumnAdded = false;
+        }
+
+        MeasureHelper.initList(this.rows);
+        MeasureHelper.initList(this.columns);
+
+        this.columnStarValue = -1;
+        this.rowStarValue = -1;
+    }
+
+    private itemMeasured(measureSpec: MeasureSpecs, isFakeMeasure: boolean): void {
         if (!isFakeMeasure) {
-            this.columns[measureSpec.columnIndex].measuredCount++;
-            this.rows[measureSpec.rowIndex].measuredCount++;
+            this.columns[measureSpec.getColumnIndex()].measuredCount++;
+            this.rows[measureSpec.getRowIndex()].measuredCount++;
             measureSpec.measured = true;
         }
 
         if (measureSpec.autoColumnsCount > 0 && measureSpec.starColumnsCount === 0) {
-            for (let i = measureSpec.columnIndex; i < measureSpec.columnIndex + measureSpec.columnSpan; i++) {
-                let columnGroup = this.columns[i];
-                if (columnGroup.isAuto) {
+            let size = measureSpec.getColumnIndex() + measureSpec.getColumnSpan();
+            for (let i = measureSpec.getColumnIndex(); i < size; i++) {
+                let columnGroup: ItemGroup = this.columns[i];
+                if (columnGroup.getIsAuto()) {
                     columnGroup.currentMeasureToFixCount++;
                 }
             }
         }
 
         if (measureSpec.autoRowsCount > 0 && measureSpec.starRowsCount === 0) {
-            for (let i = measureSpec.rowIndex; i < measureSpec.rowIndex + measureSpec.rowSpan; i++) {
-                let rowGroup = this.rows[i];
-                if (rowGroup.isAuto) {
+            let size = measureSpec.getRowIndex() + measureSpec.getRowSpan();
+            for (let i = measureSpec.getRowIndex(); i < size; i++) {
+                let rowGroup: ItemGroup = this.rows[i];
+                if (rowGroup.getIsAuto()) {
                     rowGroup.currentMeasureToFixCount++;
                 }
             }
         }
     }
 
-    private fixColumns() {
+    private fixColumns(): void {
         let currentColumnWidth = 0;
         let columnStarCount = 0;
-        this.columns.forEach((value: ColumnGroup, index: number, array: ColumnGroup[]) => {
+
+        let columnCount = this.columns.length;
+        for (let i = 0; i < columnCount; i++) {
+            let item: ItemGroup = this.columns[i];
+
             // Star columns are still zeros (not calculated).
-            currentColumnWidth += value.width;
-            // Should we use value.isStar instead? It returns star only if space is not infinity.
-            if (value.column.isStar) {
-                columnStarCount += value.column.value;
+            currentColumnWidth += item.length;
+            if (item.rowOrColumn.isStar) {
+                columnStarCount += item.rowOrColumn.value;
             }
-        });
+        }
 
         this.columnStarValue = columnStarCount > 0 ? (this.width - currentColumnWidth) / columnStarCount : 0;
 
-        if (this.horizontalStretch) {
-            this.columns.forEach((value: ColumnGroup, index: number, array: ColumnGroup[]) => {
-                if (value.isStar) {
-                    value.width = value.column.value * this.columnStarValue;
+        if (this.stretchedHorizontally) {
+            for (let i = 0; i < columnCount; i++) {
+                let item: ItemGroup = this.columns[i];
+                if (item.getIsStar()) {
+                    item.length = item.rowOrColumn.value * this.columnStarValue;
                 }
-            });
+            }
         }
     }
 
-    private fixRows() {
+    private fixRows(): void {
         let currentRowHeight = 0;
         let rowStarCount = 0;
-        this.rows.forEach((value: RowGroup, index: number, array: RowGroup[]) => {
+
+        let rowCount = this.rows.length;
+        for (let i = 0; i < rowCount; i++) {
+            let item: ItemGroup = this.rows[i];
+
             // Star rows are still zeros (not calculated).
-            currentRowHeight += value.height;
-            // Should we use value.isStar instead? It returns star only if space is not infinity.
-            if (value.row.isStar) {
-                rowStarCount += value.row.value;
+            currentRowHeight += item.length;
+            if (item.rowOrColumn.isStar) {
+                rowStarCount += item.rowOrColumn.value;
             }
-        });
+        }
 
         this.rowStarValue = rowStarCount > 0 ? (this.height - currentRowHeight) / rowStarCount : 0;
 
-        if (this.verticalStretch) {
-            this.rows.forEach((value: RowGroup, index: number, array: RowGroup[]) => {
-                if (value.isStar) {
-                    value.height = value.row.value * this.rowStarValue;
+        if (this.stretchedVertically) {
+            for (let i = 0; i < rowCount; i++) {
+                let item: ItemGroup = this.rows[i];
+                if (item.getIsStar()) {
+                    item.length = item.rowOrColumn.value * this.rowStarValue;
                 }
-            });
+            }
         }
     }
 
-    private fakeMeasure() {
-        // Fake measure - measure all elemtns that have star rows and auto columns - with infinity Width and infinity Height
-        for (let i = 0; i < this.columns.length; i++) {
-            let columnGroup = this.columns[i];
-            if (columnGroup.allMeasured) {
+    private fakeMeasure(): void {
+        // Fake measure - measure all elements that have star rows and auto columns - with infinity Width and infinity Height
+        for (let i = 0, size = this.columns.length; i < size; i++) {
+            let columnGroup: ItemGroup = this.columns[i];
+            if (columnGroup.getAllMeasured()) {
                 continue;
             }
 
-            for (let j = 0; j < columnGroup.children.length; j++) {
-                let measureSpec = columnGroup.children[j];
+            for (let j = 0, childrenCount = columnGroup.children.length; j < childrenCount; j++) {
+                let measureSpec: MeasureSpecs = columnGroup.children[j];
                 if (measureSpec.starRowsCount > 0 && measureSpec.autoColumnsCount > 0 && measureSpec.starColumnsCount === 0) {
                     this.measureChild(measureSpec, true);
                 }
@@ -516,11 +657,11 @@ class MeasureHelper {
         }
     }
 
-    private measureFixedColumnsNoStarRows() {
-        for (let i = 0; i < this.columns.length; i++) {
-            let columnGroup = this.columns[i];
-            for (let j = 0; j < columnGroup.children.length; j++) {
-                let measureSpec = columnGroup.children[j];
+    private measureFixedColumnsNoStarRows(): void {
+        for (let i = 0, size = this.columns.length; i < size; i++) {
+            let columnGroup: ItemGroup = this.columns[i];
+            for (let j = 0, childrenCount = columnGroup.children.length; j < childrenCount; j++) {
+                let measureSpec: MeasureSpecs = columnGroup.children[j];
                 if (measureSpec.starColumnsCount > 0 && measureSpec.starRowsCount === 0) {
                     this.measureChildFixedColumns(measureSpec);
                 }
@@ -528,11 +669,11 @@ class MeasureHelper {
         }
     }
 
-    private measureNoStarColumnsFixedRows() {
-        for (let i = 0; i < this.columns.length; i++) {
-            let columnGroup = this.columns[i];
-            for (let j = 0; j < columnGroup.children.length; j++) {
-                let measureSpec = columnGroup.children[j];
+    private measureNoStarColumnsFixedRows(): void {
+        for (let i = 0, size = this.columns.length; i < size; i++) {
+            let columnGroup: ItemGroup = this.columns[i];
+            for (let j = 0, childrenCount = columnGroup.children.length; j < childrenCount; j++) {
+                let measureSpec: MeasureSpecs = columnGroup.children[j];
                 if (measureSpec.starRowsCount > 0 && measureSpec.starColumnsCount === 0) {
                     this.measureChildFixedRows(measureSpec);
                 }
@@ -540,38 +681,59 @@ class MeasureHelper {
         }
     }
 
-    public measure() {
-        this.init();
+    private static canFix(list: Array<ItemGroup>): boolean {
+        for (let i = 0, size = list.length; i < size; i++) {
+            let item: ItemGroup = list[i];
+            if (!item.getCanBeFixed()) {
+                return false;
+            }
+        }
 
+        return true;
+    }
+
+    private static getMeasureLength(list: Array<ItemGroup>): number {
+        let result = 0;
+        for (let i = 0, size = list.length; i < size; i++) {
+            let item: ItemGroup = list[i];
+            result += item.length;
+        }
+
+        return result;
+    }
+
+    public measure(): void {
+		
         // Measure auto & pixel columns and rows (no spans).
-        for (let i = 0; i < this.columns.length; i++) {
-            let columnGroup = this.columns[i];
-            for (let j = 0; j < columnGroup.children.length; j++) {
-                let measureSpec = columnGroup.children[j];
-                if (measureSpec.isStar || measureSpec.spanned) {
+        let size = this.columns.length;
+        for (let i = 0; i < size; i++) {
+            let columnGroup: ItemGroup = this.columns[i];
+            for (let j = 0, childrenCount = columnGroup.children.length; j < childrenCount; j++) {
+                let measureSpec: MeasureSpecs = columnGroup.children[j];
+                if (measureSpec.getIsStar() || measureSpec.getSpanned()) {
                     continue;
                 }
 
-                this.measureChild(measureSpec);
+                this.measureChild(measureSpec, false);
             }
         }
 
         // Measure auto & pixel columns and rows (with spans).
-        for (let i = 0; i < this.columns.length; i++) {
-            let columnGroup = this.columns[i];
-            for (let j = 0; j < columnGroup.children.length; j++) {
+        for (let i = 0; i < size; i++) {
+            let columnGroup: ItemGroup = this.columns[i];
+            for (let j = 0, childrenCount = columnGroup.children.length; j < childrenCount; j++) {
                 let measureSpec = columnGroup.children[j];
-                if (measureSpec.isStar || !measureSpec.spanned) {
+                if (measureSpec.getIsStar() || !measureSpec.getSpanned()) {
                     continue;
                 }
 
-                this.measureChild(measureSpec);
+                this.measureChild(measureSpec, false);
             }
         }
 
         // try fix stars!
-        let fixColumns: boolean = this.columns.every((colGroup, i, a) => colGroup.canBeFixed);
-        let fixRows: boolean = this.rows.every((rowGroup, i, a) => rowGroup.canBeFixed);
+        let fixColumns: boolean = MeasureHelper.canFix(this.columns);
+        let fixRows: boolean = MeasureHelper.canFix(this.rows);
 
         if (fixColumns) {
             this.fixColumns();
@@ -609,69 +771,65 @@ class MeasureHelper {
         }
 
         // Rows and columns are fixed here - measure remaining elements
-        for (let i = 0; i < this.columns.length; i++) {
-            let columnGroup = this.columns[i];
-            for (let j = 0; j < columnGroup.children.length; j++) {
-                let measureSpec = columnGroup.children[j];
+        size = this.columns.length;
+        for (let i = 0; i < size; i++) {
+            let columnGroup: ItemGroup = this.columns[i];
+            for (let j = 0, childCount = columnGroup.children.length; j < childCount; j++) {
+                let measureSpec: MeasureSpecs = columnGroup.children[j];
                 if (!measureSpec.measured) {
                     this.measureChildFixedColumnsAndRows(measureSpec);
                 }
             }
         }
 
-        this.measuredWidth = 0;
-        this.columns.forEach((value: ColumnGroup, index: number, array: ColumnGroup[]) => {
-            this.measuredWidth += value.width;
-        });
-
-        this.measuredHeight = 0;
-        this.rows.forEach((value: RowGroup, index: number, array: RowGroup[]) => {
-            this.measuredHeight += value.height;
-        });
+        this.measuredWidth = MeasureHelper.getMeasureLength(this.columns);
+        this.measuredHeight = MeasureHelper.getMeasureLength(this.rows);
     }
 
-    measureChild(measureSpec: MeasureSpecs, isFakeMeasure: boolean = false) {
-        let widthMeasureSpec: number = (measureSpec.autoColumnsCount > 0) ? this.infinity : utils.layout.makeMeasureSpec(measureSpec.pixelWidth, utils.layout.EXACTLY);
-        let heightMeasureSpec: number = (isFakeMeasure || measureSpec.autoRowsCount > 0) ? this.infinity : utils.layout.makeMeasureSpec(measureSpec.pixelHeight, utils.layout.EXACTLY);
+    private measureChild(measureSpec: MeasureSpecs, isFakeMeasure: boolean): void {
+        let widthMeasureSpec = (measureSpec.autoColumnsCount > 0) ? this.infinity : utils.layout.makeMeasureSpec(measureSpec.pixelWidth, utils.layout.EXACTLY);
+        let heightMeasureSpec = (isFakeMeasure || measureSpec.autoRowsCount > 0) ? this.infinity : utils.layout.makeMeasureSpec(measureSpec.pixelHeight, utils.layout.EXACTLY);
 
-        let childSize = View.measureChild(this.grid, measureSpec.child, widthMeasureSpec, heightMeasureSpec);
+        let childSize = View.measureChild(null, measureSpec.child, widthMeasureSpec, heightMeasureSpec);
+        let childMeasuredWidth: number = childSize.measuredWidth;
+        let childMeasuredHeight: number = childSize.measuredHeight;
 
-        let columnSpanEnd = measureSpec.columnIndex + measureSpec.columnSpan;
-        let rowSpanEnd = measureSpec.rowIndex + measureSpec.rowSpan;
+        let columnSpanEnd: number = measureSpec.getColumnIndex() + measureSpec.getColumnSpan();
+        let rowSpanEnd: number = measureSpec.getRowIndex() + measureSpec.getRowSpan();
 
         if (measureSpec.autoColumnsCount > 0) {
-            let remainingSpace = childSize.measuredWidth;
+            let remainingSpace = childMeasuredWidth;
 
-            for (let i = measureSpec.columnIndex; i < columnSpanEnd; i++) {
-                let columnGroup = this.columns[i];
-                remainingSpace -= columnGroup.width;
+            for (let i = measureSpec.getColumnIndex(); i < columnSpanEnd; i++) {
+                let columnGroup: ItemGroup = this.columns[i];
+                remainingSpace -= columnGroup.length;
             }
 
             if (remainingSpace > 0) {
                 let growSize = remainingSpace / measureSpec.autoColumnsCount;
-                for (let i = measureSpec.columnIndex; i < columnSpanEnd; i++) {
-                    let columnGroup = this.columns[i];
-                    if (columnGroup.isAuto) {
-                        columnGroup.width += growSize;
+                for (let i = measureSpec.getColumnIndex(); i < columnSpanEnd; i++) {
+                    let columnGroup: ItemGroup = this.columns[i];
+                    if (columnGroup.getIsAuto()) {
+                        columnGroup.length += growSize;
                     }
                 }
             }
         }
 
         if (!isFakeMeasure && measureSpec.autoRowsCount > 0) {
-            let remainingSpace = childSize.measuredHeight;
+            let remainingSpace: number = childMeasuredHeight;
 
-            for (let i = measureSpec.rowIndex; i < rowSpanEnd; i++) {
-                let rowGroup = this.rows[i];
-                remainingSpace -= rowGroup.height;
+            for (let i = measureSpec.getRowIndex(); i < rowSpanEnd; i++) {
+                let rowGroup: ItemGroup = this.rows[i];
+                remainingSpace -= rowGroup.length;
             }
 
             if (remainingSpace > 0) {
                 let growSize = remainingSpace / measureSpec.autoRowsCount;
-                for (let i = measureSpec.rowIndex; i < rowSpanEnd; i++) {
-                    let rowGroup = this.rows[i];
-                    if (rowGroup.isAuto) {
-                        rowGroup.height += growSize;
+                for (let i = measureSpec.getRowIndex(); i < rowSpanEnd; i++) {
+                    let rowGroup: ItemGroup = this.rows[i];
+                    if (rowGroup.getIsAuto()) {
+                        rowGroup.length += growSize;
                     }
                 }
             }
@@ -680,179 +838,217 @@ class MeasureHelper {
         this.itemMeasured(measureSpec, isFakeMeasure);
     }
 
-    measureChildFixedColumns(measureSpec: MeasureSpecs) {
-        let columnIndex = measureSpec.columnIndex;
-        let columnSpanEnd = columnIndex + measureSpec.columnSpan;
-        let rowIndex = measureSpec.rowIndex;
-        let rowSpanEnd = rowIndex + measureSpec.rowSpan;
+    private measureChildFixedColumns(measureSpec: MeasureSpecs): void {
+        let columnIndex = measureSpec.getColumnIndex();
+        let columnSpanEnd = columnIndex + measureSpec.getColumnSpan();
+        let rowIndex = measureSpec.getRowIndex();
+        let rowSpanEnd = rowIndex + measureSpec.getRowSpan();
+
+        let columnsWidth = 0;
+        let growSize = 0;
 
-        let columnsWidth: number = 0;
         for (let i = columnIndex; i < columnSpanEnd; i++) {
-            let columnGroup = this.columns[i];
-            if (!columnGroup.isStar) {
-                columnsWidth += columnGroup.width;
+            let columnGroup: ItemGroup = this.columns[i];
+            if (!columnGroup.getIsStar()) {
+                columnsWidth += columnGroup.length;
             }
         }
 
-        let measureWidth = columnsWidth + measureSpec.starColumnsCount * this.columnStarValue;
+        let measureWidth = Math.floor(columnsWidth + measureSpec.starColumnsCount * this.columnStarValue);
 
-        let widthMeasureSpec = utils.layout.makeMeasureSpec(measureWidth, this.horizontalStretch ? utils.layout.EXACTLY : utils.layout.AT_MOST);
-        let heightMeasureSpec: number = (measureSpec.autoRowsCount > 0) ? this.infinity : utils.layout.makeMeasureSpec(measureSpec.pixelHeight, utils.layout.EXACTLY);
-        let childSize = View.measureChild(this.grid, measureSpec.child, widthMeasureSpec, heightMeasureSpec);
+        let widthMeasureSpec = utils.layout.makeMeasureSpec(measureWidth, this.stretchedHorizontally ? utils.layout.EXACTLY : utils.layout.AT_MOST);
+        let heightMeasureSpec = (measureSpec.autoRowsCount > 0) ? this.infinity : utils.layout.makeMeasureSpec(measureSpec.pixelHeight, utils.layout.EXACTLY);
 
-        this.updateColumnGroupWidth(measureSpec, childSize.measuredWidth);
+        let childSize = View.measureChild(null, measureSpec.child, widthMeasureSpec, heightMeasureSpec);
+        let childMeasuredWidth = childSize.measuredWidth;
+        let childMeasuredHeight = childSize.measuredHeight;
+
+        // Distribute width over star columns
+        if (!this.stretchedHorizontally) {
+            let remainingSpace = childMeasuredWidth;
+            for (let i = columnIndex; i < columnSpanEnd; i++) {
+                let columnGroup: ItemGroup = this.columns[i];
+                remainingSpace -= columnGroup.length;
+            }
+
+            if (remainingSpace > 0) {
+                growSize = remainingSpace / measureSpec.starColumnsCount;
+                for (let i = columnIndex; i < columnSpanEnd; i++) {
+                    let columnGroup: ItemGroup = this.columns[i];
+                    if (columnGroup.getIsStar()) {
+                        columnGroup.length += growSize;
+                    }
+                }
+            }
+        }
 
         // Distribute height over auto rows
         if (measureSpec.autoRowsCount > 0) {
-            let remainingSpace = childSize.measuredHeight;
+            let remainingSpace = childMeasuredHeight;
 
             for (let i = rowIndex; i < rowSpanEnd; i++) {
-                let rowGroup = this.rows[i];
-                remainingSpace -= rowGroup.height;
+                let rowGroup: ItemGroup = this.rows[i];
+                remainingSpace -= rowGroup.length;
             }
 
             if (remainingSpace > 0) {
-                let growSize = remainingSpace / measureSpec.autoRowsCount;
+                growSize = remainingSpace / measureSpec.autoRowsCount;
                 for (let i = rowIndex; i < rowSpanEnd; i++) {
-                    let rowGroup = this.rows[i];
-                    if (rowGroup.isAuto) {
-                        rowGroup.height += growSize;
+                    let rowGroup: ItemGroup = this.rows[i];
+                    if (rowGroup.getIsAuto()) {
+                        rowGroup.length += growSize;
                     }
                 }
             }
         }
 
-        this.itemMeasured(measureSpec);
+        this.itemMeasured(measureSpec, false);
     }
 
-    measureChildFixedRows(measureSpec: MeasureSpecs) {
-        let columnIndex = measureSpec.columnIndex;
-        let columnSpanEnd = columnIndex + measureSpec.columnSpan;
-        let rowIndex = measureSpec.rowIndex;
-        let rowSpanEnd = rowIndex + measureSpec.rowSpan;
-        let rowsHeight: number = 0;
+    private measureChildFixedRows(measureSpec: MeasureSpecs): void {
+        let columnIndex = measureSpec.getColumnIndex();
+        let columnSpanEnd = columnIndex + measureSpec.getColumnSpan();
+        let rowIndex = measureSpec.getRowIndex();
+        let rowSpanEnd = rowIndex + measureSpec.getRowSpan();
+        let rowsHeight = 0;
 
         for (let i = rowIndex; i < rowSpanEnd; i++) {
-            let rowGroup = this.rows[i];
-            if (!rowGroup.isStar) {
-                rowsHeight += rowGroup.height;
+            let rowGroup: ItemGroup = this.rows[i];
+            if (!rowGroup.getIsStar()) {
+                rowsHeight += rowGroup.length;
             }
         }
 
-        let measureHeight = rowsHeight + measureSpec.starRowsCount * this.rowStarValue;
+        let measureHeight = Math.floor(rowsHeight + measureSpec.starRowsCount * this.rowStarValue);
+
+        let widthMeasureSpec = (measureSpec.autoColumnsCount > 0) ? this.infinity : utils.layout.makeMeasureSpec(measureSpec.pixelWidth, utils.layout.EXACTLY);
+        let heightMeasureSpec = utils.layout.makeMeasureSpec(measureHeight, this.stretchedVertically ? utils.layout.EXACTLY : utils.layout.AT_MOST);
+
+        let childSize = View.measureChild(null, measureSpec.child, widthMeasureSpec, heightMeasureSpec);
+        let childMeasuredWidth = childSize.measuredWidth;
+        let childMeasuredHeight = childSize.measuredHeight;
+
+        let remainingSpace = 0;
+        let growSize = 0;
 
-        let widthMeasureSpec: number = (measureSpec.autoColumnsCount > 0) ? this.infinity : utils.layout.makeMeasureSpec(measureSpec.pixelWidth, utils.layout.EXACTLY);
-        let heightMeasureSpec = utils.layout.makeMeasureSpec(measureHeight, this.verticalStretch ? utils.layout.EXACTLY : utils.layout.AT_MOST);
-        let childSize = View.measureChild(this.grid, measureSpec.child, widthMeasureSpec, heightMeasureSpec);
-        
         // Distribute width over auto columns
         if (measureSpec.autoColumnsCount > 0) {
-            let remainingSpace = childSize.measuredWidth;
+            remainingSpace = childMeasuredWidth;
 
             for (let i = columnIndex; i < columnSpanEnd; i++) {
-                let columnGroup = this.columns[i];
-                remainingSpace -= columnGroup.width;
+                let columnGroup: ItemGroup = this.columns[i];
+                remainingSpace -= columnGroup.length;
             }
 
             if (remainingSpace > 0) {
-                let growSize = remainingSpace / measureSpec.autoColumnsCount;
+                growSize = remainingSpace / measureSpec.autoColumnsCount;
                 for (let i = columnIndex; i < columnSpanEnd; i++) {
-                    let columnGroup = this.columns[i];
-                    if (columnGroup.isAuto) {
-                        columnGroup.width += growSize;
+                    let columnGroup: ItemGroup = this.columns[i];
+
+                    if (columnGroup.getIsAuto()) {
+                        columnGroup.length += growSize;
                     }
                 }
             }
         }
 
-        this.updateRowGroupHeight(measureSpec, childSize.measuredHeight);
+        // Distribute height over star rows
+        if (!this.stretchedVertically) {
+            remainingSpace = childMeasuredHeight;
+            for (let i = rowIndex; i < rowSpanEnd; i++) {
+                let rowGroup: ItemGroup = this.rows[i];
+                remainingSpace -= rowGroup.length;
+            }
 
-        this.itemMeasured(measureSpec);
+            if (remainingSpace > 0) {
+                growSize = remainingSpace / measureSpec.starRowsCount;
+                for (let i = rowIndex; i < rowSpanEnd; i++) {
+                    let rowGroup: ItemGroup = this.rows[i];
+                    if (rowGroup.getIsStar()) {
+                        rowGroup.length += growSize;
+                    }
+                }
+            }
+        }
+
+        this.itemMeasured(measureSpec, false);
     }
 
-    measureChildFixedColumnsAndRows(measureSpec: MeasureSpecs): void {
-        let columnIndex = measureSpec.columnIndex;
-        let columnSpanEnd = columnIndex + measureSpec.columnSpan;
-        let rowIndex = measureSpec.rowIndex;
-        let rowSpanEnd = rowIndex + measureSpec.rowSpan;
+    private measureChildFixedColumnsAndRows(measureSpec: MeasureSpecs): void {
+        let columnIndex = measureSpec.getColumnIndex();
+        let columnSpanEnd = columnIndex + measureSpec.getColumnSpan();
+        let rowIndex = measureSpec.getRowIndex();
+        let rowSpanEnd = rowIndex + measureSpec.getRowSpan();
 
-        let columnGroup: ColumnGroup;
-        let rowGroup: RowGroup;
-
-        let columnsWidth: number = 0;
+        let columnsWidth = 0;
         for (let i = columnIndex; i < columnSpanEnd; i++) {
-            columnGroup = this.columns[i];
-            if (!columnGroup.isStar) {
-                columnsWidth += columnGroup.width;
+            let columnGroup: ItemGroup = this.columns[i];
+            if (!columnGroup.getIsStar()) {
+                columnsWidth += columnGroup.length;
             }
         }
 
-        let rowsHeight: number = 0;
+        let rowsHeight = 0;
         for (let i = rowIndex; i < rowSpanEnd; i++) {
-            rowGroup = this.rows[i];
-            if (!rowGroup.isStar) {
-                rowsHeight += rowGroup.height;
+            let rowGroup: ItemGroup = this.rows[i];
+            if (!rowGroup.getIsStar()) {
+                rowsHeight += rowGroup.length;
             }
         }
 
-        let measureWidth = columnsWidth + measureSpec.starColumnsCount * this.columnStarValue;
-        let measureHeight = rowsHeight + measureSpec.starRowsCount * this.rowStarValue;
+        let measureWidth = Math.floor(columnsWidth + measureSpec.starColumnsCount * this.columnStarValue);
+        let measureHeight = Math.floor(rowsHeight + measureSpec.starRowsCount * this.rowStarValue);
 
         // if (have stars) & (not stretch) - at most
-        let widthMeasureSpec = utils.layout.makeMeasureSpec(measureWidth, (measureSpec.starColumnsCount > 0 && !this.horizontalStretch) ? utils.layout.AT_MOST : utils.layout.EXACTLY);
-        let heightMeasureSpec = utils.layout.makeMeasureSpec(measureHeight, (measureSpec.starRowsCount > 0 && !this.verticalStretch) ? utils.layout.AT_MOST : utils.layout.EXACTLY);
+        let widthMeasureSpec = utils.layout.makeMeasureSpec(measureWidth,
+            (measureSpec.starColumnsCount > 0 && !this.stretchedHorizontally) ? utils.layout.AT_MOST : utils.layout.EXACTLY);
 
-        let childSize = View.measureChild(this.grid, measureSpec.child, widthMeasureSpec, heightMeasureSpec);
+        let heightMeasureSpec = utils.layout.makeMeasureSpec(measureHeight,
+            (measureSpec.starRowsCount > 0 && !this.stretchedVertically) ? utils.layout.AT_MOST : utils.layout.EXACTLY);
 
-        this.updateColumnGroupWidth(measureSpec, childSize.measuredWidth);
-        this.updateRowGroupHeight(measureSpec, childSize.measuredHeight);
+        let childSize = View.measureChild(null, measureSpec.child, widthMeasureSpec, heightMeasureSpec);
+        let childMeasuredWidth = childSize.measuredWidth;
+        let childMeasuredHeight = childSize.measuredHeight;
 
-        this.itemMeasured(measureSpec);
-    }
-
-    private updateRowGroupHeight(measureSpec: MeasureSpecs, remainingSpace: number): void {
-        // Distribute height over star rows
-        if (!this.verticalStretch) {
-            let rowIndex = measureSpec.rowIndex;
-            let rowSpanEnd = rowIndex + measureSpec.rowSpan;
-
-            for (let i = rowIndex; i < rowSpanEnd; i++) {
-                let rowGroup = this.rows[i];
-                remainingSpace -= rowGroup.height;
-            }
-
-            if (remainingSpace > 0) {
-                let growSize = remainingSpace / measureSpec.starRowsCount;
-                for (let i = rowIndex; i < rowSpanEnd; i++) {
-                    let rowGroup = this.rows[i];
-                    if (rowGroup.isStar) {
-                        rowGroup.height += growSize;
-                    }
-                }
-            }
-        }
-    }
-
-    private updateColumnGroupWidth(measureSpec: MeasureSpecs, remainingSpace: number): void {
-        // Distribute width over star columns
-        if (!this.horizontalStretch) {
-            let columnIndex = measureSpec.columnIndex;
-            let columnSpanEnd = columnIndex + measureSpec.columnSpan;
+        let remainingSpace = childMeasuredWidth;
+        let growSize = 0;
 
+        if (!this.stretchedHorizontally) {
             for (let i = columnIndex; i < columnSpanEnd; i++) {
-                let columnGroup = this.columns[i];
-                remainingSpace -= columnGroup.width;
+                let columnGroup: ItemGroup = this.columns[i];
+                remainingSpace -= columnGroup.length;
             }
 
             if (remainingSpace > 0) {
-                let growSize = remainingSpace / measureSpec.starColumnsCount;
+                growSize = remainingSpace / measureSpec.starColumnsCount;
                 for (let i = columnIndex; i < columnSpanEnd; i++) {
-                    let columnGroup = this.columns[i];
-                    if (columnGroup.isStar) {
-                        columnGroup.width += growSize;
+                    let columnGroup: ItemGroup = this.columns[i];
+                    if (columnGroup.getIsStar()) {
+                        columnGroup.length += growSize;
                     }
                 }
             }
         }
+
+        remainingSpace = childMeasuredHeight;
+
+        if (!this.stretchedVertically) {
+            for (let i = rowIndex; i < rowSpanEnd; i++) {
+                let rowGroup: ItemGroup = this.rows[i];
+                remainingSpace -= rowGroup.length;
+            }
+
+            if (remainingSpace > 0) {
+                growSize = remainingSpace / measureSpec.starRowsCount;
+                for (let i = rowIndex; i < rowSpanEnd; i++) {
+                    let rowGroup: ItemGroup = this.rows[i];
+                    if (rowGroup.getIsStar()) {
+                        rowGroup.length += growSize;
+                    }
+                }
+            }
+        }
+
+        this.itemMeasured(measureSpec, false);
     }
 }
\ No newline at end of file

From b67c2623ed2151be076cebdec430dda89d8c16c1 Mon Sep 17 00:00:00 2001
From: Hristo Hristov <hristo.hristov@telerik.com>
Date: Tue, 19 Jan 2016 10:53:55 +0200
Subject: [PATCH 2/3] Added new Page in one test Updated package.json widget
 version

---
 apps/tests/xml-declaration/xml-declaration-tests.ts | 3 ++-
 package.json                                        | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/apps/tests/xml-declaration/xml-declaration-tests.ts b/apps/tests/xml-declaration/xml-declaration-tests.ts
index d26c50091..fe30755f0 100644
--- a/apps/tests/xml-declaration/xml-declaration-tests.ts
+++ b/apps/tests/xml-declaration/xml-declaration-tests.ts
@@ -103,7 +103,8 @@ export function test_loadWithOptionsWithXML() {
     var v = builder.load({
         path: "~/xml-declaration/mymodulewithxml",
         name: "MyControl",
-        exports: exports
+        exports: exports,
+        page: new Page()
     });
     TKUnit.assert(v instanceof view.View, "Expected result: View; Actual result: " + v + ";");
 };
diff --git a/package.json b/package.json
index 2e8f80724..2746a754a 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
   },
   "typings": "tns-core-modules.d.ts",
   "dependencies": {
-    "tns-core-modules-widgets": "1.6.0"
+    "tns-core-modules-widgets": "1.6.1"
   },
   "nativescript": {
     "platforms": {

From 345d007755a1c5de9488f530f63a1649ee8e6154 Mon Sep 17 00:00:00 2001
From: Hristo Hristov <hristo.hristov@telerik.com>
Date: Tue, 19 Jan 2016 11:27:11 +0200
Subject: [PATCH 3/3] Revert version of widgets

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 2746a754a..2e8f80724 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
   },
   "typings": "tns-core-modules.d.ts",
   "dependencies": {
-    "tns-core-modules-widgets": "1.6.1"
+    "tns-core-modules-widgets": "1.6.0"
   },
   "nativescript": {
     "platforms": {