2016-11-23 11:12:51 -08:00
|
|
|
/**
|
2018-09-11 15:27:47 -07:00
|
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
2016-11-23 11:12:51 -08:00
|
|
|
*
|
2019-03-28 04:44:34 -07:00
|
|
|
* This source code is licensed under the MIT license found in the LICENSE
|
|
|
|
* file in the root directory of this source tree.
|
2016-11-23 11:12:51 -08:00
|
|
|
*/
|
2017-01-31 09:28:09 -08:00
|
|
|
// @Generated by gentest/gentest.rb from gentest/fixtures/YGRoundingTest.html
|
2016-11-23 11:12:51 -08:00
|
|
|
|
|
|
|
using System;
|
|
|
|
using NUnit.Framework;
|
|
|
|
|
2016-12-02 11:18:16 -08:00
|
|
|
namespace Facebook.Yoga
|
2016-11-23 11:12:51 -08:00
|
|
|
{
|
|
|
|
[TestFixture]
|
2016-12-03 04:40:21 -08:00
|
|
|
public class YGRoundingTest
|
2016-11-23 11:12:51 -08:00
|
|
|
{
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_flex_basis_flex_grow_row_width_of_100()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.FlexDirection = YogaFlexDirection.Row;
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root.Width = 100;
|
|
|
|
root.Height = 100;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0.FlexGrow = 1;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.FlexGrow = 1;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child2.FlexGrow = 1;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(33f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(33f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(34f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(67f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(33f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutHeight);
|
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(67f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(33f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(33f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(34f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(33f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_flex_basis_flex_grow_row_prime_number_width()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.FlexDirection = YogaFlexDirection.Row;
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root.Width = 113;
|
|
|
|
root.Height = 100;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0.FlexGrow = 1;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.FlexGrow = 1;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child2.FlexGrow = 1;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child3 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child3.FlexGrow = 1;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(3, root_child3);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child4 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child4.FlexGrow = 1;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(4, root_child4);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(113f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(23f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(23f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(22f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(45f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(23f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(68f, root_child3.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child3.LayoutY);
|
|
|
|
Assert.AreEqual(22f, root_child3.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child3.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(90f, root_child4.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child4.LayoutY);
|
|
|
|
Assert.AreEqual(23f, root_child4.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child4.LayoutHeight);
|
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(113f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(90f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(23f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(68f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(22f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(45f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(23f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(23f, root_child3.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child3.LayoutY);
|
|
|
|
Assert.AreEqual(22f, root_child3.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child3.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child4.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child4.LayoutY);
|
|
|
|
Assert.AreEqual(23f, root_child4.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child4.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_flex_basis_flex_shrink_row()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.FlexDirection = YogaFlexDirection.Row;
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root.Width = 101;
|
|
|
|
root.Height = 100;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0.FlexShrink = 1;
|
|
|
|
root_child0.FlexBasis = 100;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.FlexBasis = 25;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child2.FlexBasis = 25;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(101f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(51f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(51f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(25f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(76f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(25f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutHeight);
|
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(101f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(50f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(51f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(25f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(25f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(25f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_flex_basis_overrides_main_size()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root.Width = 100;
|
|
|
|
root.Height = 113;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0.FlexGrow = 1;
|
|
|
|
root_child0.FlexBasis = 50;
|
|
|
|
root_child0.Height = 20;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.FlexGrow = 1;
|
|
|
|
root_child1.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child2.FlexGrow = 1;
|
|
|
|
root_child2.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(64f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(64f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(25f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(64f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(64f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(25f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_total_fractial()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
2016-11-29 09:04:43 -08:00
|
|
|
root.Width = 87.4f;
|
|
|
|
root.Height = 113.4f;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child0.FlexGrow = 0.7f;
|
|
|
|
root_child0.FlexBasis = 50.3f;
|
2016-11-29 09:04:43 -08:00
|
|
|
root_child0.Height = 20.3f;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child1.FlexGrow = 1.6f;
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child2.FlexGrow = 1.1f;
|
2016-11-29 09:04:43 -08:00
|
|
|
root_child2.Height = 10.7f;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(59f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(59f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(30f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(59f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(59f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(30f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_total_fractial_nested()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
2016-11-29 09:04:43 -08:00
|
|
|
root.Width = 87.4f;
|
|
|
|
root.Height = 113.4f;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child0.FlexGrow = 0.7f;
|
|
|
|
root_child0.FlexBasis = 50.3f;
|
2016-11-29 09:04:43 -08:00
|
|
|
root_child0.Height = 20.3f;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0_child0 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0_child0.FlexGrow = 1;
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child0_child0.FlexBasis = 0.3f;
|
2017-01-08 07:58:31 -08:00
|
|
|
root_child0_child0.Bottom = 13.3f;
|
2016-11-29 09:04:43 -08:00
|
|
|
root_child0_child0.Height = 9.9f;
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child0.Insert(0, root_child0_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0_child1 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0_child1.FlexGrow = 4;
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child0_child1.FlexBasis = 0.3f;
|
2017-01-08 07:58:31 -08:00
|
|
|
root_child0_child1.Top = 13.3f;
|
2016-11-29 09:04:43 -08:00
|
|
|
root_child0_child1.Height = 1.1f;
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child0.Insert(1, root_child0_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child1.FlexGrow = 1.6f;
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
2016-11-23 11:12:51 -08:00
|
|
|
root_child2.FlexGrow = 1.1f;
|
2016-11-29 09:04:43 -08:00
|
|
|
root_child2.Height = 10.7f;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(59f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0_child0.LayoutX);
|
|
|
|
Assert.AreEqual(-13f, root_child0_child0.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child0_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(12f, root_child0_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0_child1.LayoutX);
|
|
|
|
Assert.AreEqual(25f, root_child0_child1.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child0_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(47f, root_child0_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(59f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(30f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(59f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0_child0.LayoutX);
|
|
|
|
Assert.AreEqual(-13f, root_child0_child0.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child0_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(12f, root_child0_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0_child1.LayoutX);
|
|
|
|
Assert.AreEqual(25f, root_child0_child1.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child0_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(47f, root_child0_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(59f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(30f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(87f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_fractial_input_1()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root.Width = 100;
|
2016-11-29 09:04:43 -08:00
|
|
|
root.Height = 113.4f;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0.FlexGrow = 1;
|
|
|
|
root_child0.FlexBasis = 50;
|
|
|
|
root_child0.Height = 20;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.FlexGrow = 1;
|
|
|
|
root_child1.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child2.FlexGrow = 1;
|
|
|
|
root_child2.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(64f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(64f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(25f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(64f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(64f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(25f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_fractial_input_2()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root.Width = 100;
|
2016-11-29 09:04:43 -08:00
|
|
|
root.Height = 113.6f;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0.FlexGrow = 1;
|
|
|
|
root_child0.FlexBasis = 50;
|
|
|
|
root_child0.Height = 20;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.FlexGrow = 1;
|
|
|
|
root_child1.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child2.FlexGrow = 1;
|
|
|
|
root_child2.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(114f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(65f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(65f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(25f, root_child2.LayoutHeight);
|
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(114f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(65f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(65f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(25f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_fractial_input_3()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
2017-01-08 07:58:31 -08:00
|
|
|
root.Top = 0.3f;
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root.Width = 100;
|
2016-11-29 09:04:43 -08:00
|
|
|
root.Height = 113.4f;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0.FlexGrow = 1;
|
|
|
|
root_child0.FlexBasis = 50;
|
|
|
|
root_child0.Height = 20;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.FlexGrow = 1;
|
|
|
|
root_child1.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child2.FlexGrow = 1;
|
|
|
|
root_child2.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(114f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
New round-to-pixel-grid algorithm that fixes possible subpixel gaps between sibling nodes
Summary:
This diff introduces new, little bit sophisticated round-to-pixel-grid algorithm.
**Motivation:**
Previous simple and straightforward solution works in most cases but sometimes produce the not-so-great result. A while ago Nick Lockwood described this problem and proposed the solution in RN's RCTShadowView class:
For example, say you have the following structure:
// +--------+---------+--------+
// | |+-------+| |
// | || || |
// | |+-------+| |
// +--------+---------+--------+
Say the screen width is 320 pts so the three big views will get the following x bounds from our layout system:
{0, 106.667}, {106.667, 213.333}, {213.333, 320}
Assuming screen scale is 2, these numbers must be rounded to the nearest 0.5 to fit the pixel grid:
{0, 106.5}, {106.5, 213.5}, {213.5, 320}
You'll notice that the three widths are 106.5, 107, 106.5.
This is great for the parent views but it gets trickier when we consider rounding for the subview. When we go to round the bounds for the subview in the middle, it's relative bounds are {0, 106.667} which gets rounded to {0, 106.5}. This will cause the subview to be one pixel smaller than it should be. This is why we need to pass in the absolute position in order to do the rounding relative to the screen's grid rather than the view's grid. After passing in the absolutePosition of {106.667, y}, we do the following calculations:
absoluteLeft = round(absolutePosition.x + viewPosition.left) = round(106.667 + 0) = 106.5
absoluteRight = round(absolutePosition.x + viewPosition.left + viewSize.width) + round(106.667 + 0 + 106.667) = 213.5
width = 213.5 - 106.5 = 107
You'll notice that this is the same width we calculated for the parent view because we've taken its position into account.
I believe this is awesome. I also believe that we have to decouple this logic from RN and put it into awesome Yoga. So I did it in this diff.
**Fun fact:**
The original implementation of this algorithm in RN had (and still have) a bug, which was found by Dustin dshahidehpour and fixed in D4133643. Therefore that diff was unlanded because it broke something unrelated inside RN text engine. I will fix that problem in RN later.
**Why do we need to change test methodology?**
Because the way we receive layout metrics from Chrome browser actually directly related to rounding problem. Previously we used `offsetHeight` and `offsetWidth` properties of the DOM node, which contain naively rounded values from `computedStyle` or `getBoundingClientRect`. (Which is we are trying to fix!) So, I added the new function that computes node size using two-step-rounding approach, conceptually similar to one that implemented in Yoga. Note: Chrome browser performs rounding layout as part of rendering process and actual values that can ve computed by counting actual pixel are different from these natively rounded ones.
**Why do some tests now have different desired values?**
These changes actually prove that my approach is correct and more useful for actual view rendering goals. So, let's take a look at test with changed values `rounding_fractial_input_3`:
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Reviewed By: emilsjolander
Differential Revision: D4941266
fbshipit-source-id: 07500f5cc93c628219500e9e07291438e9d5d36c
2017-04-25 17:29:27 -07:00
|
|
|
Assert.AreEqual(65f, root_child0.LayoutHeight);
|
2016-11-23 11:12:51 -08:00
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(64f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
New round-to-pixel-grid algorithm that fixes possible subpixel gaps between sibling nodes
Summary:
This diff introduces new, little bit sophisticated round-to-pixel-grid algorithm.
**Motivation:**
Previous simple and straightforward solution works in most cases but sometimes produce the not-so-great result. A while ago Nick Lockwood described this problem and proposed the solution in RN's RCTShadowView class:
For example, say you have the following structure:
// +--------+---------+--------+
// | |+-------+| |
// | || || |
// | |+-------+| |
// +--------+---------+--------+
Say the screen width is 320 pts so the three big views will get the following x bounds from our layout system:
{0, 106.667}, {106.667, 213.333}, {213.333, 320}
Assuming screen scale is 2, these numbers must be rounded to the nearest 0.5 to fit the pixel grid:
{0, 106.5}, {106.5, 213.5}, {213.5, 320}
You'll notice that the three widths are 106.5, 107, 106.5.
This is great for the parent views but it gets trickier when we consider rounding for the subview. When we go to round the bounds for the subview in the middle, it's relative bounds are {0, 106.667} which gets rounded to {0, 106.5}. This will cause the subview to be one pixel smaller than it should be. This is why we need to pass in the absolute position in order to do the rounding relative to the screen's grid rather than the view's grid. After passing in the absolutePosition of {106.667, y}, we do the following calculations:
absoluteLeft = round(absolutePosition.x + viewPosition.left) = round(106.667 + 0) = 106.5
absoluteRight = round(absolutePosition.x + viewPosition.left + viewSize.width) + round(106.667 + 0 + 106.667) = 213.5
width = 213.5 - 106.5 = 107
You'll notice that this is the same width we calculated for the parent view because we've taken its position into account.
I believe this is awesome. I also believe that we have to decouple this logic from RN and put it into awesome Yoga. So I did it in this diff.
**Fun fact:**
The original implementation of this algorithm in RN had (and still have) a bug, which was found by Dustin dshahidehpour and fixed in D4133643. Therefore that diff was unlanded because it broke something unrelated inside RN text engine. I will fix that problem in RN later.
**Why do we need to change test methodology?**
Because the way we receive layout metrics from Chrome browser actually directly related to rounding problem. Previously we used `offsetHeight` and `offsetWidth` properties of the DOM node, which contain naively rounded values from `computedStyle` or `getBoundingClientRect`. (Which is we are trying to fix!) So, I added the new function that computes node size using two-step-rounding approach, conceptually similar to one that implemented in Yoga. Note: Chrome browser performs rounding layout as part of rendering process and actual values that can ve computed by counting actual pixel are different from these natively rounded ones.
**Why do some tests now have different desired values?**
These changes actually prove that my approach is correct and more useful for actual view rendering goals. So, let's take a look at test with changed values `rounding_fractial_input_3`:
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Reviewed By: emilsjolander
Differential Revision: D4941266
fbshipit-source-id: 07500f5cc93c628219500e9e07291438e9d5d36c
2017-04-25 17:29:27 -07:00
|
|
|
Assert.AreEqual(24f, root_child1.LayoutHeight);
|
2016-11-23 11:12:51 -08:00
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
New round-to-pixel-grid algorithm that fixes possible subpixel gaps between sibling nodes
Summary:
This diff introduces new, little bit sophisticated round-to-pixel-grid algorithm.
**Motivation:**
Previous simple and straightforward solution works in most cases but sometimes produce the not-so-great result. A while ago Nick Lockwood described this problem and proposed the solution in RN's RCTShadowView class:
For example, say you have the following structure:
// +--------+---------+--------+
// | |+-------+| |
// | || || |
// | |+-------+| |
// +--------+---------+--------+
Say the screen width is 320 pts so the three big views will get the following x bounds from our layout system:
{0, 106.667}, {106.667, 213.333}, {213.333, 320}
Assuming screen scale is 2, these numbers must be rounded to the nearest 0.5 to fit the pixel grid:
{0, 106.5}, {106.5, 213.5}, {213.5, 320}
You'll notice that the three widths are 106.5, 107, 106.5.
This is great for the parent views but it gets trickier when we consider rounding for the subview. When we go to round the bounds for the subview in the middle, it's relative bounds are {0, 106.667} which gets rounded to {0, 106.5}. This will cause the subview to be one pixel smaller than it should be. This is why we need to pass in the absolute position in order to do the rounding relative to the screen's grid rather than the view's grid. After passing in the absolutePosition of {106.667, y}, we do the following calculations:
absoluteLeft = round(absolutePosition.x + viewPosition.left) = round(106.667 + 0) = 106.5
absoluteRight = round(absolutePosition.x + viewPosition.left + viewSize.width) + round(106.667 + 0 + 106.667) = 213.5
width = 213.5 - 106.5 = 107
You'll notice that this is the same width we calculated for the parent view because we've taken its position into account.
I believe this is awesome. I also believe that we have to decouple this logic from RN and put it into awesome Yoga. So I did it in this diff.
**Fun fact:**
The original implementation of this algorithm in RN had (and still have) a bug, which was found by Dustin dshahidehpour and fixed in D4133643. Therefore that diff was unlanded because it broke something unrelated inside RN text engine. I will fix that problem in RN later.
**Why do we need to change test methodology?**
Because the way we receive layout metrics from Chrome browser actually directly related to rounding problem. Previously we used `offsetHeight` and `offsetWidth` properties of the DOM node, which contain naively rounded values from `computedStyle` or `getBoundingClientRect`. (Which is we are trying to fix!) So, I added the new function that computes node size using two-step-rounding approach, conceptually similar to one that implemented in Yoga. Note: Chrome browser performs rounding layout as part of rendering process and actual values that can ve computed by counting actual pixel are different from these natively rounded ones.
**Why do some tests now have different desired values?**
These changes actually prove that my approach is correct and more useful for actual view rendering goals. So, let's take a look at test with changed values `rounding_fractial_input_3`:
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Reviewed By: emilsjolander
Differential Revision: D4941266
fbshipit-source-id: 07500f5cc93c628219500e9e07291438e9d5d36c
2017-04-25 17:29:27 -07:00
|
|
|
Assert.AreEqual(25f, root_child2.LayoutHeight);
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(114f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
New round-to-pixel-grid algorithm that fixes possible subpixel gaps between sibling nodes
Summary:
This diff introduces new, little bit sophisticated round-to-pixel-grid algorithm.
**Motivation:**
Previous simple and straightforward solution works in most cases but sometimes produce the not-so-great result. A while ago Nick Lockwood described this problem and proposed the solution in RN's RCTShadowView class:
For example, say you have the following structure:
// +--------+---------+--------+
// | |+-------+| |
// | || || |
// | |+-------+| |
// +--------+---------+--------+
Say the screen width is 320 pts so the three big views will get the following x bounds from our layout system:
{0, 106.667}, {106.667, 213.333}, {213.333, 320}
Assuming screen scale is 2, these numbers must be rounded to the nearest 0.5 to fit the pixel grid:
{0, 106.5}, {106.5, 213.5}, {213.5, 320}
You'll notice that the three widths are 106.5, 107, 106.5.
This is great for the parent views but it gets trickier when we consider rounding for the subview. When we go to round the bounds for the subview in the middle, it's relative bounds are {0, 106.667} which gets rounded to {0, 106.5}. This will cause the subview to be one pixel smaller than it should be. This is why we need to pass in the absolute position in order to do the rounding relative to the screen's grid rather than the view's grid. After passing in the absolutePosition of {106.667, y}, we do the following calculations:
absoluteLeft = round(absolutePosition.x + viewPosition.left) = round(106.667 + 0) = 106.5
absoluteRight = round(absolutePosition.x + viewPosition.left + viewSize.width) + round(106.667 + 0 + 106.667) = 213.5
width = 213.5 - 106.5 = 107
You'll notice that this is the same width we calculated for the parent view because we've taken its position into account.
I believe this is awesome. I also believe that we have to decouple this logic from RN and put it into awesome Yoga. So I did it in this diff.
**Fun fact:**
The original implementation of this algorithm in RN had (and still have) a bug, which was found by Dustin dshahidehpour and fixed in D4133643. Therefore that diff was unlanded because it broke something unrelated inside RN text engine. I will fix that problem in RN later.
**Why do we need to change test methodology?**
Because the way we receive layout metrics from Chrome browser actually directly related to rounding problem. Previously we used `offsetHeight` and `offsetWidth` properties of the DOM node, which contain naively rounded values from `computedStyle` or `getBoundingClientRect`. (Which is we are trying to fix!) So, I added the new function that computes node size using two-step-rounding approach, conceptually similar to one that implemented in Yoga. Note: Chrome browser performs rounding layout as part of rendering process and actual values that can ve computed by counting actual pixel are different from these natively rounded ones.
**Why do some tests now have different desired values?**
These changes actually prove that my approach is correct and more useful for actual view rendering goals. So, let's take a look at test with changed values `rounding_fractial_input_3`:
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Reviewed By: emilsjolander
Differential Revision: D4941266
fbshipit-source-id: 07500f5cc93c628219500e9e07291438e9d5d36c
2017-04-25 17:29:27 -07:00
|
|
|
Assert.AreEqual(65f, root_child0.LayoutHeight);
|
2016-11-23 11:12:51 -08:00
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(64f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
New round-to-pixel-grid algorithm that fixes possible subpixel gaps between sibling nodes
Summary:
This diff introduces new, little bit sophisticated round-to-pixel-grid algorithm.
**Motivation:**
Previous simple and straightforward solution works in most cases but sometimes produce the not-so-great result. A while ago Nick Lockwood described this problem and proposed the solution in RN's RCTShadowView class:
For example, say you have the following structure:
// +--------+---------+--------+
// | |+-------+| |
// | || || |
// | |+-------+| |
// +--------+---------+--------+
Say the screen width is 320 pts so the three big views will get the following x bounds from our layout system:
{0, 106.667}, {106.667, 213.333}, {213.333, 320}
Assuming screen scale is 2, these numbers must be rounded to the nearest 0.5 to fit the pixel grid:
{0, 106.5}, {106.5, 213.5}, {213.5, 320}
You'll notice that the three widths are 106.5, 107, 106.5.
This is great for the parent views but it gets trickier when we consider rounding for the subview. When we go to round the bounds for the subview in the middle, it's relative bounds are {0, 106.667} which gets rounded to {0, 106.5}. This will cause the subview to be one pixel smaller than it should be. This is why we need to pass in the absolute position in order to do the rounding relative to the screen's grid rather than the view's grid. After passing in the absolutePosition of {106.667, y}, we do the following calculations:
absoluteLeft = round(absolutePosition.x + viewPosition.left) = round(106.667 + 0) = 106.5
absoluteRight = round(absolutePosition.x + viewPosition.left + viewSize.width) + round(106.667 + 0 + 106.667) = 213.5
width = 213.5 - 106.5 = 107
You'll notice that this is the same width we calculated for the parent view because we've taken its position into account.
I believe this is awesome. I also believe that we have to decouple this logic from RN and put it into awesome Yoga. So I did it in this diff.
**Fun fact:**
The original implementation of this algorithm in RN had (and still have) a bug, which was found by Dustin dshahidehpour and fixed in D4133643. Therefore that diff was unlanded because it broke something unrelated inside RN text engine. I will fix that problem in RN later.
**Why do we need to change test methodology?**
Because the way we receive layout metrics from Chrome browser actually directly related to rounding problem. Previously we used `offsetHeight` and `offsetWidth` properties of the DOM node, which contain naively rounded values from `computedStyle` or `getBoundingClientRect`. (Which is we are trying to fix!) So, I added the new function that computes node size using two-step-rounding approach, conceptually similar to one that implemented in Yoga. Note: Chrome browser performs rounding layout as part of rendering process and actual values that can ve computed by counting actual pixel are different from these natively rounded ones.
**Why do some tests now have different desired values?**
These changes actually prove that my approach is correct and more useful for actual view rendering goals. So, let's take a look at test with changed values `rounding_fractial_input_3`:
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Reviewed By: emilsjolander
Differential Revision: D4941266
fbshipit-source-id: 07500f5cc93c628219500e9e07291438e9d5d36c
2017-04-25 17:29:27 -07:00
|
|
|
Assert.AreEqual(24f, root_child1.LayoutHeight);
|
2016-11-23 11:12:51 -08:00
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
New round-to-pixel-grid algorithm that fixes possible subpixel gaps between sibling nodes
Summary:
This diff introduces new, little bit sophisticated round-to-pixel-grid algorithm.
**Motivation:**
Previous simple and straightforward solution works in most cases but sometimes produce the not-so-great result. A while ago Nick Lockwood described this problem and proposed the solution in RN's RCTShadowView class:
For example, say you have the following structure:
// +--------+---------+--------+
// | |+-------+| |
// | || || |
// | |+-------+| |
// +--------+---------+--------+
Say the screen width is 320 pts so the three big views will get the following x bounds from our layout system:
{0, 106.667}, {106.667, 213.333}, {213.333, 320}
Assuming screen scale is 2, these numbers must be rounded to the nearest 0.5 to fit the pixel grid:
{0, 106.5}, {106.5, 213.5}, {213.5, 320}
You'll notice that the three widths are 106.5, 107, 106.5.
This is great for the parent views but it gets trickier when we consider rounding for the subview. When we go to round the bounds for the subview in the middle, it's relative bounds are {0, 106.667} which gets rounded to {0, 106.5}. This will cause the subview to be one pixel smaller than it should be. This is why we need to pass in the absolute position in order to do the rounding relative to the screen's grid rather than the view's grid. After passing in the absolutePosition of {106.667, y}, we do the following calculations:
absoluteLeft = round(absolutePosition.x + viewPosition.left) = round(106.667 + 0) = 106.5
absoluteRight = round(absolutePosition.x + viewPosition.left + viewSize.width) + round(106.667 + 0 + 106.667) = 213.5
width = 213.5 - 106.5 = 107
You'll notice that this is the same width we calculated for the parent view because we've taken its position into account.
I believe this is awesome. I also believe that we have to decouple this logic from RN and put it into awesome Yoga. So I did it in this diff.
**Fun fact:**
The original implementation of this algorithm in RN had (and still have) a bug, which was found by Dustin dshahidehpour and fixed in D4133643. Therefore that diff was unlanded because it broke something unrelated inside RN text engine. I will fix that problem in RN later.
**Why do we need to change test methodology?**
Because the way we receive layout metrics from Chrome browser actually directly related to rounding problem. Previously we used `offsetHeight` and `offsetWidth` properties of the DOM node, which contain naively rounded values from `computedStyle` or `getBoundingClientRect`. (Which is we are trying to fix!) So, I added the new function that computes node size using two-step-rounding approach, conceptually similar to one that implemented in Yoga. Note: Chrome browser performs rounding layout as part of rendering process and actual values that can ve computed by counting actual pixel are different from these natively rounded ones.
**Why do some tests now have different desired values?**
These changes actually prove that my approach is correct and more useful for actual view rendering goals. So, let's take a look at test with changed values `rounding_fractial_input_3`:
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Reviewed By: emilsjolander
Differential Revision: D4941266
fbshipit-source-id: 07500f5cc93c628219500e9e07291438e9d5d36c
2017-04-25 17:29:27 -07:00
|
|
|
Assert.AreEqual(25f, root_child2.LayoutHeight);
|
2016-11-23 11:12:51 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_fractial_input_4()
|
|
|
|
{
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaConfig config = new YogaConfig();
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root = new YogaNode(config);
|
2017-01-08 07:58:31 -08:00
|
|
|
root.Top = 0.7f;
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root.Width = 100;
|
2016-11-29 09:04:43 -08:00
|
|
|
root.Height = 113.4f;
|
2016-11-23 11:12:51 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child0.FlexGrow = 1;
|
|
|
|
root_child0.FlexBasis = 50;
|
|
|
|
root_child0.Height = 20;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child1.FlexGrow = 1;
|
|
|
|
root_child1.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
Add feature to use percentage as value unit
Summary:
Adds the feature to use percentage as a value unit.
You can use the function ```YGPx(float)``` and ```YGPercent(float)``` for convenience.
I did some benchmarks:
```
Without Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.146683 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.490101 ms
Huge nested layout: median: 23.000000 ms, stddev: 0.928291 ms
Stack with flex: median: 0.000000 ms, stddev: 0.170587 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.143384 ms
Nested flex: median: 0.000000 ms, stddev: 0.477791 ms
Huge nested layout: median: 22.000000 ms, stddev: 2.129779 ms
With Percentage Feature - Release x86:
Stack with flex: median: 0.000000 ms, stddev: 0.132951 ms
Align stretch in undefined axis: median: 0.000000 ms, stddev: 0.136525 ms
Nested flex: median: 0.000000 ms, stddev: 0.489570 ms
Huge nested layout: median: 21.000000 ms, stddev: 1.390476 ms
Closes https://github.com/facebook/yoga/pull/258
Reviewed By: dshahidehpour
Differential Revision: D4361945
Pulled By: emilsjolander
fbshipit-source-id: a8f5bc63ad352eb9410d792729e56664468cd76a
2017-01-02 05:20:37 -08:00
|
|
|
root_child2.FlexGrow = 1;
|
|
|
|
root_child2.Height = 10;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.Insert(2, root_child2);
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(1f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(64f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(64f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(25f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
|
2016-12-02 05:47:43 -08:00
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
2016-11-23 11:12:51 -08:00
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(1f, root.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(113f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(64f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(64f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(25f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(89f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(100f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(24f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
New round-to-pixel-grid algorithm that fixes possible subpixel gaps between sibling nodes
Summary:
This diff introduces new, little bit sophisticated round-to-pixel-grid algorithm.
**Motivation:**
Previous simple and straightforward solution works in most cases but sometimes produce the not-so-great result. A while ago Nick Lockwood described this problem and proposed the solution in RN's RCTShadowView class:
For example, say you have the following structure:
// +--------+---------+--------+
// | |+-------+| |
// | || || |
// | |+-------+| |
// +--------+---------+--------+
Say the screen width is 320 pts so the three big views will get the following x bounds from our layout system:
{0, 106.667}, {106.667, 213.333}, {213.333, 320}
Assuming screen scale is 2, these numbers must be rounded to the nearest 0.5 to fit the pixel grid:
{0, 106.5}, {106.5, 213.5}, {213.5, 320}
You'll notice that the three widths are 106.5, 107, 106.5.
This is great for the parent views but it gets trickier when we consider rounding for the subview. When we go to round the bounds for the subview in the middle, it's relative bounds are {0, 106.667} which gets rounded to {0, 106.5}. This will cause the subview to be one pixel smaller than it should be. This is why we need to pass in the absolute position in order to do the rounding relative to the screen's grid rather than the view's grid. After passing in the absolutePosition of {106.667, y}, we do the following calculations:
absoluteLeft = round(absolutePosition.x + viewPosition.left) = round(106.667 + 0) = 106.5
absoluteRight = round(absolutePosition.x + viewPosition.left + viewSize.width) + round(106.667 + 0 + 106.667) = 213.5
width = 213.5 - 106.5 = 107
You'll notice that this is the same width we calculated for the parent view because we've taken its position into account.
I believe this is awesome. I also believe that we have to decouple this logic from RN and put it into awesome Yoga. So I did it in this diff.
**Fun fact:**
The original implementation of this algorithm in RN had (and still have) a bug, which was found by Dustin dshahidehpour and fixed in D4133643. Therefore that diff was unlanded because it broke something unrelated inside RN text engine. I will fix that problem in RN later.
**Why do we need to change test methodology?**
Because the way we receive layout metrics from Chrome browser actually directly related to rounding problem. Previously we used `offsetHeight` and `offsetWidth` properties of the DOM node, which contain naively rounded values from `computedStyle` or `getBoundingClientRect`. (Which is we are trying to fix!) So, I added the new function that computes node size using two-step-rounding approach, conceptually similar to one that implemented in Yoga. Note: Chrome browser performs rounding layout as part of rendering process and actual values that can ve computed by counting actual pixel are different from these natively rounded ones.
**Why do some tests now have different desired values?**
These changes actually prove that my approach is correct and more useful for actual view rendering goals. So, let's take a look at test with changed values `rounding_fractial_input_3`:
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Previously: 64+25+24=114 (Incorrect!)
Now: 65+24+25=114 (Correct!)
Reviewed By: emilsjolander
Differential Revision: D4941266
fbshipit-source-id: 07500f5cc93c628219500e9e07291438e9d5d36c
2017-04-25 17:29:27 -07:00
|
|
|
[Test]
|
|
|
|
public void Test_rounding_inner_node_controversy_horizontal()
|
|
|
|
{
|
|
|
|
YogaConfig config = new YogaConfig();
|
|
|
|
|
|
|
|
YogaNode root = new YogaNode(config);
|
|
|
|
root.FlexDirection = YogaFlexDirection.Row;
|
|
|
|
root.Width = 320;
|
|
|
|
|
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
|
|
|
root_child0.FlexGrow = 1;
|
|
|
|
root_child0.Height = 10;
|
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
|
|
|
root_child1.FlexGrow = 1;
|
|
|
|
root_child1.Height = 10;
|
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
|
|
|
YogaNode root_child1_child0 = new YogaNode(config);
|
|
|
|
root_child1_child0.FlexGrow = 1;
|
|
|
|
root_child1_child0.Height = 10;
|
|
|
|
root_child1.Insert(0, root_child1_child0);
|
|
|
|
|
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
|
|
|
root_child2.FlexGrow = 1;
|
|
|
|
root_child2.Height = 10;
|
|
|
|
root.Insert(2, root_child2);
|
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(320f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(107f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(107f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(106f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutY);
|
|
|
|
Assert.AreEqual(106f, root_child1_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root_child1_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(213f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(107f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root_child2.LayoutHeight);
|
|
|
|
|
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(320f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(213f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(107f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(107f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(106f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutY);
|
|
|
|
Assert.AreEqual(106f, root_child1_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root_child1_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(107f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(10f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_inner_node_controversy_vertical()
|
|
|
|
{
|
|
|
|
YogaConfig config = new YogaConfig();
|
|
|
|
|
|
|
|
YogaNode root = new YogaNode(config);
|
|
|
|
root.Height = 320;
|
|
|
|
|
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
|
|
|
root_child0.FlexGrow = 1;
|
|
|
|
root_child0.Width = 10;
|
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
|
|
|
root_child1.FlexGrow = 1;
|
|
|
|
root_child1.Width = 10;
|
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
|
|
|
YogaNode root_child1_child0 = new YogaNode(config);
|
|
|
|
root_child1_child0.FlexGrow = 1;
|
|
|
|
root_child1_child0.Width = 10;
|
|
|
|
root_child1.Insert(0, root_child1_child0);
|
|
|
|
|
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
|
|
|
root_child2.FlexGrow = 1;
|
|
|
|
root_child2.Width = 10;
|
|
|
|
root.Insert(2, root_child2);
|
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(107f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(107f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(106f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root_child1_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(106f, root_child1_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(213f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(107f, root_child2.LayoutHeight);
|
|
|
|
|
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(107f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(107f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(106f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root_child1_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(106f, root_child1_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(213f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(10f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(107f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Test]
|
|
|
|
public void Test_rounding_inner_node_controversy_combined()
|
|
|
|
{
|
|
|
|
YogaConfig config = new YogaConfig();
|
|
|
|
|
|
|
|
YogaNode root = new YogaNode(config);
|
|
|
|
root.FlexDirection = YogaFlexDirection.Row;
|
|
|
|
root.Width = 640;
|
|
|
|
root.Height = 320;
|
|
|
|
|
|
|
|
YogaNode root_child0 = new YogaNode(config);
|
|
|
|
root_child0.FlexGrow = 1;
|
|
|
|
root_child0.Height = 100.Percent();
|
|
|
|
root.Insert(0, root_child0);
|
|
|
|
|
|
|
|
YogaNode root_child1 = new YogaNode(config);
|
|
|
|
root_child1.FlexGrow = 1;
|
|
|
|
root_child1.Height = 100.Percent();
|
|
|
|
root.Insert(1, root_child1);
|
|
|
|
|
|
|
|
YogaNode root_child1_child0 = new YogaNode(config);
|
|
|
|
root_child1_child0.FlexGrow = 1;
|
|
|
|
root_child1_child0.Width = 100.Percent();
|
|
|
|
root_child1.Insert(0, root_child1_child0);
|
|
|
|
|
|
|
|
YogaNode root_child1_child1 = new YogaNode(config);
|
|
|
|
root_child1_child1.FlexGrow = 1;
|
|
|
|
root_child1_child1.Width = 100.Percent();
|
|
|
|
root_child1.Insert(1, root_child1_child1);
|
|
|
|
|
|
|
|
YogaNode root_child1_child1_child0 = new YogaNode(config);
|
|
|
|
root_child1_child1_child0.FlexGrow = 1;
|
|
|
|
root_child1_child1_child0.Width = 100.Percent();
|
|
|
|
root_child1_child1.Insert(0, root_child1_child1_child0);
|
|
|
|
|
|
|
|
YogaNode root_child1_child2 = new YogaNode(config);
|
|
|
|
root_child1_child2.FlexGrow = 1;
|
|
|
|
root_child1_child2.Width = 100.Percent();
|
|
|
|
root_child1.Insert(2, root_child1_child2);
|
|
|
|
|
|
|
|
YogaNode root_child2 = new YogaNode(config);
|
|
|
|
root_child2.FlexGrow = 1;
|
|
|
|
root_child2.Height = 100.Percent();
|
|
|
|
root.Insert(2, root_child2);
|
|
|
|
root.StyleDirection = YogaDirection.LTR;
|
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(640f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(213f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(213f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(107f, root_child1_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child1.LayoutX);
|
|
|
|
Assert.AreEqual(107f, root_child1_child1.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(106f, root_child1_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child1_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1_child1_child0.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1_child1_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(106f, root_child1_child1_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child2.LayoutX);
|
|
|
|
Assert.AreEqual(213f, root_child1_child2.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(107f, root_child1_child2.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(427f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(213f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root_child2.LayoutHeight);
|
|
|
|
|
|
|
|
root.StyleDirection = YogaDirection.RTL;
|
|
|
|
root.CalculateLayout();
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root.LayoutY);
|
|
|
|
Assert.AreEqual(640f, root.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(427f, root_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child0.LayoutY);
|
|
|
|
Assert.AreEqual(213f, root_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(213f, root_child1.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1_child0.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(107f, root_child1_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child1.LayoutX);
|
|
|
|
Assert.AreEqual(107f, root_child1_child1.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1_child1.LayoutWidth);
|
|
|
|
Assert.AreEqual(106f, root_child1_child1.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child1_child0.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child1_child1_child0.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1_child1_child0.LayoutWidth);
|
|
|
|
Assert.AreEqual(106f, root_child1_child1_child0.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child1_child2.LayoutX);
|
|
|
|
Assert.AreEqual(213f, root_child1_child2.LayoutY);
|
|
|
|
Assert.AreEqual(214f, root_child1_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(107f, root_child1_child2.LayoutHeight);
|
|
|
|
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutX);
|
|
|
|
Assert.AreEqual(0f, root_child2.LayoutY);
|
|
|
|
Assert.AreEqual(213f, root_child2.LayoutWidth);
|
|
|
|
Assert.AreEqual(320f, root_child2.LayoutHeight);
|
|
|
|
}
|
|
|
|
|
2016-11-23 11:12:51 -08:00
|
|
|
}
|
|
|
|
}
|