Updated charted DEP to 0.4.X

packages/charted/lib/charts/src/chart_axis_impl.dart

 //
 // Copyright 2014 Google Inc. All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 //
 
 part of charted.charts;
 
@@ skipping 65 matching lines @@
     _orientation = orientation;
     _isVertical =
         _orientation == ORIENTATION_LEFT || _orientation == ORIENTATION_RIGHT;
 
     var layout = _area.layout.chartArea;
     size = _isVertical
         ? new MutableRect.size(_theme.verticalAxisWidth, layout.width)
         : new MutableRect.size(layout.height, _theme.horizontalAxisHeight);
 
     // Handle auto re-sizing of horizontal axis.
+    var ticks = (_config != null && !isNullOrEmpty(_config.tickValues))
+        ? _config.tickValues
+        : scale.ticks,
+    formatter = _columnSpec.formatter == null
+        ? scale.createTickFormatter()
+        : _columnSpec.formatter,
+    textMetrics = new TextMetrics(fontStyle: _theme.ticksFont),
+    formattedTicks = ticks.map((x) => formatter(x)).toList(),
+    shortenedTicks = formattedTicks;
     if (_isVertical) {
-      var ticks = (_config != null && !isNullOrEmpty(_config.tickValues))
-              ? _config.tickValues
-              : scale.ticks,
-          formatter = _columnSpec.formatter == null
-              ? scale.createTickFormatter()
-              : _columnSpec.formatter,
-          textMetrics = new TextMetrics(fontStyle: _theme.ticksFont),
-          formattedTicks = ticks.map((x) => formatter(x)).toList(),
-          shortenedTicks = formattedTicks;
-
       var width = textMetrics.getLongestTextWidth(formattedTicks).ceil();
       if (width > _theme.verticalAxisWidth) {
         width = _theme.verticalAxisWidth;
         shortenedTicks = formattedTicks
             .map((x) => textMetrics.ellipsizeText(x, width))
             .toList();
       }
       if (_theme.verticalAxisAutoResize) {
         size.width =
             width + _theme.axisTickPadding + math.max(_theme.axisTickSize, 0);
       }
+
       _axisTicksPlacement =
           new PrecomputedAxisTicks(ticks, formattedTicks, shortenedTicks);
+    } else {
+      // Precompute if extra room is needed for rotated label.
+      var width = layout.width -
+          _area.layout.axes[ORIENTATION_LEFT].width -
+          _area.layout.axes[ORIENTATION_RIGHT].width;
+      var allowedWidth = width ~/ ticks.length,
+          maxLabelWidth = textMetrics.getLongestTextWidth(formattedTicks);
+      if (!RotateHorizontalAxisTicks.needsLabelRotation(
+          allowedWidth, maxLabelWidth)) {
+        size.height = textMetrics.fontSize * 2;
+      }
     }
   }
 
   void draw(Element element, SelectionScope scope, {bool preRender: false}) {
     assert(element != null && element is GElement);
     assert(scale != null);
 
     var rect = _area.layout.axes[_orientation],
         renderAreaRect = _area.layout.renderArea,
         range = _isVertical ? [rect.height, 0] : [0, rect.width],
@@ skipping 24 matching lines @@
     axis.create(element, scope,
         axisTicksBuilder: _axisTicksPlacement, isRTL: _area.config.isRTL);
   }
 
   void clear() {}
 
   // Scale passed through configuration takes precedence
   Scale get scale =>
       (_config != null && _config.scale != null) ? _config.scale : _scale;
 
-  set scale(Scale value) => _scale = value;
+  set scale(Scale value) {
+    _scale = value;
+  }
 }
 
 class PrecomputedAxisTicks implements SvgAxisTicks {
   final int rotation = 0;
   final Iterable ticks;
   final Iterable formattedTicks;
   final Iterable shortenedTicks;
   const PrecomputedAxisTicks(
       this.ticks, this.formattedTicks, this.shortenedTicks);
   void init(SvgAxis axis) {}
 }
 
 class RotateHorizontalAxisTicks implements SvgAxisTicks {
   final Rect rect;
   final String ticksFont;
   final int tickLineLength;
 
   int rotation = 0;
   Iterable ticks;
-  Iterable formattedTicks;
+  Iterable<String> formattedTicks;
   Iterable shortenedTicks;
 
   RotateHorizontalAxisTicks(this.rect, this.ticksFont, this.tickLineLength);
 
+  static bool needsLabelRotation(num allowedWidth, num maxLabelWidth) =>
+      0.90 * allowedWidth < maxLabelWidth;
+
   void init(SvgAxis axis) {
     assert(axis.orientation == ORIENTATION_BOTTOM ||
         axis.orientation == ORIENTATION_TOP);
     assert(ticksFont != null);
     ticks = axis.tickValues;
     formattedTicks = ticks.map((x) => axis.tickFormat(x)).toList();
     shortenedTicks = formattedTicks;
 
     var range = axis.scale.rangeExtent,
         textMetrics = new TextMetrics(fontStyle: ticksFont),
         allowedWidth = (range.max - range.min) ~/ ticks.length,
         maxLabelWidth = textMetrics.getLongestTextWidth(formattedTicks);
 
     // Check if we need rotation
-    if (0.90 * allowedWidth < maxLabelWidth) {
+    if (needsLabelRotation(allowedWidth, maxLabelWidth)) {
       var rectHeight =
           tickLineLength > 0 ? rect.height - tickLineLength : rect.height;
       rotation = 45;
 
       // Check if we have enough space to render full chart
       allowedWidth = (1.4142 * (rectHeight)) - (textMetrics.fontSize / 1.4142);
       if (maxLabelWidth > allowedWidth) {
         shortenedTicks = formattedTicks
             .map((x) => textMetrics.ellipsizeText(x, allowedWidth))
             .toList();
       }
     }
   }
 }