mainwindow.java

Libgist is an implementation of the Generalized Search Tree, a template index structure that makes i

// MainWindow.java
// Copyright (c) 1998, Regents of the University of California
// $Id: MainWindow.java,v 1.3 1999/12/14 06:07:34 marcel Exp $

//import com.sun.java.swing.*;
import javax.swing.*;
import javax.swing.event.*;
//import com.sun.java.swing.event.*;
//import com.sun.java.swing.preview.*;
import java.awt.event.*;
import java.awt.*;
import java.io.*;
import java.lang.*;
import java.io.*;
import java.util.*;

/*
 * MainWindow - main amdb GUI window
 *
 * Contains menus, console window, etc.
 */

public class MainWindow extends JFrame //implements WindowListener
{

// GUI states w.r.t. status of menu items
static final int INITSTATE = 0;
static final int IDXOPENSTATE = 1;
static final int DEBUGSTATE = 2;
static final int ANLOPENSTATE = 3;
static final int STOPSTATE = 4;
// various stuff
JDesktopPane desktop;
public ConsoleWindow consoleFrame; // our text output window
boolean scriptWasCancelled; // set by 'Stop' button, read by execution thread
int guiState; // one of the above; determines which menu items are enabled
String idxName; // filename of currently open index
OpThread opThread; // thread to execute libgist operations (debugging fcts in separate thread)
Workload wkld; // profile we're currently working with
WkldStatsDlg wkldStatsDlg;
SplitStatsDlg splitStatsDlg;
PenaltyStatsDlg penaltyStatsDlg;
TreeView treeView; // internal frame subclass for display of tree structure
boolean isOpen; // true if some index is opened
LibgistCommand cmd; // passed to opThread for execution
boolean inWkld = false; // true if opThread is executing an analysis workload for us
StringBuffer echoBuffer = new StringBuffer();
public ResultProcessor echoResults = 
    new ResultProcessor() {
	public void processItem(String key, String data) {
	    if (!inWkld && showResultsItem.getState()) {
		consoleFrame.echoTuple(key + ": " + data);
	    }
	}
    };

// global GUI state, needed for enabling/disabling them
JMenuBar menuBar;
JMenu fileMenu, debugMenu, opsMenu, analysisMenu, windowsMenu, treeStatsMenu;
JMenuItem newItem, openItem, closeItem, flushItem, exitItem, settingsItem, optionsItem;
JMenuItem dumpItem;
JMenuItem insertItem, deleteItem, searchItem, executeItem;
JMenuItem breakpointsItem;
JCheckBoxMenuItem traceAllItem;
AbstractAction stepAction, nextAction, contAction, stopAction, cancelAction;
JMenuItem newAnalysisItem, openAnalysisItem, completeAnalysisItem, 
    wkldStatsItem, splitStatsItem, penaltyStatsItem;
JCheckBoxMenuItem showCmdsItem, showResultsItem, showTraceItem;
JCheckBoxMenuItem checkPenaltyItem;
JMenuItem utilItem, slotCntItem, predSzItem;
JMenuItem tileItem;

// analysis info
AnalysisInfo analysisInfo;

public void
windowActivated(WindowEvent e)
{
}

public void
windowClosed(WindowEvent e)
{
}

public void
windowClosing(WindowEvent e)
{
    try {
	Libgist.close();
    } catch (LibgistException exc) {
	// can't do very much at this point
	System.err.println("Could not close " + exc);
    }
    opThread.stopNow();
    System.exit(0);    
}

public void
windowDeactivated(WindowEvent e)
{
}

public void
windowDeiconified(WindowEvent e)
{
}

public void
windowIconified(WindowEvent e)
{
}

public void
windowOpened(WindowEvent e)
{
}

public TreeView
treeView()
{
    return treeView;
}

// returns the old state and applies the new state
// 'isScript' and 'enableCancel' are only relevant for debug mode
public int
setGuiState(int state)
{
    return setGuiState(state, false, false);
}

public int
setGuiState(int state, boolean isScript, boolean enableCancel)
{
    DbgOutput.println(2, "state: " + state);
    int oldState = guiState;
    guiState = state;
    switch (guiState) {
    case INITSTATE:
        enableInit();
	break;
    case IDXOPENSTATE:
        enableIndexOpened();
	break;
    case DEBUGSTATE:
        enableDebug(isScript, enableCancel);
	break;
    case ANLOPENSTATE:
        enableAnalysis();
	break;
    }
    return oldState;
}

// enable all menu items/menus for operations that require 
// a Gist to work on, excluding the debugging functions
private void
enableIndexOpened()
{
    DbgOutput.println(1, "enableIndexOpened()");
    setAllEnabled(true);
    // debugging operations only during operations
    stepAction.setEnabled(false);
    stopAction.setEnabled(false);
    cancelAction.setEnabled(false);
    nextAction.setEnabled(false);
    contAction.setEnabled(false);

    // no profile opened
    completeAnalysisItem.setEnabled(false);
    wkldStatsItem.setEnabled(false);
    splitStatsItem.setEnabled(false);
    penaltyStatsItem.setEnabled(false);
}

// enable startup menu items that don't require an index or profile to work with
private void
enableInit()
{
    setAllEnabled(false);

    // we can create and open indices
    fileMenu.setEnabled(true);
    newItem.setEnabled(true);
    openItem.setEnabled(true);

    // we can execute scripts
    opsMenu.setEnabled(true);
    executeItem.setEnabled(true);

    // we can open profile
    analysisMenu.setEnabled(true);
    openAnalysisItem.setEnabled(true);
}

// enable/disable all menu items/actions
private void
setAllEnabled(boolean enabled)
{
    DbgOutput.println(2, "enabled: " + enabled);
    fileMenu.setEnabled(enabled);
    newItem.setEnabled(enabled);
    openItem.setEnabled(enabled);
    closeItem.setEnabled(enabled);
    //dumpItem.setEnabled(enabled);
    flushItem.setEnabled(enabled);
    optionsItem.setEnabled(enabled);
    settingsItem.setEnabled(enabled);

    debugMenu.setEnabled(enabled);
    stepAction.setEnabled(enabled);
    stopAction.setEnabled(enabled);
    cancelAction.setEnabled(enabled);
    nextAction.setEnabled(enabled);
    contAction.setEnabled(enabled);
    breakpointsItem.setEnabled(enabled);

    opsMenu.setEnabled(enabled);
    insertItem.setEnabled(enabled);
    deleteItem.setEnabled(enabled);
    searchItem.setEnabled(enabled);
    executeItem.setEnabled(enabled);

    treeStatsMenu.setEnabled(enabled);
    utilItem.setEnabled(enabled);
    predSzItem.setEnabled(enabled);
    slotCntItem.setEnabled(enabled);

    analysisMenu.setEnabled(enabled);
    newAnalysisItem.setEnabled(enabled);
    openAnalysisItem.setEnabled(enabled);
    completeAnalysisItem.setEnabled(enabled);
    wkldStatsItem.setEnabled(enabled);
    splitStatsItem.setEnabled(enabled);
    penaltyStatsItem.setEnabled(enabled);

    // these are never disabled
    windowsMenu.setEnabled(true);
    showCmdsItem.setEnabled(true);
    showResultsItem.setEnabled(true);
    showTraceItem.setEnabled(true);
    tileItem.setEnabled(true);
}

// set all menu items related to debugging enabled, all else disabled;
// for insert, remove and fetch: continue, step
// additionally for scripts: next and sometimes cancel
private void
enableDebug(boolean isScript, boolean enableCancel)
{
    setAllEnabled(false);
    debugMenu.setEnabled(true);
    stepAction.setEnabled(true);
    cancelAction.setEnabled(enableCancel);
    nextAction.setEnabled(isScript);
    contAction.setEnabled(true);
    breakpointsItem.setEnabled(true);
    treeStatsMenu.setEnabled(true);
    utilItem.setEnabled(true);
    predSzItem.setEnabled(true);
    slotCntItem.setEnabled(true);
}

// set all menu items except for "stop" to disabled
private void
enableStop()
{
    setAllEnabled(false);
    debugMenu.setEnabled(true);
    stopAction.setEnabled(true);
}


///////////////////////////////////////////////////////////////////////////////
// enableAnalysis - enable menu items for analysis
//
// Description:
//
///////////////////////////////////////////////////////////////////////////////

private void
enableAnalysis()
{
    setAllEnabled(false);
    analysisMenu.setEnabled(true);

    // get info on state of analysis
    String scriptFile;
    Libgist.getAnalysisInfo(analysisInfo);

    // newAnalysisItem not enabled: can't create new profile, we just closed the index
    newAnalysisItem.setEnabled(false);
    openAnalysisItem.setEnabled(true);
    completeAnalysisItem.setEnabled(true);

    wkldStatsItem.setEnabled(analysisInfo.actualHasWkldStats);
    splitStatsItem.setEnabled(analysisInfo.actualHasSplitStats);
    penaltyStatsItem.setEnabled(analysisInfo.actualHasPenaltyStats);

    // general tree statistics are okay
    treeStatsMenu.setEnabled(true);
    utilItem.setEnabled(true);
    predSzItem.setEnabled(true);
    slotCntItem.setEnabled(true);

    // can always select another index or exit
    fileMenu.setEnabled(true);
    newItem.setEnabled(true);
    openItem.setEnabled(true);
    exitItem.setEnabled(true);
}

// saves the current configuration (breakpoints, window sizes and positions...)
private void
saveConfig()
{
    try {
	ObjectOutputStream out = new ObjectOutputStream(
	    new FileOutputStream(idxName + ".config"));
	Breakpoints.save(out);
	Properties.save(out);
	out.close();
    } catch (IOException exc) {
	consoleFrame.echoInfo("Could not save settings: " + exc);
    }
}

// reads the configuration (breakpoints, window sizes and positions...) for the current index
private void
restoreConfig()
{
    Breakpoints.reset();
    Properties.reset();
    try {
	ObjectInputStream in = new ObjectInputStream(
	    new FileInputStream(idxName + ".config"));
	Breakpoints.restore(in);
	Properties.restore(in);
	in.close();
    } catch (IOException exc) {
	// something went wrong - there probably was no .config file
	// ignore it
    }
}

// resets the configuration (breakpoints, window sizes and positions...)
private void
resetConfig()
{
    Breakpoints.reset();
    Properties.reset();
}


///////////////////////////////////////////////////////////////////////////////
// resetState - clean up when switching GUI state 
//
// Description:
//	- goes to INITSTATE and makes all open dialogs invisible
///////////////////////////////////////////////////////////////////////////////

private void
resetState()
{
    if (treeView != null) {
	treeView.dispose();
	treeView = null;
    }
    isOpen = false;
    idxName = null;
    setGuiState(INITSTATE);
    //setTitle("amdb");
    setTree("");
    wkldStatsDlg.setVisible(false);
    splitStatsDlg.setVisible(false);
    penaltyStatsDlg.setVisible(false);
}

// tiles treeView, globalView and consoleFrame
public void
tile()
{
    if (treeView != null) treeView.tile();
    consoleFrame.tile();
}


///////////////////////////////////////////////////////////////////////////////
// echoCmd - display command in console
//
// Description:
//
// Exceptions: none
///////////////////////////////////////////////////////////////////////////////

public void
echoCmd(LibgistCommand cmd)
{
    if (!showCmdsItem.getState()) {
        return;
    }

    echoBuffer.setLength(0); // reset
    switch (cmd.cmdType) {

    case LibgistCommand.INSERT:
	echoBuffer.append("insert \"").append(cmd.key);
	echoBuffer.append("\" \"").append(cmd.data).append("\"");
	break;
    
    case LibgistCommand.REMOVE:
	echoBuffer.append("delete \"").append(cmd.qual);
	echoBuffer.append("\"");
	break;
    
    case LibgistCommand.FETCH:
	echoBuffer.append("select ");