Make TabBar conform to the Material spec for icon/text tabs

sky/sdk/lib/widgets/tabs.dart

 // 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 'dart:math' as math;
 
 import 'package:sky/rendering/box.dart';
 import 'package:sky/rendering/object.dart';
 import 'package:sky/widgets/basic.dart';
 import 'package:sky/widgets/icon.dart';
 import 'package:sky/widgets/ink_well.dart';
 import 'package:sky/widgets/theme.dart';
 import 'package:sky/widgets/widget.dart';
 
 typedef void SelectedIndexChanged(int selectedIndex);
 
 const double _kTabHeight = 46.0;
+const double _kTextAndIconTabHeight = 72.0;
 const double _kTabIndicatorHeight = 2.0;
-const double _kTabBarHeight = _kTabHeight + _kTabIndicatorHeight;
 const double _kMinTabWidth = 72.0;
 const int _kTabIconSize = 24;
 
 class TabBarParentData extends BoxParentData with
     ContainerParentDataMixin<RenderBox> { }
 
 class RenderTabBar extends RenderBox with
     ContainerRenderObjectMixin<RenderBox, TabBarParentData>,
     RenderBoxContainerDefaultsMixin<RenderBox, TabBarParentData> {
 
@@ skipping 17 matching lines @@
 
   Color _indicatorColor;
   Color get indicatorColor => _indicatorColor;
   void set indicatorColor(Color value) {
     if (_indicatorColor != value) {
       _indicatorColor = value;
       markNeedsPaint();
     }
   }
 
+  bool _textAndIcons;
+  bool get textAndIcons => _textAndIcons;
+  void set textAndIcons(bool value) {
+    if (_textAndIcons != value) {
+      _textAndIcons = value;
+      markNeedsLayout();
+    }
+  }
+
   void setupParentData(RenderBox child) {
     if (child.parentData is! TabBarParentData)
       child.parentData = new TabBarParentData();
   }
 
   double getMinIntrinsicWidth(BoxConstraints constraints) {
     BoxConstraints widthConstraints =
         new BoxConstraints(maxWidth: constraints.maxWidth, maxHeight: constraints.maxHeight);
     double maxWidth = 0.0;
     RenderBox child = firstChild;
@@ skipping 11 matching lines @@
     double maxWidth = 0.0;
     RenderBox child = firstChild;
     while (child != null) {
       maxWidth = math.max(maxWidth, child.getMaxIntrinsicWidth(widthConstraints));
       assert(child.parentData is TabBarParentData);
       child = child.parentData.nextSibling;
     }
     return constraints.constrainWidth(maxWidth * childCount);
   }
 
-  double _getIntrinsicHeight(BoxConstraints constraints) => constraints.constrainHeight(_kTabBarHeight);
+  double get _tabBarHeight {
+    return (textAndIcons ? _kTextAndIconTabHeight : _kTabHeight) + _kTabIndicatorHeight;
+  }
+
+  double _getIntrinsicHeight(BoxConstraints constraints) => constraints.constrainHeight(_tabBarHeight);
 
   double getMinIntrinsicHeight(BoxConstraints constraints) => _getIntrinsicHeight(constraints);
 
   double getMaxIntrinsicHeight(BoxConstraints constraints) => _getIntrinsicHeight(constraints);
 
   void performLayout() {
     assert(constraints is BoxConstraints);
 
-    size = constraints.constrain(new Size(constraints.maxWidth, _kTabBarHeight));
+    size = constraints.constrain(new Size(constraints.maxWidth, _tabBarHeight));
     assert(!size.isInfinite);
 
     if (childCount == 0)
       return;
 
     double tabWidth = size.width / childCount;
     BoxConstraints tabConstraints =
       new BoxConstraints.tightFor(width: tabWidth, height: size.height);
     double x = 0.0;
     RenderBox child = firstChild;
     while (child != null) {
       child.layout(tabConstraints);
       assert(child.parentData is TabBarParentData);
       child.parentData.position = new Point(x, 0.0);
       x += tabWidth;
       child = child.parentData.nextSibling;
     }
   }
 
   void hitTestChildren(HitTestResult result, { Point position }) {
     defaultHitTestChildren(result, position: position);
   }
 
   void _paintIndicator(RenderCanvas canvas, RenderBox selectedTab) {
     if (indicatorColor == null)
       return;
 
     var size = new Size(selectedTab.size.width, _kTabIndicatorHeight);
-    var point = new Point(selectedTab.parentData.position.x, _kTabHeight);
+    var point = new Point(
+      selectedTab.parentData.position.x,
+      _tabBarHeight - _kTabIndicatorHeight);
     Rect rect = new Rect.fromPointAndSize(point, size);
     canvas.drawRect(rect, new Paint()..color = indicatorColor);
   }
 
   void paint(RenderCanvas canvas) {
     if (backgroundColor != null) {
       Rect rect = new Rect.fromSize(size);
       canvas.drawRect(rect, new Paint()..color = backgroundColor);
     }
 
     int index = 0;
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is TabBarParentData);
       canvas.paintChild(child, child.parentData.position);
       if (index++ == selectedIndex)
         _paintIndicator(canvas, child);
       child = child.parentData.nextSibling;
     }
   }
 }
 
 class TabBarWrapper extends MultiChildRenderObjectWrapper {
   TabBarWrapper({
     List<Widget> children,
     this.selectedIndex,
     this.backgroundColor,
     this.indicatorColor,
+    this.textAndIcons,
     String key 
   }) : super(key: key, children: children);
 
   final int selectedIndex;
   final Color backgroundColor;
   final Color indicatorColor;
+  final bool textAndIcons; 
 
   RenderTabBar get root => super.root;
   RenderTabBar createNode() => new RenderTabBar();
 
   void syncRenderObject(Widget old) {
     super.syncRenderObject(old);
     root.selectedIndex = selectedIndex;
     root.backgroundColor = backgroundColor;
     root.indicatorColor = indicatorColor;
+    root.textAndIcons = textAndIcons;
   }
 }
 
 class TabLabel {
   const TabLabel({ this.text, this.icon });
 
   final String text;
   final String icon;
 }
 
@@ skipping 20 matching lines @@
   }
 
   Widget build() {
     Widget labelContents;
     if (label.icon == null) {
       labelContents = _buildLabelText();
     } else if (label.text == null) {
       labelContents = _buildLabelIcon();
     } else {
       labelContents = new Flex(
-        <Widget>[_buildLabelText(), _buildLabelIcon()], 
+        <Widget>[
+          new Container(
+            child: _buildLabelIcon(),
+            margin: const EdgeDims.only(bottom: 10.0)
+          ),
+          _buildLabelText()
+        ], 
         justifyContent: FlexJustifyContent.center,
         alignItems: FlexAlignItems.center,
         direction: FlexDirection.vertical
       );
     }
 
     Widget highlightedLabel = new Opacity(
       child: labelContents, 
       opacity: selected ? 1.0 : 0.7
     );
@@ skipping 32 matching lines @@
     );
     return new Listener(
       child: tab,
       onGestureTap: (_) => _handleTap(tabIndex)
     );
   }
 
   Widget build() {
     assert(labels != null && labels.isNotEmpty);
     List<Widget> tabs = <Widget>[];
+    bool textAndIcons = false;
     for (int tabIndex = 0; tabIndex < labels.length; tabIndex++) {
       tabs.add(_toTab(labels[tabIndex], tabIndex));
+      if (labels[tabIndex].text != null && labels[tabIndex].icon != null)
+        textAndIcons = true;
     }
     return new TabBarWrapper(
       children: tabs, 
       selectedIndex: selectedIndex,
       backgroundColor: Theme.of(this).primary[500],
-      indicatorColor: Theme.of(this).accent[200]
+      indicatorColor: Theme.of(this).accent[200],
+      textAndIcons: textAndIcons
     );
   }
 }
-
-