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.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 appl.util.NonEditableTableModel;

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