android-4.1.1_r1/s

/*
 * Copyright (C) 2012 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.ide.eclipse.gltrace.editors;

import com.android.ide.eclipse.gltrace.GLProtoBuf.GLMessage.Function;
import com.android.ide.eclipse.gltrace.model.GLCall;
import com.android.ide.eclipse.gltrace.model.GLTrace;

import org.eclipse.jface.resource.FontRegistry;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.MouseTrackListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
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.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 java.util.ArrayList;
import java.util.List;

public class DurationMinimap extends Canvas {
    /** Default alpha value. */
    private static final int DEFAULT_ALPHA = 255;

    /** Alpha value for highlighting visible calls. */
    private static final int VISIBLE_CALLS_HIGHLIGHT_ALPHA = 50;

    /** Clamp call durations at this value. */
    private static final long CALL_DURATION_CLAMP = 20000;

    private static final String FONT_KEY = "default.font";      //$NON-NLS-1$

    /** Scale font size by this amount to get the max display length of call duration. */
    private static final int MAX_DURATION_LENGTH_SCALE = 6;

    /** List of GL Calls in the trace. */
    private final List<GLCall> mCalls;

    /** Number of GL contexts in the trace. */
    private final int mContextCount;

    /** Starting call index of currently displayed frame. */
    private int mStartCallIndex;

    /** Ending call index of currently displayed frame. */
    private int mEndCallIndex;

    /** The top index that is currently visible in the table. */
    private int mVisibleCallTopIndex;

    /** The bottom index that is currently visible in the table. */
    private int mVisibleCallBottomIndex;

    private Color mBackgroundColor;
    private Color mDurationLineColor;
    private Color mGlDrawColor;
    private Color mGlErrorColor;
    private Color mContextHeaderColor;
    private Color mVisibleCallsHighlightColor;
    private Color mMouseMarkerColor;

    private FontRegistry mFontRegistry;
    private int mFontWidth;
    private int mFontHeight;

    // back buffers used for double buffering
    private Image mBackBufferImage;
    private GC mBackBufferGC;

    // mouse state
    private boolean mMouseInSelf;
    private int mMouseY;

    // helper object used to position various items on screen
    private final PositionHelper mPositionHelper;

    public DurationMinimap(Composite parent, GLTrace trace) {
        super(parent, SWT.NO_BACKGROUND);

        mCalls = trace.getGLCalls();
        mContextCount = trace.getContexts().size();

        initializeColors();
        initializeFonts();

        mPositionHelper = new PositionHelper(
                mFontHeight,
                mContextCount,
                mFontWidth * MAX_DURATION_LENGTH_SCALE, /* max display length for call. */
                CALL_DURATION_CLAMP                     /* max duration */);

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

        addListener(SWT.Resize, new Listener() {
            @Override
            public void handleEvent(Event event) {
                controlResized();
            }
        });

        addMouseMoveListener(new MouseMoveListener() {
            @Override
            public void mouseMove(MouseEvent e) {
                mouseMoved(e);
            }
        });

        addMouseListener(new MouseAdapter() {
            @Override
            public void mouseUp(MouseEvent e) {
                mouseClicked(e);
            }
        });

        addMouseTrackListener(new MouseTrackListener() {
            @Override
            public void mouseHover(MouseEvent e) {
            }

            @Override
            public void mouseExit(MouseEvent e) {
                mMouseInSelf = false;
                redraw();
            }

            @Override
            public void mouseEnter(MouseEvent e) {
                mMouseInSelf = true;
                redraw();
            }
        });
    }

    @Override
    public void dispose() {
        disposeColors();
        disposeBackBuffer();
        super.dispose();
    }

    private void initializeColors() {
        mBackgroundColor = new Color(getDisplay(), 0x33, 0x33, 0x33);
        mDurationLineColor = new Color(getDisplay(), 0x08, 0x51, 0x9c);
        mGlDrawColor = new Color(getDisplay(), 0x6b, 0xae, 0xd6);
        mContextHeaderColor = new Color(getDisplay(), 0xd1, 0xe5, 0xf0);
        mVisibleCallsHighlightColor = new Color(getDisplay(), 0xcc, 0xcc, 0xcc);
        mMouseMarkerColor = new Color(getDisplay(), 0xaa, 0xaa, 0xaa);

        mGlErrorColor = getDisplay().getSystemColor(SWT.COLOR_RED);
    }

    private void disposeColors() {
        mBackgroundColor.dispose();
        mDurationLineColor.dispose();
        mGlDrawColor.dispose();
        mContextHeaderColor.dispose();
        mVisibleCallsHighlightColor.dispose();
        mMouseMarkerColor.dispose();
    }

    private void initializeFonts() {
        mFontRegistry = new FontRegistry(getDisplay());
        mFontRegistry.put(FONT_KEY,
                new FontData[] { new FontData("Arial", 8, SWT.NORMAL) });  //$NON-NLS-1$

        GC gc = new GC(getDisplay());
        gc.setFont(mFontRegistry.get(FONT_KEY));
        mFontWidth = gc.getFontMetrics().getAverageCharWidth();
        mFontHeight = gc.getFontMetrics().getHeight();
        gc.dispose();
    }

    private void initializeBackBuffer() {
        Rectangle clientArea = getClientArea();

        if (clientArea.width == 0 || clientArea.height == 0) {
            mBackBufferImage = null;
            mBackBufferGC = null;
            return;
        }

        mBackBufferImage = new Image(getDisplay(),
                clientArea.width,
                clientArea.height);
        mBackBufferGC = new GC(mBackBufferImage);
    }

    private void disposeBackBuffer() {
        if (mBackBufferImage != null) {
            mBackBufferImage.dispose();
            mBackBufferImage = null;
        }

        if (mBackBufferGC != null) {
            mBackBufferGC.dispose();
            mBackBufferGC = null;
        }
    }

    private void mouseMoved(MouseEvent e) {
        mMouseY = e.y;
        redraw();
    }

    private void mouseClicked(MouseEvent e) {
        if (mMouseInSelf) {
            int selIndex = mPositionHelper.getCallAt(mMouseY);
            sendCallSelectedEvent(selIndex);
            redraw();
        }
    }

    private void draw(Display display, GC gc) {
        if (mBackBufferImage == null) {
            initializeBackBuffer();
        }

        if (mBackBufferImage == null) {
            return;
        }

        // draw contents onto the back buffer
        drawBackground(mBackBufferGC, mBackBufferImage.getBounds());
        drawContextHeaders(mBackBufferGC);
        drawCallDurations(mBackBufferGC);
        drawVisibleCallHighlights(mBackBufferGC);
        drawMouseMarkers(mBackBufferGC);

        // finally copy over the rendered back buffer onto screen
        int width = getClientArea().width;
        int height = getClientArea().height;
        gc.drawImage(mBackBufferImage,
                0, 0, width, height,
                0, 0, width, height);
    }

    private void drawBackground(GC gc, Rectangle bounds) {
        gc.setBackground(mBackgroundColor);
        gc.fillRectangle(bounds);
    }

    private void drawContextHeaders(GC gc) {
        if (mContextCount <= 1) {
            return;
        }

        gc.setForeground(mContextHeaderColor);
        gc.setFont(mFontRegistry.get(FONT_KEY));
        for (int i = 0; i < mContextCount; i++) {
            Point p = mPositionHelper.getHeaderLocation(i);
            gc.drawText("CTX" + Integer.toString(i), p.x, p.y);
        }
    }

    /** Draw the call durations as a sequence of lines.
     *
     * Calls are arranged on the y-axis based on the sequence in which they were originally
     * called by the application. If the display height is lesser than the number of calls, then
     * not every call is shown - the calls are underscanned based the height of the display.
     *
     * The x-axis shows two pieces of information: the duration of the call, and the context
     * in which the call was made. The duration controls how long the displayed line is, and
     * the context controls the starting offset of the line.
     */
    private void drawCallDurations(GC gc) {
        if (mCalls == null || mCalls.size() < mEndCallIndex) {
            return;
        }

        gc.setBackground(mDurationLineColor);

        int callUnderScan = mPositionHelper.getCallUnderScanValue();
        for (int i = mStartCallIndex; i < mEndCallIndex; i += callUnderScan) {
            boolean resetColor = false;
            GLCall c = mCalls.get(i);

            long duration = c.getWallDuration();

            if (c.hasErrors()) {
                gc.setBackground(mGlErrorColor);
                resetColor = true;

                // If the call has any errors, we want it to be visible in the minimap
                // regardless of how long it took.
                duration = mPositionHelper.getMaxDuration();
            } else if (c.getFunction() == Function.glDrawArrays
                    || c.getFunction() == Function.glDrawElements
                    || c.getFunction() == Function.eglSwapBuffers) {
                gc.setBackground(mGlDrawColor);
                resetColor = true;

                // render all draw calls & swap buffer at max length
                duration = mPositionHelper.getMaxDuration();
            }

            Rectangle bounds = mPositionHelper.getDurationBounds(
                    i - mStartCallIndex,
                    c.getContextId(),
                    duration);
            gc.fillRectangle(bounds);

            if (resetColor) {
                gc.setBackground(mDurationLineColor);
            }
        }
    }

    /**
     * Draw a bounding box that highlights the currently visible range of calls in the
     * {@link GLFunctionTraceViewer} table.
     */
    private void drawVisibleCallHighlights(GC gc) {
        gc.setAlpha(VISIBLE_CALLS_HIGHLIGHT_ALPHA);
        gc.setBackground(mVisibleCallsHighlightColor);
        gc.fillRectangle(mPositionHelper.getBoundsFramingCalls(
                mVisibleCallTopIndex - mStartCallIndex,
                mVisibleCallBottomIndex - mStartCallIndex));
        gc.setAlpha(DEFAULT_ALPHA);
    }

    private void drawMouseMarkers(GC gc) {
        if (!mMouseInSelf) {
            return;
        }

        if (mPositionHelper.getCallAt(mMouseY) < 0) {
            return;
        }

        gc.setForeground(mMouseMarkerColor);
        gc.drawLine(0, mMouseY, getClientArea().width, mMouseY);
    }

    private void controlResized() {
        // regenerate back buffer on size changes
        disposeBackBuffer();
        initializeBackBuffer();

        redraw();
    }

    public int getMinimumWidth() {
        return mPositionHelper.getMinimumWidth();
    }

    /** Set the GL Call start and end indices for currently displayed frame. */
    public void setCallRangeForCurrentFrame(int startCallIndex, int endCallIndex) {
        mStartCallIndex = startCallIndex;
        mEndCallIndex = endCallIndex;
        mPositionHelper.updateCallDensity(mEndCallIndex - mStartCallIndex, getClientArea().height);
        redraw();
    }

    /**
     * Set the call range that is currently visible in the {@link GLFunctionTraceViewer} table.
     * @param visibleTopIndex index of call currently visible at the top of the table.
     * @param visibleBottomIndex index of call currently visible at the bottom of the table.
     */
    public void setVisibleCallRange(int visibleTopIndex, int visibleBottomIndex) {
        mVisibleCallTopIndex = visibleTopIndex;
        mVisibleCallBottomIndex = visibleBottomIndex;
        redraw();
    }

    public interface ICallSelectionListener {
        void callSelected(int selectedCallIndex);
    }

    private List<ICallSelectionListener> mListeners = new ArrayList<ICallSelectionListener>();

    public void addCallSelectionListener(ICallSelectionListener l) {
        mListeners.add(l);
    }

    private void sendCallSelectedEvent(int selectedCall) {
        for (ICallSelectionListener l : mListeners) {
            l.callSelected(selectedCall);
        }
    }

    /** Utility class to help with the positioning and sizes of elements in the canvas. */
    private static class PositionHelper {
        /** Left Margin after which duration lines are drawn. */
        private static final int LEFT_MARGIN = 5;

        /** Top margin after which header is drawn. */
        private static final int TOP_MARGIN = 5;

        /** # of pixels of padding between duration markers for different contexts. */
        private static final int CONTEXT_PADDING = 10;

        private final int mHeaderMargin;
        private final int mContextCount;
        private final int mMaxDurationLength;
        private final long mMaxDuration;
        private final double mScale;

        private int mCallCount;
        private int mNumCallsPerPixel = 1;

        public PositionHelper(int fontHeight, int contextCount,
                int maxDurationLength, long maxDuration) {
            mContextCount = contextCount;
            mMaxDurationLength = maxDurationLength;
            mMaxDuration = maxDuration;
            mScale = (double) maxDurationLength / maxDuration;

            // header region is present only there are multiple contexts
            if (mContextCount > 1) {
                mHeaderMargin = fontHeight * 3;
            } else {
                mHeaderMargin = 0;
            }
        }

        /** Get the minimum width of the canvas. */
        public int getMinimumWidth() {
            return LEFT_MARGIN + (mMaxDurationLength + CONTEXT_PADDING) * mContextCount;
        }

        /** Get the bounds for a call duration line. */
        public Rectangle getDurationBounds(int callIndex, int context, long duration) {
            if (duration <= 0) {
                duration = 1;
            } else if (duration > mMaxDuration) {
                duration = mMaxDuration;
            }

            int x = LEFT_MARGIN + ((mMaxDurationLength + CONTEXT_PADDING) * context);
            int y = (callIndex/mNumCallsPerPixel) + TOP_MARGIN + mHeaderMargin;
            int w = (int) (duration * mScale);
            int h = 1;

            return new Rectangle(x, y, w, h);
        }

        public long getMaxDuration() {
            return mMaxDuration;
        }

        /** Get the bounds for calls spanning given range. */
        public Rectangle getBoundsFramingCalls(int startCallIndex, int endCallIndex) {
            if (startCallIndex >= 0 && endCallIndex >= startCallIndex
                    && endCallIndex <= mCallCount) {
                int x = LEFT_MARGIN;
                int y = (startCallIndex/mNumCallsPerPixel) + TOP_MARGIN + mHeaderMargin;
                int w = ((mMaxDurationLength + CONTEXT_PADDING) * mContextCount);
                int h = (endCallIndex - startCallIndex)/mNumCallsPerPixel;
            return new Rectangle(x, y, w, h);
            } else {
                return new Rectangle(0, 0, 0, 0);
            }
        }

        public Point getHeaderLocation(int context) {
            int x = LEFT_MARGIN + ((mMaxDurationLength + CONTEXT_PADDING) * context);
            return new Point(x, TOP_MARGIN);
        }

        /** Update the call density based on the number of calls to be displayed and
         * the available height to display them in. */
        public void updateCallDensity(int callCount, int displayHeight) {
            mCallCount = callCount;

            if (displayHeight <= 0) {
                displayHeight = callCount + 1;
            }

            mNumCallsPerPixel = (callCount / displayHeight) + 1;
        }

        /** Get the underscan value. In cases where there are more calls to be displayed
         * than there are availble pixels, we only display 1 out of every underscan calls. */
        public int getCallUnderScanValue() {
            return mNumCallsPerPixel;
        }

        /** Get the index of the call at given y offset. */
        public int getCallAt(int y) {
            if (!isWithinBounds(y)) {
                return -1;
            }

            Rectangle displayBounds = getBoundsFramingCalls(0, mCallCount);
            return (y - displayBounds.y) * mNumCallsPerPixel;
        }

        /** Does the provided y offset map to a valid call? */
        private boolean isWithinBounds(int y) {
            Rectangle displayBounds = getBoundsFramingCalls(0, mCallCount);
            if (y < displayBounds.y) {
                return false;
            }

            if (y > (displayBounds.y + displayBounds.height)) {
                return false;
            }

            return true;
        }
    }
}