github/flutter
7
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2025-06-03 00:51:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make the limit that defines Row/Column free space configurable (#4646)

Browse Source
This commit is contained in:
Hans Muller 2016-06-21 14:29:22 -07:00 committed by GitHub
parent fad7cf59e3
commit 0e38cba95f
17 changed files with 892 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dev/benchmarks/complex_layout/lib/main.dart
View File

@ -261,7 +261,7 @@ class IconWithText extends StatelessWidget {
@override
Widget build(BuildContext context) {
return new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new IconButton(
icon: new Icon(icon),
@ -282,7 +282,7 @@ class MiniIconWithText extends StatelessWidget {
@override
Widget build(BuildContext context) {
return new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Padding(
padding: new EdgeInsets.only(right: 8.0),

6
examples/flutter_gallery/lib/demo/buttons_demo.dart
View File

@ -97,7 +97,7 @@ class _ButtonsDemoState extends State<ButtonsDemo> {
return new Align(
alignment: new FractionalOffset(0.5, 0.4),
child: new ButtonBar(
alignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new RaisedButton(
child: new Text('RAISED BUTTON'),
@ -118,7 +118,7 @@ class _ButtonsDemoState extends State<ButtonsDemo> {
return new Align(
alignment: new FractionalOffset(0.5, 0.4),
child: new ButtonBar(
alignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new FlatButton(
child: new Text('FLAT BUTTON'),
@ -165,7 +165,7 @@ class _ButtonsDemoState extends State<ButtonsDemo> {
return new Align(
alignment: new FractionalOffset(0.5, 0.4),
child: new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new IconButton(
icon: new Icon(Icons.thumb_up),

14
examples/flutter_gallery/lib/demo/selection_controls_demo.dart
View File

@ -80,10 +80,10 @@ class _SelectionControlsDemoState extends State<SelectionControlsDemo> {
return new Align(
alignment: new FractionalOffset(0.5, 0.4),
child: new Column(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Checkbox(value: checkboxValueA, onChanged: (bool value) {
setState(() {
@ -98,7 +98,7 @@ class _SelectionControlsDemoState extends State<SelectionControlsDemo> {
]
),
new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
// Disabled checkboxes
new Checkbox(value: true, onChanged: null),
@ -114,10 +114,10 @@ class _SelectionControlsDemoState extends State<SelectionControlsDemo> {
return new Align(
alignment: new FractionalOffset(0.5, 0.4),
child: new Column(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Radio<int>(
value: 0,
@ -138,7 +138,7 @@ class _SelectionControlsDemoState extends State<SelectionControlsDemo> {
),
// Disabled radio buttons
new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Radio<int>(
value: 0,
@ -166,7 +166,7 @@ class _SelectionControlsDemoState extends State<SelectionControlsDemo> {
return new Align(
alignment: new FractionalOffset(0.5, 0.4),
child: new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Switch(value: switchValue, onChanged: (bool value) {
setState(() {

2
examples/stocks/lib/stock_symbol_viewer.dart
View File

@ -61,7 +61,7 @@ class StockSymbolView extends StatelessWidget {
)
),
],
mainAxisAlignment: MainAxisAlignment.collapse
mainAxisSize: MainAxisSize.min
)
);
}

5
packages/flutter/lib/src/material/button_bar.dart
View File

@ -29,12 +29,16 @@ class ButtonBar extends StatelessWidget {
ButtonBar({
Key key,
this.alignment: MainAxisAlignment.end,
this.mainAxisSize: MainAxisSize.max,
this.children
}) : super(key: key);
/// How the children should be placed along the horizontal axis.
final MainAxisAlignment alignment;
/// How much horizontal space is available. See [Row.mainAxisSize].
final MainAxisSize mainAxisSize;
/// The buttons to arrange horizontally.
///
/// Typically [RaisedButton] or [FlatButton] widgets.
@ -51,6 +55,7 @@ class ButtonBar extends StatelessWidget {
),
child: new Row(
mainAxisAlignment: alignment,
mainAxisSize: mainAxisSize,
children: children.map/*<Widget>*/((Widget child) {
return new Padding(
padding: new EdgeInsets.symmetric(horizontal: paddingUnit),

2
packages/flutter/lib/src/material/chip.dart
View File

@ -116,7 +116,7 @@ class Chip extends StatelessWidget {
),
child: new Row(
children: children,
mainAxisAlignment: MainAxisAlignment.collapse
mainAxisSize: MainAxisSize.min
)
)
);

3
packages/flutter/lib/src/material/drop_down.dart
View File

@ -485,7 +485,8 @@ class _DropDownButtonState<T> extends State<DropDownButton<T>> {
Widget result = new DefaultTextStyle(
style: style,
child: new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: <Widget>[
// We use an IndexedStack to make sure we have enough width to show any
// possible item as the selected item without changing size.

2
packages/flutter/lib/src/material/list_item.dart
View File

@ -169,7 +169,7 @@ class ListItem extends StatelessWidget {
Widget center = primaryLine;
if (subtitle != null && (isTwoLine || isThreeLine)) {
center = new Column(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
primaryLine,

2
packages/flutter/lib/src/material/tabs.dart
View File

@ -1207,7 +1207,7 @@ class TabPageSelector<T> extends StatelessWidget {
label: 'Page ${selection.index + 1} of ${selection.values.length}',
child: new Row(
children: selection.values.map((T tab) => _buildTabIndicator(selection, tab, animation, selectedColor, previousColor)).toList(),
mainAxisAlignment: MainAxisAlignment.collapse
mainAxisSize: MainAxisSize.min
)
);
}

2
packages/flutter/lib/src/material/text_selection.dart
View File

@ -44,7 +44,7 @@ class _TextSelectionToolbar extends StatelessWidget {
elevation: 1,
child: new Container(
height: 44.0,
child: new Row(mainAxisAlignment: MainAxisAlignment.collapse, children: items)
child: new Row(mainAxisSize: MainAxisSize.min, children: items)
)
);
}

4
packages/flutter/lib/src/material/time_picker.dart
View File

@ -279,10 +279,10 @@ class _TimePickerHeader extends StatelessWidget {
onTap: _handleChangeDayPeriod,
behavior: HitTestBehavior.opaque,
child: new Column(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Text('AM', style: amStyle),
new Container(width: 0.0, height: 8.0), // Vertical spsacer
new Container(width: 0.0, height: 8.0), // Vertical spacer
new Text('PM', style: pmStyle),
]
)

71
packages/flutter/lib/src/rendering/flex.dart
View File

@ -29,6 +29,19 @@ enum FlexDirection {
vertical
}
/// The incoming constraint parameter that defines how much space is available
/// along the main axis in a flex layout. Flex layouts allocate the difference
/// between the available space and the sum of the sizes of the children
/// which are not flexible to the layout's flexible children and the space
/// around the children. See [Row], [Column], [MainAxisAlignment], [Flexible].
enum MainAxisSize {
/// The available space is defined by the incoming constraint's min parameter.
min,
/// The available space is defined by the incoming constraint's max parameter.
max,
}
/// How the children should be placed along the main axis in a flex layout.
enum MainAxisAlignment {
/// Place the children as close to the start of the main axis as possible.
@ -47,10 +60,7 @@ enum MainAxisAlignment {
spaceAround,
/// Place the free space evenly between the children as well as before and after the first and last child.
spaceEvenly,
/// Do not expand to fill the free space. None of the children may specify a flex factor.
collapse,
spaceEvenly
}
/// How the children should be placed along the cross axis in a flex layout.
@ -97,11 +107,13 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, Fl
RenderFlex({
List<RenderBox> children,
FlexDirection direction: FlexDirection.horizontal,
MainAxisSize mainAxisSize: MainAxisSize.max,
MainAxisAlignment mainAxisAlignment: MainAxisAlignment.start,
CrossAxisAlignment crossAxisAlignment: CrossAxisAlignment.center,
TextBaseline textBaseline
}) : _direction = direction,
_mainAxisAlignment = mainAxisAlignment,
_mainAxisSize = mainAxisSize,
_crossAxisAlignment = crossAxisAlignment,
_textBaseline = textBaseline {
addAll(children);
@ -121,12 +133,23 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, Fl
MainAxisAlignment get mainAxisAlignment => _mainAxisAlignment;
MainAxisAlignment _mainAxisAlignment;
set mainAxisAlignment (MainAxisAlignment value) {
assert(value != null);
if (_mainAxisAlignment != value) {
_mainAxisAlignment = value;
markNeedsLayout();
}
}
/// The limit used to compute free space along the main axis.
MainAxisSize get mainAxisSize => _mainAxisSize;
MainAxisSize _mainAxisSize;
set mainAxisSize (MainAxisSize value) {
if (_mainAxisSize != value) {
_mainAxisSize = value;
markNeedsLayout();
}
}
/// How the children should be placed along the cross axis.
CrossAxisAlignment get crossAxisAlignment => _crossAxisAlignment;
CrossAxisAlignment _crossAxisAlignment;
@ -299,10 +322,14 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, Fl
int totalFlex = 0;
int totalChildren = 0;
assert(constraints != null);
final double mainSize = (_direction == FlexDirection.horizontal) ? constraints.constrainWidth() : constraints.constrainHeight();
final bool canFlex = mainSize < double.INFINITY && mainAxisAlignment != MainAxisAlignment.collapse;
double crossSize = 0.0; // This is determined as we lay out the children
double freeSpace = canFlex ? mainSize : 0.0;
final bool isHorizontal = _direction == FlexDirection.horizontal;
final double minMainSize = isHorizontal ? constraints.minWidth : constraints.minHeight;
final double maxMainSize = isHorizontal ? constraints.maxWidth : constraints.maxHeight;
final double availableSize = mainAxisSize == MainAxisSize.max ? maxMainSize : minMainSize;
final bool canFlex = availableSize < double.INFINITY;
double crossSize = 0.0;
double allocatedSize = 0.0; // Sum of the sizes of the the non-flexible children.
RenderBox child = firstChild;
while (child != null) {
final FlexParentData childParentData = child.parentData;
@ -315,12 +342,7 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, Fl
final String dimension = _direction == FlexDirection.horizontal ? 'width' : 'height';
String error, message;
String addendum = '';
if (mainAxisAlignment == MainAxisAlignment.collapse) {
error = 'RenderFlex children have non-zero flex but mainAxisAlignment is set to "collapse".';
message = 'The MainAxisAlignment.collapse value indicates that the $identity is to shrink-wrap its children '
'along the $axis axis. Setting a flex on a child (e.g. using a Flexible) indicates that the '
'child is to expand to fill the remaining space in the $axis direction.';
} else if (mainSize == double.INFINITY) {
if (availableSize == double.INFINITY) {
error = 'RenderFlex children have non-zero flex but incoming $dimension constraints are unbounded.';
message = 'When a $identity is in a parent that does not provide a finite $dimension constraint, for example '
'if it is in a $axis scrollable, it will try to shrink-wrap its children along the $axis '
@ -397,16 +419,16 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, Fl
}
}
child.layout(innerConstraints, parentUsesSize: true);
freeSpace -= _getMainSize(child);
allocatedSize += _getMainSize(child);
crossSize = math.max(crossSize, _getCrossSize(child));
}
assert(child.parentData == childParentData);
child = childParentData.nextSibling;
}
_overflow = math.max(0.0, -freeSpace);
freeSpace = math.max(0.0, freeSpace);
_overflow = math.max(0.0, allocatedSize - (canFlex ? maxMainSize : 0.0));
// Distribute remaining space to flexible children, and determine baseline.
// Distribute free space to flexible children, and determine baseline.
double freeSpace = math.max(0.0, (canFlex ? availableSize : 0.0) - allocatedSize);
double maxBaselineDistance = 0.0;
double usedSpace = 0.0;
if (totalFlex > 0 || crossAxisAlignment == CrossAxisAlignment.baseline) {
@ -470,20 +492,23 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, Fl
double betweenSpace;
double remainingSpace;
if (canFlex) {
final bool isMainAxisSizeMax = mainAxisSize == MainAxisSize.max;
final double preferredSize = isMainAxisSizeMax ? maxMainSize : allocatedSize;
remainingSpace = math.max(0.0, freeSpace - usedSpace);
switch (_direction) {
case FlexDirection.horizontal:
size = constraints.constrain(new Size(mainSize, crossSize));
size = constraints.constrain(new Size(preferredSize, crossSize));
crossSize = size.height;
assert(size.width == mainSize);
assert(isMainAxisSizeMax ? size.width == maxMainSize : size.width >= minMainSize);
break;
case FlexDirection.vertical:
size = constraints.constrain(new Size(crossSize, mainSize));
size = constraints.constrain(new Size(crossSize, preferredSize));
crossSize = size.width;
assert(size.height == mainSize);
assert(isMainAxisSizeMax ? size.height == maxMainSize : size.height >= minMainSize);
break;
}
} else {
assert(mainAxisSize == MainAxisSize.max);
leadingSpace = 0.0;
betweenSpace = 0.0;
switch (_direction) {
@ -502,7 +527,6 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, Fl
}
switch (_mainAxisAlignment) {
case MainAxisAlignment.start:
case MainAxisAlignment.collapse:
leadingSpace = 0.0;
betweenSpace = 0.0;
break;
@ -632,6 +656,7 @@ class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, Fl
super.debugFillDescription(description);
description.add('direction: $_direction');
description.add('mainAxisAlignment: $_mainAxisAlignment');
description.add('mainAxisSize: $_mainAxisSize');
description.add('crossAxisAlignment: $_crossAxisAlignment');
description.add('textBaseline: $_textBaseline');
}

41
packages/flutter/lib/src/widgets/basic.dart
View File

@ -29,6 +29,7 @@ export 'package:flutter/rendering.dart' show
GridSpecification,
HitTestBehavior,
MainAxisAlignment,
MainAxisSize,
MaxTileWidthGridDelegate,
MultiChildLayoutDelegate,
PaintingContext,
@ -1778,12 +1779,14 @@ class Flex extends MultiChildRenderObjectWidget {
Key key,
this.direction: FlexDirection.horizontal,
this.mainAxisAlignment: MainAxisAlignment.start,
this.mainAxisSize: MainAxisSize.max,
this.crossAxisAlignment: CrossAxisAlignment.center,
this.textBaseline,
List<Widget> children: _emptyWidgetList
}) : super(key: key, children: children) {
assert(direction != null);
assert(mainAxisAlignment != null);
assert(mainAxisSize != null);
assert(crossAxisAlignment != null);
assert(crossAxisAlignment != CrossAxisAlignment.baseline || textBaseline != null);
}
@ -1794,6 +1797,17 @@ class Flex extends MultiChildRenderObjectWidget {
/// How the children should be placed along the main axis.
final MainAxisAlignment mainAxisAlignment;
/// The limit that defines how much space is available along the main axis.
///
/// By default the size of this widget will be as big as the incoming
/// max constraint. In other words it will become as big as possible
/// along its main axis by growing [Flexible] children and inserting
/// space between children per the [mainAxisAlignment] parameter.
/// If mainAxisSize is [MainAxisSize.min] then this widget's size along
/// the main axis will be as small as possible. This version of the layout
/// is sometimes referred to as "shrink wrapping".
final MainAxisSize mainAxisSize;
/// How the children should be placed along the cross axis.
final CrossAxisAlignment crossAxisAlignment;
@ -1801,13 +1815,22 @@ class Flex extends MultiChildRenderObjectWidget {
final TextBaseline textBaseline;
@override
RenderFlex createRenderObject(BuildContext context) => new RenderFlex(direction: direction, mainAxisAlignment: mainAxisAlignment, crossAxisAlignment: crossAxisAlignment, textBaseline: textBaseline);
RenderFlex createRenderObject(BuildContext context) {
return new RenderFlex(
direction: direction,
mainAxisAlignment: mainAxisAlignment,
mainAxisSize: mainAxisSize,
crossAxisAlignment: crossAxisAlignment,
textBaseline: textBaseline
);
}
@override
void updateRenderObject(BuildContext context, RenderFlex renderObject) {
renderObject
..direction = direction
..mainAxisAlignment = mainAxisAlignment
..mainAxisSize = mainAxisSize
..crossAxisAlignment = crossAxisAlignment
..textBaseline = textBaseline;
}
@ -1820,12 +1843,13 @@ class Flex extends MultiChildRenderObjectWidget {
class Row extends Flex {
/// Creates a horizontal array of children.
///
/// The [direction], [mainAxisAlignment], and [crossAxisAlignment] arguments
/// must not be null. If [crossAxisAlignment] is
/// [CrossAxisAlignment.baseline], then [textBaseline] must not be null.
/// The [direction], [mainAxisAlignment], [mainAxisSize], and
/// [crossAxisAlignment] arguments must not be null. If [crossAxisAlignment]
/// is [CrossAxisAlignment.baseline], then [textBaseline] must not be null.
Row({
Key key,
MainAxisAlignment mainAxisAlignment: MainAxisAlignment.start,
MainAxisSize mainAxisSize: MainAxisSize.max,
CrossAxisAlignment crossAxisAlignment: CrossAxisAlignment.center,
TextBaseline textBaseline,
List<Widget> children: _emptyWidgetList
@ -1834,6 +1858,7 @@ class Row extends Flex {
key: key,
direction: FlexDirection.horizontal,
mainAxisAlignment: mainAxisAlignment,
mainAxisSize: mainAxisSize,
crossAxisAlignment: crossAxisAlignment,
textBaseline: textBaseline
);
@ -1846,12 +1871,13 @@ class Row extends Flex {
class Column extends Flex {
/// Creates a vertical array of children.
///
/// The [direction], [mainAxisAlignment], and [crossAxisAlignment] arguments
/// must not be null. If [crossAxisAlignment] is
/// [CrossAxisAlignment.baseline], then [textBaseline] must not be null.
/// The [direction], [mainAxisAlignment], [mainAxisSize], and
/// [crossAxisAlignment] arguments must not be null. If [crossAxisAlignment]
/// is [CrossAxisAlignment.baseline], then [textBaseline] must not be null.
Column({
Key key,
MainAxisAlignment mainAxisAlignment: MainAxisAlignment.start,
MainAxisSize mainAxisSize: MainAxisSize.max,
CrossAxisAlignment crossAxisAlignment: CrossAxisAlignment.center,
TextBaseline textBaseline,
List<Widget> children: _emptyWidgetList
@ -1860,6 +1886,7 @@ class Column extends Flex {
key: key,
direction: FlexDirection.vertical,
mainAxisAlignment: mainAxisAlignment,
mainAxisSize: mainAxisSize,
crossAxisAlignment: crossAxisAlignment,
textBaseline: textBaseline
);

389
packages/flutter/test/widget/column_test.dart Normal file
View File

@ -0,0 +1,389 @@
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:flutter_test/flutter_test.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/widgets.dart';
void main() {
testWidgets('Column with one flexible child', (WidgetTester tester) async {
final Key columnKey = new Key('column');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Column should be as high as the test: 600.
// Default is MainAxisAlignment.start so children so the children's
// top edges should be at 0, 100, 500, child2's height should be 400.
await tester.pumpWidget(new Center(
child: new Column(
key: columnKey,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Flexible(child: new Container(key: child1Key, width: 100.0, height: 100.0)),
new Container(key: child2Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(columnKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(600.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(0.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(400.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(100.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(500.0));
});
testWidgets('Column with default main axis parameters', (WidgetTester tester) async {
final Key columnKey = new Key('column');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Column should be as high as the test: 600.
// Default is MainAxisAlignment.start so children so the children's
// top edges should be at 0, 100, 200
await tester.pumpWidget(new Center(
child: new Column(
key: columnKey,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
new Container(key: child2Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(columnKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(600.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(0.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(100.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(200.0));
});
testWidgets('Column with MainAxisAlignment.center', (WidgetTester tester) async {
final Key columnKey = new Key('column');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
// Default is MainAxisSize.max so the Column should be as high as the test: 600.
// The 100x100 children's top edges should be at 200, 300
await tester.pumpWidget(new Center(
child: new Column(
key: columnKey,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(columnKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(600.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(200.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(300.0));
});
testWidgets('Column with MainAxisAlignment.end', (WidgetTester tester) async {
final Key columnKey = new Key('column');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Column should be as high as the test: 600.
// The 100x100 children's top edges should be at 300, 400, 500.
await tester.pumpWidget(new Center(
child: new Column(
key: columnKey,
mainAxisAlignment: MainAxisAlignment.end,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
new Container(key: child2Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(columnKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(600.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(300.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(400.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(500.0));
});
testWidgets('Column with MainAxisAlignment.spaceBetween', (WidgetTester tester) async {
final Key columnKey = new Key('column');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Column should be as high as the test: 600.
// The 100x100 children's top edges should be at 0, 250, 500
await tester.pumpWidget(new Center(
child: new Column(
key: columnKey,
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
new Container(key: child2Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(columnKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(600.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(0.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(250.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(500.0));
});
testWidgets('Column with MainAxisAlignment.spaceAround', (WidgetTester tester) async {
final Key columnKey = new Key('column');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
final Key child3Key = new Key('child3');
// Default is MainAxisSize.max so the Column should be as high as the test: 600.
// The 100x100 children's top edges should be at 25, 175, 325, 475
await tester.pumpWidget(new Center(
child: new Column(
key: columnKey,
mainAxisAlignment: MainAxisAlignment.spaceAround,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
new Container(key: child2Key, width: 100.0, height: 100.0),
new Container(key: child3Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(columnKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(600.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(25.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(175.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(325.0));
renderBox = tester.renderObject(find.byKey(child3Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(475.0));
});
testWidgets('Column with MainAxisAlignment.spaceEvenly', (WidgetTester tester) async {
final Key columnKey = new Key('column');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Column should be as high as the test: 600.
// The 100x20 children's top edges should be at 135, 290, 445
await tester.pumpWidget(new Center(
child: new Column(
key: columnKey,
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 20.0),
new Container(key: child1Key, width: 100.0, height: 20.0),
new Container(key: child2Key, width: 100.0, height: 20.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(columnKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(600.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(20.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(135.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(20.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(290.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(20.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dy, equals(445.0));
});
testWidgets('Column and MainAxisSize.min', (WidgetTester tester) async {
final Key flexKey = new Key('flexKey');
// Default is MainAxisSize.max so the Column should be as high as the test: 600.
await tester.pumpWidget(new Center(
child: new Column(
key: flexKey,
children: <Widget>[
new Container(width: 100.0, height: 100.0),
new Container(width: 100.0, height: 150.0)
]
)
));
RenderBox renderBox = tester.renderObject(find.byKey(flexKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(600.0));
// Column with MainAxisSize.min without flexible children shrink wraps.
await tester.pumpWidget(new Center(
child: new Column(
key: flexKey,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Container(width: 100.0, height: 100.0),
new Container(width: 100.0, height: 150.0)
]
)
));
renderBox = tester.renderObject(find.byKey(flexKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(250.0));
});
testWidgets('Column MainAxisSize.min layout at zero size', (WidgetTester tester) async {
final Key childKey = new Key('childKey');
await tester.pumpWidget(new Center(
child: new Container(
width: 0.0,
height: 0.0,
child: new Column(
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Container(
key: childKey,
width: 100.0,
height: 100.0
)
]
)
)
));
RenderBox renderBox = tester.renderObject(find.byKey(childKey));
expect(renderBox.size.width, equals(0.0));
expect(renderBox.size.height, equals(100.0));
});
}

112
packages/flutter/test/widget/flex_test.dart
View File

@ -47,116 +47,4 @@ void main() {
await tester.tap(find.text('X'));
expect(didReceiveTap, isTrue);
});
testWidgets('Row and FlexJustifyContent.collapse', (WidgetTester tester) async {
final Key flexKey = new Key('flexKey');
// Row without mainAxisAlignment: FlexJustifyContent.collapse
await tester.pumpWidget(new Center(
child: new Row(
children: <Widget>[
new Container(width: 10.0, height: 100.0),
new Container(width: 30.0, height: 100.0)
],
key: flexKey
)
));
RenderBox renderBox = tester.renderObject(find.byKey(flexKey));
expect(renderBox.size.width, equals(800.0));
expect(renderBox.size.height, equals(100.0));
// Row with mainAxisAlignment: FlexJustifyContent.collapse
await tester.pumpWidget(new Center(
child: new Row(
children: <Widget>[
new Container(width: 10.0, height: 100.0),
new Container(width: 30.0, height: 100.0)
],
key: flexKey,
mainAxisAlignment: MainAxisAlignment.collapse
)
));
renderBox = tester.renderObject(find.byKey(flexKey));
expect(renderBox.size.width, equals(40.0));
expect(renderBox.size.height, equals(100.0));
});
testWidgets('Column and FlexJustifyContent.collapse', (WidgetTester tester) async {
final Key flexKey = new Key('flexKey');
// Column without mainAxisAlignment: FlexJustifyContent.collapse
await tester.pumpWidget(new Center(
child: new Column(
children: <Widget>[
new Container(width: 100.0, height: 100.0),
new Container(width: 100.0, height: 150.0)
],
key: flexKey
)
));
RenderBox renderBox = tester.renderObject(find.byKey(flexKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(600.0));
// Column with mainAxisAlignment: FlexJustifyContent.collapse
await tester.pumpWidget(new Center(
child: new Column(
children: <Widget>[
new Container(width: 100.0, height: 100.0),
new Container(width: 100.0, height: 150.0)
],
key: flexKey,
mainAxisAlignment: MainAxisAlignment.collapse
)
));
renderBox = tester.renderObject(find.byKey(flexKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(250.0));
});
testWidgets('Can layout at zero size', (WidgetTester tester) async {
final Key childKey = new Key('childKey');
await tester.pumpWidget(new Center(
child: new Container(
width: 0.0,
height: 0.0,
child: new Column(
children: <Widget>[
new Container(
key: childKey,
width: 100.0,
height: 100.0
)
],
mainAxisAlignment: MainAxisAlignment.collapse
)
)
));
RenderBox renderBox = tester.renderObject(find.byKey(childKey));
expect(renderBox.size.width, equals(0.0));
expect(renderBox.size.height, equals(100.0));
await tester.pumpWidget(new Center(
child: new Container(
width: 0.0,
height: 0.0,
child: new Row(
children: <Widget>[
new Container(
key: childKey,
width: 100.0,
height: 100.0
)
],
mainAxisAlignment: MainAxisAlignment.collapse
)
)
));
renderBox = tester.renderObject(find.byKey(childKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(0.0));
});
}

2
packages/flutter/test/widget/rotated_box_test.dart
View File

@ -16,7 +16,7 @@ void main() {
key: rotatedBoxKey,
quarterTurns: 1,
child: new Row(
mainAxisAlignment: MainAxisAlignment.collapse,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new GestureDetector(
onTap: () { log.add('left'); },

394
packages/flutter/test/widget/row_test.dart Normal file
View File

@ -0,0 +1,394 @@
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:flutter_test/flutter_test.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/widgets.dart';
void main() {
testWidgets('Row with one Flexible child', (WidgetTester tester) async {
final Key rowKey = new Key('row');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Row should be as wide as the test: 800.
// Default is MainAxisAlignment.start so children so the children's
// left edges should be at 0, 100, 700, child2's width should be 600
await tester.pumpWidget(new Center(
child: new Row(
key: rowKey,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Flexible(child: new Container(key: child1Key, width: 100.0, height: 100.0)),
new Container(key: child2Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(rowKey));
expect(renderBox.size.width, equals(800.0));
expect(renderBox.size.height, equals(100.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(0.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(600.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(100.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(700.0));
});
testWidgets('Row with default main axis parameters', (WidgetTester tester) async {
final Key rowKey = new Key('row');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Row should be as wide as the test: 800.
// Default is MainAxisAlignment.start so children so the children's
// left edges should be at 0, 100, 200
await tester.pumpWidget(new Center(
child: new Row(
key: rowKey,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
new Container(key: child2Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(rowKey));
expect(renderBox.size.width, equals(800.0));
expect(renderBox.size.height, equals(100.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(0.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(100.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(200.0));
});
testWidgets('Row with MainAxisAlignment.center', (WidgetTester tester) async {
final Key rowKey = new Key('row');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
// Default is MainAxisSize.max so the Row should be as wide as the test: 800.
// The 100x100 children's left edges should be at 300, 400
await tester.pumpWidget(new Center(
child: new Row(
key: rowKey,
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(rowKey));
expect(renderBox.size.width, equals(800.0));
expect(renderBox.size.height, equals(100.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(300.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(400.0));
});
testWidgets('Row with MainAxisAlignment.end', (WidgetTester tester) async {
final Key rowKey = new Key('row');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Row should be as wide as the test: 800.
// The 100x100 children's left edges should be at 500, 600, 700.
await tester.pumpWidget(new Center(
child: new Row(
key: rowKey,
mainAxisAlignment: MainAxisAlignment.end,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
new Container(key: child2Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(rowKey));
expect(renderBox.size.width, equals(800.0));
expect(renderBox.size.height, equals(100.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(500.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(600.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(700.0));
});
testWidgets('Row with MainAxisAlignment.spaceBetween', (WidgetTester tester) async {
final Key rowKey = new Key('row');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Row should be as wide as the test: 800.
// The 100x100 children's left edges should be at 0, 350, 700
await tester.pumpWidget(new Center(
child: new Row(
key: rowKey,
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
new Container(key: child2Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(rowKey));
expect(renderBox.size.width, equals(800.0));
expect(renderBox.size.height, equals(100.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(0.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(350.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(700.0));
});
testWidgets('Row with MainAxisAlignment.spaceAround', (WidgetTester tester) async {
final Key rowKey = new Key('row');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
final Key child3Key = new Key('child3');
// Default is MainAxisSize.max so the Row should be as wide as the test: 800.
// The 100x100 children's left edges should be at 50, 250, 450, 650
await tester.pumpWidget(new Center(
child: new Row(
key: rowKey,
mainAxisAlignment: MainAxisAlignment.spaceAround,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 100.0, height: 100.0),
new Container(key: child2Key, width: 100.0, height: 100.0),
new Container(key: child3Key, width: 100.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(rowKey));
expect(renderBox.size.width, equals(800.0));
expect(renderBox.size.height, equals(100.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(50.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(250.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(450.0));
renderBox = tester.renderObject(find.byKey(child3Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(650.0));
});
testWidgets('Row with MainAxisAlignment.spaceEvenly', (WidgetTester tester) async {
final Key rowKey = new Key('row');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
final Key child2Key = new Key('child2');
// Default is MainAxisSize.max so the Row should be as wide as the test: 800.
// The 200x100 children's left edges should be at 50, 300, 550
await tester.pumpWidget(new Center(
child: new Row(
key: rowKey,
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: <Widget>[
new Container(key: child0Key, width: 200.0, height: 100.0),
new Container(key: child1Key, width: 200.0, height: 100.0),
new Container(key: child2Key, width: 200.0, height: 100.0),
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(rowKey));
expect(renderBox.size.width, equals(800.0));
expect(renderBox.size.height, equals(100.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(200.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(50.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(200.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(300.0));
renderBox = tester.renderObject(find.byKey(child2Key));
expect(renderBox.size.width, equals(200.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(550.0));
});
testWidgets('Row and MainAxisSize.min', (WidgetTester tester) async {
final Key rowKey = new Key('rowKey');
final Key child0Key = new Key('child0');
final Key child1Key = new Key('child1');
// Row with MainAxisSize.min without flexible children shrink wraps.
// Row's width should be 250, children should be at 0, 100.
await tester.pumpWidget(new Center(
child: new Row(
key: rowKey,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
new Container(key: child0Key, width: 100.0, height: 100.0),
new Container(key: child1Key, width: 150.0, height: 100.0)
]
)
));
RenderBox renderBox;
BoxParentData boxParentData;
renderBox = tester.renderObject(find.byKey(rowKey));
expect(renderBox.size.width, equals(250.0));
expect(renderBox.size.height, equals(100.0));
renderBox = tester.renderObject(find.byKey(child0Key));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(0.0));
renderBox = tester.renderObject(find.byKey(child1Key));
expect(renderBox.size.width, equals(150.0));
expect(renderBox.size.height, equals(100.0));
boxParentData = renderBox.parentData;
expect(boxParentData.offset.dx, equals(100.0));
});
testWidgets('Row MainAxisSize.min layout at zero size', (WidgetTester tester) async {
final Key childKey = new Key('childKey');
await tester.pumpWidget(new Center(
child: new Container(
width: 0.0,
height: 0.0,
child: new Row(
children: <Widget>[
new Container(
key: childKey,
width: 100.0,
height: 100.0
)
],
mainAxisSize: MainAxisSize.min
)
)
));
RenderBox renderBox = tester.renderObject(find.byKey(childKey));
expect(renderBox.size.width, equals(100.0));
expect(renderBox.size.height, equals(0.0));
});
}