Application: gvSIG desktop » gvSIG scripting

// jEdit settings:

// :tabSize=4:indentSize=4:noTabs=true:folding=explicit:collapseFolds=1:

package thing;

import java.awt.Color;

import java.awt.Font;

import java.awt.Frame;

import java.awt.Image;

import java.awt.datatransfer.DataFlavor;

import java.awt.datatransfer.StringSelection;

import java.awt.datatransfer.Transferable;

import java.awt.datatransfer.UnsupportedFlavorException;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Reader;

import java.io.StringReader;

import java.text.ParseException;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Map;

import java.util.Stack;

import java.util.StringTokenizer;

import java.util.logging.Level;

import java.util.logging.Logger;

import thinlet.Thinlet;

import utils.AWTUtils;

import thinletcommons.ColorChooser;

import thinletcommons.FileChooser;

import thinletcommons.FileFilter;

import thinletcommons.ExtensionFileFilter;

import thinletcommons.FontChooser;

import thinletcommons.MessageDialog;

/**

 * ThinG GUI logic handler/controller.

 *

 * @author Dirk Moebius

 */

public class Handler

{

    //{{{ logging

    private static final Logger log = Logger.getLogger("thing");

    private static final boolean debug() { return log.isLoggable(Level.FINE); }

    //}}}

    //{{{ constants

    private static final int TAB_XML = 0;

    private static final int TAB_PREVIEW = 1;

    //}}}

    //{{{ private members

    private Thinlet thinlet;

    private HashMap components = new HashMap();

    private PropertyManager propmgr;

    private File file;

    private boolean isChanged = false;

    private String clipboard;

    // components of main panel

    private Object root;

    private Object preview;

    private Object tree;

    private Object props;

    private Object tabs;

    private Object statusbar;

    private Object toolbar;

    //}}}

    //{{{ constructor Handler(Thinlet thinlet)

    Handler(Thinlet thinlet)

    {

        this.thinlet = thinlet;

        init();

        setStatusText("ThinG v" + Main.getVersion() + " - created by Dirk Moebius (dmoebius@gmx.net)");

    }

    //}}}

    //{{{ public handler callbacks

    //{{{ public void menu_file_new()

    public void menu_file_new()

    {

        if(!checkForChanges())

            return;

        setSelectedFile(null);

        init();

        setChanged(false);

        setStatusText("New gui created.");

    }

    //}}}

    //{{{ public void menu_file_open()

    public void menu_file_open()

    {

        if(!checkForChanges())

            return;

        File selectedFile = getFile(FileChooser.MODE_OPEN, "Load Thinlet XML file...", thinlet, this.file);

        if(selectedFile != null)

        {

            setSelectedFile(selectedFile);

            load();

        }

    }

    //}}}

    //{{{ public void menu_file_reload()

    public void menu_file_reload()

    {

        if(!checkForChanges())

            return;

        if(this.file != null)

            load();

    }

    //}}}

    //{{{ public void menu_file_save()

    public void menu_file_save()

    {

        save(false);

    }

    //}}}

    //{{{ public void menu_file_save_as()

    public void menu_file_save_as()

    {

        save(true);

    }

    //}}}

    //{{{ public void menu_file_exit()

    public void menu_file_exit()

    {

        if(exit())

            System.exit(0);

    }

    //}}}

    //{{{ public void menu_edit_copy()

    public void menu_edit_copy()

    {

        Object component = getSelectedComponent();

        if(component != null)

        {

            // serialize selected component tree to Thinlet XML

            this.clipboard = serialize(component);

            // insert xml string into system clipboard

            StringSelection selection = new StringSelection(this.clipboard);

            thinlet.getToolkit().getSystemClipboard().setContents(selection, selection);

            updateToolbar(component);

            setStatusText("" + ThinletWorkarounds.getTotalCount(thinlet, component)

                + " components copied to system clipboard.");

        }

    }

    //}}}

    //{{{ public void menu_edit_cut()

    public void menu_edit_cut()

    {

        menu_edit_copy();

        menu_edit_delete();

    }

    //}}}

    //{{{ public void menu_edit_paste()

    public void menu_edit_paste()

    {

        if(this.clipboard != null)

        {

            Object parentTreenode = getSelectedTreeNode(); // note: may be null

            addComponents(parentTreenode, -1, this.clipboard);

            setStatusText("Pasted components from internal clipboard.");

        }

    }

    //}}}

    //{{{ public void menu_edit_paste_systemcb()

    public void menu_edit_paste_systemcb()

    {

        // get access to system clipboard

        Transferable transferable = thinlet.getToolkit().getSystemClipboard().getContents(thinlet);

        if(transferable == null)

        {

            if(debug()) log.fine("paste from system clipboard: clipboard is empty");

            setStatusText("Note: clipboard is empty");

            return;

        }

        if(!transferable.isDataFlavorSupported(DataFlavor.stringFlavor))

        {

            log.warning("paste from system clipboard: clipboard contains something that is not a string");

            messagebox("Clipboard Error", "System clipboard does not contain a string.");

            return;

        }

        // get string contents of system clipboard

        String text = null;

        try

        {

            text = (String) transferable.getTransferData(DataFlavor.stringFlavor);

        }

        catch(Exception e)

        {

            log.log(Level.SEVERE, "Error getting clipboard contents", e);

            setStatusText("Error getting clipboard contents: " + e

                + "   See log for details.");

        }

        // try to add string, assuming it contains Thinlet XML

        if(text != null)

        {

            Object parentTreenode = getSelectedTreeNode(); // note: may be null

            addComponents(parentTreenode, -1, text);

            setStatusText("Pasted components from system clipboard.");

        }

    }

    //}}}

    //{{{ public void menu_edit_delete()

    public void menu_edit_delete()

    {

        removeSelectedComponent();

    }

    //}}}

    //{{{ public void menu_edit_settings()

    public void menu_edit_settings()

    {

        new SettingsDialog(AWTUtils.getFrame(thinlet)).show();

    }

    //}}}

    //{{{ public void menu_tools_generate()

    public void menu_tools_generate()

    {

        if(isEmpty())

            messagebox("Error", "Nothing to generate.\nPlease add components first.");

        else

            new GenerateDialog(AWTUtils.getFrame(thinlet), this).show();

    }

    //}}}

    //{{{ public void menu_help_about()

    public void menu_help_about()

    {

        MessageDialog dlg = new MessageDialog(AWTUtils.getFrame(thinlet),

            "About ThinG",

            AWTUtils.getIcon(thinlet, "/thing/icons/thing.gif"),

            "ThinG v" + Main.getVersion() + "\n"

            + "\n"

            + "Created by Dirk Moebius (dmoebius@gmx.net)\n"

            + "\n"

            + "ThinG is free software, and you are welcome to redistribute it\n"

            + "under the terms of the GNU General Public License, Version 2.\n"

            + "See the license file doc/COPYING.txt for details.\n"

            + "\n"

            + "Many thanks to:\n"

            + "    Robert Bajzat (Thinlet inventor)\n"

            + "    Wolf Paulus (inventor of the best Thinlet RAD tool available:\n"

            + "        Theodore, see http://www.carlsbadcubes.com/theodore/)\n");

        dlg.show();

    }

    //}}}

    //{{{ public void addComponent(Object toolbarButton)

    public void addComponent(Object toolbarButton)

    {

        String classname = getToolbarButtonClassname(toolbarButton);

        Object newNode = null;

        if(isEmpty())

        {

            // no elements in tree: add component at top/first element

            newNode = addComponentImpl(classname, null, -1, null);

        }

        else

        {

            Object parentTreenode = getSelectedTreeNode();

            if(parentTreenode != null)

            {

                // create new tree node below currently selected tree node

                newNode = addComponentImpl(classname, parentTreenode, -1, null);

            }

        }

        setSelectedTreeNode(newNode);

    }

    //}}}

    //{{{ public void moveComponentUp()

    public void moveComponentUp()

    {

        moveSelectedComponent(-1);

    }

    //}}}

    //{{{ public void moveComponentDown()

    public void moveComponentDown()

    {

        moveSelectedComponent(1);

    }

    //}}}

    //{{{ public void treeSelectionChanged()

    public void treeSelectionChanged()

    {

        thinlet.removeAll(props);

        Object component = getSelectedComponent();

        if(component != null)

            addTableProperties(component);

        updateToolbar(component);

        updatePropertyEditor(component, null);

    }

    //}}}

    //{{{ public void tableSelectionChanged()

    public void tableSelectionChanged()

    {

        Object component = getSelectedComponent();

        String propName = getSelectedPropertyName();

        if(component != null)

            updatePropertyEditor(component, propName);

    }

    //}}}

    //{{{ public void propEditBooleanChanged(String text, boolean isSelected)

    public void propEditBooleanChanged(String text, boolean isSelected)

    {

        boolean value = (text.equals("true") && isSelected);

        Object component = getSelectedComponent();

        String propName = getSelectedPropertyName();

        if(component != null && propName != null)

        {

            propmgr.setValue(component, propName, Boolean.toString(value));

            updateTableProperty(component, propName);

            if(debug()) log.fine("property " + propName + " for component "

                + ThinletWorkarounds.toString(component) + " changed to " + value);

            setStatusText("Component " + ThinletWorkarounds.toString(component)

                + ": Property " + propName + " changed to " + value);

        }

    }

    //}}}

    //{{{ public void propEditIntegerChanged(String value)

    public void propEditIntegerChanged(String value)

    {

        if(value.length() == 0)

            return;

        Object component = getSelectedComponent();

        String propName = getSelectedPropertyName();

        if(component != null && propName != null)

        {

            propmgr.setValue(component, propName, value);

            updateTableProperty(component, propName);

            if(debug()) log.fine("property " + propName + " for component "

                + ThinletWorkarounds.toString(component) + " changed to " + value);

            setStatusText("Component " + ThinletWorkarounds.toString(component)

                + ": Property " + propName + " changed to " + value);

        }

    }

    //}}}

    //{{{ public void propEditChoiceChanged(Object combobox, int selected)

    public void propEditChoiceChanged(Object combobox, int selected)

    {

        String choice = thinlet.getString(thinlet.getItem(combobox, selected), "text");

        Object component = getSelectedComponent();

        String propName = getSelectedPropertyName();

        if(component != null && propName != null && choice != null)

        {

            propmgr.setValue(component, propName, choice);

            updateTableProperty(component, propName);

            if(debug()) log.fine("property " + propName + " for component "

                + ThinletWorkarounds.toString(component) + " changed to " + choice);

            setStatusText("Component " + ThinletWorkarounds.toString(component)

                + ": Property " + propName + " changed to " + choice);

        }

    }

    //}}}

    //{{{ public void propEditStringChanged(String text)

    public void propEditStringChanged(String text)

    {

        Object component = getSelectedComponent();

        String propName = getSelectedPropertyName();

        if(component != null && propName != null && text != null)

        {

            String classname = Thinlet.getClass(component);

            ThinletDTD.Property property = ThinletDTD.getProperty(classname, propName);

            try

            {

                switch(property.getType())

                {

                    case ThinletDTD.Property.STRING:

                        propmgr.setValue(component, property, text);

                        if(propName.equals("name"))

                        {

                            // update tree node text

                            String nodeText = classname;

                            if(text.length() > 0) nodeText += " [" + text + "]";

                            thinlet.setString(getSelectedTreeNode(), "text", nodeText);

                        }

                        break;

                    case ThinletDTD.Property.PROPERTY:

                        // check input

                        StringTokenizer st = new StringTokenizer(text, ";");

                        while (st.hasMoreTokens()) {

                            String token = st.nextToken();

                            int equals = token.indexOf('=');

                            if(equals < 0)

                            {

                                messagebox("Input Error", "Token '" + token + "'\nis missing the '=' character.");

                                return;

                            }

                        }

                        // remove all existing properties

                        Enumeration enumx = ThinletWorkarounds.getPropertyKeys(component);

                        while(enumx.hasMoreElements())

                            thinlet.putProperty(component, (String)enumx.nextElement(), null);

                        // set new properties

                        propmgr.setValue(component, property, text);

                        break;

                    case ThinletDTD.Property.KEYSTROKE:

                        propmgr.setValue(component, property, text);

                        break;

                    case ThinletDTD.Property.METHOD:

                        propmgr.setValue(component, property, text);

                        break;

                    case ThinletDTD.Property.ICON:

                        propmgr.setValue(component, property, text);

                        break;

                    default:

                        throw new IllegalArgumentException("illegal property type: " + property.getType());

                }

            }

            catch(IllegalArgumentException e)

            {

                StringBuffer errmsg = new StringBuffer("Illegal argument value");

                String exmsg = e.getMessage();

                if(exmsg != null && exmsg.length() > 0)

                    errmsg.append(" (").append(exmsg).append(").");

                else

                    errmsg.append(".");

                messagebox("Input Error", errmsg.toString());

                return;

            }

            updateTableProperty(component, propName);

            if(debug()) log.fine("property " + propName + " for component "

                + ThinletWorkarounds.toString(component) + " changed to "

                + (text.length() > 20 ? (text.substring(0,20) + "...") : text));

            setStatusText("Component " + ThinletWorkarounds.toString(component)

                + ": Property " + propName + " changed to "

                + (text.length() > 20 ? (text.substring(0,20) + "...") : text));

        }

    }

    //}}}

    //{{{ public void propEditChooseButtonClicked()

    public void propEditChooseButtonClicked()

    {

        Object component = getSelectedComponent();

        String propName = getSelectedPropertyName();

        if(component != null && propName != null)

        {

            String classname = Thinlet.getClass(component);

            ThinletDTD.Property property = ThinletDTD.getProperty(classname, propName);

            switch(property.getType())

            {

                case ThinletDTD.Property.FONT:

                    FontChooser fontchooser = new FontChooser(AWTUtils.getFrame(thinlet), "Please choose font:");

                    fontchooser.setSelectedFont(ThinletWorkarounds.getFont(thinlet, component, propName));

                    fontchooser.show();

                    Font font = fontchooser.getSelectedFont();

                    if(font != null)

                        thinlet.setFont(component, propName, font);

                    break;

                case ThinletDTD.Property.COLOR:

                    ColorChooser colorchooser = new ColorChooser(AWTUtils.getFrame(thinlet), "Please choose color:");

                    colorchooser.setSelectedColor(ThinletWorkarounds.getColor(component, propName));

                    colorchooser.show();

                    Color color = colorchooser.getSelectedColor();

                    if(color != null)

                        thinlet.setColor(component, propName, color);

                    break;

                case ThinletDTD.Property.COMPONENT:

                    ComponentChooser compchooser = new ComponentChooser(

                        AWTUtils.getFrame(thinlet), "Please select a named component:",

                        getTopComponent(), propmgr.getValueString(component, "name"));

                    compchooser.setSelectedComponent(propmgr.getValueString(component, property));

                    compchooser.show();

                    if(!compchooser.isCancelled())

                        propmgr.setValue(component, property, compchooser.getSelectedComponent());

                    break;

                default:

                    throw new IllegalArgumentException("unexpected property type: " + property.getType());

            }

            updateTableProperty(component, propName);

            if(debug()) log.fine("property " + propName + " for component "

                + ThinletWorkarounds.toString(component) + " changed to "

                + propmgr.getValueString(component, propName));

            setStatusText("Component " + ThinletWorkarounds.toString(component)

                + ": Property " + propName + " changed.");

        }

    }

    //}}}

    //{{{ public void propEditReset()

    public void propEditReset()

    {

        Object component = getSelectedComponent();

        String propName = getSelectedPropertyName();

        if(component != null && propName != null)

        {

            ThinletDTD.Property property = PropertyManager.getProperty(component, propName);

            String defaultValue = PropertyManager.getDefaultValueString(property);

            propmgr.setValue(component, property, defaultValue);

            updateTableProperty(component, propName);

            updatePropertyEditor(component, propName);

            setStatusText("Component " + ThinletWorkarounds.toString(component)

                + ": Property " + propName + " reset to default value \"" + defaultValue + "\".");

        }

    }

    //}}}

    //{{{ public void tabSelected(int tabNo)

    /**

     * serialize the current components tree every time the user switches

     * to the XML panel.

     */

    public void tabSelected(int tabNo)

    {

        if(debug()) log.fine("tab selected: " + tabNo);

        if(tabNo == TAB_XML)

        {

            Object component = getTopComponent();

            Object xmltext = thinlet.find("serialize");

            if(component != null)

                thinlet.setString(xmltext, "text", serialize(component));

            else

                thinlet.setString(xmltext, "text", "");

        }

    }

    //}}}

    //{{{ public void focusgained(Object component)

    public void focusgained(Object component)

    {

        Object treenode = getTreeNodeForComponent(component);

        setSelectedTreeNode(treenode);

    }

    //}}}

    //}}} handler actions

    //{{{ package protected methods

    //{{{ boolean exit()

    /**

     * Perform the "Exit" action.

     *

     * @return true if the application should exit.

     */

    boolean exit()

    {

        boolean stateOk = checkForChanges();

        if(stateOk)

            log.info("ThinG exits.");

        return stateOk;

    }

    //}}}

    //{{{ Object getTopComponent()

    Object getTopComponent()

    {

        Object treenode = thinlet.getItem(tree, 0);

        return (treenode != null) ? getComponentForNode(treenode) : null;

    }

    //}}}

    //{{{ Thinlet getThinlet()

    Thinlet getThinlet()

    {

        return thinlet;

    }

    //}}}

    //{{{ PropertyManager getPropertyManager()

    PropertyManager getPropertyManager()

    {

        return propmgr;

    }

    //}}}

    //{{{ File getCurrentFile()

    File getCurrentFile()

    {

        return file;

    }

    //}}}

    //{{{ void setStatusText(String text)

    void setStatusText(String text)

    {

        thinlet.setString(statusbar, "text", text);

    }

    //}}}

    //}}} package protected methods

    //{{{ private methods

    //{{{ private Object addComponentImpl(String classname, Object parentTreenode, int index, Hashtable attributes)

    /**

     * Add a component.

     *

     * @param attributes  a key-value list of attributes for the new component.

     *     Keys and elements should be Strings.

     * @return the newly created tree node

     */

    private Object addComponentImpl(String classname, Object parentTreenode, int index, Hashtable attributes)

    {

        if(classname.equals("bean"))

            throw new IllegalArgumentException("Sorry, the <bean> element is not support yet.");

        Object newNode = Thinlet.create("node");

        Object newComponent = Thinlet.create(classname);

        if(parentTreenode == null)

        {

            if(!isAddAllowed(classname, null))

                throw new IllegalArgumentException("<" + classname

                    + "> may not be added add top-level.");

            // add new component to preview panel

            thinlet.add(this.preview, newComponent);

            // no elements in tree: add component at top/first element

            thinlet.add(this.tree, newNode);

        }

        else

        {

            // add new component to preview panel

            Object containerComponent = getComponentForNode(parentTreenode);

            if(!isAddAllowed(classname, containerComponent))

                throw new IllegalArgumentException("<" + classname

                    + "> may not be added to <"

                    + Thinlet.getClass(containerComponent) + ">");

            if("header".equals(classname))

                index = 0; // header is always added as first child

            else if("popupmenu".equals(classname))

                index = -1; // popupmenu is always added as last child

            else if(index == 0 || index == -1)

            {

                // trying to add normal component as first or last child

                int count = thinlet.getCount(parentTreenode);

                if(count > 0)

                {

                    // check if first child is "header", if yes, add after that

                    // check if last child is "popupmenu", if yes, add before that

                    if(index == 0 && Thinlet.getClass(getComponentForNode(

                        thinlet.getItem(parentTreenode, index))).equals("header"))

                    {

                        index++;

                        if(index >= count) index = -1;

                    }

                    else if(index == -1 && Thinlet.getClass(getComponentForNode(

                        thinlet.getItem(parentTreenode, count - 1))).equals("popupmenu"))

                    {

                        index = count - 1;

                    }

                }

            }

            thinlet.add(containerComponent, newComponent, index);

            // create new tree node below current tree node

            thinlet.add(parentTreenode, newNode, index);

        }

        // store tree node/component pair

        components.put(newNode, newComponent);

        // set node text

        String nodeText = classname;

        if(attributes != null && attributes.get("name") != null)

            nodeText += " [" + attributes.get("name") + "]";

        thinlet.setString(newNode, "text", nodeText);

        // mark view as changed

        setChanged(true);

        // set attributes

        if(attributes != null)

        {

            for(Enumeration keys = attributes.keys(); keys.hasMoreElements(); )

            {

                String key = (String) keys.nextElement();

                String value = (String) attributes.get(key);

                propmgr.setValue(newComponent, key, value);

            }

        }

        ThinletDTD.Widget widget = ThinletDTD.getWidget(classname);

        if(widget.isInstanceOf("component"))

            thinlet.setMethod(newComponent, "focusgained", "focusgained(this)", root, this);

        return newNode;

    }

    //}}}

    //{{{ private void updatePropertyEditor(Object component, String propName)

    private void updatePropertyEditor(Object component, String propName)

    {

        Object propedit_panel = thinlet.find("propedit_panel");

        thinlet.removeAll(propedit_panel);

        if(propName == null)

        {

            thinlet.setString(thinlet.find("propedit_name"), "text", "");

            thinlet.setBoolean(thinlet.find("propedit_reset"), "enabled", false);

            return;

        }

        String classname = Thinlet.getClass(component);

        ThinletDTD.Property property = ThinletDTD.getProperty(classname, propName);

        Object value = propmgr.getValue(component, property);

        if(debug()) log.fine("setup property: " + propName + " for component: " + ThinletWorkarounds.toString(component));

        thinlet.setString(thinlet.find("propedit_name"), "text", propName + ":");

        thinlet.setBoolean(thinlet.find("propedit_reset"), "enabled", true);

        switch(property.getType())

        {

            case ThinletDTD.Property.STRING:

            case ThinletDTD.Property.ICON:

            case ThinletDTD.Property.KEYSTROKE:

            case ThinletDTD.Property.METHOD:

            case ThinletDTD.Property.PROPERTY:

                Object textfield = Thinlet.create("textfield");

                thinlet.add(propedit_panel, textfield);

                thinlet.setString(textfield, "text", propmgr.getValueString(component, property));

                thinlet.setChoice(textfield, "valign", "center");

                thinlet.setInteger(textfield, "weightx", 1);

                thinlet.setInteger(textfield, "weighty", 1);

                thinlet.setMethod(textfield, "perform", "propEditStringChanged(this.text)", root, this);

                break;

            case ThinletDTD.Property.BOOLEAN:

                Object boolTrue = Thinlet.create("checkbox");

                Object boolFalse = Thinlet.create("checkbox");

                thinlet.add(propedit_panel, boolTrue);

                thinlet.add(propedit_panel, boolFalse);

                thinlet.setString(boolTrue, "text", "true");

                thinlet.setString(boolTrue, "group", "propedit_panel");

                thinlet.setChoice(boolTrue, "valign", "center");

                thinlet.setInteger(boolTrue, "weighty", 1);

                thinlet.setInteger(boolTrue, "mnemonic", 0);

                thinlet.setMethod(boolTrue, "action", "propEditBooleanChanged(this.text, this.selected)", root, this);

                thinlet.setString(boolFalse, "text", "false");

                thinlet.setString(boolFalse, "group", "propedit_panel");

                thinlet.setChoice(boolFalse, "valign", "center");

                thinlet.setInteger(boolFalse, "weighty", 1);

                thinlet.setInteger(boolFalse, "mnemonic", 0);

                thinlet.setMethod(boolFalse, "action", "propEditBooleanChanged(this.text, this.selected)", root, this);

                if(((Boolean)value).booleanValue())

                    thinlet.setBoolean(boolTrue, "selected", true);

                else

                    thinlet.setBoolean(boolFalse, "selected", true);

                break;

            case ThinletDTD.Property.INTEGER:

                Object spinbox = Thinlet.create("spinbox");

                thinlet.add(propedit_panel, spinbox);

                thinlet.setString(spinbox, "text", ((Integer)value).toString());

                thinlet.setChoice(spinbox, "valign", "center");

                thinlet.setInteger(spinbox, "weightx", 1);

                thinlet.setInteger(spinbox, "weighty", 1);

                thinlet.setMethod(spinbox, "action", "propEditIntegerChanged(this.text)", root, this);

                break;

            case ThinletDTD.Property.CHOICE:

                Object combobox = Thinlet.create("combobox");

                thinlet.add(propedit_panel, combobox);

                thinlet.setString(combobox, "text", (String)value);

                thinlet.setBoolean(combobox, "editable", false);

                thinlet.setChoice(combobox, "valign", "center");

                thinlet.setInteger(combobox, "weightx", 1);

                thinlet.setInteger(combobox, "weighty", 1);

                thinlet.setMethod(combobox, "action", "propEditChoiceChanged(this, this.selected)", root, this);

                String[] choices = property.getChoices();

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

                {

                    Object choice = Thinlet.create("choice");

                    thinlet.add(combobox, choice);

                    thinlet.setString(choice, "text", choices[i]);

                    if(((String)value).equals(choices[i]))

                        thinlet.setInteger(combobox, "selected", i);

                }

                break;

            case ThinletDTD.Property.COLOR:

            case ThinletDTD.Property.FONT:

            case ThinletDTD.Property.COMPONENT:

                Object button = Thinlet.create("button");

                thinlet.add(propedit_panel, button);

                thinlet.setString(button, "text", "Choose...");

                thinlet.setInteger(button, "mnemonic", 0);

                thinlet.setMethod(button, "action", "propEditChooseButtonClicked()", root, this);

                Font font = ThinletWorkarounds.getFont(thinlet, button, "font");

                font = font.deriveFont(10.0f);

                thinlet.setFont(button, font);

                //thinlet.setChoice(button, "valign", "center");

                //thinlet.setInteger(button, "weighty", 1);

                break;

            case ThinletDTD.Property.BEAN:

                // only display, not changeable

                Object label = Thinlet.create("label");

                thinlet.add(propedit_panel, label);

                thinlet.setString(label, "text", propmgr.getValueString(component, property));

                thinlet.setChoice(label, "valign", "center");

                thinlet.setInteger(label, "weightx", 1);

                thinlet.setInteger(label, "weighty", 1);

                break;

            default:

                throw new IllegalArgumentException("unexpected property type: " + property.getType());

        }

    }

    //}}}

    //{{{ private void addTableProperties(Object component)

    private void addTableProperties(Object component)

    {

        String classname = Thinlet.getClass(component);

        ThinletDTD.Property[] properties = ThinletDTD.getProperties(classname);

        if(debug()) log.fine("add table properties for component: " + ThinletWorkarounds.toString(component));

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

            if(shouldShowProperty(classname, properties[i].getName()))

                addTableProperty(component, properties[i]);

    }

    //}}}

    //{{{ private void addTableProperty(Object component, ThinletDTD.Property property)

    private void addTableProperty(Object component, ThinletDTD.Property property)

    {

        Object row = Thinlet.create("row");

        Object cellName = Thinlet.create("cell");

        Object cellValue = Thinlet.create("cell");

        thinlet.add(props, row);

        thinlet.add(row, cellName);

        thinlet.add(row, cellValue);

        thinlet.setString(cellName, "text", property.getName());

        thinlet.setString(cellValue, "text", propmgr.getValueString(component, property));

    }

    //}}}

    //{{{ private void removeSelectedComponent()

    private void removeSelectedComponent()

    {

        Object treenode = getSelectedTreeNode();

        Object component = getSelectedComponent();

        if(treenode != null && component != null)

        {

            thinlet.remove(treenode);

            thinlet.remove(component);

            propmgr.removeComponent(component);

            components.remove(treenode);

            // later FIXME: recursively remove all subcomponents of 'component'

            // from 'propmgr' and 'components' hashmap.

            treeSelectionChanged();

            setChanged(true);

        }

    }

    //}}}

    //{{{ private void updateTableProperty(Object component, String propName)

    private void updateTableProperty(Object component, String propName)

    {

        Object cellValue = getSelectedTableCell(1);

        thinlet.setString(cellValue, "text", propmgr.getValueString(component, propName));

        setChanged(true);

    }

    //}}}

    //{{{ private static boolean shouldShowProperty(String classname, String prop)

    private static boolean shouldShowProperty(String classname, String prop)

    {

        if("for".equals(prop))

        {

            // show property "for" only for labels, but not it's subclasses

            // such as button, checkbox, togglebutton

            return classname.equals("label");

        }

        else if("closable".equals(prop) && "dialog".equals(classname))

        {

            // don't show property "closable" (it has been replaced by "close")

            return false;

        }

        else

            return true;

    }

    //}}}

    //{{{ private Object getComponentForNode(Object treenode)

    private Object getComponentForNode(Object treenode)

    {

        Object component = components.get(treenode);

        if(component == null)

            throw new IllegalArgumentException("something is wrong, no component stored for tree node: "

                + ThinletWorkarounds.toString(treenode));

        else

            return component;

    }

    //}}}

    //{{{ private Object getTreeNodeForComponent(Object component)

    private Object getTreeNodeForComponent(Object component)

    {

        for(Iterator it = components.entrySet().iterator(); it.hasNext(); )

        {

            Map.Entry entry = (Map.Entry) it.next();

            if(entry.getValue() == component)

                return entry.getKey();

        }

        throw new IllegalArgumentException("something is wrong, no tree node stored for component: "

            + ThinletWorkarounds.toString(component));

    }

    //}}}

    //{{{ private void setSelectedTreeNode(Object treenode)

    private void setSelectedTreeNode(Object treenode)

    {

        // selects the treenode, deselects all others

        ThinletWorkarounds.setSelectedItem(thinlet, tree, treenode);

        treeSelectionChanged();

    }

    //}}}

    //{{{ private Object getSelectedTreeNode()

    private Object getSelectedTreeNode()

    {

        Object treenode = thinlet.getSelectedItem(tree);

        return treenode;

    }

    //}}}

    //{{{ private Object getSelectedComponent()

    private Object getSelectedComponent()

    {

        Object treenode = getSelectedTreeNode();

        return (treenode != null) ? getComponentForNode(treenode) : null;

    }

    //}}}

    //{{{ private String getSelectedPropertyName()

    private String getSelectedPropertyName()

    {

        Object cell = getSelectedTableCell(0);

        if(cell != null)

            return thinlet.getString(cell, "text");

        return null;

    }

    //}}}

    //{{{ private String getSelectedPropertyValue()

    private String getSelectedPropertyValue()

    {

        Object cell = getSelectedTableCell(1);

        if(cell != null)

            return thinlet.getString(cell, "text");

        return null;

    }

    //}}}

    //{{{ private Object getSelectedTableCell(int cellNo)

    private Object getSelectedTableCell(int cellNo)

    {

        Object treenode = getSelectedTreeNode();

        if(treenode != null)

        {

            Object row = thinlet.getSelectedItem(props);

            if(row != null)

                return thinlet.getItem(row, cellNo);

        }

        return null;

    }

    //}}}

    //{{{ private String getToolbarButtonClassname(Object toolbarButton)

    private String getToolbarButtonClassname(Object toolbarButton)

    {

        if("separator".equals(Thinlet.getClass(toolbarButton)))

            return null;

        String classname = (String) thinlet.getProperty(toolbarButton, "classname");

        if(classname == null)

        {

            String name = thinlet.getString(toolbarButton, "name");

            throw new IllegalArgumentException("toolbar button " + name + ": missing classname property");

        }

        return classname;

    }

    //}}}

    //{{{ private void updateToolbar(Object selectedComponent)

    private void updateToolbar(Object selectedComponent)

    {

        ThinletDTD.Widget selectedWidget = null;

        if(selectedComponent != null)

            selectedWidget = ThinletDTD.getWidget(Thinlet.getClass(selectedComponent));

        Object[] items = thinlet.getItems(toolbar);

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

        {

            String classname = getToolbarButtonClassname(items[i]);

            if(classname != null)

            {

                boolean addAllowed = isAddAllowed(classname, selectedComponent, selectedWidget);

                thinlet.setBoolean(items[i], "visible", addAllowed);

            }

        }

        // buttons & menus "Cut"/"Copy"/"Delete"/"Paste"

        thinlet.setBoolean(thinlet.find("tb_edit_cut"), "enabled", selectedComponent != null);

        thinlet.setBoolean(thinlet.find("tb_edit_copy"), "enabled", selectedComponent != null);

        thinlet.setBoolean(thinlet.find("tb_edit_delete"), "enabled", selectedComponent != null);

        thinlet.setBoolean(thinlet.find("menu_edit_cut"), "enabled", selectedComponent != null);

        thinlet.setBoolean(thinlet.find("menu_edit_copy"), "enabled", selectedComponent != null);

        thinlet.setBoolean(thinlet.find("menu_edit_delete"), "enabled", selectedComponent != null);

        thinlet.setBoolean(thinlet.find("tb_edit_paste"), "enabled", this.clipboard != null);

        thinlet.setBoolean(thinlet.find("menu_edit_paste"), "enabled", this.clipboard != null);

        // buttons "Move Up"/"Move Down"

        thinlet.setBoolean(thinlet.find("tb_edit_moveup"), "enabled", false);

        thinlet.setBoolean(thinlet.find("tb_edit_movedown"), "enabled", false);

        if(selectedComponent != null)

        {

            String classname = Thinlet.getClass(selectedComponent);

            if(!("popupmenu".equals(classname)) && !("header".equals(classname)))

            {

                Object treenode = getSelectedTreeNode();

                Object parentTreenode = thinlet.getParent(treenode);

                int count = thinlet.getCount(parentTreenode);

                int index = ThinletWorkarounds.getIndexOfItem(thinlet, parentTreenode, treenode);

                String firstNode = (count > 0) ? Thinlet.getClass(getComponentForNode(thinlet.getItem(parentTreenode, 0))) : "";

                String lastNode = (count > 0) ? Thinlet.getClass(getComponentForNode(thinlet.getItem(parentTreenode, count - 1))) : "";

                // move up is allowed if pos > 0, and item at pos 0 is not a header

                thinlet.setBoolean(thinlet.find("tb_edit_moveup"), "enabled",

                    index > 0 && !(index == 1 && firstNode.equals("header")));

                // move down is allowed if pos < last pos, and item at last pos is not a popupmenu

                thinlet.setBoolean(thinlet.find("tb_edit_movedown"), "enabled",

                    index < count-1 && !(index == count - 2 && lastNode.equals("popupmenu")));

            }

        }

    }

    //}}}

    //{{{ private void updateTitle()

    private void updateTitle()

    {

        Frame frame = AWTUtils.getFrame(thinlet);

        // frame may be null at startup time

        if(frame != null)

        {

            StringBuffer title = new StringBuffer("ThinG - ");

            if(file == null)

                title.append("[untitled]");

            else

                title.append(file.getName());

            if(isChanged)

                title.append(" [modified]");

            frame.setTitle(title.toString());

        }

    }

    //}}}

    //{{{ private boolean isAddAllowed(String classname, Object container)

    /**

     * Check the dtd whether it is allowed to add the widget of the specified

     * classname to the specified container object.

     *

     * @param container  the container; may be <code>null</code>, in which

     *  case the methods checks allowance for top-level objects such as

     *  <code>panel</code> etc.

     */

    private boolean isAddAllowed(String classname, Object container)

    {

        ThinletDTD.Widget containerWidget = null;

        if(container != null)

            containerWidget = ThinletDTD.getWidget(Thinlet.getClass(container));

        return isAddAllowed(classname, container, containerWidget);

    }

    //}}}

    //{{{ private boolean isAddAllowed(String classname, Object container, ThinletDTD.Widget containerWidget)

    /**

     * Check the dtd whether it is allowed to add the widget of the specified

     * classname to the specified container object.

     * Use this method instead of {@link #isAddAllowed(String,Object), if you

     * have already determined the {@link ThinletDTD.Widget widget} for the

     * container object, in order to speed up performance.

     *

     * @param container  the container; may be <code>null</code>, in which

     *  case the methods checks allowance for top-level objects such as

     *  <code>panel</code> etc.

     */

    private boolean isAddAllowed(String classname, Object container, ThinletDTD.Widget containerWidget)

    {

        if(container == null)

        {

            // no container selected: only top-level elements allowed

            if(thinlet.getCount(tree) > 0)

                return false;

            return "panel".equals(classname)

                || "desktop".equals(classname)

                || "dialog".equals(classname)

                || "splitpane".equals(classname)

                || "tabbedpane".equals(classname);

        }

        else

        {

            boolean allowed = containerWidget.isSubWidgetAllowed(classname);

            if(!allowed)