ScopeViewActions.java

Go to the documentation of this file.

package edu.rice.cs.hpc.viewer.scope;

import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.TreeViewerColumn;
import org.eclipse.jface.dialogs.Dialog;

import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.CoolBar;

import edu.rice.cs.hpc.data.experiment.Experiment;
import edu.rice.cs.hpc.data.experiment.scope.RootScope;
import edu.rice.cs.hpc.data.experiment.scope.Scope;
import edu.rice.cs.hpc.data.experiment.metric.*;
import edu.rice.cs.hpc.viewer.metric.*;
import edu.rice.cs.hpc.viewer.util.Utilities;
import edu.rice.cs.hpc.viewer.window.Database;
import edu.rice.cs.hpc.viewer.window.ViewerWindow;
import edu.rice.cs.hpc.viewer.window.ViewerWindowManager;
public abstract class ScopeViewActions extends ScopeActions /* implements IToolbarManager*/ {
    //-------------- DATA
    protected ScopeTreeViewer   treeViewer;         // tree 
    protected RootScope         myRootScope;        // the root scope of this view

    // laksono 2009.04.07
    protected ScopeZoom objZoom = null;
    
    public interface IActionType {};
    public enum ActionType implements IActionType {ZoomIn, ZoomOut} ;
    
    protected IWorkbenchWindow objWindow;
    
    public ScopeViewActions(Shell shell, IWorkbenchWindow window, Composite parent, CoolBar coolbar) {
        super(shell, parent, coolbar);
        
        this.objWindow  = window;
        createGUI(parent, coolbar);
        // need to instantiate the zoom class after the creation of GUIs
        objZoom = new ScopeZoom(treeViewer, (ScopeViewActionsGUI) this.objActionsGUI);
    }

    abstract protected  Composite createGUI(Composite parent, CoolBar coolbar);

    public void updateContent(Experiment exp, RootScope scope) {
        this.myRootScope = scope;
        this.objActionsGUI.updateContent(exp, scope);
    }
    
    public void setTreeViewer(ScopeTreeViewer tree) {
        this.treeViewer = tree;
        this.objActionsGUI.setTreeViewer(tree);
        this.objZoom.setViewer(tree);
    }

    private HotCallPath getHotCallPath(TreePath pathItem, TreeItem item, Scope scope, BaseMetric metric, int iLevel) {
        if(scope == null || metric == null || item == null)
            return null;
        // expand the immediate child if necessary
        if(!item.getExpanded()) {
            this.treeViewer.expandToLevel(pathItem, 1);
        }
        int iCounts = item.getItemCount();

        HotCallPath objCallPath = new HotCallPath();
        // we found the hot call path
        objCallPath.path = pathItem; // this.treeViewer.getTreePath(child);
        objCallPath.item = item; // child;
        objCallPath.node = (Scope) item.getData(); // nodeChild;
        objCallPath.is_found = false;

        // singly depth first search
        // bug fix: we only drill once !
        if (iCounts > 0) {
            TreeItem child = item.getItem(0);
            Object o = child.getData();
            if(o instanceof Scope) {
                // get the child node
                Scope scopeChild = (Scope) o;

                MetricValue mvParent = metric.getValue(scope);
                MetricValue mvChild = metric.getValue(scopeChild);
                double dParent = MetricValue.getValue(mvParent);
                double dChild = MetricValue.getValue(mvChild);
                
                // simple comparison: if the child has "significant" difference compared to its parent
                // then we consider it as hot path node.
                if(dChild < (ScopeViewActions.fTHRESHOLD * dParent)) {
                    objCallPath.is_found = (iLevel>0);
                    return objCallPath;
                } else {
                    // let's move deeper down the tree
                    HotCallPath objHotPath = this.getHotCallPath(this.treeViewer.getTreePath(child), 
                            child, scopeChild, metric, iLevel+ 1);
                    return objHotPath; 
                }
            }
        } else {
            objCallPath.is_found = true;
        }
        // if we reach at this statement, then there is no hot call path !
        return objCallPath;
    }

    private Scope getInputNode() {
        Object o = treeViewer.getInput();
        Scope child;
        if (!(o instanceof Scope)) {
                TreeItem []tiObjects = this.treeViewer.getTree().getItems();
                o = tiObjects[0];
                if(o instanceof Scope)
                    child = (Scope)tiObjects[0].getData(); //the 0th item can be the aggregate metric
                else if(tiObjects.length>1)
                    // in case of the top row is not a node, the second one MUST BE a node
                    child = (Scope)tiObjects[1].getData();
                else
                    // Otherwise there is something wrong with the data and the tree
                    throw (new java.lang.RuntimeException("ScopeViewActions: tree contains unknown objects"));
                // tricky solution when zoom-out the flattened node
                if(child != null)
                    child = (Scope)child.getParent();
        } else 
            child = (Scope) o;
        return child;
    }
    
    
    //====================================================================================
    // ----------------------------- ACTIONS ---------------------------------------------
    //====================================================================================

    private class RestoreMessageThread extends Thread { 
        RestoreMessageThread() {
            super();
        }
         public void run() {
             try{
                 sleep(5000);
             } catch(InterruptedException e) {
                 e.printStackTrace();
             }
             // need to run from UI-thread for restoring the background
             // without UI-thread we will get SWTException !!
             if (objShell != null && !objShell.isDisposed()) {
                 Display display = objShell.getDisplay();
                 if (display != null && !display.isDisposed()) {
                     display.asyncExec(new Runnable() {
                         public void run() {
                             objActionsGUI.restoreMessage();
                         }
                     });
                 }
             }
         }
     }
    
    public void showInfoMessage(String sMsg) {
        this.objActionsGUI.showInfoMessage(sMsg);
        // remove the msg in 5 secs
        RestoreMessageThread thrRestoreMessage = new RestoreMessageThread();
        thrRestoreMessage.start();
    }
    
    public void showErrorMessage(String strMsg) {
        this.objActionsGUI.showErrorMessage(strMsg);
        // remove the msg in 5 secs
        RestoreMessageThread thrRestoreMessage = new RestoreMessageThread();
        thrRestoreMessage.start();

    }
    
    public void showHotCallPath() {
        // find the selected node
        ISelection sel = treeViewer.getSelection();
        if (!(sel instanceof TreeSelection)) {
            System.err.println("SVA: not a TreeSelecton instance");
            return;
        }
        TreeSelection objSel = (TreeSelection) sel;
        // get the node
        Object o = objSel.getFirstElement();
        if (!(o instanceof Scope)) {
            showErrorMessage("Please select a scope node.");
            return;
        }
        Scope current = (Scope) o;
        // get the item
        TreeItem item = this.treeViewer.getTree().getSelection()[0];
        // get the path
        TreePath []arrPath = objSel.getPaths();
        // get the selected metric
        TreeColumn colSelected = this.treeViewer.getTree().getSortColumn();
        if((colSelected == null) || colSelected.getWidth() == 0) {
            // the column is hidden or there is no column sorted
            this.showErrorMessage("Please select a column to sort before using this feature.");
            return;
        }
        // get the metric data
        Object data = colSelected.getData();
        if(data instanceof BaseMetric && item != null) {
            BaseMetric metric = (BaseMetric) data;
            // find the hot call path
            int iLevel = 0;
            HotCallPath objHot = this.getHotCallPath(arrPath[0], item, current, metric, iLevel);
            this.treeViewer.setSelection(new TreeSelection(objHot.path), true);
            if(objHot.is_found == false) {
                this.showErrorMessage("No hot child.");
            }
        } else {
            // It is almost impossible for the jvm to reach this part of branch.
            // but if it is the case, it should be a BUG !!
            if(data !=null )
                System.err.println("SVA BUG: data="+data.getClass()+" item= " + (item==null? 0 : item.getItemCount()));
            else
                this.showErrorMessage("Please select a metric column !");
        }
    }
    
    public Scope getSelectedNode() {
        ISelection sel = treeViewer.getSelection();
        if (!(sel instanceof TreeSelection))
            return null;
        Object o = ((TreeSelection)sel).getFirstElement();
        if (!(o instanceof Scope)) {
            return null;
        }
        return (Scope) o;
    }
    public void zoomIn() {
        // set the new view based on the selected node
        Scope current = this.getSelectedNode();
        if(current == null)
            return;
        
        // ---------------------- save the current view
        Scope objInputNode = this.getInputNode();
        objZoom.zoomIn(current, objInputNode);
        Scope nodeSelected = this.getSelectedNode();
        
        registerAction(ActionType.ZoomIn);
        
        checkStates(nodeSelected);
    }
    
    public void zoomOut() {     
        objZoom.zoomOut();
        // funny behavior on Windows: they still keep the track of the previously selected item !!
        // therefore we need to check again the state of the buttons
        Scope nodeSelected = this.getSelectedNode();
        
        registerAction(ActionType.ZoomOut);

        this.checkStates(nodeSelected);
    }
    
    public ScopeZoom getScopeZoom () {
        return this.objZoom;
    }
    
    protected void addTreeColumn(TreeColumn colMetric) {
        this.objActionsGUI.addMetricColumns(colMetric);
    }
    
    public void addExtNewMetric() {
        
        if (this.myRootScope == null)
            return;
        
        final Experiment exp = (Experiment) this.myRootScope.getExperiment();
        
        // prepare the dialog box
        ExtDerivedMetricDlg dlg = new ExtDerivedMetricDlg(this.objShell, exp);

        // display the dialog box
        if(dlg.open() == Dialog.OK) {

            final DerivedMetric objMetric = dlg.getMetric();
            
            exp.addDerivedMetric(objMetric);
                        
            // get our database file and the experiment index assigned for it
            String dbPath = exp.getDefaultDirectory().getAbsolutePath();
            ViewerWindow vWin = ViewerWindowManager.getViewerWindow(this.objWindow);
            if (vWin == null) {
                System.out.printf("ScopeViewActions.addExtNewMetric: ViewerWindow class not found\n");
                return;
            }
            int dbNum = vWin.getDbNum(exp);
            if (dbNum < 0) {
                System.out.printf("ScopeViewActions.addExtNewMetric: Database for path " + dbPath + " not found\n");
                return;
            }

            // get the views created for our database
            Database db = vWin.getDb(dbPath);
            if (db == null) {
                System.out.printf("ScopeViewActions.addExtNewMetric: Database class not found\n");
                return;
            }
            
            for(BaseScopeView view: db.getExperimentView().getViews()) {
                
                ScopeTreeViewer objTreeViewer = view.getTreeViewer();
                
                objTreeViewer.getTree().setRedraw(false);
                TreeViewerColumn colDerived = objTreeViewer.addTreeColumn(objMetric,  false);
                
                // update the viewer, to refresh its content and invoke the provider
                // bug SWT https://bugs.eclipse.org/bugs/show_bug.cgi?id=199811
                // we need to hold the UI to draw until all the data is available
                // 2012.09.21: do not refresh. It crashes on linux/gtk/ppc
                //objTreeViewer.refresh();  // we refresh to update the data model of the table
                
                // notify the GUI that we have added a new column
                ScopeViewActions objAction = view.getViewActions();
                objAction.addTreeColumn(colDerived.getColumn());
                //this.objActionsGUI.addMetricColumns(colDerived); 
                objTreeViewer.getTree().setRedraw(true);
                // adjust the column width 
                //colDerived.getColumn().pack();
                
                // instead of refresh, we use update which will reset the input and
                //  reinitialize the table. It isn't elegant, but works in all platforms
                view.updateDisplay();
            }
        }
    }

    public void resizeColumns() {
        this.objActionsGUI.resizeTableColumns();
    }


    public String getContent(TreeItem []items, String sSeparator) {
        StringBuffer sbText = new StringBuffer();
        
        // get all selected items
        for (int i=0; i< items.length; i++) {
            TreeItem objItem = items[i];
            Object o = objItem.getData();
            // let get the metrics if the selected item is a scope node
            if (o instanceof Scope) {
                Scope objScope = (Scope) o;
                this.getContent(objScope, sSeparator, sbText);
            } else {
                // in case user click the first row, we need a special treatment
                // first row of the table is supposed to be a sub-header, but at the moment we allow user
                //      to do anything s/he wants.
                String sElements[] = (String []) o; 
                sbText.append( "\"" + sElements[0] + "\"" );
                sbText.append( sSeparator ); // separate the node title and the metrics
                sbText.append( this.treeViewer.getTextBasedOnColumnStatus(sElements, sSeparator, 1, 0) );
            }
            sbText.append(Utilities.NEW_LINE);
        }
        return sbText.toString();
    }
    
    private void getContent( Scope objScope, String sSeparator, StringBuffer sbText ) {

        final TreeColumn []columns = treeViewer.getTree().getColumns();
        sbText.append( "\"" + objScope.getName() + "\"" );
        
        final Experiment exp = (Experiment) objScope.getExperiment();
        
        for(int j=1; j<columns.length; j++) 
        {
            if (columns[j].getWidth()>0) {
                // the column is not hidden
                BaseMetric metric = exp.getMetric(j-1); // bug fix: the metric starts from 0
                sbText.append(sSeparator + metric.getMetricTextValue(objScope));
            }
        }
    }
    
    public String getContent(TreePath []elements, String sSeparator) {
        StringBuffer sbText = new StringBuffer();
        for (int i=0; i<elements.length; i++ ) {
            TreePath item = elements[i];
            int nbSegments = item.getSegmentCount();
            for ( int j=0; j<nbSegments; j++ ) {
                Object o = item.getSegment(j);
                if (o instanceof Scope) {
                    this.getContent((Scope)o, sSeparator, sbText);
                }
            }
            sbText.append(Utilities.NEW_LINE);
        }
        return sbText.toString();
    }
    
    //--------------------------------------------------------------------------
    // BUTTONS CHECK
    //--------------------------------------------------------------------------
    public boolean shouldZoomInBeEnabled(Scope node) {
        return this.objZoom.canZoomIn(node);
    }
    
    public boolean shouldZoomOutBeEnabled() {
        if (objZoom == null )
            return false;
        else
            return objZoom.canZoomOut();
    }
    

    public void checkNodeButtons() {
        Scope nodeSelected = this.getSelectedNode();
        if(nodeSelected == null)
            this.objActionsGUI.disableNodeButtons();
        else
            this.checkStates(nodeSelected);
    }
    
    public void disableButtons () {
        objActionsGUI.disableNodeButtons();
    }
    
    
    
    public abstract void checkStates ( Scope nodeSelected );
    
    public abstract void checkStates();
    
    protected abstract void registerAction( IActionType type );
    
    //===========================================================================
    //------------------- ADDITIONAL CLASSES ------------------------------------
    //===========================================================================
    class HotCallPath {
        // the path of the item
        public TreePath path;
        // the item
        public TreeItem item;
        // the node associated
        public Scope node;
        
        // indicate if a hot path is found or not
        public boolean is_found = false;
    }

}