Source code: org/greenstone/gatherer/gui/metaaudit/MetaAuditFrame.java
1 /**
2 *#########################################################################
3 *
4 * A component of the Gatherer application, part of the Greenstone digital
5 * library suite from the New Zealand Digital Library Project at the
6 * University of Waikato, New Zealand.
7 *
8 * <BR><BR>
9 *
10 * Author: John Thompson, Greenstone Digital Library, University of Waikato
11 *
12 * <BR><BR>
13 *
14 * Copyright (C) 1999 New Zealand Digital Library Project
15 *
16 * <BR><BR>
17 *
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation; either version 2 of the License, or
21 * (at your option) any later version.
22 *
23 * <BR><BR>
24 *
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 * GNU General Public License for more details.
29 *
30 * <BR><BR>
31 *
32 * You should have received a copy of the GNU General Public License
33 * along with this program; if not, write to the Free Software
34 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 *########################################################################
36 */
37 package org.greenstone.gatherer.gui.metaaudit;
38
39 import java.awt.*;
40 import java.awt.event.*;
41 import javax.swing.*;
42 import javax.swing.event.*;
43 import javax.swing.tree.*;
44 import org.greenstone.gatherer.Dictionary;
45 import org.greenstone.gatherer.Gatherer;
46 import org.greenstone.gatherer.file.FileNode;
47 import org.greenstone.gatherer.util.TreeSynchronizer;
48 import org.greenstone.gatherer.gui.SimpleMenuBar;
49 import org.greenstone.gatherer.gui.ModalDialog;
50
51 /** The MetaAuditFrame provides a table view of all of the metadata assigned to a selection of FileNodes. All values for a certain file and a certain metadata element appear in the same cell. This table can be sorted by any column, and also has a MS Excel-like AutoFilter allowing you to restrict the rows visible to only those that match a certain set of criteria (applied to each column, and then 'ANDED', or cojoined, to determine the filter). Finally this dialog does not block the Gatherer tool, so the file selection can be changed and the dialog will just generate a new table dynamically.<BR>
52 * Much effort has gone into optimizing this table, as it quickly becomes slow and unresponsive to build/filter/sort when the number of records selected is high. However its performance is still nowhere as good as the Excel spreadsheet, and selections of 1000+ records can cause some serious waiting problems. Performance progression, shown in terms of time taken to perform action, are shown below. Note that building includes both the creation of the data model, and/or the time taken to lay out row and column sizes (due to this using multiple entry cells). Also all tables, by default, must be sorted by one column, which is initially the first column in ascending order:<BR><BR>
53 * <TABLE border=1 cellspacing=0 cellpadding=5>
54 * <TR><TD align=center colspan=5>Time Taken with 1000 records (ms)</TD></TR>
55 * <TR><TD>Action</TD><TD>Original</TD><TD>Revision 1</TD><TD>Revision 2</TD><TD>Revision 3</TD></TR>
56 * <TR><TD>Build</TD><TD align=right>113013</TD><TD align=right>1500</TD><TD align=right>1280</TD><TD align=right>665</TD></TR>
57 * <TR><TD>Sort</TD><TD align=right>34228</TD><TD align=right>353</TD><TD align=right>341</TD><TD align=right>338</TD></TR>
58 * <TR><TD>Filter</TD><TD align=right>57110</TD><TD align=right>485</TD><TD align=right>485</TD><TD align=right>485</TD></TR>
59 * </TABLE>
60 * <BR><BR>
61 * <TABLE border=1 cellspacing=0 cellpadding=5>
62 * <TR><TD align=center colspan=5>Time Taken with 10,000 records (ms) [hdlsub]</TD></TR>
63 * <TR><TD>Action</TD><TD>Original</TD><TD>Revision 1</TD><TD>Revision 2</TD><TD>Revision 3</TD></TR>
64 * <TR><TD>Build</TD><TD align=right>DNF</TD><TD align=right>8667</TD><TD align=right>6784</TD><TD align=right>3081</TD></TR>
65 * <TR><TD>Sort</TD><TD align=right>DNF</TD><TD align=right>236</TD><TD align=right>241</TD><TD align=right>228</TD></TR>
66 * <TR><TD>Filter</TD><TD align=right>DNF</TD><TD align=right>59272</TD><TD align=right>59767</TD><TD align=right>59614</TD></TR>
67 * </TABLE>
68 * <BR><BR>
69 * <TABLE border=1 cellspacing=0 cellpadding=5>
70 * <TR><TD align=center colspan=5>Time Taken with 30,000 records (ms) [hdl]</TD></TR>
71 * <TR><TD>Action</TD><TD>Original</TD><TD>Revision 1</TD><TD>Revision 2</TD><TD>Revision 3</TD></TR>
72 * <TR><TD>Build</TD><TD align=right>DNF</TD><TD align=right>19037</TD><TD align=right>16478</TD><TD align=right>8111</TD></TR>
73 * <TR><TD>Sort</TD><TD align=right>DNF</TD><TD align=right>314</TD><TD align=right>301</TD><TD align=right>385</TD></TR>
74 * <TR><TD>Filter</TD><TD align=right>DNF</TD><TD align=right>[300000]</TD><TD align=right>[300000]</TD><TD align=right>[300000]</TD></TR>
75 * </TABLE><BR><BR>
76 * It is easy to see that while building and sorting have become quite fast and reasonable, sorting is still unacceptable in terms of performance. The difficulty is this, that while sorting is easy (and fast) to implement via the Decorator pattern (making the overall table model a MDVC one) it requires the entire contents of a column to be available. Thus no matter the speed of your sort algorithm you will end up making N calls to getValueAt() in the table data model, for N records. This is not a problem for the initial model, hence the small sort times. However when you attempt to place another deocrator model (or modify the existing one) in order to filter only selected rows, even if the filtering itself takes little time, this little time quickly grows to unacceptable levels. In fact testing has shown it to grow much faster than linear time (though I'm not sure where). Doubling the number of records to filter increases the processing time by 5-7 times.<BR>
77 * In attempting to solve this problem, I have found many resources that mention a similar problem when trying to build visual representations of database tables, especially over networks or other temporally-non-deterministic connections. The common solution is to 'page' only those records necessary into memory on demand, thus making initial response significantly faster, while paying a small price for subsequent page seeks. There are even studies and algorithms for determining pages loads etc, I would imagine garnered from the memory management community. However none of these really help me usless I can get around the problem of having to have the entire columns population immeditaly accessable for sorting purposes.<BR>
78 * I believe with more time is would be possible to make a hybrid table model with properties such as you would require for the aforemenetioned database application, but which also provides fast methods for determining the highest and lowest records perhaps by building traversable heaps in the original model. Such a solution would incur a build penalty, and could consume significant memory, but would provide ordered and sequential access to the data within.<BR>
79 * The discussion aside, I have run out of time to do anything further on this, so will include as is, and provide a warning dialog whenever the number of records might suffer slow processing (1000+ records).
80 * @author John Thompson, Greenstone Digital Library, University of Waikato
81 * @version 2.3
82 */
83 public class MetaAuditFrame
84 extends ModalDialog
85 implements TreeSelectionListener {
86 public AutofilterDialog autofilter_dialog;
87 /** Whether the selection has changed since the last time we built the model (because it has been hidden and theres no point refreshing a model you can't see!). */
88 private boolean invalid = true;
89 /** An array holding the most recent list of paths selected (plus some nulls for those paths removed). */
90 private FileNode records[];
91 /** A reference to ourselves so that inner classes can interact with us. */
92 private MetaAuditFrame self;
93 /** The table in which the metadata is shown. */
94 private MetaAuditTable table;
95 /** The default size for the metaaudit dialog. */
96 static final private Dimension SIZE = new Dimension(640,505);
97
98 /** Constructor.*/
99 public MetaAuditFrame(TreeSynchronizer tree_sync, FileNode records[]) {
100 super(Gatherer.g_man);
101
102 // Arguments
103 this.autofilter_dialog = new AutofilterDialog(this);
104 this.records = records;
105 this.self = this;
106 this.table = new MetaAuditTable(this);
107
108 // Creation
109 setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
110 setSize(SIZE);
111 setJMenuBar(new SimpleMenuBar("reviewingmetadata"));
112 Dictionary.registerText(this, "MetaAudit.Title");
113 JPanel content_pane = (JPanel) getContentPane();
114 JPanel button_pane = new JPanel();
115
116 JButton close_button = new JButton();
117 close_button.setMnemonic(KeyEvent.VK_C);
118 Dictionary.registerBoth(close_button, "MetaAudit.Close", "MetaAudit.Close_Tooltip");
119
120 // Connection
121 close_button.addActionListener(new CloseListener());
122 tree_sync.addTreeSelectionListener(this);
123
124 // Layout
125 button_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
126 button_pane.setLayout(new BorderLayout());
127 button_pane.add(close_button, BorderLayout.CENTER);
128
129 content_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
130 content_pane.setLayout(new BorderLayout());
131 content_pane.add(new JScrollPane(table), BorderLayout.CENTER);
132 content_pane.add(button_pane, BorderLayout.SOUTH);
133
134 Dimension screen_size = Gatherer.config.screen_size;
135 setLocation((screen_size.width - SIZE.width) / 2, (screen_size.height - SIZE.height) / 2);
136 screen_size = null;
137 close_button = null;
138 button_pane = null;
139 content_pane = null;
140 }
141
142 /** Destructor. */
143 public void destroy() {
144 records = null;
145 self = null;
146 table = null;
147 }
148
149 /** Display the dialog on screen. */
150 public void display() {
151 if(invalid) {
152 rebuildModel();
153 }
154 setVisible(true);
155 }
156
157 public void setRecords(FileNode[] records) {
158 this.records = records;
159 if(isVisible()) {
160 rebuildModel();
161 }
162 else {
163 invalid = true;
164 }
165 }
166
167 /** This method is called whenever the selection within the collection tree changes. This causes the table to be rebuilt with a new model.
168 * @param event A <strong>TreeSelectionEvent</strong> containing information about the event.
169 */
170 public void valueChanged(TreeSelectionEvent event) {
171 Object source = event.getSource();
172 if(source instanceof JTree) {
173 TreePath paths[] = ((JTree)source).getSelectionPaths();
174 if(paths != null) {
175 records = new FileNode[paths.length];
176 for(int i = 0; i < paths.length; i++) {
177 records[i] = (FileNode) paths[i].getLastPathComponent();
178 }
179 if(isVisible()) {
180 rebuildModel();
181 }
182 else {
183 invalid = true;
184 }
185 }
186 }
187 }
188
189 public void wait(boolean waiting) {
190 Component glass_pane = getGlassPane();
191 if(waiting) {
192 // Show wait cursor.
193 glass_pane.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
194 glass_pane.setVisible(true);
195 }
196 else {
197 // Hide wait cursor.
198 glass_pane.setVisible(false);
199 glass_pane.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
200 }
201 glass_pane = null;
202 }
203
204 /** Rebuild the metaaudit table model using the current collection tree selection.
205 */
206 private void rebuildModel() {
207 // Build and set model
208 table.newModel(records);
209 // Done.
210 invalid = false;
211 }
212
213 /** Listens for actions upon the close button, and if detected closes the dialog */
214 private class CloseListener
215 implements ActionListener {
216 /** Any implementation of ActionListener must include this method so that we can be informed when an action has been performed on our target control(s).
217 * @param event An <strong>ActionEvent</strong> containing information about the event.
218 */
219 public void actionPerformed(ActionEvent event) {
220 self.setVisible(false);
221 }
222 }
223 }