Changeset 4346

Timestamp:

2003-05-27T14:53:30+12:00 (21 years ago)

Author:

kjdon

Message:

added in a log history list for build messages

Location:

trunk/gli/src/org/greenstone/gatherer/gui

Files:

• CreatePane.java (modified) (8 diffs)
• OptionsPane.java (modified) (5 diffs)

trunk/gli/src/org/greenstone/gatherer/gui/CreatePane.java

@@ -112 +112 @@
      /** The pane which contains the progress information. */
      private JPanel progress_pane = null;
+    /** the pane on the right-hand side - shows the requested options view */
+    private JPanel right = null;
      /** This pane is the one that is updated to show the requested options view. */
-     private JPanel target_pane = null;
-     /** The scrolling pane the log is inside. */
-     private JScrollPane scroll_log = null;
-     private JScrollPane scroll_pane;
+    //private JPanel target_pane = null;
+    /** The scrolling pane the log is inside. */
+    private JScrollPane scroll_log = null;
+    /** the scrolling pane the righthand side is inside - only used for import and build options. the log and log list are not inside a scrollpane */
+    private JScrollPane scroll_pane;
      /** The log for the current process. */
      private JTextArea process_log = null;
@@ -146 +149 @@
       */
      public CreatePane() {
-          this.target_pane = new JPanel(new BorderLayout());
+         //this.target_pane = new JPanel(new BorderLayout());
           Collection collection = Gatherer.c_man.getCollection();
-          if(collection != null) {
-                this.options_pane = new OptionsPane(target_pane, message_log, collection.build_options);
-          }
+          //if(collection != null) {
+          //    this.options_pane = new OptionsPane(message_log, collection.build_options);
+          // }
           // Create components
           card_layout = new CardLayout();
@@ -209 +212 @@
       */
      public void collectionChanged(boolean ready) {
-          ///ystem.err.println("Collection changed... ");
+         ///ystem.err.println("Collection changed... ");
           if(Gatherer.c_man != null && Gatherer.c_man.ready()) {
-                this.options_pane = new OptionsPane(target_pane, message_log, Gatherer.c_man.getCollection().build_options);
+              
+              if (!processing &&this.options_pane!=null) {
+              // we only do this if we are not processing - if we are processing, then we haven't added the new entry yet, and it will be added by another method
+              this.options_pane.resetLogList(); // saves any residual message
+              } 
+              this.options_pane = new OptionsPane(message_log, Gatherer.c_man.getCollection().build_options);
+              tree.valueChanged(null);
           }
      }
@@ -230 +239 @@
           left.add(tree, BorderLayout.CENTER);
 
-          JPanel right = new JPanel();
+          right = new JPanel();
           right.setBorder(BorderFactory.createEmptyBorder(0,0,5,5));
           right.setLayout(new BorderLayout());
-          scroll_pane = new JScrollPane(target_pane);
-          right.add(scroll_pane, BorderLayout.CENTER);
+          //scroll_pane = new JScrollPane(target_pane);
+          //right.add(scroll_pane, BorderLayout.CENTER);
 
           JPanel options_area = new JPanel();
@@ -358 +367 @@
       * @param event A <strong>GShellEvent</strong> that contains details of the final state of the <strong>GShell</strong> after task completion.
       */
-     public synchronized void processComplete(GShellEvent event) {
-          if(event.getType() == GShell.BUILD) {
-                processing = false;
-                cancel_button.setEnabled(false);
-                build_button.setEnabled(true);
-                card_layout.show(main_pane, CONTROL);
-          }
-     }
+    public synchronized void processComplete(GShellEvent event) {
+    if(event.getType() == GShell.BUILD) {
+        processing = false;
+        cancel_button.setEnabled(false);
+        build_button.setEnabled(true);
+        int status = event.getStatus();
+        if (status == GShell.OK) {
+        options_pane.addNewLog(OptionsPane.SUCCESSFUL);
+        } else {
+        options_pane.addNewLog(OptionsPane.UNSUCCESSFUL);
+        }
+        card_layout.show(main_pane, CONTROL);
+    }
+    }
      /** This method retrieves a phrase from the dictionary based apon the key.
       * @param key A <strong>String</strong> used as a reference to the correct phrase.
@@ -409 +424 @@
                 scroll_log = new JScrollPane(process_log);
                 progress_pane.add(scroll_log, BorderLayout.CENTER);
+                // clear the log list and message_log
+                options_pane.resetLogList();
                 // Change the view.
                 processing = true;
@@ -437 +454 @@
                 build_button.setEnabled(true);
                 cancel_button.setEnabled(false);
+                processing = false;
+                options_pane.addNewLog(OptionsPane.CANCELLED);
                 card_layout.show(main_pane, CONTROL);
                 // Set the stop flag in all the process monitor.
@@ -496 +515 @@
                 TreePath path = null;
                 OptionTreeNode node = null; 
-                if(event != null) {
-                     path = event.getPath();
-                     node = (OptionTreeNode)path.getLastPathComponent();
-                }
+                //if(event != null) {
+                    //path = event.getPath();
+                    path = getSelectionPath();
+                    if(path != null) {
+                    node = (OptionTreeNode)path.getLastPathComponent();
+                    }
+                //}
                 if(previous_pane != null) {
                      //target_pane.remove(previous_pane);
                      options_pane.update(previous_pane);
+                     if(scroll_pane != null) {
+                         right.remove(scroll_pane);
+                     }
+                     else {
+                         right.remove(previous_pane);
+                     }
                      previous_pane = null;
+                     scroll_pane = null;
                 }
                 if(node != null && node.equals(building)) {
                      previous_pane = options_pane.buildBuild();
+                     scroll_pane = new JScrollPane(previous_pane);
+                     right.add(scroll_pane, BorderLayout.CENTER);
                      //target_pane.add(previous_pane, BorderLayout.CENTER);
                 }
                 else if(node != null && node.equals(importing)) {
                      previous_pane = options_pane.buildImport();
+                     scroll_pane = new JScrollPane(previous_pane);
+                     right.add(scroll_pane, BorderLayout.CENTER);
                      //target_pane.add(previous_pane, BorderLayout.CENTER);
                 }
                 else {
                      previous_pane = options_pane.buildLog();
+                     right.add(previous_pane, BorderLayout.CENTER);
+                     right.updateUI(); // we need to repaint the log pane, cos it hasn't changed since last time
+                     ///ystem.err.println("I've added the log back to the right pane again.");
                      //target_pane.add(previous_pane, BorderLayout.CENTER);
                 }
-                scroll_pane.setViewportView(previous_pane);
+                //scroll_pane.setViewportView(previous_pane);
                 previous_pane.validate();
           }

trunk/gli/src/org/greenstone/gatherer/gui/OptionsPane.java

@@ -56 +56 @@
  */
 final public class OptionsPane
-     extends JPanel {
-     /** The <strong>BuildOptions</strong> data object contains all the option settings we wish to persist between Gatherer sessions (and thus is stored in <strong>Collection</strong>). */
-     private BuildOptions build_options = null;
-     /** This <strong>JPanel</strong> is used to display the varying options panes. */
-     private JPanel target_pane = null;
-     /** All process messages are written to this log text area. */
-     private JTextArea log = null;
-     static private int BUILD = 0;
-     static private int IMPORT = 1;
-     static private Dimension LABEL_SIZE = new Dimension(180, 25);
-     static private Dimension LOG_SIZE = new Dimension(610, 360);
-     /** The minimum size of a options pane, to prevent refresh problems around the bottom of shorter panes. */
-     static private Dimension PANE_SIZE = new Dimension(610, 350);
-     static private Dimension ROW_SIZE = new Dimension(610, 25);
-     static private Dimension SPINNER_SIZE = new Dimension(100, 25);
-     static private String DESCRIPTION_SEP = " + ";
+    extends JPanel {
+    /** The <strong>BuildOptions</strong> data object contains all the option settings we wish to persist between Gatherer sessions (and thus is stored in <strong>Collection</strong>). */
+    private BuildOptions build_options = null;
+    /** the log pane - we only create it once now, not each time */
+    private JPanel log_pane = null;
+    /** the list of previous log messages */
+    private JList log_list = null;
+    /** whether that currently showing log is changed or not */
+    private boolean is_log_changed = false;
+    /** the list entry that is currently displayed */
+    private FileEntry displayed_log = null;
+    /** a listener for changes in the log text */
+    private LogChangeListener log_change_listener = null;
+    /** All process messages are written to this log text area. */
+    private JTextArea log_display = null;
+
+    static final public char SUCCESSFUL = 's';
+    static final public char UNSUCCESSFUL = 'u';
+    static final public char CANCELLED = 'c';
+    
+    static private int BUILD = 0;
+    static private int IMPORT = 1;
+    static private Dimension LABEL_SIZE = new Dimension(180, 25);
+    static private Dimension LOG_SIZE = new Dimension(610, 360);
+    /** The minimum size of a options pane, to prevent refresh problems around the bottom of shorter panes. */
+    static private Dimension PANE_SIZE = new Dimension(610, 350);
+    static private Dimension ROW_SIZE = new Dimension(610, 25);
+    static private Dimension SPINNER_SIZE = new Dimension(100, 25);
+    static private String DESCRIPTION_SEP = " + ";
+    
+    
      /** The default constructor creates the few session length options, but either retrieves the rest from the current collection, or creates a default set of options. */
-     public OptionsPane(JPanel target_pane, JTextArea log, BuildOptions build_options) {
-          this.log = log;
+     public OptionsPane(JTextArea log, BuildOptions build_options) {
+          this.log_display = log;
           this.build_options = build_options;
-          this.target_pane = target_pane;
-     }
+          this.log_change_listener = new LogChangeListener();
+          //this.target_pane = target_pane;
+     }
+
+    /** creates a new log from the text in log. The new file is named 
+     * build_log.<current time>.txt. A new FileEntry is added to teh log list
+     * and made selected. A fresh listener is added to teh document */
+    public void addNewLog(char success) {
+    ///ystem.out.println("add new log");
+        
+    // create the file name
+    long time = System.currentTimeMillis();
+    StringBuffer name = new StringBuffer();
+    name.append("build_log.");
+    name.append(time);
+    name.append(success);
+    name.append(".txt");
+    File f = new File(Gatherer.c_man.getCollectionLog()+name.toString());
+    // just in case there is no log directory
+    File parent_file = f.getParentFile();
+    parent_file.mkdirs();
+
+    // save the log text to the file
+    saveLogFile(f);
+    is_log_changed=false;
+    log_display.getDocument().addDocumentListener(log_change_listener);
+
+    // create the file entry and add it to the list at pos 0 - it will always be the newest one created
+    FileEntry fe = new FileEntry(f);
+    ((DefaultListModel)log_list.getModel()).add(0, fe);
+    log_list.setSelectedIndex(0);
+    displayed_log = fe;
+
+    }
+
      /** This method creates the panel with all the build only options on it.
       * @return A <strong>JPanel</strong> which can be used to display all the build only options.
@@ -134 +182 @@
           return pane;
      }
-     /** This method is used to build a panel based on the message log, which is nothing like any of the other panel.
+     /** This method is used to build a panel based on the message log, which is nothing like any of the other panels.
       * @return A <strong>JPanel</strong> containing a scrollable text area which represents the shell process message log.
       */
      public JPanel buildLog() {
-          JPanel pane = new JPanel(new BorderLayout());
-          /*
-          // Build a list of the log files available, ordering by last modified. Log files end .log (duh!)
-          DefaultComboBoxModel model = new DefaultComboBoxModel();
-          File etc_directory = new File(gatherer.c_man.getCollectionEtc());
-          File children[] = etc_directory.listFiles();
+         // we now save the log pane
+         if (log_pane == null) {
+         log_pane = new JPanel(new BorderLayout());
+          
+          // Build a list of the log files available, ordering by last modified. Log files are like build_log.date.txt
+          DefaultListModel contents = new DefaultListModel();
+          File log_directory = new File(Gatherer.c_man.getCollectionLog());
+          File children[] = log_directory.listFiles();
           for(int i = 0; children != null && i < children.length; i++) {
-                if(children[i].getName().endsWith(".log")) {
-                     FileEntry entry = new FileEntry(children[i]);
-                     // We are about to insert it. But where.
-                     boolean found = false;
-                     for(int j = 0; j < model.getSize(); j++) {
-                          FileEntry sibling = (FileEntry) model.getElementAt(i);
-                          int order = entry.compareTo(sibling);
-                          if(order < 0) {
-                                model.insertElementAt(entry, j);
-                                found = true;
-                          }
-                     }
-                     if(!found) {
-                          model.addElement(entry);
-                     }
-                }
-          }
-          JComboBox logs_box = new JComboBox(model);
-          // If log is empty, reload the most recent log.
-          if(log.getText().length() == 0 && model.getSize() > 0) {
-                loadLog(model.getElementAt(0));
-          }
-          */
-          pane.add(log, BorderLayout.CENTER);
-          //pane.add(logs_box, BorderLayout.SOUTH);
-          return pane;
+              if(children[i].getName().startsWith("build_log")&&children[i].getName().endsWith(".txt") ) {
+              FileEntry entry = new FileEntry(children[i]);
+              // We are about to insert it. But where.
+              boolean found = false;
+              for(int j = 0; j < contents.size(); j++) {
+                  FileEntry sibling = (FileEntry) contents.getElementAt(j);
+                  int order = entry.compareTo(sibling);
+                  if(order > 0) {
+                  contents.insertElementAt(entry, j);
+                  found = true;
+                  break;
+                  }
+              }
+              if(!found) {
+                  contents.addElement(entry);
+              }
+              }
+          }
+          
+          log_list = new JList(contents); 
+          log_list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+          log_list.setLayoutOrientation(JList.VERTICAL);
+          log_list.setVisibleRowCount(3);
+          log_list.addListSelectionListener(new LogListListener());
+          
+          JScrollPane list_scroller = new JScrollPane(log_list);
+          
+          // If log is not empty and we have something in displayed_log - make that element selected
+          if (log_display.getText().length()>0 && displayed_log != null) {
+              int index = contents.indexOf(displayed_log);
+              if (index != -1) {
+              log_list.setSelectedIndex(index);
+              }
+              
+          }
+          log_pane.add(new JScrollPane(log_display), BorderLayout.CENTER);
+          JLabel log_history_label = new JLabel(get("LogHistory"));
+          JPanel log_history_pane = new JPanel();
+          log_history_pane.setLayout(new BorderLayout());
+          log_history_pane.add(log_history_label, BorderLayout.NORTH);
+          log_history_pane.add(list_scroller, BorderLayout.SOUTH);
+          log_pane.add(log_history_pane, BorderLayout.SOUTH);
+         }
+         return log_pane;
+     }
+
+     /** This method retrieves a phrase from the dictionary based apon the key.
+      * @param key A <strong>String</strong> used as a reference to the correct phrase.
+      * @return A phrase, matching the key, as a <strong>String</strong>.
+      */
+     private String get(String key) {
+          return get(key, null);
+     }
+     /** This method retrieves a phrase from the dictionary based apon the key and arguments.
+      * @param key A <strong>String</strong> used as a reference to the correct phrase.
+      * @param args A <strong>String[]</strong> whose contents are often substituted into the phrase before it is returned.
+      * @return A phrase, matching the key and constructed using the arguments, as a <strong>String</strong>.
+      * @see org.greenstone.gatherer.Dictionary
+      * @see org.greenstone.gatherer.Gatherer
+      */
+     private String get(String key, String args[]) {
+          if(key.indexOf(".") == -1) {
+                key = "OptionsPane." + key;
+          }
+          return Gatherer.dictionary.get(key, args);
      }
      /** Attempts to discover the latest document count. 
@@ -184 +273 @@
           return 1;
      }
-    
-     public void saveLog() {
-          /*
-          try {
-                long name_long = System.currentTimeMillis();
-                String name = name_long + ".log";
-                File;
-                FileOutputStream fos = new FileOutputStream(file);
-          }
-          catch(Exception error) {
-          }
-          */
-     }
+    
+    /** Loads a new log into the log text - saves the currently showing one,
+     * and loads the new one, adding a fresh listener to the document
+     * Note, we need to remove any listener before making the changes, then 
+     * add a listener back in 
+     */
+    public void loadSelectedLog(FileEntry fe) {
+    ///ystem.out.println("load selected log");
+    if (is_log_changed) {
+        saveLogFile(displayed_log.getFile());
+    } else {
+        log_display.getDocument().removeDocumentListener(log_change_listener);
+    }
+    
+    displayed_log = fe;
+    if (fe != null) {
+        log_display.setText(fe.getFileText());
+    } else {
+        log_display.setText("");
+    }
+    is_log_changed=false;
+    log_display.getDocument().addDocumentListener(log_change_listener);
+    
+    }
+
+    /** Neutralizes the log list - saves any unsaved changes to the current log
+     * clears the log text, unselects the log list, and adds a fresh listener 
+     * to the log's document 
+     * Note, we need to remove any listener before making the changes, then 
+     * add a listener back in */
+    public void resetLogList() {
+    ///ystem.out.println("reset log");
+    if (is_log_changed) {
+        saveLogFile(displayed_log.getFile());
+    } else {
+        log_display.getDocument().removeDocumentListener(log_change_listener);
+    }
+    log_display.setText("");
+    displayed_log = null;
+    if (log_list != null) {
+        log_list.clearSelection();
+    }
+    is_log_changed=false;
+    log_display.getDocument().addDocumentListener(log_change_listener);
+    
+    }
+
+    /** saves the current text in log to the File specified */
+    public void saveLogFile(File file) {
+    
+    try {
+        BufferedWriter out = new BufferedWriter(new FileWriter(file)); // uses the default encoding
+        String log_text = log_display.getText();
+        // set teh return delims to true, then swap them for newLine() (platform dependent) - having return delims set to false seemed to not get empty strings so that empty lines were not preserved.
+        StringTokenizer t = new StringTokenizer(log_text, "\n", true);
+        while (t.hasMoreTokens()) {
+        String token = t.nextToken();
+        if (token.equals("\n")) {
+            out.newLine(); 
+        } else {
+            out.write(token, 0, token.length());
+        }
+        
+        }
+        out.close();
+        
+    } catch(Exception e) {
+        System.out.println("Error in saving log file: "+file.toString());
+        e.printStackTrace();
+    }
+    
+    
+    }
+
 
      /** Given a panel containing ArgumentControls, update the values associated with them. */
      public void update(JPanel panel) {
+         if(panel == log_pane) {
+         return;
+         }
+
           for(int i = 0; i < panel.getComponentCount(); i++) {
                 Component component = panel.getComponent(i);
@@ -432 +586 @@
      }
 
+    /** holds a File which has a particular naming convention
+     * build_log.date.txt 
+     * also keeps a Date corresponding to the date in its name*/
+    private class FileEntry {
+    
+    private Date date=null;
+    private File file=null;
+    private String display=null;
+    public FileEntry(File f) {
+        this.file=f;
+        this.date = getDateFromFileName();
+        this.display = createDisplayText();
+        
+    }
+
+    /** returns 0 if the dates are the same, -ve number if the current FileEntry is earlier than the fe FileEntry ...*/
+    public int compareTo(FileEntry fe) {
+        Date d = fe.getDate();
+        return date.compareTo(d);
+    }
+    
+    public Date getDate() {
+        return this.date;
+    }
+    public File getFile() {
+        return this.file;
+    }
+    /** returns the contents of the file */
+    public String getFileText() {
+        if (!this.file.exists()) {
+        return "";
+        }
+        StringBuffer contents = new StringBuffer();
+        try {
+        BufferedReader in = new BufferedReader(new FileReader(this.file));
+        String line;
+        
+        while ((line = in.readLine()) != null) {
+            contents.append(line);
+            contents.append("\n");
+        }
+        } catch (FileNotFoundException fnfe) {
+        System.err.println("Error: log file not found: "+ this.file.toString());
+        return "";
+        } catch (IOException ioe) {
+        System.err.println("Error: exception occurred when trying to read in file "+this.file.toString()+", "+ioe.getMessage());
+        
+        }
+        
+        return contents.toString();
+    }
+    /** we only want the date out of the file name, not the whole path */
+    public String toString() {
+        return this.display; 
+    }
+    /** creates the display text for the list */
+    private String createDisplayText() {
+        StringBuffer d = new StringBuffer();
+        d.append(date.toString());
+        char success= this.file.getName().charAt(23);
+        switch (success) {
+        case OptionsPane.SUCCESSFUL:
+        d.append(get("Successful"));
+        break;
+        case OptionsPane.UNSUCCESSFUL:
+        d.append(get("Unsuccessful"));
+        break;
+        case OptionsPane.CANCELLED:
+        d.append(get("Cancelled"));
+        break;
+        }
+        return d.toString();
+    }
+    /** extracts the date from the file name */
+    private Date getDateFromFileName() {
+        String name = this.file.getName();
+        String date_string = name.substring(10, 23);//name.length()-4);
+        return new Date(Long.parseLong(date_string));
+    }
+
+    
+    }
+
+    /** A DocumentListener that listens for changes in the log_display document
+     * if a change is registered, the flag is_log_changed is set to true,
+     * and the listener removes itself from log_display 
+     * Because we only want to register user's changes, the listener must be removed before the system makes any changes, and then put back. For example, each time we switchlogs to display, a remove event and an insert event are sent. We dont want to register these as changes to the document, so the listener must be removed before the switch, and added back afterwards */
+    private class LogChangeListener implements DocumentListener {
+
+    public void changedUpdate(DocumentEvent e) {
+        ///ystem.out.println("changed update");
+        registerChange();
+    }
+    public void insertUpdate(DocumentEvent e) {
+        ///ystem.out.println("insert update");
+        registerChange();
+    }
+    public void removeUpdate(DocumentEvent e) {
+        ///ystem.out.println("remove update");
+        registerChange();
+    }
+
+    private void registerChange() {
+        ///ystem.err.println("a change in the doc occurred, removing the listener");
+        is_log_changed = true;
+        log_display.getDocument().removeDocumentListener(this);
+    }
+    }
+    
+    /** a ListSelectionListener that triggers the load of a newly selected 
+    log */
+    private class LogListListener implements ListSelectionListener {
+
+    public void valueChanged(ListSelectionEvent e) {
+        if (!e.getValueIsAdjusting()) { // we get two events for one change in list selection - use the false one ( the second one) 
+        JList source  = (JList)e.getSource();
+        FileEntry fe = (FileEntry) source.getSelectedValue();
+        loadSelectedLog(fe);
+        }
+    }
+    }
+
      /** Listener that sets the tooltip associated to a combobox to the tooltip relevant to the selected item. */
      private class ToolTipUpdater
@@ -462 +738 @@
           }
      }
+
+
 }