source: gli/trunk/src/org/greenstone/gatherer/gui/GUIManager.java@ 14974

Last change on this file since 14974 was 14974, checked in by davidb, 16 years ago

Changes to GLI to support export into Fedora. New utility called flisvn diff gems/MetadataSetManager.java

  • Property svn:keywords set to Author Date Id Revision
File size: 31.5 KB
Line 
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 */
37package org.greenstone.gatherer.gui;
38
39import java.awt.*;
40import java.awt.datatransfer.*;
41import java.awt.event.*;
42import java.io.File;
43import java.lang.*;
44import java.net.*;
45import java.util.*;
46import javax.swing.*;
47import javax.swing.event.*;
48import javax.swing.filechooser.*;
49import javax.swing.plaf.*;
50import javax.swing.text.*;
51import org.greenstone.gatherer.Configuration;
52import org.greenstone.gatherer.DebugStream;
53import org.greenstone.gatherer.Dictionary;
54import org.greenstone.gatherer.Gatherer;
55import org.greenstone.gatherer.collection.Collection;
56import org.greenstone.gatherer.collection.CollectionManager;
57import org.greenstone.gatherer.file.FileOpenActionListener;
58import org.greenstone.gatherer.file.WorkspaceTree;
59import org.greenstone.gatherer.gui.metaaudit.MetaAuditFrame;
60import org.greenstone.gatherer.gui.tree.DragTree;
61import org.greenstone.gatherer.metadata.MetadataSet;
62import org.greenstone.gatherer.remote.RemoteGreenstoneServer;
63import org.greenstone.gatherer.util.JarTools;
64import org.greenstone.gatherer.util.StaticStrings;
65import org.greenstone.gatherer.util.Utility;
66
67/** The GUIManager is in charge of creating the Gatherer window frame then filling it with the goodness of the view panes. GUIManager not only creates these panes, but allows some messaging between them. Furthermore GUIManager includes functionality from menu driven choices, simply as it was easier to put it here once and have it accessible from all pane children. */
68public class GUIManager
69 extends JFrame
70 implements ActionListener, ChangeListener, WindowFocusListener{
71 /** The download pane contains controls for downloading internet sites. */
72 public DownloadPane download_pane = null;
73 /** The gather pane is more like a file manager where you drag files from one tree to another. */
74 public GatherPane gather_pane = null;
75 /** The enrich pane is used to assign, edit and remove metadata from files within the collection. */
76 public EnrichPane enrich_pane = null;
77 /** The design pane allows you to edit the design of the library in terms of the collection configuration file. - the stuff that requires rebuilding */
78 public DesignPane design_pane = null;
79 /** The create pane contains scripting options for importing and building collections into libraries. */
80 public CreatePane create_pane = null;
81 /** The format pane allows you to edit the design of the library in terms of the collection configuration file. - the stuff that doesn't require rebuilding */
82 public FormatPane format_pane = null;
83
84 public FileOpenActionListener foa_listener = new FileOpenActionListener();
85
86
87 /** A reference to the currently instantiated help window, if any. */
88 private HelpFrame help = null;
89 /** The menu bar. */
90 public MenuBar menu_bar = null;
91 public MetaAuditFrame meta_audit;
92 /** Are certain panes currently locked? */
93 private boolean locked = false;
94 /** The size of the Gatherer window. */
95 private Dimension size = null;
96 /** The panel within the window that other components are placed on. */
97 private JPanel content_pane = null;
98 /** The last view pane selected. */
99 private JPanel previous_pane;
100 /** The main tab pane containing the different views, available here to trap view change events. */
101 private JTabbedPane tab_pane = null;
102 /** A threaded tab changer to try and avoid NPE on exit. */
103 private TabUpdater tab_updater = null;
104
105
106
107
108
109 final static String newline = "\n";
110 final static String space = " ";
111
112
113 /**Constructor. Enable window events and arranges all other components.
114 * @param size The intial <strong>Dimension</strong> of the screen.
115 */
116 public GUIManager(Dimension size) {
117 super();
118 // Initialization
119 this.help = new HelpFrame();
120 this.size = size;
121
122 this.setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
123
124 // Add a focus listener to ourselves. Thus if we gain focus when a Modal Dialog should instead have it, we can try to bring the modal dialog to the fore.
125 this.addFocusListener(new GLIGUIFocusListener());
126
127 this.addWindowFocusListener(this);
128
129 // Make the Tool tip hang around for a rediculous amount of time.
130 ToolTipManager.sharedInstance().setDismissDelay(10000);
131
132 // Set up some other UI stuff. (fonts handled in Gatherer.main())
133 UIManager.put("FileChooser.lookInLabelText", Dictionary.get("SaveCollectionBox.Look_In"));
134 UIManager.put("FileChooser.filesOfTypeLabelText", Dictionary.get("SaveCollectionBox.Files_Of_Type"));
135 UIManager.put("FileChooser.fileNameLabelText", Dictionary.get("SaveCollectionBox.File_Name"));
136 }
137
138
139 public void windowGainedFocus(WindowEvent e)
140 {
141 }
142
143
144 public void windowLostFocus(WindowEvent e)
145 {
146 // Save the loaded collection
147 if (Gatherer.c_man != null && Gatherer.c_man.ready() && Gatherer.c_man.getCollection().cdm != null) {
148 Gatherer.c_man.saveCollection();
149 }
150 }
151
152
153 private class GLIGUIFocusListener
154 extends FocusAdapter {
155 public void focusGained(FocusEvent e) {
156 if (ModalDialog.current_modal != null) {
157 ModalDialog.current_modal.makeVisible();
158 ModalDialog.current_modal.toFront();
159 }
160 }
161 }
162
163 /** Any implementation of <i>ActionListener</i> must include this method so that we can be informed when an action has occured. In this case we are listening to actions from the menu-bar, and should react appropriately.
164 * @param event An <strong>ActionEvent</strong> containing information about the action that has occured.
165 */
166 public void actionPerformed(ActionEvent event) {
167 Object esrc = event.getSource();
168 // *************
169 // File Options.
170 // *************
171 if (esrc == menu_bar.file_associations) {
172 Gatherer.assoc_man.edit();
173 }
174 else if (esrc == menu_bar.file_close) {
175 saveThenCloseCurrentCollection();
176 }
177 else if (esrc == menu_bar.file_delete) {
178 new DeleteCollectionTask().start();
179 }
180 else if (esrc == menu_bar.file_cdimage) {
181 WriteCDImagePrompt wcdip = new WriteCDImagePrompt();
182 wcdip.display();
183 wcdip.destroy();
184 wcdip = null;
185 }
186 else if (esrc == menu_bar.file_exportas) {
187 ExportAsPrompt eap = new ExportAsPrompt();
188 eap.display();
189 eap.destroy();
190 eap = null;
191 }
192 else if (esrc == menu_bar.file_exit) {
193 exit();
194 }
195 else if (esrc == menu_bar.file_new) {
196 new NewCollectionTask().start();
197 }
198 else if (esrc == menu_bar.file_open) {
199 new OpenCollectionTask().start();
200 }
201 else if (esrc == menu_bar.file_options) {
202 new Preferences();
203 }
204 else if (esrc == menu_bar.file_save) {
205 Gatherer.c_man.saveCollection();
206 }
207
208 // *************
209 // Edit Options.
210 // *************
211 else if(esrc == menu_bar.edit_copy) {
212 try {
213 KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
214 // Get the component with selected text as a JTextComponent
215 JTextComponent text = (JTextComponent) kfm.getPermanentFocusOwner();//getFocusOwner();
216 text.copy();
217 }
218 catch (Exception cce) {
219 // If the component is not a text component ignore the copy command
220 DebugStream.println(cce.toString());
221 }
222 }
223 else if(esrc == menu_bar.edit_cut) {
224 try {
225 KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
226 // Get the component with selected text as a JTextComponent
227 JTextComponent text = (JTextComponent) kfm.getPermanentFocusOwner();
228 // Cut the text to the clipboard
229 text.cut();
230 }
231 catch (ClassCastException cce) {
232 // If the component is not a text component ignore the cut command
233 DebugStream.println(cce.toString());
234 }
235 }
236 else if(esrc == menu_bar.edit_paste) {
237 try {
238 KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
239 // Get the component with selected text as a JTextComponent
240 JTextComponent text = (JTextComponent) kfm.getPermanentFocusOwner();
241 // Cut the text to the clipboard
242 text.paste();
243 }
244 catch (ClassCastException cce) {
245 // If the component is not a text component ignore the paste command
246 DebugStream.println(cce.toString());
247 }
248 }
249
250 // *************
251 // Help Options.
252 // *************
253 else if (esrc == menu_bar.help_general) {
254 HelpFrame.setView("introduction");
255 }
256 else if (esrc == menu_bar.help_download) {
257 HelpFrame.setView("downloadingfiles");
258 }
259 else if (esrc == menu_bar.help_gather) {
260 HelpFrame.setView("collectingfiles");
261 }
262 else if (esrc == menu_bar.help_enrich) {
263 HelpFrame.setView("enrichingacollection");
264 }
265 else if (esrc == menu_bar.help_design) {
266 HelpFrame.setView("designingacollection");
267 }
268 else if (esrc == menu_bar.help_create) {
269 HelpFrame.setView("producingthecollection");
270 }
271 else if (esrc == menu_bar.help_format) {
272 HelpFrame.setView("formattingacollection");
273 }
274 else if (esrc == menu_bar.help_about) {
275 new AboutDialog(this);
276 }
277 }
278
279
280 /** Any actions that should happen after the display of the Gatherer window can be called here. Currently only updates the browser pane if it is active to work around bug in Mozilla renderer implementation.
281 */
282 public void afterDisplay() {
283 if (download_pane != null) {
284 download_pane.afterDisplay();
285 }
286 enrich_pane.afterDisplay();
287 }
288
289
290 public void closeCurrentCollection()
291 {
292 tab_pane.setSelectedComponent(gather_pane);
293 Gatherer.c_man.closeCollection();
294 }
295
296
297 public void saveThenCloseCurrentCollection()
298 {
299 Gatherer.c_man.saveCollection();
300 closeCurrentCollection();
301 }
302
303
304 /** This is called when we're absolutely finished with the GLI. It is *not* called when the applet is suspended.
305 */
306 public void destroy()
307 {
308 // Destroying create pane ensures the latest log has been closed
309 if (create_pane != null) {
310 create_pane.destroy();
311 }
312
313 // Deal to help
314 if (help != null) {
315 help.destroy();
316 help = null;
317 }
318 }
319
320
321 /** Enabled events on the window to be trapped, creates all the visual components, then builds the tab and other layouts.
322 */
323 public void display() {
324 content_pane = (JPanel) this.getContentPane();
325 // Enable window-type events to be fired.
326 enableEvents(AWTEvent.WINDOW_EVENT_MASK);
327 // Initialise and layout sub-components, plus other window dressing.
328 try {
329 this.setSize(size);
330
331 // Set the title
332 String collection_title = null;
333 String collection_name = null;
334 if (Gatherer.c_man.ready()) {
335 Collection collection = Gatherer.c_man.getCollection();
336 collection_title = collection.getTitle();
337 collection_name = collection.getName();
338 collection = null;
339 }
340 setTitle(collection_title, collection_name);
341 collection_title = null;
342 collection_name = null;
343
344 // Pretty corner icon
345 this.setIconImage(JarTools.getImage("gatherer_small.gif").getImage());
346 // BorderLayout for the main screen. I'll try my best to avoid these in subcomponents as they're space greedy.
347 content_pane.setLayout(new BorderLayout());
348 // Create the menu-bar and stick it up the top.
349 menu_bar = new MenuBar(new MenuListenerImpl());
350
351 //feedback changes
352 //content_pane.add(menu_bar, BorderLayout.NORTH);
353 this.setJMenuBar(menu_bar);
354 // end feedback changes
355
356 // Create the tabbed pane and plop it in the center where it will
357 // expand to consume all available space like any good gas would.
358 tab_pane = new JTabbedPane();
359 tab_pane.addChangeListener(this);
360 tab_pane.setFont(Configuration.getFont("general.font", false));
361
362 if (Configuration.get("workflow.download", true)) {
363 download_pane = new DownloadPane();
364 // "GUI.Download_Tooltip" is used automatically
365 tab_pane.addTab(Dictionary.get("GUI.Download"), JarTools.getImage("download.gif"), download_pane, Dictionary.get("GUI.Download_Tooltip"));
366 tab_pane.setEnabledAt(tab_pane.indexOfComponent(download_pane), Configuration.get("workflow.download", false));
367 }
368
369 gather_pane = new GatherPane();
370 gather_pane.display();
371 if (Configuration.get("workflow.gather", true)) {
372 // "GUI.Gather_Tooltip" is used automatically
373 tab_pane.addTab(Dictionary.get("GUI.Gather"), JarTools.getImage("gather.gif"), gather_pane, Dictionary.get("GUI.Gather_Tooltip"));
374 tab_pane.setEnabledAt(tab_pane.indexOfComponent(gather_pane), Configuration.get("workflow.gather", false));
375 }
376
377 enrich_pane = new EnrichPane();
378 enrich_pane.display();
379 if (Configuration.get("workflow.enrich", true)) {
380 // "GUI.Enrich_Tooltip" is used automatically
381 tab_pane.addTab(Dictionary.get("GUI.Enrich"), JarTools.getImage("enrich.gif"), enrich_pane, Dictionary.get("GUI.Enrich_Tooltip"));
382 tab_pane.setEnabledAt(tab_pane.indexOfComponent(enrich_pane), false);
383 }
384
385 design_pane = new DesignPane();
386 design_pane.display();
387 if (Configuration.get("workflow.design", true)) {
388 // "GUI.Design_Tooltip" is used automatically
389 if (Configuration.fedora_info.isActive()) {
390 tab_pane.addTab("Plugins", JarTools.getImage("design.gif"), design_pane, Dictionary.get("GUI.Design_Tooltip"));
391 }
392 else {
393 tab_pane.addTab(Dictionary.get("GUI.Design"), JarTools.getImage("design.gif"), design_pane, Dictionary.get("GUI.Design_Tooltip"));
394 }
395
396 tab_pane.setEnabledAt(tab_pane.indexOfComponent(design_pane), false);
397 }
398
399 create_pane = new CreatePane();
400 create_pane.display();
401 if (Configuration.get("workflow.create", true)) {
402 // "GUI.Create_Tooltip" is used automatically
403 tab_pane.addTab(Dictionary.get("GUI.Create"), JarTools.getImage("create.gif"), create_pane, Dictionary.get("GUI.Create_Tooltip"));
404 tab_pane.setEnabledAt(tab_pane.indexOfComponent(create_pane), false);
405 }
406
407 format_pane = new FormatPane();
408 format_pane.display();
409 if (Configuration.get("workflow.format", true)) {
410 tab_pane.addTab(Dictionary.get("GUI.Format"), JarTools.getImage("format.gif"), format_pane, Dictionary.get("GUI.Format_Tooltip"));
411 tab_pane.setEnabledAt(tab_pane.indexOfComponent(format_pane), false);
412 }
413
414 // The MetaAuditFrame must be created after the gather/enrich panes but before they get focus
415 meta_audit = new MetaAuditFrame();
416
417 // Select the collect pane if it is available
418 if (tab_pane.indexOfComponent(gather_pane) != -1) {
419 tab_pane.setSelectedComponent(gather_pane);
420 }
421 // Otherwise find the first tab that is enabled and select that.
422 else {
423 for (int i = 0; i < tab_pane.getTabCount(); i++) {
424 if (tab_pane.isEnabledAt(i)) {
425 tab_pane.setSelectedIndex(i);
426 break;
427 }
428 }
429 }
430
431 content_pane.add(tab_pane, BorderLayout.CENTER);
432
433 // Add an extra progress bar at the bottom of every screen when using a remote Greenstone server
434 if (Gatherer.isGsdlRemote) {
435 JPanel remote_greenstone_server_progress_panel = new JPanel();
436 JLabel remote_greenstone_server_progress_label = new JLabel(Dictionary.get("RemoteGreenstoneServer.Progress"));
437 remote_greenstone_server_progress_panel.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
438 remote_greenstone_server_progress_panel.setLayout(new BorderLayout());
439 remote_greenstone_server_progress_panel.add(remote_greenstone_server_progress_label, BorderLayout.WEST);
440 remote_greenstone_server_progress_panel.add(RemoteGreenstoneServer.getProgressBar(), BorderLayout.CENTER);
441 content_pane.add(remote_greenstone_server_progress_panel, BorderLayout.SOUTH);
442 }
443
444 // Call refresh to update all controls to reflect current collection status.
445 refresh(-1, Gatherer.c_man.ready());
446 }
447 catch (Exception e) {
448 DebugStream.printStackTrace(e);
449 // The GUI failing to build is an app killer
450 e.printStackTrace();
451 System.exit(1);
452 }
453 }
454
455 public void exit()
456 {
457 exit(0);
458 }
459
460 /** This method ensures that all the things needing saving are saved before Gatherer.exit() is called.
461 */
462 public void exit(int exit_status)
463 {
464 // If we have a collection open remember it for next time, then save it and close it
465 if (Gatherer.c_man.ready()) {
466 Configuration.setString("general.open_collection", true, CollectionManager.getLoadedCollectionColFilePath());
467 saveThenCloseCurrentCollection();
468 }
469 else {
470 Configuration.setString("general.open_collection", true, null);
471 }
472
473 // Store the current position and size of the GLI for next time
474 Configuration.setBounds("general.bounds", true, getBounds());
475
476 // Save configuration
477 Configuration.save();
478
479 // Hide the main window
480 setVisible(false);
481
482 // If we're running as an applet we don't quit here (we quit when the browser calls GathererApplet.destroy())
483 if (!Gatherer.isApplet) {
484 Gatherer.exit(exit_status);
485 }
486 }
487
488
489 /** This method is called when the collection is being built, and is used to disable all controls in all pane which could change the state of the collection.
490 */
491 public void lockCollection(boolean import_stage, boolean lock)
492 {
493 locked = lock;
494
495 if (import_stage) {
496 int gather_pos = tab_pane.indexOfComponent(gather_pane);
497 if (gather_pos != -1) {
498 tab_pane.setEnabledAt(gather_pos, !lock);
499 }
500 int enrich_pos = tab_pane.indexOfComponent(enrich_pane);
501 if (enrich_pos != -1) {
502 tab_pane.setEnabledAt(enrich_pos, !lock);
503 }
504 }
505
506 int design_pos = tab_pane.indexOfComponent(design_pane);
507 if (design_pos != -1) {
508 tab_pane.setEnabledAt(design_pos, !lock);
509 }
510 }
511
512
513 public void modeChanged(int mode) {
514 // Set the title
515 String collection_title = null;
516 String collection_name = null;
517 if (Gatherer.c_man.ready()) {
518 Collection collection = Gatherer.c_man.getCollection();
519 collection_title = collection.getTitle();
520 collection_name = collection.getName();
521 collection = null;
522 }
523 setTitle(collection_title, collection_name);
524 collection_title = null;
525 collection_name = null;
526 // Now pass on the message to anyone who cares
527 if (download_pane != null) {
528 download_pane.modeChanged(mode);
529 }
530 if (gather_pane != null) {
531 gather_pane.modeChanged(mode);
532 }
533 if (enrich_pane != null) {
534 enrich_pane.modeChanged(mode);
535 }
536 if (design_pane != null) {
537 design_pane.modeChanged(mode);
538 }
539 if (create_pane != null) {
540 create_pane.modeChanged(mode);
541 }
542 if (format_pane != null) {
543 format_pane.modeChanged(mode);
544 }
545 }
546
547
548 public void refresh(int refresh_reason, boolean collection_loaded)
549 {
550 // Set the collection information in the title bar
551 if (collection_loaded) {
552 Collection collection = Gatherer.c_man.getCollection();
553 setTitle(collection.getTitle(), collection.getName());
554 }
555 else {
556 setTitle(null, null);
557 }
558
559 // Update the menu bar
560 menu_bar.refresh(refresh_reason, collection_loaded);
561
562 // Update the loaded panes
563 if (download_pane != null) {
564 download_pane.refresh(refresh_reason, collection_loaded);
565 }
566 if (gather_pane != null) {
567 gather_pane.refresh(refresh_reason, collection_loaded);
568 }
569 if (enrich_pane != null) {
570 enrich_pane.refresh(refresh_reason, collection_loaded);
571 }
572 if (design_pane != null) {
573 design_pane.refresh(refresh_reason, collection_loaded);
574 }
575 if (create_pane != null) {
576 create_pane.refresh(refresh_reason, collection_loaded);
577 }
578 if (format_pane != null) {
579 format_pane.refresh(refresh_reason, collection_loaded);
580 }
581
582 // Now enable tabs as necessary. Do this on event queue to prevent crazy NPEs
583 if (!locked) {
584 if (tab_updater == null) {
585 tab_updater = new TabUpdater(tab_pane, collection_loaded);
586 }
587 else {
588 tab_updater.setReady(collection_loaded);
589 }
590 SwingUtilities.invokeLater(tab_updater);
591 }
592 }
593
594
595 public void refreshCollectionTree(int refresh_reason)
596 {
597 if (gather_pane != null) {
598 gather_pane.refreshCollectionTree(refresh_reason);
599 }
600 }
601
602
603 public void refreshWorkspaceTree(int refresh_reason)
604 {
605 if (gather_pane != null) {
606 gather_pane.refreshWorkspaceTree(refresh_reason);
607 }
608 }
609
610
611 /** Specifies whether a certain tab is enabled or not. */
612 private void setTabEnabled(String rawname, boolean state) {
613 // Retrieve the dictionary based name.
614 String name = Dictionary.get("GUI." + rawname);
615 int index = tab_pane.indexOfTab(name);
616 // Of course we may not have this tab available.
617 if(index != -1) {
618 // Some tabs are also dependant on if a collection is ready
619 Component component = tab_pane.getComponentAt(index);
620 if(component == enrich_pane || component == design_pane || component == create_pane || component == format_pane) {
621 tab_pane.setEnabledAt(index, state && Gatherer.c_man != null && Gatherer.c_man.ready());
622 }
623 else {
624 tab_pane.setEnabledAt(index, state);
625 }
626 // If this was the currently selected tab and it is now disabled, change the view to the first enabled tab.
627 if(tab_pane.getSelectedIndex() == index && !state) {
628 boolean found = false;
629 for(int i = 0; !found && i < tab_pane.getTabCount(); i++) {
630 if(tab_pane.isEnabledAt(i)) {
631 tab_pane.setSelectedIndex(i);
632 found = true;
633 }
634 }
635 // If there are no tabs enabled, which should be impossible, then select the first tab
636 if(!found) {
637 tab_pane.setSelectedIndex(0);
638 }
639 }
640 }
641 }
642
643 /** Change the string shown in the title bar of the main gui frame. If either value is null, the 'No Collection' string is shown instead.
644 * @param title
645 * @param name
646 */
647 public void setTitle(String title, String name) {
648 // Finally display the collection name in the title bar.
649 StringBuffer title_buffer = new StringBuffer(Configuration.getApplicationTitle());
650 title_buffer.append(StaticStrings.SPACE_CHARACTER);
651 title_buffer.append(Gatherer.PROGRAM_VERSION);
652 title_buffer.append(StaticStrings.SPACE_CHARACTER);
653 title_buffer.append(StaticStrings.SPACE_CHARACTER);
654 // Describe the current user mode
655 title_buffer.append(StaticStrings.MODE_STR);
656 title_buffer.append(Configuration.getModeAsString());
657 title_buffer.append(StaticStrings.SPACE_CHARACTER);
658 title_buffer.append(StaticStrings.SPACE_CHARACTER);
659 // Now for the current collection
660 title_buffer.append(StaticStrings.COLLECTION_STR);
661 if (title != null && name != null) {
662 title_buffer.append(title);
663 title_buffer.append(StaticStrings.SPACE_CHARACTER);
664 title_buffer.append(StaticStrings.OPEN_PARENTHESIS_CHARACTER);
665 title_buffer.append(name);
666 title_buffer.append(StaticStrings.CLOSE_PARENTHESIS_CHARACTER);
667 }
668 else {
669 title_buffer.append(Dictionary.get("Collection.No_Collection"));
670 }
671 this.setTitle(title_buffer.toString());
672 title_buffer = null;
673 }
674
675
676 private class OpenCollectionTask
677 extends Thread
678 {
679 public void run()
680 {
681 String collection_file_path = showOpenCollectionDialog();
682
683 // User has selected a collection to open
684 if (collection_file_path != null) {
685 // If there is already a collection open, save and close it
686 if (Gatherer.c_man.ready()) {
687 saveThenCloseCurrentCollection();
688 }
689
690 // Open the selected collection
691 Gatherer.c_man.loadCollection(collection_file_path);
692 }
693 }
694 }
695
696
697 /** When the load collection option is chosen this method is called to produce the modal file load prompt.
698 */
699 private String showOpenCollectionDialog()
700 {
701 OpenCollectionDialog dialog = new OpenCollectionDialog();
702 if (dialog.display() == OpenCollectionDialog.OK_OPTION) {
703 return dialog.getFileName();
704 }
705
706 // User must have cancelled the action
707 return null;
708 }
709
710
711 /** When called this method causes the MetadataAuditTable to display a nice dialog box which contains all the metadata assigned in the collection.
712 */
713 public void showMetaAuditBox() {
714 wait(true);
715 meta_audit.display();
716 wait(false);
717 }
718
719
720 private class NewCollectionTask
721 extends Thread
722 {
723 public void run()
724 {
725 // Create the collection details prompt from new collection prompt
726 NewCollectionDetailsPrompt ncd_prompt = new NewCollectionDetailsPrompt();
727
728 // Create the new collection (if not cancelled) in a new thread.
729 if (!ncd_prompt.isCancelled()) {
730 // If there is already a collection open, save and close it.
731 if (Gatherer.c_man.ready()) {
732 saveThenCloseCurrentCollection();
733 }
734
735 // Create new collection.
736 Gatherer.c_man.createCollection(ncd_prompt.getDescription(), Configuration.getEmail(), ncd_prompt.getName(), ncd_prompt.getTitle(), ncd_prompt.getBase(), new ArrayList());
737 ncd_prompt.dispose();
738 }
739
740 // Done
741 ncd_prompt = null;
742 }
743 }
744
745
746 private class DeleteCollectionTask
747 extends Thread
748 {
749 public void run()
750 {
751 // The rest is handled by the DeleteCollectionPrompt
752 DeleteCollectionPrompt dc_prompt = new DeleteCollectionPrompt();
753 if (dc_prompt.display()) {
754 //closeCurrentCollection();
755 }
756 dc_prompt.destroy();
757 dc_prompt = null;
758 }
759 }
760
761
762 /** Any implementation of ChangeListener must include this method so we can be informed when the state of one of the registered objects changes. In this case we are listening to view changes within the tabbed pane.
763 * @param event A ChangeEvent containing information about the event that fired this call.
764 */
765 public void stateChanged(ChangeEvent event)
766 {
767 if (previous_pane != null) {
768 if (previous_pane == gather_pane) {
769 gather_pane.loseFocus();
770 }
771 else if (previous_pane == enrich_pane) {
772 enrich_pane.loseFocus();
773 }
774 else if (previous_pane == design_pane) {
775 design_pane.loseFocus();
776 }
777 else if (previous_pane == create_pane) {
778 create_pane.loseFocus();
779 }
780 else if (previous_pane == format_pane) {
781 format_pane.loseFocus();
782 }
783 }
784
785 menu_bar.tabSelected(tab_pane.getSelectedIndex());
786 int selected_index = tab_pane.getSelectedIndex();
787 if (selected_index == tab_pane.indexOfComponent(download_pane)) {
788 download_pane.gainFocus();
789 }
790 else if (selected_index == tab_pane.indexOfComponent(gather_pane)) {
791 gather_pane.gainFocus();
792 }
793 else if (selected_index == tab_pane.indexOfComponent(enrich_pane)) {
794 enrich_pane.gainFocus();
795 }
796 else if (selected_index == tab_pane.indexOfComponent(design_pane)) {
797 design_pane.gainFocus();
798 }
799 else if (selected_index == tab_pane.indexOfComponent(create_pane)) {
800 create_pane.gainFocus();
801 }
802 else if (selected_index == tab_pane.indexOfComponent(format_pane)) {
803 format_pane.gainFocus();
804 }
805
806 previous_pane = (JPanel) tab_pane.getSelectedComponent();
807
808 }
809
810
811 private MouseListener mouse_blocker_listener = new MouseAdapter() {};
812
813 public void updateUI()
814 {
815 JPanel pane = (JPanel) getContentPane();
816 pane.updateUI();
817 // Also update all of the tabs according to workflow.
818 workflowUpdate("Download", Configuration.get("workflow.download", false));
819 workflowUpdate("Gather", Configuration.get("workflow.gather", false));
820 workflowUpdate("Enrich", Configuration.get("workflow.enrich", false));
821 workflowUpdate("Design", Configuration.get("workflow.design", false));
822 workflowUpdate("Create", Configuration.get("workflow.create", false));
823 workflowUpdate("Format", Configuration.get("workflow.format", false));
824 }
825
826 public void wait(boolean waiting) {
827 Component glass_pane = getGlassPane();
828 if(waiting) {
829 // Show wait cursor.
830 glass_pane.addMouseListener(mouse_blocker_listener);
831 glass_pane.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
832 glass_pane.setVisible(true);
833 }
834 else {
835 // Hide wait cursor.
836 glass_pane.setVisible(false);
837 glass_pane.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
838 glass_pane.removeMouseListener(mouse_blocker_listener);
839 }
840 glass_pane = null;
841 }
842
843 public void workflowUpdate(String raw, boolean state) {
844 WorkflowUpdater task = new WorkflowUpdater(raw, state);
845 SwingUtilities.invokeLater(task);
846 task = null;
847 }
848
849
850 /**Overridden from JFrame so we can exit safely when window is closed (or destroyed).
851 * @param event A <strong>WindowEvent</strong> containing information about the event that fired this call.
852 */
853 protected void processWindowEvent(WindowEvent event) {
854 if(event.getID() == WindowEvent.WINDOW_CLOSING) {
855 exit();
856 }
857 }
858
859
860 /** Listens to actions upon the menu bar, and if it detects a click over the help menu brings the help window to the front if it has become hidden.
861 */
862 private class MenuListenerImpl
863 implements MenuListener {
864 /** Called whenever a popup menu is hidden, but we don't care.
865 * @param e Some <strong>MenuEvent</strong> that we could care less about.
866 */
867 public void menuCanceled(MenuEvent e) {
868 }
869 /** Called whenever a menu header (ie button) becomes unselected, but we don't care.
870 * @param e Some <strong>MenuEvent</strong> that we could care less about.
871 */
872 public void menuDeselected(MenuEvent e) {
873 }
874 /** This method, when a menu is first opened, is the only one we respond to by bringing the help window to the front if possible, but only if there is a help window and the help menu is the one opening.
875 * @param e The <strong>MenuEvent</strong> whose source is checked.
876 */
877 public void menuSelected(MenuEvent e) {
878 if(e.getSource() == menu_bar.help) {
879 if(menu_bar.help.isSelected()) {
880 menu_bar.help.doClick(10);
881 }
882 }
883 }
884 }
885
886 private class TabUpdater
887 implements Runnable {
888 private boolean ready = false;
889 private int download_pos = -1;
890 private int enrich_pos = -1;
891 private int design_pos = -1;
892 private int create_pos = -1;
893 private int format_pos = -1;
894 private int export_pos = -1;
895 private JTabbedPane tab_pane = null;
896
897 public TabUpdater(JTabbedPane tab_pane, boolean ready) {
898 this.ready = ready;
899 this.tab_pane = tab_pane;
900 download_pos = tab_pane.indexOfComponent(download_pane);
901 enrich_pos = tab_pane.indexOfComponent(enrich_pane);
902 design_pos = tab_pane.indexOfComponent(design_pane);
903 create_pos = tab_pane.indexOfComponent(create_pane);
904 format_pos = tab_pane.indexOfComponent(format_pane);
905 }
906
907 public void run()
908 {
909 if (download_pos != -1) {
910 if (ready) {
911 tab_pane.setEnabledAt(download_pos, Configuration.get("workflow.download", false));
912 }
913 else {
914 tab_pane.setEnabledAt(download_pos, Configuration.get("workflow.download", true));
915 }
916 }
917 if (enrich_pos != -1) {
918 tab_pane.setEnabledAt(enrich_pos, ready && Configuration.get("workflow.enrich", false));
919 }
920 if (design_pos != -1) {
921 tab_pane.setEnabledAt(design_pos, ready && Configuration.get("workflow.design", false) && Configuration.getMode() > Configuration.ASSISTANT_MODE);
922 }
923 if (create_pos != -1) {
924 tab_pane.setEnabledAt(create_pos, ready && Configuration.get("workflow.create", false));
925 }
926 if (format_pos != -1) {
927 tab_pane.setEnabledAt(format_pos, ready && Configuration.get("workflow.format", false) && Configuration.getMode() > Configuration.ASSISTANT_MODE);
928 }
929 }
930
931 public void setReady(boolean ready) {
932 this.ready = ready;
933 }
934 }
935
936 private class WorkflowUpdater
937 implements Runnable {
938 private boolean state;
939 private String raw;
940 public WorkflowUpdater(String raw, boolean state) {
941 this.raw = raw;
942 this.state = state;
943 }
944 public void run() {
945 setTabEnabled(raw, state);
946 }
947 }
948}
Note: See TracBrowser for help on using the repository browser.