LMMenubar.java

import javax.swing.*;
import javax.swing.border.EmptyBorder;
import java.awt.*;
import java.awt.event.*;
import java.io.File;

/**
 * Written by Daniel Barter, Alby Himelick, and Grace Whitmore.
 * For CS204 - Software Design
 * 4 June 2012
 *
 * Builds a menu for the frame. Includes a file menu with options to start a
 * new NFA, open an NFA, save the current NFA, and close the window, and a
 * help menu with a small 'Getting Started' help dialog. Implements
 * ActionListener for the menu options and WindowListener to handle the
 * closing of the frame.
 *
 * "LM" objects: allow interaction between the menubar and those parts of
 *      the GUI
 * JFileChooser fileChooser: used for save and open dialogs
 * File curFile: the currently opened file, or null if file is unsaved
 * File curDir: the directory of the currently opened file, or null if the
 *      file is unsaved
 */
public class LMMenubar
    extends JMenuBar
    implements ActionListener, WindowListener
{
    private LMWorkspacePanel workspacePanel;
    private LMOptionsPanel optionsPanel;
    private LMInputToolbar inputToolbar;
    private LMMessagePanel messagePanel;
    
    private JFileChooser fileChooser = new JFileChooser();
    
    private File curFile;
    private File curDir;

    /**
     * Constructor for the Menubar. Calls JMenuBar's constructor and buildUI()
     * to construct the menu.
     */
    public LMMenubar()
    {
        super();
        buildUI();
    }

    /**
     * Sets the workspacePanel. Allows the menu to interact with the
     * workspace.
     *
     * LMWorkspacePanel workspacePanel: the current (and only) workspace
     */
    public void setWorkspacePanel(LMWorkspacePanel workspacePanel)
    {
        this.workspacePanel = workspacePanel;
    }

    /**
     * Sets the OptionsPanel. Allows the menu to interact with the
     * options panel.
     *
     * LMOptionsPanel optionsPanel: the current (and only) options panel
     */
    public void setOptionsPanel(LMOptionsPanel optionsPanel)
    {
        this.optionsPanel = optionsPanel;
    }

    /**
     * Sets the InputToolbar. Allows the menu to interact with the
     * input toolbar.
     *
     * LMInputToolbar inputToolbar: the current (and only) input toolbar
     */
    public void setInputToolbar(LMInputToolbar inputToolbar)
    {
        this.inputToolbar = inputToolbar;
    }

    /**
     * Sets the MessagePanel. Allows the menu to interact with the
     * message panel.
     *
     * LMMessagePanel messagePanel: the current (and only) message panel
     */
    public void setMessagePanel(LMMessagePanel messagePanel)
    {
        this.messagePanel = messagePanel;
    }

    /**
     * Displays a "save changes?" dialog when the user does something that
     * would lose the current NFA if the current NFA has been modified.
     *
     * Returns true if the user cancels the action (so they stay on the current
     * NFA) or false if they don't (either choosing to save or not).
     */
    private boolean showSaveChangesDialog()
    {
        if (!workspacePanel.isModified())// && curFile != null && curFile.exists())
        {
            return false;
        }

        int returnVal = JOptionPane.showConfirmDialog(workspacePanel,
            "Do you want to save changes to the current NFA?",
            "Save current file?",
            JOptionPane.YES_NO_CANCEL_OPTION,
            JOptionPane.QUESTION_MESSAGE);

        if (returnVal == JOptionPane.YES_OPTION)
        {
            saveNFA();
            return false;
        }
        else if (returnVal == JOptionPane.NO_OPTION)
        {
            workspacePanel.setModified(false);
            return false;
        }
        else //if (returnVal == JOptionPane.CANCEL_OPTION)
        {
            return true;
        }
        // return false;
    }

    /**
     * Called when a menu item is selected. Chooses an action based on the 
     * item selected. Part of ActionListener implementation.
     *
     * ActionEvent e: the ActionEvent generated by clicking on a menu item
     */
    public void actionPerformed(ActionEvent e)
    {
        String command = e.getActionCommand();

        if (command.equals("new nfa"))
        {
            startNewNFA();
        }

        else if (command.equals("open"))
        {
            openNFA();
        }

        else if (command.equals("save"))
        {
            saveNFA();
        }

        else if (command.equals("save as"))
        {
            saveAsNFA();
        }

        else if (command.equals("close"))
        {
            close();
        }

        else if (command.equals("started"))
        {
            JOptionPane.showMessageDialog(this,
                "Language Machine is a tool that lets you draw NFAs (or DFAs) and test them with input strings.\n\nTo draw a machine, use the state tools to add non-accepting and accepting states and connect\nthem with the transition tool. Assign rules to transitions in the Transition Options panel on the\nright. Use the select tool to move states and the delete tool to remove states or transitions.\nLanguage Machine uses the convention that any undrawn transitions go to a non-accepting\nstate which loops on all input.\n\n You can save and load NFAs (with any desired file extention).",
                "Getting Started",
                JOptionPane.PLAIN_MESSAGE);
        }
    }

    /**
     * Starts a new NFA. Asks the user if they want to save changes to the
     * current NFA. Only called in actionPerformed().
     */
    private void startNewNFA()
    {
        boolean canceled = showSaveChangesDialog();

        if (!canceled)
        {
            workspacePanel.setNFA(new NFA(new StartState(100, 250, false)));
            curFile = null;
            curDir = null;
            messagePanel.setFilename("Untitled NFA");
            optionsPanel.changeOptions("blank");
            inputToolbar.clearAcceptanceText();
            inputToolbar.getInputTextField().setText("");
            workspacePanel.setTool(LMWorkspacePanel.SELECT_TOOL);
            workspacePanel.repaint();
        }
    }

    /**
     * Attempts to open a file as an NFA. If the load succeeds, loads and draws
     * the new NFA. Otherwise, an error message is displayed and the current
     * NFA is still open. Only called in actionPerformed().
     */
    private void openNFA()
    {
        boolean canceled = showSaveChangesDialog();

        if (!canceled)
        {
            int choice = fileChooser.showOpenDialog(workspacePanel);
            if (choice == JFileChooser.APPROVE_OPTION)
            {
                curFile = fileChooser.getSelectedFile();
                curDir = fileChooser.getCurrentDirectory();
                if (curFile.exists())
                {
                    String filename = curFile.getName();
                    NFA nfa = new NFA();
                    if (nfa.load(curDir + "/" + filename))
                    {
                        workspacePanel.setNFA(nfa);
                        workspacePanel.setTool(LMWorkspacePanel.SELECT_TOOL);
                        workspacePanel.repaint();
                        messagePanel.setFilename(filename);
                    }
                }
                else
                {
                    JOptionPane.showMessageDialog(workspacePanel,
                        "Invalid file name. Failed to open file.",
                        "Invalid file name",
                        JOptionPane.ERROR_MESSAGE);
                }
            }
        }
    }

    /**
     * Saves the current NFA. If it hasn't already been saved, opens a 'save as'
     * dialog. Otherwise, saves the NFA using the current filename (curFile).
     * Only called in actionPerformed().
     */
    public void saveNFA()
    {
        // curFile = fileChooser.getSelectedFile();
        // curDir = fileChooser.getCurrentDirectory();

        if (curFile != null && curFile.exists())
        {
            workspacePanel.getNFA().save(curDir + "/" + curFile.getName());
            workspacePanel.setModified(false);
            messagePanel.setFilename(curFile.getName());
        }
        else
        {
            saveAsNFA();
        }
    }

    /**
     * Does a 'save as' of the current NFA, allowing the user to select a name
     * and location to save the file. Called by saveNFA() when the file hasn't
     * yet been saved. Shows a warning message if a file with the given name
     * already exists.
     */
    public void saveAsNFA()
    {
        int returnVal = fileChooser.showSaveDialog(workspacePanel);
        if (returnVal == JFileChooser.APPROVE_OPTION)
        {
            curFile = fileChooser.getSelectedFile();
            curDir = fileChooser.getCurrentDirectory();

            if (!curFile.exists())
            {
                workspacePanel.getNFA().save(curDir + "/" + curFile.getName());
                workspacePanel.setModified(false);
                messagePanel.setFilename(curFile.getName());
            }
            else
            {
                int choice = JOptionPane.showConfirmDialog(workspacePanel,
                    "This file already exists. Are you sure you want to overwirte it?",
                    "File already exists",
                    JOptionPane.YES_NO_OPTION,
                    JOptionPane.WARNING_MESSAGE);

                if (choice == JOptionPane.YES_OPTION)
                {
                    workspacePanel.getNFA().save(curDir + "/" + curFile.getName());
                    workspacePanel.setModified(false);
                    messagePanel.setFilename(curFile.getName());
                }
            }
            // workspacePanel.setModified(false);
        }
    }

    /**
     * Closes the window. Equivalent to clicking the 'x' in the corner. Shows
     * the save dialog if the current NFA is unsaved.
     */
    public void close()
    {
        boolean canceled = showSaveChangesDialog();

            if (!canceled)
            {
                System.exit(0);
            }
    }

    /**
     * Defines the action to perform upon clicking the close 'x' in the corner.
     * Uses the same closer() method as selecting close from the menu. Part of
     * the WindowListener implementation.
     */
    public void windowClosing(WindowEvent e)
    {
        close();
    }

    /**
     * Adds items to the menu to build the menu's UI.
     */
    private void buildUI()
    {
        JMenu fileMenu = new JMenu("File");
        // fileMenu.setMnemonic(KeyEvent.VK_F);
        fileMenu.setBorder(new EmptyBorder(5, 5, 5, 5));

        JMenuItem newNFAItem = new JMenuItem("New NFA");
        // newNFAItem.setBorder(new EmptyBorder(5, 5, 5, 5));
        newNFAItem.setPreferredSize(new Dimension(150, 25));
        newNFAItem.setActionCommand("new nfa");
        newNFAItem.addActionListener(this);
        fileMenu.add(newNFAItem);

        JMenuItem openItem = new JMenuItem("Open...");
        openItem.setPreferredSize(new Dimension(150, 25));
        openItem.setActionCommand("open");
        openItem.addActionListener(this);
        fileMenu.add(openItem);

        JMenuItem saveItem = new JMenuItem("Save");
        saveItem.setPreferredSize(new Dimension(150, 25));
        saveItem.setActionCommand("save");
        saveItem.addActionListener(this);
        fileMenu.add(saveItem);

        JMenuItem saveAsItem = new JMenuItem("Save As...");
        saveAsItem.setPreferredSize(new Dimension(150, 25));
        saveAsItem.setActionCommand("save as");
        saveAsItem.addActionListener(this);
        fileMenu.add(saveAsItem);

        JSeparator separator = new JSeparator();
        separator.setPreferredSize(new Dimension(0, 10));
        fileMenu.add(separator);

        JMenuItem closeItem = new JMenuItem("Close");
        // closeItem.setBorder(new EmptyBorder(5, 5, 5, 5));
        closeItem.setPreferredSize(new Dimension(150, 25));
        closeItem.setActionCommand("close");
        closeItem.addActionListener(this);
        fileMenu.add(closeItem);

        add(fileMenu);

        JMenu helpMenu = new JMenu("Help");
        helpMenu.setBorder(new EmptyBorder(5, 5, 5, 5));

        JMenuItem startedItem = new JMenuItem("Getting Started");
        startedItem.setPreferredSize(new Dimension(150, 25));
        startedItem.setActionCommand("started");
        startedItem.addActionListener(this);
        helpMenu.add(startedItem);

        add(helpMenu);
    }

    /**
     * Unimplemented WindowListener methods for the WindowListener implementation.
     */
    public void windowActivated(WindowEvent e) {}

    public void windowClosed(WindowEvent e) {}

    public void windowDeactivated(WindowEvent e) {}

    public void windowDeiconified(WindowEvent e) {}

    public void windowIconified(WindowEvent e) {}

    public void windowOpened(WindowEvent e) {}
}