Subversion Repositories HomeAutomation

/**

 * File created by Jimmy

 * at 2003-dec-23 21:43:41

 */

package Macbeth;

import Macbeth.System.*;

import Macbeth.Utilities.*;

import com.jgoodies.plaf.windows.ExtWindowsLookAndFeel;

import com.jgoodies.plaf.plastic.PlasticXPLookAndFeel;

import com.jgoodies.plaf.plastic.Plastic3DLookAndFeel;

import javax.swing.*;

import javax.swing.event.*;

import java.awt.*;

import java.awt.event.*;

import java.util.HashMap;

import java.util.Iterator;

import java.io.IOException;

import java.net.URL;

/**

 * A full featured kernel with graphical user interface.

 * @author Jimmy

 */

public class GUIKernel extends MbKernel {

    //a list of references to all loaded module GUI windows

    private HashMap loadedModuleGUIs;

    //the module whose info page we're currently viewing

    private MbModule selectedModule;

    /**

     * Creates a new instance of GUIKernel.

     * @param configFile The XML-configuration file to use.

     */

    public GUIKernel(String configFile) {

        super(configFile);

        selectedModule = null;

        //create GUI

        try {

            _debug.println("Loading Swing look and feel");

            //UIManager.setLookAndFeel(new ExtWindowsLookAndFeel());

            UIManager.setLookAndFeel(new Plastic3DLookAndFeel());

        } catch (Exception e) {}

        _debug.println("Creating Swing GUI");

        GUI g = new GUI();

        g.setVisible(true);

        try {

            startup();

        } catch (MbStartupException e) {

            _errors.println("Failed to start up kernel! (message: '" + e.getMessage() + "')");

            shutdown();

        }

        g.updateHTMLBar();

    }

    /**

     * Gets a short description of the kernel.

     * @return A short description of the kernel.

     */

    public String description() {

        return "Advanced kernel with graphical user interface";

    }

    /**

     * Starts up this kernel.

     */

    public void startup() throws MbStartupException {

        //startup MbKernel

        super.startup();

        loadedModuleGUIs = new HashMap(32);

    }

    /**

     * Shuts down this kernel.

     */

    public void shutdown() {

        //shut down MbKernel

        super.shutdown();

    }

    /**

     * Finds out whether or not a module has a graphical user interface.

     * @param moduleName The classname of the module.

     * @return True if this module has a GUI, false otherwise (or if module wasn't found).

     */

    public boolean moduleHasGUI(String moduleName) {

        //get the module

        MbModule m = (MbModule)loadedModules.get(moduleName);

        if (m!=null) {

            //get its interfaces

            Class[] interfaces = m.getClass().getInterfaces();

            //check whether the module implements the MbModuleGUI interface

            for (int i=0; i<interfaces.length; i++) {

                if (interfaces[i].getName().equals("Macbeth.System.MbModuleGUI")) {

                    return true;

                }

            }

        }

        return false;

    }

    /**

     * Gets the HTML-page from a specified module.

     * @param moduleName The classname of the module whose HTML-page you want to get.

     * @return Full HTML-code for this modules HTML-page. If the specified module

     * doesn't have a HTML-interface, its description is returned instead.

     */

    public String getHTMLPage(String moduleName) {

        //get the module

        MbModule mod = (MbModule)loadedModules.get(moduleName);

        //get its html-interface

        MbHTMLInterface html = mod.getHTMLInterface();

        //if this module has a HTML-interface

        if (html!=null) {

            //then return the HTML-page

            return html.getHTMLPage();

            //else, if this module doesn't have a html-interface

        } else {

            //return description instead

            return mod.description();

        }

    }

    /**

     * The whole graphical user interface for this kernel.

     */

    private class GUI extends JFrame implements ActionListener,WindowListener {

        //private JSplitPane contentArea;

        private JEditorPane htmlBar;

        private JScrollPane htmlBarScrolled;

        private JTabbedPane tabbedArea;

        private JEditorPane tabInfo;

        private JScrollPane tabInfoScrolled;

        private MDIDesktopPane tabGUI;

        private JScrollPane tabGUIScrolled;

        //private JTextArea console;

        private JEditorPane console;

        //private MbHTMLDocument consoleDocument;

        private JScrollPane consoleScrolled;

        private JMenuBar menuBar;

        public GUI() {

            setTitle("Macbeth GUI kernel");

        //create html bar

            htmlBar = new JEditorPane();

            htmlBar.setEditable(false);

            htmlBar.setBorder(BorderFactory.createEmptyBorder());

            htmlBar.setContentType("text/html");

            htmlBar.addHyperlinkListener(new HyperlinkActionsHTMLBar());

            htmlBarScrolled = new JScrollPane(htmlBar);

            htmlBarScrolled.setMinimumSize(new Dimension(100,100));

            htmlBarScrolled.setBorder(BorderFactory.createEmptyBorder());

        //create info tab

            tabInfo = new JEditorPane();

            tabInfo.setBorder(BorderFactory.createEmptyBorder());

            tabInfo.setContentType("text/html");

            tabInfo.addHyperlinkListener(new HyperlinkActionsInfoPage());

            tabInfo.setText("<html><h1>Macbeth!</h1></html>");

            tabInfo.setEditable(false);

            tabInfoScrolled = new JScrollPane(tabInfo);

            tabInfoScrolled.setBorder(BorderFactory.createEmptyBorder());

        //create gui tab

            tabGUI = new MDIDesktopPane();

            tabGUI.setBorder(BorderFactory.createEmptyBorder());

            tabGUIScrolled = new JScrollPane(tabGUI);

            tabGUIScrolled.setBorder(BorderFactory.createEmptyBorder());

        //create tabbed view

            tabbedArea = new JTabbedPane();

            tabbedArea.addTab("Info Page", null, tabInfoScrolled, "Module information");

            tabbedArea.addTab("GUI Desktop", null, tabGUIScrolled, "Module GUI desktop");

            tabbedArea.setPreferredSize(new Dimension(600,500));

            tabbedArea.setMinimumSize(new Dimension(100,100));

            tabbedArea.setBorder(BorderFactory.createEmptyBorder());

        //create console area

            console = new JEditorPane();

            console.setEditable(false);

            console.setContentType("text/html");

            //console = new JTextArea();

            //console.setMargin(new Insets(5,5,5,5));

            console.setBorder(BorderFactory.createEmptyBorder());

            consoleScrolled = new JScrollPane(console);

            consoleScrolled.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

            consoleScrolled.setPreferredSize(new Dimension(600,80));

            consoleScrolled.setMinimumSize(new Dimension(200,50));

            consoleScrolled.setBorder(BorderFactory.createEmptyBorder());

            consoleScrolled.addComponentListener(

                    new ComponentListener(){

                        //when console is resized, make sure it scrolls down to bottom

                        public void componentResized(ComponentEvent e) {

                            //hmm....ugly hack, but it doesn't seem to work without the 0-position

                            console.setCaretPosition(0);

                            console.setCaretPosition(console.getDocument().getLength());

                        }

                        public void componentMoved(ComponentEvent e) {}

                        public void componentShown(ComponentEvent e) {}

                        public void componentHidden(ComponentEvent e) {}

                    });

            _errors = new TextFormatterStream(new EditorPaneStream(console));

            ((TextFormatterStream)_errors).setPreString("<font size=\"-1\" color=\"red\">");

            ((TextFormatterStream)_errors).setPostString("</font>");

            _info = new TextFormatterStream(new EditorPaneStream(console));

            ((TextFormatterStream)_info).setPreString("<font size=\"-1\" color=\"black\">");

            ((TextFormatterStream)_info).setPostString("</font>");

            _debug = new TextFormatterStream(new EditorPaneStream(console));

            ((TextFormatterStream)_debug).setPreString("<font size=\"-1\" color=\"#777777\">");

            ((TextFormatterStream)_debug).setPostString("</font>");

        //create menu bar

            menuBar = new JMenuBar();

            setJMenuBar(menuBar);

            JMenu menu;

            JMenuItem menuItem;

            menu = new JMenu("System");

            menu.getAccessibleContext().setAccessibleDescription("System commands");

            menuBar.add(menu);

            menuItem = new JMenuItem("Restart modules");

            menuItem.getAccessibleContext().setAccessibleDescription("Restart all modules");

            menu.add(menuItem);

            menuItem = new JMenuItem("Restart kernel");

            menu.add(menuItem);

            menu.addSeparator();

            menuItem = new JMenuItem("Quit");

            menu.add(menuItem);

        //create a split pane that holds the HTML bar to the left and the tabview to the right

            JSplitPane splitHorizontal = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,new TitledControl(htmlBarScrolled,"Macbeth menu"),tabbedArea);

            splitHorizontal.setDividerLocation(130);

            splitHorizontal.setDividerSize(6);

            //tabbedArea will get all extra space when resizing

            splitHorizontal.setResizeWeight(0.0);

            //JWindowPane splitHorizontal = new JWindowPane(JWindowPane.HORIZONTAL,"Macbeth components",htmlBarScrolled,"Content",tabbedArea,null);

        //create a split pane that holds the the content at top and the console at bottom

            JSplitPane splitVertical = new JSplitPane(JSplitPane.VERTICAL_SPLIT,splitHorizontal,new TitledControl(consoleScrolled,"Console"));

            splitVertical.setResizeWeight(0.8);

            //JWindowPane splitVertical = new JWindowPane(JWindowPane.VERTICAL,"top",splitHorizontal,"Console",consoleScrolled,null);

        //add everything to main frame

            Container content = this.getContentPane();

            content.setLayout(new BorderLayout());

            content.add(splitVertical,BorderLayout.CENTER);

            pack();

            setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);

            addWindowListener(this);

        }

        /* EVENT HANDLERS... */

        public void actionPerformed(ActionEvent e) {}

        public void windowClosing(WindowEvent e) {

            //when kernel GUI is closed, it's time to shut down

            shutdown();

            setVisible(false);

            _errors = System.err;

            _info = System.out;

            _debug = System.out;

            _debug.println("GUI has been closed");

            _debug.println("Waiting for threads to stop");

            dispose();

        }

        public void windowOpened(WindowEvent e) {}

        public void windowClosed(WindowEvent e) {}

        public void windowIconified(WindowEvent e) {}

        public void windowDeiconified(WindowEvent e) {}

        public void windowActivated(WindowEvent e) {}

        public void windowDeactivated(WindowEvent e) {}

        /**

         * Responds to hyperlink clicks in the left HTML bar.

         */

        class HyperlinkActionsHTMLBar implements HyperlinkListener {

            public void hyperlinkUpdate(HyperlinkEvent e) {

                if (e.getEventType()==HyperlinkEvent.EventType.ACTIVATED) {

                    URL url = e.getURL();

                    String description = e.getDescription();

                    //if a valid URL exists for the link

                    if (url!=null) {

                        //load the page in the main browser

                        try {

                            tabInfo.setPage(url);

                            selectedModule = null;

                        } catch (IOException e1) {

                            e1.printStackTrace();

                        }

                    }

                    //else, use the description to find out what to do

                    else {

                        //interprete the description as an internal macbeth command

                        String[] cmd = description.split(":");

                        if (cmd.length<=0) {

                            return;

                        }

                        //shows information on the specified macbeth component

                        if (cmd[0].equalsIgnoreCase("ShowInfo")) {

                            tabInfo.setText(getHTMLPage(cmd[1]));

                            selectedModule = (MbModule)loadedModules.get(cmd[1]);

                        }

                        //adds a module GUI to the GUI desktop

                        else if (cmd[0].equalsIgnoreCase("ShowGUI")) {

                            loadModuleGUI(cmd[1]);

                        }

                        //unloads a module

                        else if (cmd[0].equalsIgnoreCase("Unload")) {

                            unloadModule(cmd[1]);

                            updateHTMLBar();

                        }

                        //loads an unloaded module

                        else if (cmd[0].equalsIgnoreCase("Load")) {

                            try {

                                loadModule(cmd[1]);

                            } catch (Exception el) {

                                _errors.println("Error loading module: " + el);

                            }

                            updateHTMLBar();

                        }

                    }

                }

            }

        }

        /**

         * Responds to hyperlink clicks on module info page.

         */

        class HyperlinkActionsInfoPage implements HyperlinkListener {

            public void hyperlinkUpdate(HyperlinkEvent e) {

                if (e.getEventType()==HyperlinkEvent.EventType.ACTIVATED) {

                    URL url = e.getURL();

                    String description = e.getDescription();

                    //if a valid URL exists for the link

                    if (url!=null) {

                        //load the page in the main browser

                        try {

                            tabInfo.setPage(url);

                        } catch (IOException e1) {

                            e1.printStackTrace();

                        }

                    }

                    //else, notify the current module about the click

                    else {

                        if (selectedModule!=null) {

                            MbHTMLInterface html = selectedModule.getHTMLInterface();

                            if (html!=null) {

                                html.linkPressed(description);

                            }

                        }

                    }

                }

            }

        }

        public void updateHTMLBar() {

            String html = "<html>" + MySystem.lineBreak;

            html += "<body><b>Loaded modules</b><p>" + MySystem.lineBreak;

            //iterate through loaded modules-list

            Iterator it = loadedModules.keySet().iterator();

            while (it.hasNext()) {

                String modname = (String)it.next();

                html += "<b>" + modname + "</b><br>" + MySystem.lineBreak;

                html += " - [<a href=\"ShowInfo:" + modname + "\">Show Info</a>]<br>" + MySystem.lineBreak;

                if (moduleHasGUI(modname)) {

                    html += " - [<a href=\"ShowGUI:" + modname + "\">Load GUI</a>]<br>" + MySystem.lineBreak;

                }

                html += " - [<a href=\"Unload:" + modname + "\">Unload</a>]<br>" + MySystem.lineBreak;

            }

            html += "</p>" + MySystem.lineBreak;

            html += "<b>Unloaded modules</b><p>";

            //iterate through module list to find unloaded modules

            it = moduleList.keySet().iterator();

            while (it.hasNext()) {

                String modname = (String)it.next();

                //only show unloaded modules

                if (!loadedModules.containsKey(modname)) {

                    html += "<b>" + modname + "</b><br>" + MySystem.lineBreak;

                    html += " - [<a href=\"Load:" + modname + "\">Load</a>]<br>" + MySystem.lineBreak;

                }

            }

            html += "</p>" + MySystem.lineBreak;

            html += "</body></html>";

            htmlBar.setText(html);

        }

        /**

         * Loads the GUI for the specified module.

         * @param moduleName The module whose GUI should be loaded.

         */

        public void loadModuleGUI(String moduleName) {

            //if a GUI is already loaded for this module

            if (loadedModuleGUIs.containsKey(moduleName)) {

                //then bring this GUI to the front

                ModuleGUIWindow w = (ModuleGUIWindow)loadedModuleGUIs.get(moduleName);

                w.moveToFront();

                return;

            }

            //else, if this module does have a GUI

            else if (moduleHasGUI(moduleName)) {

                //create a new window for the GUI

                MbModuleGUI i = (MbModuleGUI)loadedModules.get(moduleName);

                ModuleGUIWindow w = new ModuleGUIWindow(moduleName);

                //and render GUI into this window

                i.renderGUI(w.getContentPane());

                w.setTitle(moduleName);

                //pack the contents to minimum possible size and show frame

                w.pack();

                w.setVisible(true);

                tabGUI.add(w);

            } else {

                //the module doesn't have any GUI

            }

        }

        /**

         * A window for a module GUI. This window will be shown

         * on the GUI desktop located inside the tabview.

         */

        private class ModuleGUIWindow extends JInternalFrame implements InternalFrameListener {

            private String moduleName;

            /**

             * Creates a new GUI window.

             * @param moduleName The name of the module.

             */

            public ModuleGUIWindow(String moduleName) {

                super();

                this.moduleName = moduleName;

                setDefaultCloseOperation(DISPOSE_ON_CLOSE);

                setResizable(true);

                setClosable(true);

                setMaximizable(false);

                addInternalFrameListener(this);

            }

            public void internalFrameOpened(InternalFrameEvent e) {

                //put a reference to this window into the hashmap

                loadedModuleGUIs.put(moduleName,this);

            }

            public void internalFrameClosed(InternalFrameEvent e) {

                //remove our reference from the hashmap

                loadedModuleGUIs.remove(moduleName);

            }

            public void internalFrameClosing(InternalFrameEvent e) {}

            public void internalFrameIconified(InternalFrameEvent e) {}

            public void internalFrameDeiconified(InternalFrameEvent e) {}

            public void internalFrameActivated(InternalFrameEvent e) {}

            public void internalFrameDeactivated(InternalFrameEvent e) {}

        }

    }

    /**

     * Program entry point.

     * @param args The command line arguments.

     */

    public static void main(String[] args) {

        String configFile = "Config\\Kernel.xml";

        //config file can also be specified with command line args

        if (args.length>0) {

            configFile = args[0];

        }

        //create new kernel

        new GUIKernel(configFile);

    }

}