AbstractMainWindow.java

Go to the documentation of this file.

package com.arcle.rmt.j2se.swing;

import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.event.*;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Container;
import java.awt.Toolkit;
import java.awt.Dimension;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.Observer;
import java.util.Observable;
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Hashtable;
import java.io.File;
import java.io.IOException;

import com.arcle.rmt.j2se.swing.ui.MoreSwingUtilities;
import com.arcle.rmt.j2se.swing.ui.LookAndFeelSelector;
import com.arcle.rmt.j2se.swing.ui.ExceptionSafeActionWrapper;
import com.arcle.rmt.j2se.swing.vc.AbstractDesktop;
import com.arcle.rmt.j2se.util.ExceptionWrapper;
import com.arcle.rmt.j2se.util.MoreCollections;
import com.arcle.rmt.j2se.util.CollectionVisitor;
import com.arcle.rmt.j2se.framework.Document;

public abstract class AbstractMainWindow extends JApplet implements Observer {

    //-----------------------------------------------------------------------
    // Command handlers

    protected void cmFileNew() {
        if (!doAskSave()) {
            return;
        }
        doNewDocument();
        updateTitle();
    }

    protected void cmFileOpen() {
        JFileChooser fc = getFileChooser();
        int option = fc.showOpenDialog(this);
        File selectedFile = fc.getSelectedFile();
        switch (option) {
        case JFileChooser.APPROVE_OPTION:
            if (selectedFile != null) {
                setDocumentFile(getCurrentFileHandler().filterFile(selectedFile));
                doOpenDocument();
            } else {
                JOptionPane.showMessageDialog(this,
                    "You didn't specify a file. Open aborted.",
                     "Open File",
                     JOptionPane.ERROR_MESSAGE);
            }
            break;
        case JFileChooser.CANCEL_OPTION:
            break;
        case JFileChooser.ERROR_OPTION:
            break;
        }
        updateTitle();
    }

    protected void cmFileSave() {
        if (getDocumentFile() == null) {
            cmFileSaveAs();
            return;
        }
        doSaveDocument();
        updateTitle();
    }

    protected void cmFileSaveAs() {
        JFileChooser fc = getFileChooser();
        int option = fc.showSaveDialog(this);
        File selectedFile = fc.getSelectedFile();
        switch (option) {
        case JFileChooser.APPROVE_OPTION:
            if (selectedFile != null) {
                setDocumentFile(getCurrentFileHandler().filterFile(selectedFile));
                doSaveDocument();
            } else {
                JOptionPane.showMessageDialog(this,
                    "You didn't specify a file name. Save aborted.",
                     "Save As",
                     JOptionPane.ERROR_MESSAGE);
            }
            break;
        case JFileChooser.CANCEL_OPTION:
            break;
        case JFileChooser.ERROR_OPTION:
            break;
        }
        updateTitle();
    }

    protected void cmFileRevert() {
        File docFile = getDocumentFile();
        if (docFile == null) {
            return;
        }

        int answer = JOptionPane.showConfirmDialog(this,
            "Do you want to re-load the document from disk and lose your changes?",
            "Revert to Saved",
            JOptionPane.YES_NO_OPTION);
        switch (answer) {
        case JOptionPane.YES_OPTION:
            doOpenDocument();
            break;
        case JOptionPane.NO_OPTION:
            // do nothing, really.
            break;
        default:
            throw new IllegalStateException(
                "Unknown value returned from JOptionPane.showConfirmDialog(): "
                + answer);
        }
    }

    protected void cmFileExit() {
        if (!doAskSave()) {
            return;
        }
        doExit();
    }

    //-----------------------------------------------------------------------
    // Command strategy methods

    protected abstract void doNewDocument();

    protected void doSaveDocument() {
        try {
            FileHandler handler = getCurrentFileHandler();
            StringBuffer log = new StringBuffer();

            handler.saveFile(getDocument(), getDocumentFile(), log);
            if (log.length() > 0) {
                MoreSwingUtilities.showTextDialog(this, log.toString(),
                    "Error(s) occured while saving document",
                    JOptionPane.ERROR_MESSAGE);
            } else {
                setDirty(false);
            }
        } catch(ExceptionWrapper e) {
            showException(e);
        }
    }

    protected void doOpenDocument() {
        try {
            FileHandler handler = getCurrentFileHandler();
            StringBuffer log = new StringBuffer();
            setDocument(handler.openFile(getDocumentFile(), log));
            if (log.length() > 0) {
                MoreSwingUtilities.showTextDialog(this, log.toString(),
                    "Error(s) occured while opening document",
                    JOptionPane.ERROR_MESSAGE);
            } else {
                setDirty(false);
            }
        } catch(ExceptionWrapper e) {
            showException(e);
        }
    }


    protected boolean doAskSave() {
        if (isDirty()) {
            // prompt to save
            int answer = JOptionPane.showConfirmDialog(this,
                "The current document has been changed, do you want to save it?",
                "Save Document",
                JOptionPane.YES_NO_CANCEL_OPTION);
            switch (answer) {
            case JOptionPane.YES_OPTION:
                cmFileSave();
                break;
            case JOptionPane.NO_OPTION:
                // do nothing, really.
                break;
            case JOptionPane.CANCEL_OPTION:
                return false; // no 'break' needed here.
            default:
                throw new IllegalStateException(
                    "Unknown value returned from JOptionPane.showConfirmDialog(): "
                    + answer);
            }
        }
        return true;
    }

    protected void doExit() {
        // handle exit as an application
        if (applicationFrame != null) {
            applicationFrame.dispose();
            // terminate after all messages have been processed
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    System.exit(0);
                }
            });
        }
    }

    //-----------------------------------------------------------------------
    // JApplet implementations

    public void init() {
        //Container cp = this;
        Container cp = getContentPane();
        cp.setLayout(new BorderLayout());
        cp.add(getDesktop(), BorderLayout.CENTER);
        initMenu();

        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                try {
                    cmFileNew();
                    System.gc();
                } catch(Exception e) {
                    showException(e);
                } catch(NoClassDefFoundError e) {
                    // catch NoClassDefFoundError that might be thrown
                    // if Xerces is not installed.
                    MoreSwingUtilities.showThrowable(AbstractMainWindow.this,
                        e, "Fatal Error - Application Component Not Found");
                }
            }
        });
    }

    public void start() {
        // It is possible that this method is invoked
        // from a thread other than the event-dispatching
        // thread.
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                updateTitle();
            }
        });
    }

    public void stop() {  }

    public void destroy() { }

    //-----------------------------------------------------------------------
    // Observer implementation

    public void update(Observable source, Object param) {
        if (source == getDocument()) {
            // maybe called from another thread
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    setDirty(true);
                }
            });
        }
    }


    //-----------------------------------------------------------------------
    // Own implementation

    protected void updateTitle() {
        if (applicationFrame != null) {
            File doc = getDocumentFile();
            String title = APPLICATION_TITLE;
            String fileName = doc != null ? " - [" + doc.getName() + "] " : FILE_UNTITILED;
            String modified = !isDirty() && doc != null ? FILE_UNMODIFIED : "";
            applicationFrame.setTitle(title + fileName + modified);
        }
    }

    protected void showException(Exception e) {
        MoreSwingUtilities.showException(this, e);
    }


    //-----------------------------------------------------------------------
    // Menu-configuration methods

    protected void initMenu() {
        JMenuBar mb = createMenuBar();
        JMenu file = createMenu();
        JMenu requirement = createMenu();
        JMenu tools = createMenu();
        JMenu help = createMenu();

        // configure
        file.setText("File");
        requirement.setText("Requirement");
        tools.setText("Tools");
        help.setText("Help");

        file.setMnemonic(KeyEvent.VK_F);
        requirement.setMnemonic(KeyEvent.VK_R);
        tools.setMnemonic(KeyEvent.VK_T);
        help.setMnemonic(KeyEvent.VK_H);

        // init submenus
        initFileMenu(file);
        initRequirementMenu(requirement);
        initToolsMenu(tools);
        initHelpMenu(help);

        // add
        mb.add(file);
        mb.add(requirement);
        mb.add(tools);
        mb.add(help);

        // done
        setJMenuBar(mb);
    }

    protected void initFileMenu(JMenu file) {
        // add to menu
        file.add(createFileNewAction());
        file.add(createFileOpenAction());
        file.add(createFileSaveAction());
        file.add(createFileSaveAsAction());
        file.addSeparator();
        file.add(createFileRevertAction());
        file.addSeparator();
        file.add(createFileExitAction());
    }

    protected void initRequirementMenu(JMenu reqMenu) {
        Iterator iter = getDesktop().getController().getActions().iterator();
        while (iter.hasNext()) {
            reqMenu.add(createMenuItem((Action) iter.next()));
        }
    }

    protected void initHelpMenu(JMenu help) {
        help.add(createHelpAboutAction());
    }

    protected void initToolsMenu(JMenu tools) {
        JMenu selectorMenu = LookAndFeelSelector.getInstance().getSelectorMenu();
        final AbstractMainWindow mainWindow = this;

        selectorMenu.addMenuListener(new MenuListener() {
            public void menuCanceled(MenuEvent e) { }
            public void menuDeselected(MenuEvent e) {
                SwingUtilities.invokeLater(new Runnable() {
                    public void run() {
                        LookAndFeel curLF = UIManager.getLookAndFeel();
                        if (curLF != lastLF) {
                            // update tree if a new LF was selected.
                            SwingUtilities.updateComponentTreeUI(mainWindow);
                            lastLF = curLF;
                            _fileChooser = null;
                        }
                    }
                });
            }
            public void menuSelected(MenuEvent e) {   }
            LookAndFeel lastLF = UIManager.getLookAndFeel();
        });

        tools.add(selectorMenu);
    }


    protected void runAsApplication(String[] args) {
        final AbstractMainWindow app = this;
        applicationFrame = createApplicationFrame(app);
        applicationFrame .addWindowListener(new WindowAdapter() {
            public void windowActivated(WindowEvent e) {
                app.start();
            }
            public void windowDeactivated(WindowEvent e) {
                app.stop();
            }
            public void windowClosing(WindowEvent e) {
                app.cmFileExit();
            }
            public void windowClosed() {
                app.destroy();
            }
        });
        init();
        //applicationFrame.pack();
        applicationFrame.setVisible(true);
    }

    //-----------------------------------------------------------------------
    // Accessor Methods

    protected AbstractDesktop getDesktop() {
        if (_desktop == null) {
            _desktop = createDesktop();
        }
        return _desktop;
    }

    public boolean isDirty() {
        return dirty;
    }

    protected void setDirty(boolean d) {
        if (d != dirty) {
            boolean old = dirty;
            dirty = d;
            firePropertyChange("dirty", new Boolean(old), new Boolean(d));
            updateTitle();  // changed status
        }
    }

    protected Document getDocument() {
        return document;
    }

    protected void setDocument(Document d) {
        Document old = document;
        if (document != null) {
            // remove this from the old document's Observers list
            document.deleteObserver(this);
        }
        document = d;
        if (document != null) {
            // add this to the new document's Observers list
            document.addObserver(this);
        }
        getDesktop().setDocument(d);
        firePropertyChange("document", old, document);
    }

    protected void setDocumentFile(File f) {
        File old = documentFile;
        documentFile = f;
        firePropertyChange("documentFile", old, documentFile);
    }

    protected File getDocumentFile() {
        return documentFile;
    }

    protected JFileChooser getFileChooser() {
        if (_fileChooser == null) {
            _fileChooser = createFileChooser();
        }
        //_fileChooser.updateUI();
        return _fileChooser;
    }

    protected Map getFileHandlers() {
        if (_fileHandlers == null) {
            Collection handlers = createFileHandlers();
            _fileHandlers = new Hashtable(handlers.size(), 1);
            CollectionVisitor visitor = new CollectionVisitor() {
                public boolean visitCollection(Object member) {
                    FileHandler fh = (FileHandler) member;
                    _fileHandlers.put(fh.getFileFilter(), fh);
                    return true;
                }
            };
            MoreCollections.visitCollection(handlers, visitor);
        }
        return _fileHandlers;
    }

    protected abstract FileHandler getDefaultFileHandler();

    protected Collection getFileFilters() {
        return getFileHandlers().keySet();

    }

    protected FileHandler getCurrentFileHandler() {
        return (FileHandler) getFileHandlers().get(getFileChooser()
            .getFileFilter());
    }


    //-----------------------------------------------------------------------
    // Factory Methods

    protected abstract AbstractDesktop createDesktop();

    protected abstract Collection createFileHandlers();

    protected Frame createApplicationFrame(Component content) {
        //final int WIDTH = 760;
        //final int HEIGHT = 420;
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        int WIDTH = screenSize.width * 3 / 4;
        int HEIGHT = screenSize.height * 3 / 4;

        JFrame applicationFrame = new JFrame();
        applicationFrame.getContentPane().add(content);

        /* DO NOT REMOVE this call to pack(),
           or the JInternalFrame within the frame will sometimes not display
           or even crashes with a NullPointerException in Sun's native code.
           See JDK Bug #4354535 in
           http://developer.java.sun.com/developer/bugParade/bugs/4354535.html
        */
        applicationFrame.pack();

        applicationFrame.setSize(WIDTH, HEIGHT);
        applicationFrame.setLocation((screenSize.width - WIDTH)/2,
            (screenSize.height - HEIGHT)/2);
        return applicationFrame;
    }

    protected JFileChooser createFileChooser() {
        Iterator filters = getFileFilters().iterator();
        JFileChooser chooser = new JFileChooser();
        while (filters.hasNext()) {
            chooser.addChoosableFileFilter((FileFilter) filters.next());
        }
        chooser.setFileFilter(getDefaultFileHandler().getFileFilter());
        chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
        chooser.setMultiSelectionEnabled(false);
        chooser.setAcceptAllFileFilterUsed(false);
        return chooser;
    }


    protected JMenuBar createMenuBar() {
        return new JMenuBar();
    }

    protected JMenu createMenu() {
        return new JMenu();
    }

    protected JMenuItem createMenuItem() {
        return new JMenuItem();
    }

    protected JMenuItem createMenuItem(final Action action) {
        if (action == null) {
            throw new IllegalArgumentException("Parameter 'action' cannot be null.");
        }
        JMenuItem mi = new JMenuItem(action);
        return mi;
    }

    protected Action createActionWrapper(Action wrapped) {
        return new ExceptionSafeActionWrapper(this, wrapped);
    }

    protected Action createFileNewAction() {
        return createActionWrapper(new FileNewAction());
    }

    protected Action createFileOpenAction() {
        return createActionWrapper(new FileOpenAction());
    }

    protected Action createFileSaveAction() {
        return createActionWrapper(new FileSaveAction());
    }

    protected Action createFileSaveAsAction() {
        return createActionWrapper(new FileSaveAsAction());
    }

    protected Action createFileRevertAction() {
        return createActionWrapper(new FileRevertAction());
    }

    protected Action createFileExitAction() {
        return createActionWrapper(new FileExitAction());
    }

    protected Action createHelpAboutAction() {
        return createActionWrapper(new HelpAboutAction());
    }

    //-----------------------------------------------------------------------
    // Member Variables

    private AbstractDesktop _desktop = null;

    private boolean dirty = false;

    private Document document = null;

    private File documentFile = null;

    private Frame applicationFrame = null;

    private JFileChooser _fileChooser = null;

    private Map _fileHandlers = null;

    protected static final String APPLICATION_TITLE = "Rambutan Desktop";

    protected static final String FILE_UNMODIFIED = "(Unmodified)";

    protected static final String FILE_UNTITILED = " -untitled- ";

    //-----------------------------------------------------------------------
    //

    protected abstract class FileHandler {
        public abstract FileFilter getFileFilter();

        public abstract Document openFile(File f, StringBuffer log)
            throws ExceptionWrapper;

        public abstract void saveFile(Document doc, File f, StringBuffer log)
            throws ExceptionWrapper;

        public abstract File filterFile(File inputFile);

        protected File assignExtension(File file, String ext) {
            try {
                /* Already exists or already have an extension?
                   Note that a dot as the first character in a file name
                   is not considered the start of an extension */
                if (file.exists() ||  file.getName().lastIndexOf('.') > 0) {
                    return file;
                }
                String newName = file.getCanonicalPath() + '.' + ext;
                return new File(newName);
            } catch(IOException e) {
                showException(e);
                return file;    // return unchanged.
            }
        }
    }


    //-----------------------------------------------------------------------
    // Action classes


    protected class FileNewAction extends AbstractAction {
        public FileNewAction() {
            putValue(NAME, "New");
            putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_N));
            putValue(SHORT_DESCRIPTION, "Creates a new blank document.");
            putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_N, KeyEvent.CTRL_MASK));
            setEnabled(true);
        }

        //--------------------------------------------------------------------
        // AbstractAction implementation

        public void actionPerformed(ActionEvent e) {
            cmFileNew();
        }

    }

    protected class FileOpenAction extends AbstractAction {
        public FileOpenAction() {
            putValue(NAME, "Open");
            putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_O));
            putValue(SHORT_DESCRIPTION, "Opens a document from the disk.");
            putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_O, KeyEvent.CTRL_MASK));
            setEnabled(true);
        }

        public void actionPerformed(ActionEvent e) {
            cmFileOpen();
        }
    }

    protected class FileSaveAction extends AbstractAction
            implements PropertyChangeListener {
        public FileSaveAction() {
            putValue(NAME, "Save");
            putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_S));
            putValue(SHORT_DESCRIPTION, "Saves the current document.");
            putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_S, KeyEvent.CTRL_MASK));
            setEnabled(isDirty());
            AbstractMainWindow.this.addPropertyChangeListener(this);
        }

        public void actionPerformed(ActionEvent e) {
            cmFileSave();
        }

        //--------------------------------------------------------------------
        // PropertyChangeListener implementation

        public void propertyChange(PropertyChangeEvent evt) {
            if (evt.getSource() == AbstractMainWindow.this) {
                if ("dirty".equals(evt.getPropertyName())) {
                    boolean dirty =((Boolean)evt.getNewValue()).booleanValue();
                    setEnabled(dirty);
                }
            }
        }

    }

    protected class FileSaveAsAction extends AbstractAction {
        public FileSaveAsAction() {
            putValue(NAME, "Save As");
            putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_A));
            putValue(SHORT_DESCRIPTION, "Saves the current document as a new file.");
            setEnabled(true);
        }

        public void actionPerformed(ActionEvent e) {
            cmFileSaveAs();
        }
    }

    protected class FileRevertAction extends AbstractAction
            implements PropertyChangeListener {
        public FileRevertAction() {
            putValue(NAME, "Revert to Saved");
            putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_R));
            putValue(SHORT_DESCRIPTION, "Re-loads the current document from disk.");
            AbstractMainWindow.this.addPropertyChangeListener(this);
            checkEnabled();
        }

        public void actionPerformed(ActionEvent e) {
            cmFileSaveAs();
        }

        //--------------------------------------------------------------------

        protected void checkEnabled() {
            setEnabled(isDirty() && getDocumentFile() != null);
        }

        //--------------------------------------------------------------------
        // PropertyChangeListener implementation

        public void propertyChange(PropertyChangeEvent evt) {
            if (evt.getSource() == AbstractMainWindow.this) {
                if ("dirty".equals(evt.getPropertyName())
                        || "document".equals(evt.getPropertyName())) {
                    checkEnabled();
                }
            }
        }
    }

    protected class FileExitAction extends AbstractAction {
        public FileExitAction () {
            putValue(NAME, "Exit");
            putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_X));
            putValue(SHORT_DESCRIPTION, "Terminates the current application.");
            setEnabled(applicationFrame != null);
        }

        public void actionPerformed(ActionEvent e) {
            cmFileExit();
        }
    }

    protected class HelpAboutAction extends AbstractAction {
        public HelpAboutAction() {
            putValue(NAME, "About");
            putValue(MNEMONIC_KEY, new Integer(KeyEvent.VK_A));
            putValue(SHORT_DESCRIPTION, "Displays version and copyright information.");
            setEnabled(true);
        }

        public void actionPerformed(ActionEvent e) {
            new AboutDialog(AbstractMainWindow.this).show();
        }
    }
}

---