Client-side support for stacktrace VM status.

runtime/bin/vmstats/bargraph.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.vmstats;
 
 class BarGraph {
   CanvasElement _canvas;
   GraphModel _model;
   List<Element> _elements;
   double scaleHeight = 0;
 
   static const int SAMPLE_WIDTH = 5;
   static const int LEFT_MARGIN = 50;
   static const int RIGHT_MARGIN = 150;
   static const int LEGEND_WIDTH = 130;
   static const int LEGEND_Y = 20;
   static const int INSIDE_MARGIN = 2;
+  static const int LINE_WIDTH = 2;
 
   static const int NUM_DIVIDERS = 5;
   static const String FONT = "14px sans-serif";
 
   BarGraph(this._canvas, this._elements) {
     var maxElements =
         (_canvas.width - LEFT_MARGIN - RIGHT_MARGIN) ~/ SAMPLE_WIDTH;
     _model = new GraphModel(maxElements);
     _model.addListener(drawGraph, null);
     drawBarGraph();
@@ skipping 13 matching lines @@
     context.strokeStyle = 'black';
     // The '2's are the width of the line, even though 1 is specified.
     context.strokeRect(
         LEFT_MARGIN - 2, 1, _canvas.width - LEFT_MARGIN - RIGHT_MARGIN + 2,
         _canvas.height - 2, 1);
 
     // Draw legend.
     var x = _canvas.width - LEGEND_WIDTH;
     var y = LEGEND_Y;
     context.font = FONT;
-    for (var i = 0; i < _elements.length; i++) {
+    for (var i = _elements.length - 1; i >= 0; i--) {
       context.fillStyle = _elements[i].color;
       context.fillRect(x, y, 20, 20);
       context.fillStyle = 'black';
       context.fillText(_elements[i].name, x + 30, y + 15);
       y += 30;
     }
   }
 
   void drawGraph(GraphModel model) {
     var graphHeight = model.maxTotal;
@@ skipping 11 matching lines @@
   }
 
   void drawChart(int maxHeight, double scale) {
     var dividerHeight = maxHeight ~/ NUM_DIVIDERS;
     var context = _canvas.context2d;
     context.beginPath();
     var height = maxHeight.toInt();
     var scaledY = dividerHeight * scale;
 
     // Draw the vertical axis values and lines.
+    context.clearRect(0, 0, LEFT_MARGIN - INSIDE_MARGIN, maxHeight);
     for (var i = 1; i < NUM_DIVIDERS; i++) {
       height -= (dividerHeight ~/ 100) * 100;
       context.font = FONT;
       context.fillStyle = 'black';
       context.textAlign = 'right';
       context.textBaseline = 'middle';
       context.fillText(height.toString(), LEFT_MARGIN - 10, scaledY);
-      context.moveTo(LEFT_MARGIN - 2, scaledY);
+      context.moveTo(LEFT_MARGIN - INSIDE_MARGIN, scaledY);
       context.strokeStyle = 'grey';
       context.lineWidth = 0.5;
       context.lineTo(_canvas.width - RIGHT_MARGIN, scaledY);
       context.stroke();
       scaledY += dividerHeight * scale;
     }
   }
 
   void drawValues(int maxHeight, num scale) {
     Iterator<Sample> iterator = _model.iterator;
     var x = LEFT_MARGIN + INSIDE_MARGIN;
+    var y = INSIDE_MARGIN;
+    var w = _canvas.width - LEFT_MARGIN - RIGHT_MARGIN - INSIDE_MARGIN;
+    var h = (maxHeight * scale).ceil() - (2 * INSIDE_MARGIN);
+    _canvas.context2d.clearRect(x, y, w, h);
 
     while (iterator.moveNext()) {
       Sample s = iterator.current;
       var y = INSIDE_MARGIN;
       if (s != null) {
         var blankHeight = scaleHeight - s.total();
         drawVerticalSegment(x, y, SAMPLE_WIDTH, blankHeight, 'white', scale);
         y += blankHeight;
         for (int i = s.length - 1; i >= 0; i--) {
           var h = s[i];
@@ skipping 16 matching lines @@
     context.beginPath();
     context.lineWidth = w;
     context.fillStyle = color;
     context.strokeStyle = color;
     if (x < INSIDE_MARGIN) {
       x = INSIDE_MARGIN;
     }
     if (y < INSIDE_MARGIN) {
       y = INSIDE_MARGIN;
     }
-    var max = _canvas.width - INSIDE_MARGIN;
-    if ((x + w) > max) {
-      w = max - x;
-    }
-    max = _canvas.height - INSIDE_MARGIN;
+    var max = _canvas.height - INSIDE_MARGIN;
     if ((y + h) > max) {
       h = max - y;
     }
     context.moveTo(x, y);
     context.lineTo(x, y + h);
     context.stroke();
   }
 }
 
 class GraphModel extends ObservableModel {
@@ skipping 60 matching lines @@
 
   int get length => _segments.length;
   int operator[](int i) => _segments[i];
 
   Iterator<int> get iterator => _segments.iterator;
 
   int total() {
     return _segments.reduce(0, (int prev, int element) => prev + element);
   }
 }