android-2.3_r1.0/s

/*
 * Copyright (C) 2006 The Android Open Source Project
 *
 * 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.android.traceview;

import org.eclipse.jface.resource.FontRegistry;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.ScrollBar;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Observable;
import java.util.Observer;

public class TimeLineView extends Composite implements Observer {

    private HashMap<String, RowData> mRowByName;
    private double mTotalElapsed;
    private RowData[] mRows;
    private Segment[] mSegments;
    private ArrayList<Segment> mSegmentList = new ArrayList<Segment>();
    private HashMap<Integer, String> mThreadLabels;
    private Timescale mTimescale;
    private Surface mSurface;
    private RowLabels mLabels;
    private SashForm mSashForm;
    private int mScrollOffsetY;

    public static final int PixelsPerTick = 50;
    private TickScaler mScaleInfo = new TickScaler(0, 0, 0, PixelsPerTick);
    private static final int LeftMargin = 10; // blank space on left
    private static final int RightMargin = 60; // blank space on right

    private Color mColorBlack;
    private Color mColorGray;
    private Color mColorDarkGray;
    private Color mColorForeground;
    private Color mColorRowBack;
    private Color mColorZoomSelection;
    private FontRegistry mFontRegistry;

    /** vertical height of drawn blocks in each row */
    private static final int rowHeight = 20;

    /** the blank space between rows */
    private static final int rowYMargin = 12;
    private static final int rowYMarginHalf = rowYMargin / 2;

    /** total vertical space for row */
    private static final int rowYSpace = rowHeight + rowYMargin;
    private static final int majorTickLength = 8;
    private static final int minorTickLength = 4;
    private static final int timeLineOffsetY = 38;
    private static final int tickToFontSpacing = 2;

    /** start of first row */
    private static final int topMargin = 70;
    private int mMouseRow = -1;
    private int mNumRows;
    private int mStartRow;
    private int mEndRow;
    private TraceUnits mUnits;
    private int mSmallFontWidth;
    private int mSmallFontHeight;
    private int mMediumFontWidth;
    private SelectionController mSelectionController;
    private MethodData mHighlightMethodData;
    private Call mHighlightCall;
    private static final int MinInclusiveRange = 3;

    /** Setting the fonts looks good on Linux but bad on Macs */
    private boolean mSetFonts = false;

    public static interface Block {
        public String getName();
        public MethodData getMethodData();
        public long getStartTime();
        public long getEndTime();
        public Color getColor();
        public double addWeight(int x, int y, double weight);
        public void clearWeight();
    }

    public static interface Row {
        public int getId();
        public String getName();
    }

    public static class Record {
        Row row;
        Block block;

        public Record(Row row, Block block) {
            this.row = row;
            this.block = block;
        }
    }

    public TimeLineView(Composite parent, TraceReader reader,
            SelectionController selectionController) {
        super(parent, SWT.NONE);
        mRowByName = new HashMap<String, RowData>();
        this.mSelectionController = selectionController;
        selectionController.addObserver(this);
        mUnits = reader.getTraceUnits();
        mThreadLabels = reader.getThreadLabels();

        Display display = getDisplay();
        mColorGray = display.getSystemColor(SWT.COLOR_GRAY);
        mColorDarkGray = display.getSystemColor(SWT.COLOR_DARK_GRAY);
        mColorBlack = display.getSystemColor(SWT.COLOR_BLACK);
        // mColorBackground = display.getSystemColor(SWT.COLOR_WHITE);
        mColorForeground = display.getSystemColor(SWT.COLOR_BLACK);
        mColorRowBack = new Color(display, 240, 240, 255);
        mColorZoomSelection = new Color(display, 230, 230, 230);

        mFontRegistry = new FontRegistry(display);
        mFontRegistry.put("small",  // $NON-NLS-1$
                new FontData[] { new FontData("Arial", 8, SWT.NORMAL) });  // $NON-NLS-1$
        mFontRegistry.put("courier8",  // $NON-NLS-1$
                new FontData[] { new FontData("Courier New", 8, SWT.BOLD) });  // $NON-NLS-1$
        mFontRegistry.put("medium",  // $NON-NLS-1$
                new FontData[] { new FontData("Courier New", 10, SWT.NORMAL) });  // $NON-NLS-1$

        Image image = new Image(display, new Rectangle(100, 100, 100, 100));
        GC gc = new GC(image);
        if (mSetFonts) {
            gc.setFont(mFontRegistry.get("small"));  // $NON-NLS-1$
        }
        mSmallFontWidth = gc.getFontMetrics().getAverageCharWidth();
        mSmallFontHeight = gc.getFontMetrics().getHeight();

        if (mSetFonts) {
            gc.setFont(mFontRegistry.get("medium"));  // $NON-NLS-1$
        }
        mMediumFontWidth = gc.getFontMetrics().getAverageCharWidth();

        image.dispose();
        gc.dispose();

        setLayout(new FillLayout());

        // Create a sash form for holding two canvas views, one for the
        // thread labels and one for the thread timeline.
        mSashForm = new SashForm(this, SWT.HORIZONTAL);
        mSashForm.setBackground(mColorGray);
        mSashForm.SASH_WIDTH = 3;

        // Create a composite for the left side of the sash
        Composite composite = new Composite(mSashForm, SWT.NONE);
        GridLayout layout = new GridLayout(1, true /* make columns equal width */);
        layout.marginHeight = 0;
        layout.marginWidth = 0;
        layout.verticalSpacing = 1;
        composite.setLayout(layout);

        // Create a blank corner space in the upper left corner
        BlankCorner corner = new BlankCorner(composite);
        GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
        gridData.heightHint = topMargin;
        corner.setLayoutData(gridData);

        // Add the thread labels below the blank corner.
        mLabels = new RowLabels(composite);
        gridData = new GridData(GridData.FILL_BOTH);
        mLabels.setLayoutData(gridData);

        // Create another composite for the right side of the sash
        composite = new Composite(mSashForm, SWT.NONE);
        layout = new GridLayout(1, true /* make columns equal width */);
        layout.marginHeight = 0;
        layout.marginWidth = 0;
        layout.verticalSpacing = 1;
        composite.setLayout(layout);

        mTimescale = new Timescale(composite);
        gridData = new GridData(GridData.FILL_HORIZONTAL);
        gridData.heightHint = topMargin;
        mTimescale.setLayoutData(gridData);

        mSurface = new Surface(composite);
        gridData = new GridData(GridData.FILL_BOTH);
        mSurface.setLayoutData(gridData);
        mSashForm.setWeights(new int[] { 1, 5 });

        final ScrollBar vBar = mSurface.getVerticalBar();
        vBar.addListener(SWT.Selection, new Listener() {
           public void handleEvent(Event e) {
               mScrollOffsetY = vBar.getSelection();
               Point dim = mSurface.getSize();
               int newScrollOffsetY = computeVisibleRows(dim.y);
               if (newScrollOffsetY != mScrollOffsetY) {
                   mScrollOffsetY = newScrollOffsetY;
                   vBar.setSelection(newScrollOffsetY);
               }
               mLabels.redraw();
               mSurface.redraw();
           }
        });

        mSurface.addListener(SWT.Resize, new Listener() {
            public void handleEvent(Event e) {
                Point dim = mSurface.getSize();

                // If we don't need the scroll bar then don't display it.
                if (dim.y >= mNumRows * rowYSpace) {
                    vBar.setVisible(false);
                } else {
                    vBar.setVisible(true);
                }
                int newScrollOffsetY = computeVisibleRows(dim.y);
                if (newScrollOffsetY != mScrollOffsetY) {
                    mScrollOffsetY = newScrollOffsetY;
                    vBar.setSelection(newScrollOffsetY);
                }

                int spaceNeeded = mNumRows * rowYSpace;
                vBar.setMaximum(spaceNeeded);
                vBar.setThumb(dim.y);

                mLabels.redraw();
                mSurface.redraw();
            }
        });

        mSurface.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseUp(MouseEvent me) {
                mSurface.mouseUp(me);
            }

            @Override
            public void mouseDown(MouseEvent me) {
                mSurface.mouseDown(me);
            }

            @Override
            public void mouseDoubleClick(MouseEvent me) {
                mSurface.mouseDoubleClick(me);
            }
        });

        mSurface.addMouseMoveListener(new MouseMoveListener() {
            public void mouseMove(MouseEvent me) {
                mSurface.mouseMove(me);
            }
        });

        mTimescale.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseUp(MouseEvent me) {
                mTimescale.mouseUp(me);
            }

            @Override
            public void mouseDown(MouseEvent me) {
                mTimescale.mouseDown(me);
            }

            @Override
            public void mouseDoubleClick(MouseEvent me) {
                mTimescale.mouseDoubleClick(me);
            }
        });

        mTimescale.addMouseMoveListener(new MouseMoveListener() {
            public void mouseMove(MouseEvent me) {
                mTimescale.mouseMove(me);
            }
        });

        mLabels.addMouseMoveListener(new MouseMoveListener() {
            public void mouseMove(MouseEvent me) {
                mLabels.mouseMove(me);
            }
        });

        setData(reader.getThreadTimeRecords());
    }

    public void update(Observable objservable, Object arg) {
        // Ignore updates from myself
        if (arg == "TimeLineView")  // $NON-NLS-1$
            return;
        // System.out.printf("timeline update from %s\n", arg);
        boolean foundHighlight = false;
        ArrayList<Selection> selections;
        selections = mSelectionController.getSelections();
        for (Selection selection : selections) {
            Selection.Action action = selection.getAction();
            if (action != Selection.Action.Highlight)
                continue;
            String name = selection.getName();
            // System.out.printf(" timeline highlight %s from %s\n", name, arg);
            if (name == "MethodData") {  // $NON-NLS-1$
                foundHighlight = true;
                mHighlightMethodData = (MethodData) selection.getValue();
                // System.out.printf(" method %s\n",
                // highlightMethodData.getName());
                mHighlightCall = null;
                startHighlighting();
            } else if (name == "Call") {  // $NON-NLS-1$
                foundHighlight = true;
                mHighlightCall = (Call) selection.getValue();
                // System.out.printf(" call %s\n", highlightCall.getName());
                mHighlightMethodData = null;
                startHighlighting();
            }
        }
        if (foundHighlight == false)
            mSurface.clearHighlights();
    }

    public void setData(ArrayList<Record> records) {
        if (records == null)
            records = new ArrayList<Record>();

        if (false) {
            System.out.println("TimelineView() list of records:");  // $NON-NLS-1$
            for (Record r : records) {
                System.out.printf("row '%s' block '%s' [%d, %d]\n", r.row  // $NON-NLS-1$
                        .getName(), r.block.getName(), r.block.getStartTime(),
                        r.block.getEndTime());
                if (r.block.getStartTime() > r.block.getEndTime()) {
                    System.err.printf("Error: block startTime > endTime\n");  // $NON-NLS-1$
                    System.exit(1);
                }
            }
        }

        // Sort the records into increasing start time, and decreasing end time
        Collections.sort(records, new Comparator<Record>() {
            public int compare(Record r1, Record r2) {
                long start1 = r1.block.getStartTime();
                long start2 = r2.block.getStartTime();
                if (start1 > start2)
                    return 1;
                if (start1 < start2)
                    return -1;

                // The start times are the same, so compare the end times
                long end1 = r1.block.getEndTime();
                long end2 = r2.block.getEndTime();
                if (end1 > end2)
                    return -1;
                if (end1 < end2)
                    return 1;

                return 0;
            }
        });

        // The records are sorted into increasing start time,
        // so the minimum start time is the start time of the first record.
        double minVal = 0;
        if (records.size() > 0)
            minVal = records.get(0).block.getStartTime();

        // Sum the time spent in each row and block, and
        // keep track of the maximum end time.
        double maxVal = 0;
        for (Record rec : records) {
            Row row = rec.row;
            Block block = rec.block;
            String rowName = row.getName();
            RowData rd = mRowByName.get(rowName);
            if (rd == null) {
                rd = new RowData(row);
                mRowByName.put(rowName, rd);
            }
            long blockStartTime = block.getStartTime();
            long blockEndTime = block.getEndTime();
            if (blockEndTime > rd.mEndTime) {
                long start = Math.max(blockStartTime, rd.mEndTime);
                rd.mElapsed += blockEndTime - start;
                mTotalElapsed += blockEndTime - start;
                rd.mEndTime = blockEndTime;
            }
            if (blockEndTime > maxVal)
                maxVal = blockEndTime;

            // Keep track of nested blocks by using a stack (for each row).
            // Create a Segment object for each visible part of a block.
            Block top = rd.top();
            if (top == null) {
                rd.push(block);
                continue;
            }

            long topStartTime = top.getStartTime();
            long topEndTime = top.getEndTime();
            if (topEndTime >= blockStartTime) {
                // Add this segment if it has a non-zero elapsed time.
                if (topStartTime < blockStartTime) {
                    Segment segment = new Segment(rd, top, topStartTime,
                            blockStartTime);
                    mSegmentList.add(segment);
                }

                // If this block starts where the previous (top) block ends,
                // then pop off the top block.
                if (topEndTime == blockStartTime)
                    rd.pop();
                rd.push(block);
            } else {
                // We may have to pop several frames here.
                popFrames(rd, top, blockStartTime);
                rd.push(block);
            }
        }

        // Clean up the stack of each row
        for (RowData rd : mRowByName.values()) {
            Block top = rd.top();
            popFrames(rd, top, Integer.MAX_VALUE);
        }

        mSurface.setRange(minVal, maxVal);
        mSurface.setLimitRange(minVal, maxVal);

        // Sort the rows into decreasing elapsed time
        Collection<RowData> rv = mRowByName.values();
        mRows = rv.toArray(new RowData[rv.size()]);
        Arrays.sort(mRows, new Comparator<RowData>() {
            public int compare(RowData rd1, RowData rd2) {
                return (int) (rd2.mElapsed - rd1.mElapsed);
            }
        });

        // Assign ranks to the sorted rows
        for (int ii = 0; ii < mRows.length; ++ii) {
            mRows[ii].mRank = ii;
        }

        // Compute the number of rows with data
        mNumRows = 0;
        for (int ii = 0; ii < mRows.length; ++ii) {
            if (mRows[ii].mElapsed == 0)
                break;
            mNumRows += 1;
        }

        // Sort the blocks into increasing rows, and within rows into
        // increasing start values.
        mSegments = mSegmentList.toArray(new Segment[mSegmentList.size()]);
        Arrays.sort(mSegments, new Comparator<Segment>() {
            public int compare(Segment bd1, Segment bd2) {
                RowData rd1 = bd1.mRowData;
                RowData rd2 = bd2.mRowData;
                int diff = rd1.mRank - rd2.mRank;
                if (diff == 0) {
                    long timeDiff = bd1.mStartTime - bd2.mStartTime;
                    if (timeDiff == 0)
                        timeDiff = bd1.mEndTime - bd2.mEndTime;
                    return (int) timeDiff;
                }
                return diff;
            }
        });

        if (false) {
            for (Segment segment : mSegments) {
                System.out.printf("seg '%s' [%6d, %6d] %s\n",
                        segment.mRowData.mName, segment.mStartTime,
                        segment.mEndTime, segment.mBlock.getName());
                if (segment.mStartTime > segment.mEndTime) {
                    System.err.printf("Error: segment startTime > endTime\n");
                    System.exit(1);
                }
            }
        }
    }

    private void popFrames(RowData rd, Block top, long startTime) {
        long topEndTime = top.getEndTime();
        long lastEndTime = top.getStartTime();
        while (topEndTime <= startTime) {
            if (topEndTime > lastEndTime) {
                Segment segment = new Segment(rd, top, lastEndTime, topEndTime);
                mSegmentList.add(segment);
                lastEndTime = topEndTime;
            }
            rd.pop();
            top = rd.top();
            if (top == null)
                return;
            topEndTime = top.getEndTime();
        }

        // If we get here, then topEndTime > startTime
        if (lastEndTime < startTime) {
            Segment bd = new Segment(rd, top, lastEndTime, startTime);
            mSegmentList.add(bd);
        }
    }

    private class RowLabels extends Canvas {

        /** The space between the row label and the sash line */
        private static final int labelMarginX = 2;

        public RowLabels(Composite parent) {
            super(parent, SWT.NO_BACKGROUND);
            addPaintListener(new PaintListener() {
                public void paintControl(PaintEvent pe) {
                    draw(pe.display, pe.gc);
                }
            });
        }

        private void mouseMove(MouseEvent me) {
            int rownum = (me.y + mScrollOffsetY) / rowYSpace;
            if (mMouseRow != rownum) {
                mMouseRow = rownum;
                redraw();
                mSurface.redraw();
            }
        }

        private void draw(Display display, GC gc) {
            if (mSegments.length == 0) {
                // gc.setBackground(colorBackground);
                // gc.fillRectangle(getBounds());
                return;
            }
            Point dim = getSize();

            // Create an image for double-buffering
            Image image = new Image(display, getBounds());

            // Set up the off-screen gc
            GC gcImage = new GC(image);
            if (mSetFonts)
                gcImage.setFont(mFontRegistry.get("medium"));  // $NON-NLS-1$

            if (mNumRows > 2) {
                // Draw the row background stripes
                gcImage.setBackground(mColorRowBack);
                for (int ii = 1; ii < mNumRows; ii += 2) {
                    RowData rd = mRows[ii];
                    int y1 = rd.mRank * rowYSpace - mScrollOffsetY;
                    gcImage.fillRectangle(0, y1, dim.x, rowYSpace);
                }
            }

            // Draw the row labels
            int offsetY = rowYMarginHalf - mScrollOffsetY;
            for (int ii = mStartRow; ii <= mEndRow; ++ii) {
                RowData rd = mRows[ii];
                int y1 = rd.mRank * rowYSpace + offsetY;
                Point extent = gcImage.stringExtent(rd.mName);
                int x1 = dim.x - extent.x - labelMarginX;
                gcImage.drawString(rd.mName, x1, y1, true);
            }

            // Draw a highlight box on the row where the mouse is.
            if (mMouseRow >= mStartRow && mMouseRow <= mEndRow) {
                gcImage.setForeground(mColorGray);
                int y1 = mMouseRow * rowYSpace - mScrollOffsetY;
                gcImage.drawRectangle(0, y1, dim.x, rowYSpace);
            }

            // Draw the off-screen buffer to the screen
            gc.drawImage(image, 0, 0);

            // Clean up
            image.dispose();
            gcImage.dispose();
        }
    }

    private class BlankCorner extends Canvas {
        public BlankCorner(Composite parent) {
            //super(parent, SWT.NO_BACKGROUND);
            super(parent, SWT.NONE);
            addPaintListener(new PaintListener() {
                public void paintControl(PaintEvent pe) {
                    draw(pe.display, pe.gc);
                }
            });
        }

        private void draw(Display display, GC gc) {
            // Create a blank image and draw it to the canvas
            Image image = new Image(display, getBounds());
            gc.drawImage(image, 0, 0);

            // Clean up
            image.dispose();
        }
    }

    private class Timescale extends Canvas {
        private Point mMouse = new Point(LeftMargin, 0);
        private Cursor mZoomCursor;
        private String mMethodName = null;
        private Color mMethodColor = null;
        private int mMethodStartY;
        private int mMarkStartX;
        private int mMarkEndX;

        /** The space between the colored block and the method name */
        private static final int METHOD_BLOCK_MARGIN = 10;

        public Timescale(Composite parent) {
            //super(parent, SWT.NO_BACKGROUND);
            super(parent, SWT.NONE);
            Display display = getDisplay();
            mZoomCursor = new Cursor(display, SWT.CURSOR_SIZEWE);
            setCursor(mZoomCursor);
            mMethodStartY = mSmallFontHeight + 1;
            addPaintListener(new PaintListener() {
                public void paintControl(PaintEvent pe) {
                    draw(pe.display, pe.gc);
                }
            });
        }

        public void setVbarPosition(int x) {
            mMouse.x = x;
        }

        public void setMarkStart(int x) {
            mMarkStartX = x;
        }

        public void setMarkEnd(int x) {
            mMarkEndX = x;
        }

        public void setMethodName(String name) {
            mMethodName = name;
        }

        public void setMethodColor(Color color) {
            mMethodColor = color;
        }

        private void mouseMove(MouseEvent me) {
            me.y = -1;
            mSurface.mouseMove(me);
        }

        private void mouseDown(MouseEvent me) {
            mSurface.startScaling(me.x);
            mSurface.redraw();
        }

        private void mouseUp(MouseEvent me) {
            mSurface.stopScaling(me.x);
        }

        private void mouseDoubleClick(MouseEvent me) {
            mSurface.resetScale();
            mSurface.redraw();
        }

        private void draw(Display display, GC gc) {
            Point dim = getSize();

            // Create an image for double-buffering
            Image image = new Image(display, getBounds());

            // Set up the off-screen gc
            GC gcImage = new GC(image);
            if (mSetFonts)
                gcImage.setFont(mFontRegistry.get("medium"));  // $NON-NLS-1$

            if (mSurface.drawingSelection()) {
                drawSelection(display, gcImage);
            }

            drawTicks(display, gcImage);

            // Draw the vertical bar where the mouse is
            gcImage.setForeground(mColorDarkGray);
            gcImage.drawLine(mMouse.x, timeLineOffsetY, mMouse.x, dim.y);

            // Draw the current millseconds
            drawTickLegend(display, gcImage);

            // Draw the method name and color, if needed
            drawMethod(display, gcImage);

            // Draw the off-screen buffer to the screen
            gc.drawImage(image, 0, 0);

            // Clean up
            image.dispose();
            gcImage.dispose();
        }

        private void drawSelection(Display display, GC gc) {
            Point dim = getSize();
            gc.setForeground(mColorGray);
            gc.drawLine(mMarkStartX, timeLineOffsetY, mMarkStartX, dim.y);
            gc.setBackground(mColorZoomSelection);
            int x, width;
            if (mMarkStartX < mMarkEndX) {
                x = mMarkStartX;
                width = mMarkEndX - mMarkStartX;
            } else {
                x = mMarkEndX;
                width = mMarkStartX - mMarkEndX;
            }
            if (width > 1) {
                gc.fillRectangle(x, timeLineOffsetY, width, dim.y);
            }
        }

        private void drawTickLegend(Display display, GC gc) {
            int mouseX = mMouse.x - LeftMargin;
            double mouseXval = mScaleInfo.pixelToValue(mouseX);
            String info = mUnits.labelledString(mouseXval);
            gc.setForeground(mColorForeground);
            gc.drawString(info, LeftMargin + 2, 1, true);

            // Display the maximum data value
            double maxVal = mScaleInfo.getMaxVal();
            info = mUnits.labelledString(maxVal);
            info = String.format(" max %s ", info);  // $NON-NLS-1$
            Point extent = gc.stringExtent(info);
            Point dim = getSize();
            int x1 = dim.x - RightMargin - extent.x;
            gc.drawString(info, x1, 1, true);
        }

        private void drawMethod(Display display, GC gc) {
            if (mMethodName == null) {
                return;
            }

            int x1 = LeftMargin;
            int y1 = mMethodStartY;
            gc.setBackground(mMethodColor);
            int width = 2 * mSmallFontWidth;
            gc.fillRectangle(x1, y1, width, mSmallFontHeight);
            x1 += width + METHOD_BLOCK_MARGIN;
            gc.drawString(mMethodName, x1, y1, true);
        }

        private void drawTicks(Display display, GC gc) {
            Point dim = getSize();
            int y2 = majorTickLength + timeLineOffsetY;
            int y3 = minorTickLength + timeLineOffsetY;
            int y4 = y2 + tickToFontSpacing;
            gc.setForeground(mColorForeground);
            gc.drawLine(LeftMargin, timeLineOffsetY, dim.x - RightMargin,
                    timeLineOffsetY);
            double minVal = mScaleInfo.getMinVal();
            double maxVal = mScaleInfo.getMaxVal();
            double minMajorTick = mScaleInfo.getMinMajorTick();
            double tickIncrement = mScaleInfo.getTickIncrement();
            double minorTickIncrement = tickIncrement / 5;
            double pixelsPerRange = mScaleInfo.getPixelsPerRange();

            // Draw the initial minor ticks, if any
            if (minVal < minMajorTick) {
                gc.setForeground(mColorGray);
                double xMinor = minMajorTick;
                for (int ii = 1; ii <= 4; ++ii) {
                    xMinor -= minorTickIncrement;
                    if (xMinor < minVal)
                        break;
                    int x1 = LeftMargin
                            + (int) (0.5 + (xMinor - minVal) * pixelsPerRange);
                    gc.drawLine(x1, timeLineOffsetY, x1, y3);
                }
            }

            if (tickIncrement <= 10) {
                // TODO avoid rendering the loop when tickIncrement is invalid. It can be zero
                // or too small.
                // System.out.println(String.format("Timescale.drawTicks error: tickIncrement=%1f", tickIncrement));
                return;
            }
            for (double x = minMajorTick; x <= maxVal; x += tickIncrement) {
                int x1 = LeftMargin
                        + (int) (0.5 + (x - minVal) * pixelsPerRange);

                // Draw a major tick
                gc.setForeground(mColorForeground);
                gc.drawLine(x1, timeLineOffsetY, x1, y2);
                if (x > maxVal)
                    break;

                // Draw the tick text
                String tickString = mUnits.valueOf(x);
                gc.drawString(tickString, x1, y4, true);

                // Draw 4 minor ticks between major ticks
                gc.setForeground(mColorGray);
                double xMinor = x;
                for (int ii = 1; ii <= 4; ii++) {
                    xMinor += minorTickIncrement;
                    if (xMinor > maxVal)
                        break;
                    x1 = LeftMargin
                            + (int) (0.5 + (xMinor - minVal) * pixelsPerRange);
                    gc.drawLine(x1, timeLineOffsetY, x1, y3);
                }
            }
        }
    }

    private static enum GraphicsState {
        Normal, Marking, Scaling, Animating
    };

    private class Surface extends Canvas {

        public Surface(Composite parent) {
            super(parent, SWT.NO_BACKGROUND | SWT.V_SCROLL);
            Display display = getDisplay();
            mNormalCursor = new Cursor(display, SWT.CURSOR_CROSS);
            mIncreasingCursor = new Cursor(display, SWT.CURSOR_SIZEE);
            mDecreasingCursor = new Cursor(display, SWT.CURSOR_SIZEW);

            initZoomFractionsWithExp();

            addPaintListener(new PaintListener() {
                public void paintControl(PaintEvent pe) {
                    draw(pe.display, pe.gc);
                }
            });

            mZoomAnimator = new Runnable() {
                public void run() {
                    animateZoom();
                }
            };

            mHighlightAnimator = new Runnable() {
                public void run() {
                    animateHighlight();
                }
            };
        }

        private void initZoomFractionsWithExp() {
            mZoomFractions = new double[ZOOM_STEPS];
            int next = 0;
            for (int ii = 0; ii < ZOOM_STEPS / 2; ++ii, ++next) {
                mZoomFractions[next] = (double) (1 << ii)
                        / (double) (1 << (ZOOM_STEPS / 2));
                // System.out.printf("%d %f\n", next, zoomFractions[next]);
            }
            for (int ii = 2; ii < 2 + ZOOM_STEPS / 2; ++ii, ++next) {
                mZoomFractions[next] = (double) ((1 << ii) - 1)
                        / (double) (1 << ii);
                // System.out.printf("%d %f\n", next, zoomFractions[next]);
            }
        }

        @SuppressWarnings("unused")
        private void initZoomFractionsWithSinWave() {
            mZoomFractions = new double[ZOOM_STEPS];
            for (int ii = 0; ii < ZOOM_STEPS; ++ii) {
                double offset = Math.PI * (double) ii / (double) ZOOM_STEPS;
                mZoomFractions[ii] = (Math.sin((1.5 * Math.PI + offset)) + 1.0) / 2.0;
                // System.out.printf("%d %f\n", ii, zoomFractions[ii]);
            }
        }

        public void setRange(double minVal, double maxVal) {
            mMinDataVal = minVal;
            mMaxDataVal = maxVal;
            mScaleInfo.setMinVal(minVal);
            mScaleInfo.setMaxVal(maxVal);
        }

        public void setLimitRange(double minVal, double maxVal) {
            mLimitMinVal = minVal;
            mLimitMaxVal = maxVal;
        }

        public void resetScale() {
            mScaleInfo.setMinVal(mLimitMinVal);
            mScaleInfo.setMaxVal(mLimitMaxVal);
        }

        private void draw(Display display, GC gc) {
            if (mSegments.length == 0) {
                // gc.setBackground(colorBackground);
                // gc.fillRectangle(getBounds());
                return;
            }

            // Create an image for double-buffering
            Image image = new Image(display, getBounds());

            // Set up the off-screen gc
            GC gcImage = new GC(image);
            if (mSetFonts)
                gcImage.setFont(mFontRegistry.get("small"));  // $NON-NLS-1$

            // Draw the background
            // gcImage.setBackground(colorBackground);
            // gcImage.fillRectangle(image.getBounds());

            if (mGraphicsState == GraphicsState.Scaling) {
                double diff = mMouse.x - mMouseMarkStartX;
                if (diff > 0) {
                    double newMinVal = mScaleMinVal - diff / mScalePixelsPerRange;
                    if (newMinVal < mLimitMinVal)
                        newMinVal = mLimitMinVal;
                    mScaleInfo.setMinVal(newMinVal);
                    // System.out.printf("diff %f scaleMin %f newMin %f\n",
                    // diff, scaleMinVal, newMinVal);
                } else if (diff < 0) {
                    double newMaxVal = mScaleMaxVal - diff / mScalePixelsPerRange;
                    if (newMaxVal > mLimitMaxVal)
                        newMaxVal = mLimitMaxVal;
                    mScaleInfo.setMaxVal(newMaxVal);
                    // System.out.printf("diff %f scaleMax %f newMax %f\n",
                    // diff, scaleMaxVal, newMaxVal);
                }
            }

            // Recompute the ticks and strips only if the size has changed,
            // or we scrolled so that a new row is visible.
            Point dim = getSize();
            if (mStartRow != mCachedStartRow || mEndRow != mCachedEndRow
                    || mScaleInfo.getMinVal() != mCachedMinVal
                    || mScaleInfo.getMaxVal() != mCachedMaxVal) {
                mCachedStartRow = mStartRow;
                mCachedEndRow = mEndRow;
                int xdim = dim.x - TotalXMargin;
                mScaleInfo.setNumPixels(xdim);
                boolean forceEndPoints = (mGraphicsState == GraphicsState.Scaling
                        || mGraphicsState == GraphicsState.Animating);
                mScaleInfo.computeTicks(forceEndPoints);
                mCachedMinVal = mScaleInfo.getMinVal();
                mCachedMaxVal = mScaleInfo.getMaxVal();
                if (mLimitMinVal > mScaleInfo.getMinVal())
                    mLimitMinVal = mScaleInfo.getMinVal();
                if (mLimitMaxVal < mScaleInfo.getMaxVal())
                    mLimitMaxVal = mScaleInfo.getMaxVal();

                // Compute the strips
                computeStrips();
            }

            if (mNumRows > 2) {
                // Draw the row background stripes
                gcImage.setBackground(mColorRowBack);
                for (int ii = 1; ii < mNumRows; ii += 2) {
                    RowData rd = mRows[ii];
                    int y1 = rd.mRank * rowYSpace - mScrollOffsetY;
                    gcImage.fillRectangle(0, y1, dim.x, rowYSpace);
                }
            }

            if (drawingSelection()) {
                drawSelection(display, gcImage);
            }

            String blockName = null;
            Color blockColor = null;

            if (mDebug) {
                double pixelsPerRange = mScaleInfo.getPixelsPerRange();
                System.out
                        .printf(
                                "dim.x %d pixels %d minVal %f, maxVal %f ppr %f rpp %f\n",
                                dim.x, dim.x - TotalXMargin, mScaleInfo
                                        .getMinVal(), mScaleInfo.getMaxVal(),
                                pixelsPerRange, 1.0 / pixelsPerRange);
            }

            // Draw the strips
            Block selectBlock = null;
            for (Strip strip : mStripList) {
                if (strip.mColor == null) {
                    // System.out.printf("strip.color is null\n");
                    continue;
                }
                gcImage.setBackground(strip.mColor);
                gcImage.fillRectangle(strip.mX, strip.mY - mScrollOffsetY, strip.mWidth,
                        strip.mHeight);
                if (mMouseRow == strip.mRowData.mRank) {
                    if (mMouse.x >= strip.mX
                            && mMouse.x < strip.mX + strip.mWidth) {
                        blockName = strip.mSegment.mBlock.getName();
                        blockColor = strip.mColor;
                    }
                    if (mMouseSelect.x >= strip.mX
                            && mMouseSelect.x < strip.mX + strip.mWidth) {
                        selectBlock = strip.mSegment.mBlock;
                    }
                }
            }
            mMouseSelect.x = 0;
            mMouseSelect.y = 0;

            if (selectBlock != null) {
                ArrayList<Selection> selections = new ArrayList<Selection>();
                // Get the row label
                RowData rd = mRows[mMouseRow];
                selections.add(Selection.highlight("Thread", rd.mName));  // $NON-NLS-1$
                selections.add(Selection.highlight("Call", selectBlock));  // $NON-NLS-1$

                int mouseX = mMouse.x - LeftMargin;
                double mouseXval = mScaleInfo.pixelToValue(mouseX);
                selections.add(Selection.highlight("Time", mouseXval));  // $NON-NLS-1$

                mSelectionController.change(selections, "TimeLineView");  // $NON-NLS-1$
                mHighlightMethodData = null;
                mHighlightCall = (Call) selectBlock;
                startHighlighting();
            }

            // Draw a highlight box on the row where the mouse is.
            // Except don't draw the box if we are animating the
            // highlighing of a call or method because the inclusive
            // highlight bar passes through the highlight box and
            // causes an annoying flashing artifact.
            if (mMouseRow >= 0 && mMouseRow < mNumRows && mHighlightStep == 0) {
                gcImage.setForeground(mColorGray);
                int y1 = mMouseRow * rowYSpace - mScrollOffsetY;
                gcImage.drawLine(0, y1, dim.x, y1);
                gcImage.drawLine(0, y1 + rowYSpace, dim.x, y1 + rowYSpace);
            }

            // Highlight a selected method, if any
            drawHighlights(gcImage, dim);

            // Draw a vertical line where the mouse is.
            gcImage.setForeground(mColorDarkGray);
            int lineEnd = Math.min(dim.y, mNumRows * rowYSpace);
            gcImage.drawLine(mMouse.x, 0, mMouse.x, lineEnd);

            if (blockName != null) {
                mTimescale.setMethodName(blockName);
                mTimescale.setMethodColor(blockColor);
                mShowHighlightName = false;
            } else if (mShowHighlightName) {
                // Draw the highlighted method name
                MethodData md = mHighlightMethodData;
                if (md == null && mHighlightCall != null)
                    md = mHighlightCall.getMethodData();
                if (md == null)
                    System.out.printf("null highlight?\n");  // $NON-NLS-1$
                if (md != null) {
                    mTimescale.setMethodName(md.getProfileName());
                    mTimescale.setMethodColor(md.getColor());
                }
            } else {
                mTimescale.setMethodName(null);
                mTimescale.setMethodColor(null);
            }
            mTimescale.redraw();

            // Draw the off-screen buffer to the screen
            gc.drawImage(image, 0, 0);

            // Clean up
            image.dispose();
            gcImage.dispose();
        }

        private void drawHighlights(GC gc, Point dim) {
            int height = highlightHeight;
            if (height <= 0)
                return;
            for (Range range : mHighlightExclusive) {
                gc.setBackground(range.mColor);
                int xStart = range.mXdim.x;
                int width = range.mXdim.y;
                gc.fillRectangle(xStart, range.mY - height - mScrollOffsetY, width, height);
            }

            // Draw the inclusive lines a bit shorter
            height -= 1;
            if (height <= 0)
                height = 1;

            // Highlight the inclusive ranges
            gc.setForeground(mColorDarkGray);
            gc.setBackground(mColorDarkGray);
            for (Range range : mHighlightInclusive) {
                int x1 = range.mXdim.x;
                int x2 = range.mXdim.y;
                boolean drawLeftEnd = false;
                boolean drawRightEnd = false;
                if (x1 >= LeftMargin)
                    drawLeftEnd = true;
                else
                    x1 = LeftMargin;
                if (x2 >= LeftMargin)
                    drawRightEnd = true;
                else
                    x2 = dim.x - RightMargin;
                int y1 = range.mY + rowHeight + 2 - mScrollOffsetY;

                // If the range is very narrow, then just draw a small
                // rectangle.
                if (x2 - x1 < MinInclusiveRange) {
                    int width = x2 - x1;
                    if (width < 2)
                        width = 2;
                    gc.fillRectangle(x1, y1, width, height);
                    continue;
                }
                if (drawLeftEnd) {
                    if (drawRightEnd) {
                        // Draw both ends
                        int[] points = { x1, y1, x1, y1 + height, x2,
                                y1 + height, x2, y1 };
                        gc.drawPolyline(points);
                    } else {
                        // Draw the left end
                        int[] points = { x1, y1, x1, y1 + height, x2,
                                y1 + height };
                        gc.drawPolyline(points);
                    }
                } else {
                    if (drawRightEnd) {
                        // Draw the right end
                        int[] points = { x1, y1 + height, x2, y1 + height, x2,
                                y1 };
                        gc.drawPolyline(points);
                    } else {
                        // Draw neither end, just the line
                        int[] points = { x1, y1 + height, x2, y1 + height };
                        gc.drawPolyline(points);
                    }
                }

                // Draw the arrowheads, if necessary
                if (drawLeftEnd == false) {
                    int[] points = { x1 + 7, y1 + height - 4, x1, y1 + height,
                            x1 + 7, y1 + height + 4 };
                    gc.fillPolygon(points);
                }
                if (drawRightEnd == false) {
                    int[] points = { x2 - 7, y1 + height - 4, x2, y1 + height,
                            x2 - 7, y1 + height + 4 };
                    gc.fillPolygon(points);
                }
            }
        }

        private boolean drawingSelection() {
            return mGraphicsState == GraphicsState.Marking
                    || mGraphicsState == GraphicsState.Animating;
        }

        private void drawSelection(Display display, GC gc) {
            Point dim = getSize();
            gc.setForeground(mColorGray);
            gc.drawLine(mMouseMarkStartX, 0, mMouseMarkStartX, dim.y);
            gc.setBackground(mColorZoomSelection);
            int width;
            int mouseX = (mGraphicsState == GraphicsState.Animating) ? mMouseMarkEndX : mMouse.x;
            int x;
            if (mMouseMarkStartX < mouseX) {
                x = mMouseMarkStartX;
                width = mouseX - mMouseMarkStartX;
            } else {
                x = mouseX;
                width = mMouseMarkStartX - mouseX;
            }
            gc.fillRectangle(x, 0, width, dim.y);
        }

        private void computeStrips() {
            double minVal = mScaleInfo.getMinVal();
            double maxVal = mScaleInfo.getMaxVal();

            // Allocate space for the pixel data
            Pixel[] pixels = new Pixel[mNumRows];
            for (int ii = 0; ii < mNumRows; ++ii)
                pixels[ii] = new Pixel();

            // Clear the per-block pixel data
            for (int ii = 0; ii < mSegments.length; ++ii) {
                mSegments[ii].mBlock.clearWeight();
            }

            mStripList.clear();
            mHighlightExclusive.clear();
            mHighlightInclusive.clear();
            MethodData callMethod = null;
            long callStart = 0;
            long callEnd = -1;
            RowData callRowData = null;
            int prevMethodStart = -1;
            int prevCallStart = -1;
            if (mHighlightCall != null) {
                int callPixelStart = -1;
                int callPixelEnd = -1;
                callStart = mHighlightCall.mGlobalStartTime;
                callEnd = mHighlightCall.mGlobalEndTime;
                callMethod = mHighlightCall.mMethodData;
                if (callStart >= minVal)
                    callPixelStart = mScaleInfo.valueToPixel(callStart);
                if (callEnd <= maxVal)
                    callPixelEnd = mScaleInfo.valueToPixel(callEnd);
                // System.out.printf("callStart,End %d,%d minVal,maxVal %f,%f
                // callPixelStart,End %d,%d\n",
                // callStart, callEnd, minVal, maxVal, callPixelStart,
                // callPixelEnd);
                int threadId = mHighlightCall.getThreadId();
                String threadName = mThreadLabels.get(threadId);
                callRowData = mRowByName.get(threadName);
                int y1 = callRowData.mRank * rowYSpace + rowYMarginHalf;
                Color color = callMethod.getColor();
                mHighlightInclusive.add(new Range(callPixelStart + LeftMargin,
                        callPixelEnd + LeftMargin, y1, color));
            }
            for (Segment segment : mSegments) {
                if (segment.mEndTime <= minVal)
                    continue;
                if (segment.mStartTime >= maxVal)
                    continue;
                Block block = segment.mBlock;
                Color color = block.getColor();
                if (color == null)
                    continue;

                double recordStart = Math.max(segment.mStartTime, minVal);
                double recordEnd = Math.min(segment.mEndTime, maxVal);
                if (recordStart == recordEnd)
                    continue;
                int pixelStart = mScaleInfo.valueToPixel(recordStart);
                int pixelEnd = mScaleInfo.valueToPixel(recordEnd);
                int width = pixelEnd - pixelStart;

                RowData rd = segment.mRowData;
                MethodData md = block.getMethodData();

                // We will add the scroll offset later when we draw the strips
                int y1 = rd.mRank * rowYSpace + rowYMarginHalf;

                // If we can't display any more rows, then quit
                if (rd.mRank > mEndRow)
                    break;

                // System.out.printf("segment %s val: [%.1f, %.1f] frac [%f, %f]
                // pixel: [%d, %d] pix.start %d weight %.2f %s\n",
                // block.getName(), recordStart, recordEnd,
                // scaleInfo.valueToPixelFraction(recordStart),
                // scaleInfo.valueToPixelFraction(recordEnd),
                // pixelStart, pixelEnd, pixels[rd.rank].start,
                // pixels[rd.rank].maxWeight,
                // pixels[rd.rank].segment != null
                // ? pixels[rd.rank].segment.block.getName()
                // : "null");

                if (mHighlightMethodData != null) {
                    if (mHighlightMethodData == md) {
                        if (prevMethodStart != pixelStart) {
                            prevMethodStart = pixelStart;
                            int rangeWidth = width;
                            if (rangeWidth == 0)
                                rangeWidth = 1;
                            mHighlightExclusive.add(new Range(pixelStart
                                    + LeftMargin, rangeWidth, y1, color));
                            Call call = (Call) block;
                            callStart = call.mGlobalStartTime;
                            int callPixelStart = -1;
                            if (callStart >= minVal)
                                callPixelStart = mScaleInfo.valueToPixel(callStart);
                            if (prevCallStart != callPixelStart) {
                                prevCallStart = callPixelStart;
                                int callPixelEnd = -1;
                                callEnd = call.mGlobalEndTime;
                                if (callEnd <= maxVal)
                                    callPixelEnd = mScaleInfo.valueToPixel(callEnd);
                                mHighlightInclusive.add(new Range(
                                        callPixelStart + LeftMargin,
                                        callPixelEnd + LeftMargin, y1, color));
                            }
                        }
                    } else if (mFadeColors) {
                        color = md.getFadedColor();
                    }
                } else if (mHighlightCall != null) {
                    if (segment.mStartTime >= callStart
                            && segment.mEndTime <= callEnd && callMethod == md
                            && callRowData == rd) {
                        if (prevMethodStart != pixelStart) {
                            prevMethodStart = pixelStart;
                            int rangeWidth = width;
                            if (rangeWidth == 0)
                                rangeWidth = 1;
                            mHighlightExclusive.add(new Range(pixelStart
                                    + LeftMargin, rangeWidth, y1, color));
                        }
                    } else if (mFadeColors) {
                        color = md.getFadedColor();
                    }
                }

                // Cases:
                // 1. This segment starts on a different pixel than the
                // previous segment started on. In this case, emit
                // the pixel strip, if any, and:
                // A. If the width is 0, then add this segment's
                // weight to the Pixel.
                // B. If the width > 0, then emit a strip for this
                // segment (no partial Pixel data).
                //
                // 2. Otherwise (the new segment starts on the same
                // pixel as the previous segment): add its "weight"
                // to the current pixel, and:
                // A. If the new segment has width 1,
                // then emit the pixel strip and then
                // add the segment's weight to the pixel.
                // B. If the new segment has width > 1,
                // then emit the pixel strip, and emit the rest
                // of the strip for this segment (no partial Pixel
                // data).

                Pixel pix = pixels[rd.mRank];
                if (pix.mStart != pixelStart) {
                    if (pix.mSegment != null) {
                        // Emit the pixel strip. This also clears the pixel.
                        emitPixelStrip(rd, y1, pix);
                    }

                    if (width == 0) {
                        // Compute the "weight" of this segment for the first
                        // pixel. For a pixel N, the "weight" of a segment is
                        // how much of the region [N - 0.5, N + 0.5] is covered
                        // by the segment.
                        double weight = computeWeight(recordStart, recordEnd,
                                pixelStart);
                        weight = block.addWeight(pixelStart, rd.mRank, weight);
                        if (weight > pix.mMaxWeight) {
                            pix.setFields(pixelStart, weight, segment, color,
                                    rd);
                        }
                    } else {
                        int x1 = pixelStart + LeftMargin;
                        Strip strip = new Strip(x1, y1, width, rowHeight, rd,
                                segment, color);
                        mStripList.add(strip);
                    }
                } else {
                    double weight = computeWeight(recordStart, recordEnd,
                            pixelStart);
                    weight = block.addWeight(pixelStart, rd.mRank, weight);
                    if (weight > pix.mMaxWeight) {
                        pix.setFields(pixelStart, weight, segment, color, rd);
                    }
                    if (width == 1) {
                        // Emit the pixel strip. This also clears the pixel.
                        emitPixelStrip(rd, y1, pix);

                        // Compute the weight for the next pixel
                        pixelStart += 1;
                        weight = computeWeight(recordStart, recordEnd,
                                pixelStart);
                        weight = block.addWeight(pixelStart, rd.mRank, weight);
                        pix.setFields(pixelStart, weight, segment, color, rd);
                    } else if (width > 1) {
                        // Emit the pixel strip. This also clears the pixel.
                        emitPixelStrip(rd, y1, pix);

                        // Emit a strip for the rest of the segment.
                        pixelStart += 1;
                        width -= 1;
                        int x1 = pixelStart + LeftMargin;
                        Strip strip = new Strip(x1, y1, width, rowHeight, rd,
                                segment, color);
                        mStripList.add(strip);
                    }
                }
            }

            // Emit the last pixels of each row, if any
            for (int ii = 0; ii < mNumRows; ++ii) {
                Pixel pix = pixels[ii];
                if (pix.mSegment != null) {
                    RowData rd = pix.mRowData;
                    int y1 = rd.mRank * rowYSpace + rowYMarginHalf;
                    // Emit the pixel strip. This also clears the pixel.
                    emitPixelStrip(rd, y1, pix);
                }
            }

            if (false) {
                System.out.printf("computeStrips()\n");
                for (Strip strip : mStripList) {
                    System.out.printf("%3d, %3d width %3d height %d %s\n",
                            strip.mX, strip.mY, strip.mWidth, strip.mHeight,
                            strip.mSegment.mBlock.getName());
                }
            }
        }

        private double computeWeight(double start, double end, int pixel) {
            double pixelStartFraction = mScaleInfo.valueToPixelFraction(start);
            double pixelEndFraction = mScaleInfo.valueToPixelFraction(end);
            double leftEndPoint = Math.max(pixelStartFraction, pixel - 0.5);
            double rightEndPoint = Math.min(pixelEndFraction, pixel + 0.5);
            double weight = rightEndPoint - leftEndPoint;
            return weight;
        }

        private void emitPixelStrip(RowData rd, int y, Pixel pixel) {
            Strip strip;

            if (pixel.mSegment == null)
                return;

            int x = pixel.mStart + LeftMargin;
            // Compute the percentage of the row height proportional to
            // the weight of this pixel. But don't let the proportion
            // exceed 3/4 of the row height so that we can easily see
            // if a given time range includes more than one method.
            int height = (int) (pixel.mMaxWeight * rowHeight * 0.75);
            if (height < mMinStripHeight)
                height = mMinStripHeight;
            int remainder = rowHeight - height;
            if (remainder > 0) {
                strip = new Strip(x, y, 1, remainder, rd, pixel.mSegment,
                        mFadeColors ? mColorGray : mColorBlack);
                mStripList.add(strip);
                // System.out.printf("emitPixel (%d, %d) height %d black\n",
                // x, y, remainder);
            }
            strip = new Strip(x, y + remainder, 1, height, rd, pixel.mSegment,
                    pixel.mColor);
            mStripList.add(strip);
            // System.out.printf("emitPixel (%d, %d) height %d %s\n",
            // x, y + remainder, height, pixel.segment.block.getName());
            pixel.mSegment = null;
            pixel.mMaxWeight = 0.0;
        }

        private void mouseMove(MouseEvent me) {
            if (false) {
                if (mHighlightMethodData != null) {
                    mHighlightMethodData = null;
                    // Force a recomputation of the strip colors
                    mCachedEndRow = -1;
                }
            }
            Point dim = mSurface.getSize();
            int x = me.x;
            if (x < LeftMargin)
                x = LeftMargin;
            if (x > dim.x - RightMargin)
                x = dim.x - RightMargin;
            mMouse.x = x;
            mMouse.y = me.y;
            mTimescale.setVbarPosition(x);
            if (mGraphicsState == GraphicsState.Marking) {
                mTimescale.setMarkEnd(x);
            }

            if (mGraphicsState == GraphicsState.Normal) {
                // Set the cursor to the normal state.
                mSurface.setCursor(mNormalCursor);
            } else if (mGraphicsState == GraphicsState.Marking) {
                // Make the cursor point in the direction of the sweep
                if (mMouse.x >= mMouseMarkStartX)
                    mSurface.setCursor(mIncreasingCursor);
                else
                    mSurface.setCursor(mDecreasingCursor);
            }
            int rownum = (mMouse.y + mScrollOffsetY) / rowYSpace;
            if (me.y < 0 || me.y >= dim.y) {
                rownum = -1;
            }
            if (mMouseRow != rownum) {
                mMouseRow = rownum;
                mLabels.redraw();
            }
            redraw();
        }

        private void mouseDown(MouseEvent me) {
            Point dim = mSurface.getSize();
            int x = me.x;
            if (x < LeftMargin)
                x = LeftMargin;
            if (x > dim.x - RightMargin)
                x = dim.x - RightMargin;
            mMouseMarkStartX = x;
            mGraphicsState = GraphicsState.Marking;
            mSurface.setCursor(mIncreasingCursor);
            mTimescale.setMarkStart(mMouseMarkStartX);
            mTimescale.setMarkEnd(mMouseMarkStartX);
            redraw();
        }

        private void mouseUp(MouseEvent me) {
            mSurface.setCursor(mNormalCursor);
            if (mGraphicsState != GraphicsState.Marking) {
                mGraphicsState = GraphicsState.Normal;
                return;
            }
            mGraphicsState = GraphicsState.Animating;
            Point dim = mSurface.getSize();

            // If the user released the mouse outside the drawing area then
            // cancel the zoom.
            if (me.y <= 0 || me.y >= dim.y) {
                mGraphicsState = GraphicsState.Normal;
                redraw();
                return;
            }

            int x = me.x;
            if (x < LeftMargin)
                x = LeftMargin;
            if (x > dim.x - RightMargin)
                x = dim.x - RightMargin;
            mMouseMarkEndX = x;

            // If the user clicked and released the mouse at the same point
            // (+/- a pixel or two) then cancel the zoom (but select the
            // method).
            int dist = mMouseMarkEndX - mMouseMarkStartX;
            if (dist < 0)
                dist = -dist;
            if (dist <= 2) {
                mGraphicsState = GraphicsState.Normal;

                // Select the method underneath the mouse
                mMouseSelect.x = mMouseMarkStartX;
                mMouseSelect.y = me.y;
                redraw();
                return;
            }

            // Make mouseEndX be the higher end point
            if (mMouseMarkEndX < mMouseMarkStartX) {
                int temp = mMouseMarkEndX;
                mMouseMarkEndX = mMouseMarkStartX;
                mMouseMarkStartX = temp;
            }

            // If the zoom area is the whole window (or nearly the whole
            // window) then cancel the zoom.
            if (mMouseMarkStartX <= LeftMargin + MinZoomPixelMargin
                    && mMouseMarkEndX >= dim.x - RightMargin - MinZoomPixelMargin) {
                mGraphicsState = GraphicsState.Normal;
                redraw();
                return;
            }

            // Compute some variables needed for zooming.
            // It's probably easiest to explain by an example. There
            // are two scales (or dimensions) involved: one for the pixels
            // and one for the values (microseconds). To keep the example
            // simple, suppose we have pixels in the range [0,16] and
            // values in the range [100, 260], and suppose the user
            // selects a zoom window from pixel 4 to pixel 8.
            //
            // usec: 100 140 180 260
            // |-------|ZZZZZZZ|---------------|
            // pixel: 0 4 8 16
            //
            // I've drawn the pixels starting at zero for simplicity, but
            // in fact the drawable area is offset from the left margin
            // by the value of "LeftMargin".
            //
            // The "pixels-per-range" (ppr) in this case is 0.1 (a tenth of
            // a pixel per usec). What we want is to redraw the screen in
            // several steps, each time increasing the zoom window until the
            // zoom window fills the screen. For simplicity, assume that
            // we want to zoom in four equal steps. Then the snapshots
            // of the screen at each step would look something like this:
            //
            // usec: 100 140 180 260
            // |-------|ZZZZZZZ|---------------|
            // pixel: 0 4 8 16
            //
            // usec: ? 140 180 ?
            // |-----|ZZZZZZZZZZZZZ|-----------|
            // pixel: 0 3 10 16
            //
            // usec: ? 140 180 ?
            // |---|ZZZZZZZZZZZZZZZZZZZ|-------|
            // pixel: 0 2 12 16
            //
            // usec: ?140 180 ?
            // |-|ZZZZZZZZZZZZZZZZZZZZZZZZZ|---|
            // pixel: 0 1 14 16
            //
            // usec: 140 180
            // |ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ|
            // pixel: 0 16
            //
            // The problem is how to compute the endpoints (denoted by ?)
            // for each step. This is a little tricky. We first need to
            // compute the "fixed point": this is the point in the selection
            // that doesn't move left or right. Then we can recompute the
            // "ppr" (pixels per range) at each step and then find the
            // endpoints. The computation of the end points is done
            // in animateZoom(). This method computes the fixed point
            // and some other variables needed in animateZoom().

            double minVal = mScaleInfo.getMinVal();
            double maxVal = mScaleInfo.getMaxVal();
            double ppr = mScaleInfo.getPixelsPerRange();
            mZoomMin = minVal + ((mMouseMarkStartX - LeftMargin) / ppr);
            mZoomMax = minVal + ((mMouseMarkEndX - LeftMargin) / ppr);

            // Clamp the min and max values to the actual data min and max
            if (mZoomMin < mMinDataVal)
                mZoomMin = mMinDataVal;
            if (mZoomMax > mMaxDataVal)
                mZoomMax = mMaxDataVal;

            // Snap the min and max points to the grid determined by the
            // TickScaler
            // before we zoom.
            int xdim = dim.x - TotalXMargin;
            TickScaler scaler = new TickScaler(mZoomMin, mZoomMax, xdim,
                    PixelsPerTick);
            scaler.computeTicks(false);
            mZoomMin = scaler.getMinVal();
            mZoomMax = scaler.getMaxVal();

            // Also snap the mouse points (in pixel space) to be consistent with
            // zoomMin and zoomMax (in value space).
            mMouseMarkStartX = (int) ((mZoomMin - minVal) * ppr + LeftMargin);
            mMouseMarkEndX = (int) ((mZoomMax - minVal) * ppr + LeftMargin);
            mTimescale.setMarkStart(mMouseMarkStartX);
            mTimescale.setMarkEnd(mMouseMarkEndX);

            // Compute the mouse selection end point distances
            mMouseEndDistance = dim.x - RightMargin - mMouseMarkEndX;
            mMouseStartDistance = mMouseMarkStartX - LeftMargin;
            mZoomMouseStart = mMouseMarkStartX;
            mZoomMouseEnd = mMouseMarkEndX;
            mZoomStep = 0;

            // Compute the fixed point in both value space and pixel space.
            mMin2ZoomMin = mZoomMin - minVal;
            mZoomMax2Max = maxVal - mZoomMax;
            mZoomFixed = mZoomMin + (mZoomMax - mZoomMin) * mMin2ZoomMin
                    / (mMin2ZoomMin + mZoomMax2Max);
            mZoomFixedPixel = (mZoomFixed - minVal) * ppr + LeftMargin;
            mFixedPixelStartDistance = mZoomFixedPixel - LeftMargin;
            mFixedPixelEndDistance = dim.x - RightMargin - mZoomFixedPixel;

            mZoomMin2Fixed = mZoomFixed - mZoomMin;
            mFixed2ZoomMax = mZoomMax - mZoomFixed;

            getDisplay().timerExec(ZOOM_TIMER_INTERVAL, mZoomAnimator);
            redraw();
            update();
        }

        // No defined behavior yet for double-click.
        private void mouseDoubleClick(MouseEvent me) {
        }

        public void startScaling(int mouseX) {
            Point dim = mSurface.getSize();
            int x = mouseX;
            if (x < LeftMargin)
                x = LeftMargin;
            if (x > dim.x - RightMargin)
                x = dim.x - RightMargin;
            mMouseMarkStartX = x;
            mGraphicsState = GraphicsState.Scaling;
            mScalePixelsPerRange = mScaleInfo.getPixelsPerRange();
            mScaleMinVal = mScaleInfo.getMinVal();
            mScaleMaxVal = mScaleInfo.getMaxVal();
        }

        public void stopScaling(int mouseX) {
            mGraphicsState = GraphicsState.Normal;
        }

        private void animateHighlight() {
            mHighlightStep += 1;
            if (mHighlightStep >= HIGHLIGHT_STEPS) {
                mFadeColors = false;
                mHighlightStep = 0;
                // Force a recomputation of the strip colors
                mCachedEndRow = -1;
            } else {
                mFadeColors = true;
                mShowHighlightName = true;
                highlightHeight = highlightHeights[mHighlightStep];
                getDisplay().timerExec(HIGHLIGHT_TIMER_INTERVAL, mHighlightAnimator);
            }
            redraw();
        }

        private void clearHighlights() {
            // System.out.printf("clearHighlights()\n");
            mShowHighlightName = false;
            highlightHeight = 0;
            mHighlightMethodData = null;
            mHighlightCall = null;
            mFadeColors = false;
            mHighlightStep = 0;
            // Force a recomputation of the strip colors
            mCachedEndRow = -1;
            redraw();
        }

        private void animateZoom() {
            mZoomStep += 1;
            if (mZoomStep > ZOOM_STEPS) {
                mGraphicsState = GraphicsState.Normal;
                // Force a normal recomputation
                mCachedMinVal = mScaleInfo.getMinVal() + 1;
            } else if (mZoomStep == ZOOM_STEPS) {
                mScaleInfo.setMinVal(mZoomMin);
                mScaleInfo.setMaxVal(mZoomMax);
                mMouseMarkStartX = LeftMargin;
                Point dim = getSize();
                mMouseMarkEndX = dim.x - RightMargin;
                mTimescale.setMarkStart(mMouseMarkStartX);
                mTimescale.setMarkEnd(mMouseMarkEndX);
                getDisplay().timerExec(ZOOM_TIMER_INTERVAL, mZoomAnimator);
            } else {
                // Zoom in slowly at first, then speed up, then slow down.
                // The zoom fractions are precomputed to save time.
                double fraction = mZoomFractions[mZoomStep];
                mMouseMarkStartX = (int) (mZoomMouseStart - fraction * mMouseStartDistance);
                mMouseMarkEndX = (int) (mZoomMouseEnd + fraction * mMouseEndDistance);
                mTimescale.setMarkStart(mMouseMarkStartX);
                mTimescale.setMarkEnd(mMouseMarkEndX);

                // Compute the new pixels-per-range. Avoid division by zero.
                double ppr;
                if (mZoomMin2Fixed >= mFixed2ZoomMax)
                    ppr = (mZoomFixedPixel - mMouseMarkStartX) / mZoomMin2Fixed;
                else
                    ppr = (mMouseMarkEndX - mZoomFixedPixel) / mFixed2ZoomMax;
                double newMin = mZoomFixed - mFixedPixelStartDistance / ppr;
                double newMax = mZoomFixed + mFixedPixelEndDistance / ppr;
                mScaleInfo.setMinVal(newMin);
                mScaleInfo.setMaxVal(newMax);

                getDisplay().timerExec(ZOOM_TIMER_INTERVAL, mZoomAnimator);
            }
            redraw();
        }

        private static final int TotalXMargin = LeftMargin + RightMargin;
        private static final int yMargin = 1; // blank space on top
        // The minimum margin on each side of the zoom window, in pixels.
        private static final int MinZoomPixelMargin = 10;
        private GraphicsState mGraphicsState = GraphicsState.Normal;
        private Point mMouse = new Point(LeftMargin, 0);
        private int mMouseMarkStartX;
        private int mMouseMarkEndX;
        private boolean mDebug = false;
        private ArrayList<Strip> mStripList = new ArrayList<Strip>();
        private ArrayList<Range> mHighlightExclusive = new ArrayList<Range>();
        private ArrayList<Range> mHighlightInclusive = new ArrayList<Range>();
        private int mMinStripHeight = 2;
        private double mCachedMinVal;
        private double mCachedMaxVal;
        private int mCachedStartRow;
        private int mCachedEndRow;
        private double mScalePixelsPerRange;
        private double mScaleMinVal;
        private double mScaleMaxVal;
        private double mLimitMinVal;
        private double mLimitMaxVal;
        private double mMinDataVal;
        private double mMaxDataVal;
        private Cursor mNormalCursor;
        private Cursor mIncreasingCursor;
        private Cursor mDecreasingCursor;
        private static final int ZOOM_TIMER_INTERVAL = 10;
        private static final int HIGHLIGHT_TIMER_INTERVAL = 50;
        private static final int ZOOM_STEPS = 8; // must be even
        private int highlightHeight = 4;
        private final int[] highlightHeights = { 0, 2, 4, 5, 6, 5, 4, 2, 4, 5,
                6 };
        private final int HIGHLIGHT_STEPS = highlightHeights.length;
        private boolean mFadeColors;
        private boolean mShowHighlightName;
        private double[] mZoomFractions;
        private int mZoomStep;
        private int mZoomMouseStart;
        private int mZoomMouseEnd;
        private int mMouseStartDistance;
        private int mMouseEndDistance;
        private Point mMouseSelect = new Point(0, 0);
        private double mZoomFixed;
        private double mZoomFixedPixel;
        private double mFixedPixelStartDistance;
        private double mFixedPixelEndDistance;
        private double mZoomMin2Fixed;
        private double mMin2ZoomMin;
        private double mFixed2ZoomMax;
        private double mZoomMax2Max;
        private double mZoomMin;
        private double mZoomMax;
        private Runnable mZoomAnimator;
        private Runnable mHighlightAnimator;
        private int mHighlightStep;
    }

    private int computeVisibleRows(int ydim) {
        // If we resize, then move the bottom row down.  Don't allow the scroll
        // to waste space at the bottom.
        int offsetY = mScrollOffsetY;
        int spaceNeeded = mNumRows * rowYSpace;
        if (offsetY + ydim > spaceNeeded) {
            offsetY = spaceNeeded - ydim;
            if (offsetY < 0) {
                offsetY = 0;
            }
        }
        mStartRow = offsetY / rowYSpace;
        mEndRow = (offsetY + ydim) / rowYSpace;
        if (mEndRow >= mNumRows) {
            mEndRow = mNumRows - 1;
        }

        return offsetY;
    }

    private void startHighlighting() {
        // System.out.printf("startHighlighting()\n");
        mSurface.mHighlightStep = 0;
        mSurface.mFadeColors = true;
        // Force a recomputation of the color strips
        mSurface.mCachedEndRow = -1;
        getDisplay().timerExec(0, mSurface.mHighlightAnimator);
    }

    private static class RowData {
        RowData(Row row) {
            mName = row.getName();
            mStack = new ArrayList<Block>();
        }

        public void push(Block block) {
            mStack.add(block);
        }

        public Block top() {
            if (mStack.size() == 0)
                return null;
            return mStack.get(mStack.size() - 1);
        }

        public void pop() {
            if (mStack.size() == 0)
                return;
            mStack.remove(mStack.size() - 1);
        }

        private String mName;
        private int mRank;
        private long mElapsed;
        private long mEndTime;
        private ArrayList<Block> mStack;
    }

    private static class Segment {
        Segment(RowData rowData, Block block, long startTime, long endTime) {
            mRowData = rowData;
            mBlock = block;
            mStartTime = startTime;
            mEndTime = endTime;
        }

        private RowData mRowData;
        private Block mBlock;
        private long mStartTime;
        private long mEndTime;
    }

    private static class Strip {
        Strip(int x, int y, int width, int height, RowData rowData,
                Segment segment, Color color) {
            mX = x;
            mY = y;
            mWidth = width;
            mHeight = height;
            mRowData = rowData;
            mSegment = segment;
            mColor = color;
        }

        int mX;
        int mY;
        int mWidth;
        int mHeight;
        RowData mRowData;
        Segment mSegment;
        Color mColor;
    }

    private static class Pixel {
        public void setFields(int start, double weight, Segment segment,
                Color color, RowData rowData) {
            mStart = start;
            mMaxWeight = weight;
            mSegment = segment;
            mColor = color;
            mRowData = rowData;
        }

        int mStart = -2; // some value that won't match another pixel
        double mMaxWeight;
        Segment mSegment;
        Color mColor; // we need the color here because it may be faded
        RowData mRowData;
    }

    private static class Range {
        Range(int xStart, int width, int y, Color color) {
            mXdim.x = xStart;
            mXdim.y = width;
            mY = y;
            mColor = color;
        }

        Point mXdim = new Point(0, 0);
        int mY;
        Color mColor;
    }
}