appl/ext/ConfigurationEditorEngine.java

package appl.ext;

import java.awt.Component;
import java.util.Set;
import java.util.Vector;

import javax.swing.DefaultListModel;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JTable;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableModel;

import appl.util.NonEditableTableModel;

import edu.bonn.xulu.XuluModellingPlatform;
import edu.bonn.xulu.gui.XuluInternalFrame;
import edu.bonn.xulu.plugin.appl.AbstractMenuPlugin;

/**
 * Handles the {@link ConfigurationEditorGUI}. The prefixes of the
 * {@link XuluConfig} are added to the {@link JList} and the suffixes to the
 * {@link JTable}. For the documentation column for every key with a name lets
 * say 'key' the value of "key.doc" is looked up in the configuration. The
 * prefixes which are values of the key "Filter.prefixes" in the
 * configuration are ignored. Also all keys which show up in "Filter.keys"
 * 
 * @see XuluConfig
 * @author Dominik Appl
 */
public class ConfigurationEditorEngine implements ListSelectionListener,
                TableModelListener {

        ConfigurationEditorGUI GUI = null;

        private DefaultTableModel tableModel;

        private JTable entryTable;

        private JList categoryList;

        private XuluConfig config;

        private String currentCategory;

        /**
         * creates a new Editor. Use {@link #getGUI()} to access the GUI.
         */
        public ConfigurationEditorEngine() {
                config = XuluConfig.getXuluConfig();
                GUI = new ConfigurationEditorGUI();
                initGUI();
        }

        /**
         * inits the GUI
         */
        private void initGUI() {

                entryTable = GUI.entryTable;
                categoryList = GUI.keyList;
                initList();
                initTable();
        }

        /**
         * initializes the table
         */
        private void initTable() {
                // only the 2nd column is editable
                tableModel = new NonEditableTableModel(
                                new Object[] { "Name", "Entry" },
                                new boolean[] { false, true }, 0);
                entryTable.setModel(tableModel);
                entryTable.setDefaultRenderer(Object.class, new ToolTipRenderer());
                entryTable.getModel().addTableModelListener(this);
                entryTable.getSelectionModel().addListSelectionListener(this);
                String firstElement = (String) categoryList.getModel().getElementAt(0);
                if (firstElement != null)
                        initTableData(firstElement);
        }

        /**
         * The table is initalized with the given category
         * 
         * @param firstElement
         */
        private void initTableData(String categoryName) {
                // get ignored keys
                String[] filteredKeys = config.getMultiProperty("Filter.keys");
                Vector<String> filter = new Vector<String>();
                for (String string : filteredKeys) {
                        filter.add(string);
                }
                Set<String> suffixes = config.getSuffixesOfPrefix(categoryName);
                // clear table
                tableModel.setRowCount(0);
                for (String suffix : suffixes) {
                        // do not enter the documentation as seperate entries
                        if (suffix.endsWith(".doc"))
                                continue;
                        String key = categoryName + "." + suffix;
                        // do not enter filtered keys
                        if (filter.contains(key))
                                continue;
                        String value = config.getProperty(key);
                        tableModel.addRow(new Object[] { suffix, value });
                }
                currentCategory = categoryName;
        }

        public ConfigurationEditorGUI getGUI() {
                return GUI;
        }

        /**
         * 
         */
        private void initList() {
                // get ignored prefixes
                String[] filteredPrefixes = config.getMultiProperty("Filter.prefixes");
                Vector<String> filter = new Vector<String>();
                for (String string : filteredPrefixes) {
                        filter.add(string);
                }
                DefaultListModel listModel = new DefaultListModel();
                Object[] prefixes = config.getPrefixes().toArray();
                for (Object object : prefixes) {
                        if (!filter.contains(object))
                                listModel.addElement(object);
                }
                this.GUI.keyList.setModel(listModel);
                // select first element
                categoryList.setSelectedIndex(0);
                categoryList.addListSelectionListener(this);
        }

        /**
         * Listens for selection changes in list and table
         * 
         * @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
         */
        public void valueChanged(ListSelectionEvent e) {
                if (e.getSource() == categoryList) {
                        String value = (String) categoryList.getSelectedValue();
                        if (value != null)
                                initTableData(value);
                        // clear documentation field
                        GUI.docArea
                                        .setText("<select a table value to see its documentation>");
                }
                // update documentation
                else if (e.getSource() == entryTable.getSelectionModel()) {
                        int selRow = entryTable.getSelectedRow();
                        // if a row is selected:
                        if (selRow >= 0) {
                                String value = (String) entryTable.getModel().getValueAt(
                                                selRow, 0);
                                String docKey = currentCategory + "." + value + ".doc";
                                String doc = config.getProperty(docKey);
                                if (doc == null)
                                        doc = "<no documentation found for this entry>";
                                GUI.docArea.setText(doc);
                        }
                }
        }

        /*
         * (non-Javadoc)
         * 
         * @see javax.swing.event.TableModelListener#tableChanged(javax.swing.event.TableModelEvent)
         */
        public void tableChanged(TableModelEvent e) {
                // handle the editing the user does
                if (e.getType() == TableModelEvent.UPDATE) {
                        int changedRow = e.getFirstRow();
                        // only the 2nd col is editable
                        String value = tableModel.getValueAt(changedRow, 1).toString();
                        String suffix = tableModel.getValueAt(changedRow, 0).toString();
                        String prefix = categoryList.getSelectedValue().toString();
                        String key = prefix + "." + suffix;
                        config.setProperty(key, value);

                }
        }

        /**
         * just for the tooltips
         * 
         * @author Dominik Appl
         */
        private class ToolTipRenderer extends DefaultTableCellRenderer {

                public ToolTipRenderer() {
                        setOpaque(true);
                }

                public Component getTableCellRendererComponent(JTable table,
                                Object color, boolean isSelected, boolean hasFocus, int row,
                                int column) {
                        Object value = table.getModel().getValueAt(row, column);
                        if (value != null)
                                setToolTipText(value.toString());
                        return super.getTableCellRendererComponent(table, color,
                                        isSelected, hasFocus, row, column);
                }

        }
}
1	package appl.ext;
2
3	import java.awt.Component;
4	import java.util.Set;
5	import java.util.Vector;
6
7	import javax.swing.DefaultListModel;
8	import javax.swing.JLabel;
9	import javax.swing.JList;
10	import javax.swing.JTable;
11	import javax.swing.event.ListSelectionEvent;
12	import javax.swing.event.ListSelectionListener;
13	import javax.swing.event.TableModelEvent;
14	import javax.swing.event.TableModelListener;
15	import javax.swing.table.DefaultTableCellRenderer;
16	import javax.swing.table.DefaultTableModel;
17	import javax.swing.table.TableCellRenderer;
18	import javax.swing.table.TableModel;
19
20	import appl.util.NonEditableTableModel;
21
22	import edu.bonn.xulu.XuluModellingPlatform;
23	import edu.bonn.xulu.gui.XuluInternalFrame;
24	import edu.bonn.xulu.plugin.appl.AbstractMenuPlugin;
25
26	/**
27	* Handles the {@link ConfigurationEditorGUI}. The prefixes of the
28	* {@link XuluConfig} are added to the {@link JList} and the suffixes to the
29	* {@link JTable}. For the documentation column for every key with a name lets
30	* say 'key' the value of "key.doc" is looked up in the configuration. The
31	* prefixes which are values of the key "Filter.prefixes" in the
32	* configuration are ignored. Also all keys which show up in "Filter.keys"
33	*
34	* @see XuluConfig
35	* @author Dominik Appl
36	*/
37	public class ConfigurationEditorEngine implements ListSelectionListener,
38	TableModelListener {
39
40	ConfigurationEditorGUI GUI = null;
41
42	private DefaultTableModel tableModel;
43
44	private JTable entryTable;
45
46	private JList categoryList;
47
48	private XuluConfig config;
49
50	private String currentCategory;
51
52	/**
53	* creates a new Editor. Use {@link #getGUI()} to access the GUI.
54	*/
55	public ConfigurationEditorEngine() {
56	config = XuluConfig.getXuluConfig();
57	GUI = new ConfigurationEditorGUI();
58	initGUI();
59	}
60
61	/**
62	* inits the GUI
63	*/
64	private void initGUI() {
65
66	entryTable = GUI.entryTable;
67	categoryList = GUI.keyList;
68	initList();
69	initTable();
70	}
71
72	/**
73	* initializes the table
74	*/
75	private void initTable() {
76	// only the 2nd column is editable
77	tableModel = new NonEditableTableModel(
78	new Object[] { "Name", "Entry" },
79	new boolean[] { false, true }, 0);
80	entryTable.setModel(tableModel);
81	entryTable.setDefaultRenderer(Object.class, new ToolTipRenderer());
82	entryTable.getModel().addTableModelListener(this);
83	entryTable.getSelectionModel().addListSelectionListener(this);
84	String firstElement = (String) categoryList.getModel().getElementAt(0);
85	if (firstElement != null)
86	initTableData(firstElement);
87	}
88
89	/**
90	* The table is initalized with the given category
91	*
92	* @param firstElement
93	*/
94	private void initTableData(String categoryName) {
95	// get ignored keys
96	String[] filteredKeys = config.getMultiProperty("Filter.keys");
97	Vector<String> filter = new Vector<String>();
98	for (String string : filteredKeys) {
99	filter.add(string);
100	}
101	Set<String> suffixes = config.getSuffixesOfPrefix(categoryName);
102	// clear table
103	tableModel.setRowCount(0);
104	for (String suffix : suffixes) {
105	// do not enter the documentation as seperate entries
106	if (suffix.endsWith(".doc"))
107	continue;
108	String key = categoryName + "." + suffix;
109	// do not enter filtered keys
110	if (filter.contains(key))
111	continue;
112	String value = config.getProperty(key);
113	tableModel.addRow(new Object[] { suffix, value });
114	}
115	currentCategory = categoryName;
116	}
117
118	public ConfigurationEditorGUI getGUI() {
119	return GUI;
120	}
121
122	/**
123	*
124	*/
125	private void initList() {
126	// get ignored prefixes
127	String[] filteredPrefixes = config.getMultiProperty("Filter.prefixes");
128	Vector<String> filter = new Vector<String>();
129	for (String string : filteredPrefixes) {
130	filter.add(string);
131	}
132	DefaultListModel listModel = new DefaultListModel();
133	Object[] prefixes = config.getPrefixes().toArray();
134	for (Object object : prefixes) {
135	if (!filter.contains(object))
136	listModel.addElement(object);
137	}
138	this.GUI.keyList.setModel(listModel);
139	// select first element
140	categoryList.setSelectedIndex(0);
141	categoryList.addListSelectionListener(this);
142	}
143
144	/**
145	* Listens for selection changes in list and table
146	*
147	* @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
148	*/
149	public void valueChanged(ListSelectionEvent e) {
150	if (e.getSource() == categoryList) {
151	String value = (String) categoryList.getSelectedValue();
152	if (value != null)
153	initTableData(value);
154	// clear documentation field
155	GUI.docArea
156	.setText("<select a table value to see its documentation>");
157	}
158	// update documentation
159	else if (e.getSource() == entryTable.getSelectionModel()) {
160	int selRow = entryTable.getSelectedRow();
161	// if a row is selected:
162	if (selRow >= 0) {
163	String value = (String) entryTable.getModel().getValueAt(
164	selRow, 0);
165	String docKey = currentCategory + "." + value + ".doc";
166	String doc = config.getProperty(docKey);
167	if (doc == null)
168	doc = "<no documentation found for this entry>";
169	GUI.docArea.setText(doc);
170	}
171	}
172	}
173
174	/*
175	* (non-Javadoc)
176	*
177	* @see javax.swing.event.TableModelListener#tableChanged(javax.swing.event.TableModelEvent)
178	*/
179	public void tableChanged(TableModelEvent e) {
180	// handle the editing the user does
181	if (e.getType() == TableModelEvent.UPDATE) {
182	int changedRow = e.getFirstRow();
183	// only the 2nd col is editable
184	String value = tableModel.getValueAt(changedRow, 1).toString();
185	String suffix = tableModel.getValueAt(changedRow, 0).toString();
186	String prefix = categoryList.getSelectedValue().toString();
187	String key = prefix + "." + suffix;
188	config.setProperty(key, value);
189
190	}
191	}
192
193	/**
194	* just for the tooltips
195	*
196	* @author Dominik Appl
197	*/
198	private class ToolTipRenderer extends DefaultTableCellRenderer {
199
200	public ToolTipRenderer() {
201	setOpaque(true);
202	}
203
204	public Component getTableCellRendererComponent(JTable table,
205	Object color, boolean isSelected, boolean hasFocus, int row,
206	int column) {
207	Object value = table.getModel().getValueAt(row, column);
208	if (value != null)
209	setToolTipText(value.toString());
210	return super.getTableCellRendererComponent(table, color,
211	isSelected, hasFocus, row, column);
212	}
213
214	}
215	}