path: root/eclipse/plugins/com.android.ide.eclipse.gldebugger/src/com/android/ide/eclipse/gltrace/editors/StateViewPage.java

/*
 * Copyright (C) 2011 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.GlTracePlugin;
import com.android.ide.eclipse.gltrace.editors.GLCallGroups.GLCallNode;
import com.android.ide.eclipse.gltrace.model.GLCall;
import com.android.ide.eclipse.gltrace.model.GLTrace;
import com.android.ide.eclipse.gltrace.state.GLState;
import com.android.ide.eclipse.gltrace.state.IGLProperty;
import com.android.ide.eclipse.gltrace.state.StatePrettyPrinter;
import com.android.ide.eclipse.gltrace.state.transforms.IStateTransform;
import com.google.common.base.Charsets;
import com.google.common.io.Files;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.ILock;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.IPageSite;
import org.eclipse.ui.part.Page;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * A tree view of the OpenGL state. It listens to the current GLCall that is selected
 * in the Function Trace view, and updates its view to reflect the state as of the selected call.
 */
public class StateViewPage extends Page implements ISelectionListener, ISelectionProvider {
    public static final String ID = "com.android.ide.eclipse.gltrace.views.GLState"; //$NON-NLS-1$
    private static String sLastUsedPath;
    private static final ILock sGlStateLock = Job.getJobManager().newLock();

    private GLTrace mTrace;
    private List<GLCall> mGLCalls;

    /** OpenGL State as of call {@link #mCurrentStateIndex}. */
    private IGLProperty mState;
    private int mCurrentStateIndex;

    private String[] TREE_PROPERTIES = { "Name", "Value" };
    private TreeViewer mTreeViewer;
    private StateLabelProvider mLabelProvider;

    public StateViewPage(GLTrace trace) {
        setInput(trace);
    }

    public void setInput(GLTrace trace) {
        mTrace = trace;
        if (trace != null) {
            mGLCalls = trace.getGLCalls();
        } else {
            mGLCalls = null;
        }

        mState = GLState.createDefaultState();
        mCurrentStateIndex = -1;

        if (mTreeViewer != null) {
            mTreeViewer.setInput(mState);
            mTreeViewer.refresh();
        }
    }

    @Override
    public void createControl(Composite parent) {
        final Tree tree = new Tree(parent, SWT.VIRTUAL | SWT.H_SCROLL | SWT.V_SCROLL);
        GridDataFactory.fillDefaults().grab(true, true).applyTo(tree);

        tree.setHeaderVisible(true);
        tree.setLinesVisible(true);
        tree.setLayoutData(new GridData(GridData.FILL_BOTH));

        TreeColumn col1 = new TreeColumn(tree, SWT.LEFT);
        col1.setText(TREE_PROPERTIES[0]);
        col1.setWidth(200);

        TreeColumn col2 = new TreeColumn(tree, SWT.LEFT);
        col2.setText(TREE_PROPERTIES[1]);
        col2.setWidth(200);

        mTreeViewer = new TreeViewer(tree);
        mTreeViewer.setContentProvider(new StateContentProvider());
        mLabelProvider = new StateLabelProvider();
        mTreeViewer.setLabelProvider(mLabelProvider);
        mTreeViewer.setInput(mState);
        mTreeViewer.refresh();

        final IToolBarManager manager = getSite().getActionBars().getToolBarManager();
        manager.add(new Action("Save to File",
                PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(
                        ISharedImages.IMG_ETOOL_SAVEAS_EDIT)) {
            @Override
            public void run() {
                saveCurrentState();
            }
        });
    }

    private void saveCurrentState() {
        final Shell shell = mTreeViewer.getTree().getShell();
        FileDialog fd = new FileDialog(shell, SWT.SAVE);
        fd.setFilterExtensions(new String[] { "*.txt" });
        if (sLastUsedPath != null) {
            fd.setFilterPath(sLastUsedPath);
        }

        String path = fd.open();
        if (path == null) {
            return;
        }

        File f = new File(path);
        sLastUsedPath = f.getParent();

        // export state to f
        StatePrettyPrinter pp = new StatePrettyPrinter();
        synchronized (sGlStateLock) {
            mState.prettyPrint(pp);
        }

        try {
            Files.write(pp.toString(), f, Charsets.UTF_8);
        } catch (IOException e) {
            ErrorDialog.openError(shell,
                    "Export GL State",
                    "Unexpected error while writing GL state to file.",
                    new Status(Status.ERROR, GlTracePlugin.PLUGIN_ID, e.toString()));
        }
    }

    @Override
    public void init(IPageSite pageSite) {
        super.init(pageSite);
        pageSite.getPage().addSelectionListener(this);
    }

    @Override
    public void dispose() {
        getSite().getPage().removeSelectionListener(this);
        super.dispose();
    }

    @Override
    public void selectionChanged(IWorkbenchPart part, ISelection selection) {
        if (!(part instanceof GLFunctionTraceViewer)) {
            return;
        }

        if (((GLFunctionTraceViewer) part).getTrace() != mTrace) {
            return;
        }

        if (!(selection instanceof TreeSelection)) {
            return;
        }

        GLCall selectedCall = null;

        Object data = ((TreeSelection) selection).getFirstElement();
        if (data instanceof GLCallNode) {
            selectedCall = ((GLCallNode) data).getCall();
        }

        if (selectedCall == null) {
            return;
        }

        final int selectedCallIndex = selectedCall.getIndex();

        // Creation of texture images takes a few seconds on the first run. So run
        // the update task as an Eclipse job.
        Job job = new Job("Updating GL State") {
            @Override
            protected IStatus run(IProgressMonitor monitor) {
                Set<IGLProperty> changedProperties = null;

                try {
                    sGlStateLock.acquire();
                    changedProperties = updateState(mCurrentStateIndex,
                            selectedCallIndex);
                    mCurrentStateIndex = selectedCallIndex;
                } catch (Exception e) {
                    GlTracePlugin.getDefault().logMessage(
                            "Unexpected error while updating GL State.");
                    GlTracePlugin.getDefault().logMessage(e.getMessage());
                    return new Status(Status.ERROR,
                            GlTracePlugin.PLUGIN_ID,
                            "Unexpected error while updating GL State.",
                            e);
                } finally {
                    sGlStateLock.release();
                }

                mLabelProvider.setChangedProperties(changedProperties);
                Display.getDefault().syncExec(new Runnable() {
                    @Override
                    public void run() {
                        if (!mTreeViewer.getTree().isDisposed()) {
                            mTreeViewer.refresh();
                        }
                    }
                });

                return Status.OK_STATUS;
            }
        };
        job.setPriority(Job.SHORT);
        job.schedule();
    }

    @Override
    public Control getControl() {
        if (mTreeViewer == null) {
            return null;
        }

        return mTreeViewer.getControl();
    }

    @Override
    public void setFocus() {
    }

    /**
     * Update GL state from GL call at fromIndex to the call at toIndex.
     * If fromIndex < toIndex, the GL state will be updated by applying all the transformations
     * corresponding to calls from (fromIndex + 1) to toIndex (inclusive).
     * If fromIndex > toIndex, the GL state will be updated by reverting all the calls from
     * fromIndex (inclusive) to (toIndex + 1).
     * @return GL state properties that changed as a result of this update.
     */
    private Set<IGLProperty> updateState(int fromIndex, int toIndex) {
        assert fromIndex >= -1 && fromIndex < mGLCalls.size();
        assert toIndex >= 0 && toIndex < mGLCalls.size();

        if (fromIndex < toIndex) {
            return applyTransformations(fromIndex, toIndex);
        } else if (fromIndex > toIndex) {
            return revertTransformations(fromIndex, toIndex);
        } else {
            return Collections.emptySet();
        }
    }

    private Set<IGLProperty> applyTransformations(int fromIndex, int toIndex) {
        int setSizeHint = 3 * (toIndex - fromIndex) + 10;
        Set<IGLProperty> changedProperties = new HashSet<IGLProperty>(setSizeHint);

        for (int i = fromIndex + 1; i <= toIndex; i++) {
            GLCall call = mGLCalls.get(i);
            for (IStateTransform f : call.getStateTransformations()) {
                try {
                    f.apply(mState);
                    IGLProperty changedProperty = f.getChangedProperty(mState);
                    if (changedProperty != null) {
                        changedProperties.addAll(getHierarchy(changedProperty));
                    }
                } catch (Exception e) {
                    GlTracePlugin.getDefault().logMessage("Error applying transformations for "
                            + call);
                    GlTracePlugin.getDefault().logMessage(e.toString());
                }
            }
        }

        return changedProperties;
    }

    private Set<IGLProperty> revertTransformations(int fromIndex, int toIndex) {
        int setSizeHint = 3 * (fromIndex - toIndex) + 10;
        Set<IGLProperty> changedProperties = new HashSet<IGLProperty>(setSizeHint);

        for (int i = fromIndex; i > toIndex; i--) {
            List<IStateTransform> transforms = mGLCalls.get(i).getStateTransformations();
            // When reverting transformations, iterate from the last to first so that the reversals
            // are performed in the correct sequence.
            for (int j = transforms.size() - 1; j >= 0; j--) {
                IStateTransform f = transforms.get(j);
                f.revert(mState);

                IGLProperty changedProperty = f.getChangedProperty(mState);
                if (changedProperty != null) {
                    changedProperties.addAll(getHierarchy(changedProperty));
                }
            }
        }

        return changedProperties;
    }

    /**
     * Obtain the list of properties starting from the provided property up to
     * the root of GL state.
     */
    private List<IGLProperty> getHierarchy(IGLProperty changedProperty) {
        List<IGLProperty> changedProperties = new ArrayList<IGLProperty>(5);
        changedProperties.add(changedProperty);

        // add the entire parent chain until we reach the root
        IGLProperty prop = changedProperty;
        while ((prop = prop.getParent()) != null) {
            changedProperties.add(prop);
        }

        return changedProperties;
    }

    @Override
    public void addSelectionChangedListener(ISelectionChangedListener listener) {
        mTreeViewer.addSelectionChangedListener(listener);
    }

    @Override
    public ISelection getSelection() {
        return mTreeViewer.getSelection();
    }

    @Override
    public void removeSelectionChangedListener(ISelectionChangedListener listener) {
        mTreeViewer.removeSelectionChangedListener(listener);
    }

    @Override
    public void setSelection(ISelection selection) {
        mTreeViewer.setSelection(selection);
    }
}