Update charted to 0.4.8 and roll

packages/charted/lib/charts/behaviors/hovercard.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 33 matching lines @@
 /// Constraints and known issues:
 /// (0) The implementation isn't complete yet! Specifically for CartesianArea
 ///     that uses two axes.
 /// (1) Even with all the logic, single value mode does not work well
 ///     with StackedBarChartRenderer
 /// (2) Only mouse relative positioning is supported on LayoutArea
 /// (3) Positioning only works for renderers that determine extent given a
 ///     single row.  Eg: Would not work with a water-fall chart.
 ///
 class Hovercard implements ChartBehavior {
+  static const _HOVERCARD_OFFSET = 20;
   final HovercardBuilder builder;
 
   bool _isMouseTracking;
   bool _isMultiValue;
   bool _showDimensionTitle;
   Iterable<int> _columnsToShow;
 
   Iterable placementOrder = const [
     'orientation',
     'top',
     'right',
     'bottom',
     'left',
     'orientation'
   ];
-  int offset = 20;
 
   ChartArea _area;
   ChartState _state;
   SubscriptionsDisposer _disposer = new SubscriptionsDisposer();
 
   Element _hovercardRoot;
 
   Hovercard(
       {bool isMouseTracking,
       bool isMultiValue: false,
@@ skipping 94 matching lines @@
         _positionOnTwoDimensionCartesian(column, row);
       } else {
         _positionOnSingleDimensionCartesian(column, row);
       }
     } else {
       _positionOnLayout(column, row);
     }
   }
 
   void _positionAtMousePointer(ChartEvent e) =>
-      _positionAtPoint(e.chartX, e.chartY, offset, offset, false, false);
+      _positionAtPoint(e.chartX, e.chartY, _HOVERCARD_OFFSET, _HOVERCARD_OFFSET, false, false);
 
   void _positionOnLayout(column, row) {
     // Currently for layouts, when hovercard is triggered due to change
     // in ChartState, we render hovercard in the middle of layout.
     // TODO: Get bounding rect from LayoutRenderer and position relative to it.
   }
 
   void _positionOnTwoDimensionCartesian(int column, int row) {
     // TODO: Implement multi dimension positioning.
   }
 
   void _positionOnSingleDimensionCartesian(int column, int row) {
     CartesianArea area = _area;
     var dimensionCol = area.config.dimensions.first,
         dimensionScale = area.dimensionScales.first,
         measureScale = _getScaleForColumn(column),
-        dimensionOffset = this.offset,
+        dimensionOffset = _HOVERCARD_OFFSET,
         dimensionCenterOffset = 0;
 
     // If we are using bands on the one axis that is shown
     // update position and offset accordingly.
     if (area.dimensionsUsingBands.contains(dimensionCol)) {
       assert(dimensionScale is OrdinalScale);
       dimensionOffset = (dimensionScale as OrdinalScale).rangeBand ~/ 2;
       dimensionCenterOffset = dimensionOffset;
     }
 
     var rowData = area.data.rows.elementAt(row),
         measurePosition = 0,
         isNegative = false,
         dimensionPosition = dimensionScale
                 .scale(rowData.elementAt(dimensionCol)) +
             dimensionCenterOffset;
 
     if (_isMultiValue) {
       var max = SMALL_INT_MIN, min = SMALL_INT_MAX;
       area.config.series.forEach((ChartSeries series) {
         CartesianRenderer renderer = series.renderer;
         Extent extent = renderer.extentForRow(rowData);
         if (extent.min < min) min = extent.min;
         if (extent.max > max) max = extent.max;
         measurePosition = measureScale.scale(max);
         isNegative = max < 0;
       });
     } else {
       var value = rowData.elementAt(column);
-      isNegative = value < 0;
-      measurePosition = measureScale.scale(rowData.elementAt(column));
+      if (value != null) {
+        isNegative = value < 0;
+        measurePosition = measureScale.scale(value);
+      }
     }
 
     if (area.config.isLeftAxisPrimary) {
-      _positionAtPoint(measurePosition, dimensionPosition, 0, dimensionOffset,
-          isNegative, true);
+      _positionAtPoint(measurePosition, dimensionPosition, _HOVERCARD_OFFSET,
+          dimensionOffset, isNegative, true);
     } else {
-      _positionAtPoint(dimensionPosition, measurePosition, dimensionOffset, 0,
-          isNegative, false);
+      _positionAtPoint(dimensionPosition, measurePosition, dimensionOffset,
+          _HOVERCARD_OFFSET, isNegative, false);
     }
   }
 
   void _positionAtPoint(num x, num y, num xBand, num yBand, bool negative,
       [bool isLeftPrimary = false]) {
     var rect = _hovercardRoot.getBoundingClientRect(),
         width = rect.width,
         height = rect.height,
         scaleToHostY = (_area.theme.padding != null
                 ? _area.theme.padding.top
@@ skipping 30 matching lines @@
         top = isLeftPrimary ? y - height / 2 : y;
         left = negative ? x + xBand : x - (width + xBand);
       }
       if (placement == 'bottom') {
         top = negative ? y - (height + yBand) : y + yBand;
         left = isLeftPrimary ? x - width : x - width / 2;
       }
 
       // Check if the popup is contained in the RenderArea.
       // If not, try other placements.
-      if (top > 0 &&
-          left > 0 &&
+      if (top >= 0 &&
+          left >= 0 &&
           top + height < renderAreaHeight &&
           left + width < renderAreaWidth) {
         break;
       }
     }
 
     _hovercardRoot.style
       ..top = '${top + scaleToHostY}px'
       ..left = '${left + scaleToHostX}px';
   }
@@ skipping 103 matching lines @@
       }
     }
     if (formatter == null) {
       // Formatter function must return String.  Default to identity function
       // but return the toString() instead.
       formatter = (x) => x.toString();
     }
     return formatter;
   }
 }