Roll Observatory deps (charted -> ^0.3.0)

packages/charted/lib/charts/src/layout_area_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 42 matching lines @@
   LayoutRenderer _renderer;
 
   bool _pendingLegendUpdate = false;
   List<ChartBehavior> _behaviors = new List<ChartBehavior>();
 
   SubscriptionsDisposer _rendererDisposer = new SubscriptionsDisposer();
   StreamController<ChartEvent> _valueMouseOverController;
   StreamController<ChartEvent> _valueMouseOutController;
   StreamController<ChartEvent> _valueMouseClickController;
 
-  DefaultLayoutAreaImpl(
-      this.host,
-      ChartData data,
-      ChartConfig config,
-      this._autoUpdate,
-      this.state) {
+  DefaultLayoutAreaImpl(this.host, ChartData data, ChartConfig config,
+      this._autoUpdate, this.state) {
     assert(host != null);
     assert(isNotInline(host));
 
     this.data = data;
     this.config = config;
     theme = new QuantumChartTheme();
 
     Transition.defaultEasingType = theme.transitionEasingType;
     Transition.defaultEasingMode = theme.transitionEasingMode;
     Transition.defaultDurationMilliseconds =
@@ skipping 53 matching lines @@
       this.config = _config;
     }
   }
 
   @override
   bool get autoUpdate => _autoUpdate;
 
   /// Computes the size of chart and if changed from the previous time
   /// size was computed, sets attributes on svg element
   Rect _computeChartSize() {
-    int width = host.clientWidth,
-        height = host.clientHeight;
+    int width = host.clientWidth, height = host.clientHeight;
 
     if (config.minimumSize != null) {
       width = max([width, config.minimumSize.width]);
       height = max([height, config.minimumSize.height]);
     }
 
     AbsoluteRect padding = theme.padding;
     num paddingLeft = config.isRTL ? padding.end : padding.start;
-    Rect current = new Rect(paddingLeft, padding.top,
+    Rect current = new Rect(
+        paddingLeft,
+        padding.top,
         width - (padding.start + padding.end),
         height - (padding.top + padding.bottom));
     if (layout.chartArea == null || layout.chartArea != current) {
       var transform = 'translate(${paddingLeft},${padding.top})';
 
       visualization.first.attributes['transform'] = transform;
       lowerBehaviorPane.first.attributes['transform'] = transform;
       upperBehaviorPane.first.attributes['transform'] = transform;
 
       _svg.attr('width', width.toString());
       _svg.attr('height', height.toString());
       layout.chartArea = current;
       layout.renderArea = current;
       layout._axes.clear();
     }
 
     return layout.chartArea;
   }
 
   @override
-  draw({bool preRender:false, Future schedulePostRender}) {
+  draw({bool preRender: false, Future schedulePostRender}) {
     assert(data != null && config != null);
     assert(config.series != null && config.series.isNotEmpty);
 
     // One time initialization.
     // Each [ChartArea] has it's own [SelectionScope]
     if (_scope == null) {
       _scope = new SelectionScope.element(host);
       _svg = _scope.append('svg:svg')..classed('chart-canvas');
 
       lowerBehaviorPane = _svg.append('g')..classed('lower-render-pane');
       visualization = _svg.append('g')..classed('chart-render-pane');
       upperBehaviorPane = _svg.append('g')..classed('upper-render-pane');
 
       if (_behaviors.isNotEmpty) {
-        _behaviors.forEach(
-            (b) => b.init(this, upperBehaviorPane, lowerBehaviorPane));
+        _behaviors
+            .forEach((b) => b.init(this, upperBehaviorPane, lowerBehaviorPane));
       }
     }
 
     // Compute chart sizes and filter out unsupported series
     _computeChartSize();
-    var series = config.series.firstWhere(
-            (s) => s.renderer.prepare(this, s), orElse: () => null),
+    var series = config.series
+            .firstWhere((s) => s.renderer.prepare(this, s), orElse: () => null),
         group = visualization.first.querySelector('.series-group');
 
     // We need atleast one matching series.
     assert(series != null);
 
     // Create a group for rendering, if it was not already done.
     if (group == null) {
       group = Namespace.createChildElement('g', visualization.first)
-          ..classes.add('series-group');
+        ..classes.add('series-group');
       visualization.first.append(group);
     }
 
     // If we previously displayed a series, verify that we are
     // still using the same renderer.  Otherwise, dispose the older one.
     if (_renderer != null && series.renderer != _renderer) {
       _rendererDisposer.dispose();
     }
 
     // Save and subscribe to events on the the current renderer.
@@ skipping 27 matching lines @@
             }
           }
           if (_valueMouseOutController != null) {
             _valueMouseOutController.add(e);
           }
         })
       ]);
     }
 
     Iterable<ChartLegendItem> legend =
-        _renderer.layout(group, schedulePostRender:schedulePostRender);
+        _renderer.layout(group, schedulePostRender: schedulePostRender);
 
     // Notify on the stream that the chart has been updated.
     isReady = true;
 
     // Save the list of valid series and initialize axes.
     _series = series;
 
     // Updates the legend if required.
-    _config.legend.update(legend, this);
+    if (_config.legend != null) {
+      _config.legend.update(legend, this);
+    }
   }
 
   @override
   Stream<ChartEvent> get onMouseUp =>
-      host.onMouseUp
-          .map((MouseEvent e) => new DefaultChartEventImpl(e, this));
+      host.onMouseUp.map((MouseEvent e) => new DefaultChartEventImpl(e, this));
 
   @override
-  Stream<ChartEvent> get onMouseDown =>
-      host.onMouseDown
-          .map((MouseEvent e) => new DefaultChartEventImpl(e, this));
+  Stream<ChartEvent> get onMouseDown => host.onMouseDown
+      .map((MouseEvent e) => new DefaultChartEventImpl(e, this));
 
   @override
-  Stream<ChartEvent> get onMouseOver =>
-      host.onMouseOver
-          .map((MouseEvent e) => new DefaultChartEventImpl(e, this));
+  Stream<ChartEvent> get onMouseOver => host.onMouseOver
+      .map((MouseEvent e) => new DefaultChartEventImpl(e, this));
 
   @override
   Stream<ChartEvent> get onMouseOut =>
-      host.onMouseOut
-          .map((MouseEvent e) => new DefaultChartEventImpl(e, this));
+      host.onMouseOut.map((MouseEvent e) => new DefaultChartEventImpl(e, this));
 
   @override
-  Stream<ChartEvent> get onMouseMove =>
-      host.onMouseMove
-          .map((MouseEvent e) => new DefaultChartEventImpl(e, this));
+  Stream<ChartEvent> get onMouseMove => host.onMouseMove
+      .map((MouseEvent e) => new DefaultChartEventImpl(e, this));
 
   @override
   Stream<ChartEvent> get onValueClick {
     if (_valueMouseClickController == null) {
       _valueMouseClickController = new StreamController.broadcast(sync: true);
     }
     return _valueMouseClickController.stream;
   }
 
   @override
@@ skipping 23 matching lines @@
 
   @override
   void removeChartBehavior(ChartBehavior behavior) {
     if (behavior == null || !_behaviors.contains(behavior)) return;
     if (upperBehaviorPane != null && lowerBehaviorPane != null) {
       behavior.dispose();
     }
     _behaviors.remove(behavior);
   }
 }