ViewerWindow.java

Go to the documentation of this file.

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

import java.io.File;
import java.util.ArrayList;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

import org.eclipse.core.commands.Command;
import org.eclipse.core.commands.State;
import org.eclipse.ui.ISourceProviderListener;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.ui.handlers.RegistryToggleState;
import org.eclipse.ui.services.ISourceProviderService;

import edu.rice.cs.hpc.data.experiment.Experiment;
import edu.rice.cs.hpc.filter.service.FilterMap;
import edu.rice.cs.hpc.filter.service.FilterStateProvider;
import edu.rice.cs.hpc.viewer.actions.DebugShowCCT;
import edu.rice.cs.hpc.viewer.actions.DebugShowFlatID;
import edu.rice.cs.hpc.viewer.provider.DatabaseState;

public class ViewerWindow {
    public static int maxDbNum = 5;
    private IWorkbenchWindow winObj;
    ArrayList<Database> dbObj = new ArrayList<Database>(maxDbNum);

    private Command cmdDebugCCT;
    private Command cmdDebugFlat;
    
    private AtomicInteger numAggregateDatabase = new AtomicInteger(1);

    public IWorkbenchWindow getWinObj() {
        return winObj;
    }
    
    public void setWinObj(IWorkbenchWindow window) {
        winObj = window;
        ICommandService commandService = (ICommandService) winObj.getService(ICommandService.class);
        cmdDebugCCT = commandService.getCommand( DebugShowCCT.commandId );
        cmdDebugFlat = commandService.getCommand( DebugShowFlatID.commandId );
        
        // listen to filter change of states
        final ISourceProviderService service = (ISourceProviderService) window.getService(ISourceProviderService.class);
        final FilterStateProvider service_provider = (FilterStateProvider) service.getSourceProvider(FilterStateProvider.FILTER_REFRESH_PROVIDER);
        service_provider.addSourceProviderListener(new ISourceProviderListener() {

            @Override
            public void sourceChanged(int sourcePriority, Map sourceValuesByName) {}

            @Override
            public void sourceChanged(int sourcePriority, String sourceName,
                    Object sourceValue) {
                if (sourceName.equals(FilterStateProvider.FILTER_REFRESH_PROVIDER)) 
                {
                    Boolean filter = (Boolean) sourceValue;
                    filterAllDatabases(filter);
                }
            }           
        });
    }

    private void filterAllDatabases(boolean filter)
    {
        // filter the experiment
        Experiment []experiments = getExperiments();
        if (experiments != null)
        {
            for (Experiment experiment : experiments)
            {
                if (filter) 
                {
                    // filtering is needed
                    experiment.filter(FilterMap.getInstance());
                } else 
                {
                    // filter is disabled, we need to reopen the database
                    try {
                        experiment.reopen();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        final ISourceProviderService service = (ISourceProviderService) winObj.getService(ISourceProviderService.class);
        DatabaseState databaseState = (DatabaseState) service.getSourceProvider(DatabaseState.DATABASE_NEED_REFRESH);
        databaseState.refreshDatabase(filter);
    }
    
    public int getNextDbNum() {
        return dbObj.size();
    }


    public Database getDb(String dbPath) {
        for (Database db: dbObj) {
            if (db == null) {
                continue;
            }
            String path = db.getExperiment().getDefaultDirectory().getAbsolutePath(); 
            if (dbPath.equals(path)) {
                return db;
            }
        }
        return null;
    }


    public int getOpenDatabases () {
        return dbObj.size();
    }

    public int addDatabase(Database database) {
        dbObj.add(database);
        checkService();
        return dbObj.size()-1;
    }

    public int removeDatabase (String databasePath) {
        Database db = getDb(databasePath);
        assert(db != null);
        
        if (dbObj.remove(db)) {
            checkService();
            db.dispose();
            return dbObj.size();
        }
        return -1;
    }

    public int getDbNum(Experiment experiment) {
        int i=0;
        for (Database db: dbObj) {
            if (db == null) {
                continue;
            }
            Experiment current = db.getExperiment();
            if (experiment.equals(current)) {
                break;
            }
            i++;
        }
        return i;
    }

    
    /****
     * Remove (nullify) all the allocated resources
     */
    public void dispose() {
        for (Database db : dbObj) {
            if (db != null)
                db.dispose();
        }
        dbObj = null;
    }
    
    public Database[] getDatabases() {
        Database []db = new Database[dbObj.size()];
        dbObj.toArray(db);
        return db;
    }
    
    /*****
     * get the opened experiment databases
     * @return null if there is no opened database
     */
    public Experiment[] getExperiments() {
        int numDb = getOpenDatabases();
        if (numDb == 0)
            return null;
        Experiment []experiments = new Experiment[numDb];
        
        int i=0;
        for (Database db: dbObj) {
            if (db == null)
                continue;
            experiments[i] = db.getExperiment();
            i++;
        }
        return experiments;
    }
    
    public String[] getDatabasePaths () {
        String[] dbArray = new String[getOpenDatabases()];
        
        int i=0;
        for (Database db : dbObj) {
            if (dbObj != null) {
                Experiment experiment = db.getExperiment();
                dbArray[i++] = getDatabasePath(experiment.getXMLExperimentFile());
            }
        }

        return dbArray;
    }
    
    
    public String getDatabasePath(File file) {
        
        String xmlFileName = file.getPath();
        return getDatabasePath(xmlFileName);
    }
    
    
    public String getDatabasePath(String filename) {

        int dbDir = filename.lastIndexOf(File.separator);
        String dbPath = filename.substring(0,dbDir);
        
        return dbPath;
    }
    
    /***
     * update the service provided by DatabaseState to ensure that the menus's state are refreshed
     * 
     */
    public void checkService()
    {
        ISourceProviderService sourceProviderService = (ISourceProviderService) winObj.getService(
                        ISourceProviderService.class);
        // Now get my service
        DatabaseState commandStateService = (DatabaseState) sourceProviderService
                .getSourceProvider(DatabaseState.DATABASE_ACTIVE_STATE);
        commandStateService.toogleEnabled(winObj);
        
        commandStateService = (DatabaseState) sourceProviderService
                .getSourceProvider(DatabaseState.DATABASE_MERGE_STATE);
        commandStateService.toogleEnabled(winObj);
    }
    
    /****
     * get the ID of the database. This ID has to be unique for each window, and always incremented
     * 
     * Every time we open a database, we only increment by 1
     * 
     * @return
     */
    public int reserveDatabaseNumber() {
        return numAggregateDatabase.incrementAndGet();
    }

    // --------------------------------------------------------------
    // Debug mode for this window
    // --------------------------------------------------------------
    
    public boolean showCCTLabel() 
    {
        return isDebugMode(cmdDebugCCT);
    }
    
    public boolean showFlatLabel() 
    {
        return isDebugMode(cmdDebugFlat);
    }
    
    private boolean isDebugMode(Command command) 
    {
        boolean isDebug = false;
        final State state = command.getState(RegistryToggleState.STATE_ID);
        if (state != null)
        {
            final Boolean b = (Boolean) state.getValue();
            isDebug = b.booleanValue();
        }
        return isDebug;
    }
}