Project: JsTestDriver
/*
* Copyright 2009 Google Inc. 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not 
 * use this file except in compliance with the License. You may obtain a copy of 
 * the License at 
 * 
 * http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
 * License for the specific language governing permissions and limitations under 
 * the License. 
 */
package com.google.eclipse.javascript.jstestdriver.ui.view; 
 
import org.eclipse.swt.SWT; 
import org.eclipse.swt.events.ControlAdapter; 
import org.eclipse.swt.events.ControlEvent; 
import org.eclipse.swt.events.DisposeEvent; 
import org.eclipse.swt.events.DisposeListener; 
import org.eclipse.swt.events.PaintEvent; 
import org.eclipse.swt.events.PaintListener; 
import org.eclipse.swt.graphics.Color; 
import org.eclipse.swt.graphics.GC; 
import org.eclipse.swt.graphics.Rectangle; 
import org.eclipse.swt.widgets.Canvas; 
import org.eclipse.swt.widgets.Composite; 
import org.eclipse.swt.widgets.Display; 
 
/**
 * Adaptation of the JUnitProgressBar. Paints rectangles on a canvas to represent the ProgressBar. 
 * Allows moving the bar by a few ticks at a time, as compared to one step at a time by the 
 * original progress bar. 
 * 
 * @author [email protected] (Shyam Seshadri) 
 */
 
public class TestResultProgressBar extends Canvas { 
 
  private final Color passColor; 
  private final Color failColor; 
  private int maxCount; 
  private int currentCount; 
  private int barWidth; 
  private Color currentColor; 
 
  public TestResultProgressBar(Composite parent, int style) { 
    super(parent, style | SWT.BORDER); 
    passColor = new Color(parent.getDisplay(), 9519195); 
    failColor = new Color(parent.getDisplay(), 1596363); 
    currentColor = passColor; 
    maxCount = 0
    currentCount = 0
 
    addControlListener(new ControlAdapter() { 
      @Override 
      public void controlResized(ControlEvent e) { 
        barWidth = scale(currentCount); 
        redraw(); 
      } 
    }); 
 
    addPaintListener(new PaintListener() { 
      @Override 
      public void paintControl(PaintEvent e) { 
        paint(e); 
      } 
    }); 
 
    addDisposeListener(new DisposeListener() { 
      @Override 
      public void widgetDisposed(DisposeEvent e) { 
        passColor.dispose(); 
        failColor.dispose(); 
        currentColor.dispose(); 
      } 
    }); 
  } 
 
  private void paint(PaintEvent e) { 
    GC gc = e.gc; 
    Display display = getDisplay(); 
 
    Rectangle rectangle = getClientArea(); 
    gc.fillRectangle(rectangle); 
    drawBorder(gc, rectangle.x, rectangle.y, rectangle.width - 1, rectangle.height - 1
        display.getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW), 
        display.getSystemColor(SWT.COLOR_WIDGET_HIGHLIGHT_SHADOW)); 
 
    gc.setBackground(currentColor); 
    barWidth = Math.min(rectangle.width - 2, barWidth); 
    gc.fillRectangle(11, barWidth, rectangle.height - 2); 
  } 
 
  private void paintStep(PaintEvent e, int startX, int endX) { 
    GC gc = e.gc; 
    gc.setBackground(currentColor); 
    Rectangle rectangle = getClientArea(); 
    startX = Math.max(1, startX); 
    gc.fillRectangle(startX, 1, endX - startX, rectangle.height - 2); 
  } 
 
  private void drawBorder(GC gc, int x, int y, int width, int height, Color topLeft, 
      Color bottomRight) { 
    gc.setForeground(topLeft); 
    gc.drawLine(x, y, x + width - 1, y); 
    gc.drawLine(x, y, x, y + height - 1); 
 
    gc.setForeground(bottomRight); 
    gc.drawLine(x + width, y, x + width, y + height); 
    gc.drawLine(x, y + height, x + width, y + height); 
  } 
 
  private int scale(int currentCount) { 
    if (maxCount > 0) { 
      Rectangle rectangle = getClientArea(); 
      if (rectangle.width > 0) { 
        return currentCount * (rectangle.width - 2) / maxCount; 
      } 
    } 
    return currentCount; 
  } 
 
  /**
   * Resets the progress bar to its empty state. 
   */
 
  public void reset() { 
    currentColor = passColor; 
    maxCount = 0
    barWidth = 0
    currentCount = 0
  } 
 
  /**
   * Sets the max number of ticks the progress bar is allowed to progress. 
   * @param max the max 
   */
 
  public void setMax(int max) { 
    maxCount = max; 
  } 
 
  /**
   * Steps the progress bar through given number of ticks. If not passed, then the color is changed 
   * to red. 
   * @param ticks the number of ticks to proceed through. 
   * @param passed did the tests fail 
   */
 
  public void step(int ticks, boolean passed) { 
    int x = barWidth; 
    if (!passed) { 
      currentColor = failColor; 
      x = 1
    } 
    if (currentCount < maxCount) { 
      currentCount += ticks; 
    } 
    barWidth = scale(currentCount); 
    if (currentCount >= maxCount) { 
      currentCount = maxCount; 
      barWidth = getClientArea().width - 1
    } 
    final int width = x; 
    addPaintListener(new PaintListener() { 
      @Override 
      public void paintControl(PaintEvent e) { 
        paintStep(e, width, barWidth); 
      } 
    }); 
    redraw(); 
  } 
}