Changeset 6388 for trunk/gli/src/org/greenstone/gatherer/shell/GImportProgressMonitor.java

Timestamp:

2004-01-09T15:00:44+13:00 (20 years ago)

Author:

jmt12

Message:

Completely rewrote monitors to be language independant - fixed several bugs including a decreasing progress bar and added a new reset() method to ensure that progress bars are pristine now that they can be onscreen at all times (lower detail modes)

File:

• trunk/gli/src/org/greenstone/gatherer/shell/GImportProgressMonitor.java (modified) (8 diffs)

trunk/gli/src/org/greenstone/gatherer/shell/GImportProgressMonitor.java

@@ -38 +38 @@
 
 import java.awt.Component;
+import java.util.ArrayList;
 import java.util.StringTokenizer;
 import javax.swing.JProgressBar;
+import org.greenstone.gatherer.Configuration;
 import org.greenstone.gatherer.Dictionary;
 import org.greenstone.gatherer.Gatherer;
+import org.greenstone.gatherer.shell.GShellElement;
 import org.greenstone.gatherer.shell.GShellProgressMonitor;
 import org.greenstone.gatherer.util.StaticStrings;
@@ -65 +68 @@
     /** This holds the number of documents actually processed by the import command, as garnered from the final block of text output. */
     private int num_docs;
+
+    private int threshold = Configuration.SYSTEMS_MODE;
     /** The progress bar this monitor updates. */
     private JProgressBar progress_bar;
     /** */
-    static final private String C = "c";
+    static final private String BLOCKED_ATTRIBUTE = "blocked";
+    static final private String CONSIDERED_ATTRIBUTE = "considered";
+    static final private String IGNORED_ATTRIBUTE = "ignored";
+    static final private String IMPORT_ELEMENT = "Import";
+    static final private String PROCESSED_ATTRIBUTE = "processed";    
     /** */
-    static final private String N = "n";
+    static final private String NAME_ATTRIBUTE = "n";
     /** */
-    static final private String P = "p";
+    static final private String PLUGIN_ATTRIBUTE = "p";
     /** The fixed portion of the progress bar used for the calculating of file size and other pre-import functions. */
     static final private int CALCULATION = 50000;
@@ -82 +91 @@
     static final private int PROCESSED = 750000;
     /** The element name of a file detected message. */
-    static final private String FILE = "File";
+    static final private String FILE_ELEMENT = "File";
     /** The element name of a file processing message. */
-    static final private String FILE_PROCESSING = "Processing";
+    static final private String FILEPROCESSING_ELEMENT = "Processing";
     /** The element name of an import complete message. */
-    static final private String IMPORT_COMPLETE = "ImportComplete";
+    static final private String IMPORTCOMPLETE_ELEMENT = "ImportComplete";
 
     public GImportProgressMonitor() {
@@ -93 +102 @@
     progress_bar.setMaximum(CALCULATION + PROCESSED + EXTRACTED);
     progress_bar.setMinimum(MIN);
+    progress_bar.setString(StaticStrings.SPACE_CHARACTER);
     progress_bar.setStringPainted(true);
-    progress_bar.setValue(MIN);
+    setValue(MIN);
     next_progress_value = CALCULATION;
     }
@@ -105 +115 @@
     progress_bar.setMaximum(CALCULATION + PROCESSED + EXTRACTED);
     progress_bar.setMinimum(MIN);
-    progress_bar.setValue(MIN);
+    setValue(MIN);
     next_progress_value = CALCULATION;
     }
@@ -145 +155 @@
     // The current progress is calculated to be:
     // The fixed calculation value plus the fixed processed value plus some portion of the fixed extracted value. This portion is the extracted_file_count over the total number of documents available. Note that this breaks badly for bibliographical files (for now).
-    progress_bar.setValue(CALCULATION + PROCESSED + ((EXTRACTED * extracted_file_count) / num_docs));
+    setValue(CALCULATION + PROCESSED + ((EXTRACTED * extracted_file_count) / num_docs));
     }
 
     /** This method is used to 'feed in' a line of text captured from the process.
-     * @param event the GShellEvent containing a message or other important shell information
-     */
-    public void process(GShellEvent event) {
-    // We're into parsing output, so we don't need the 'calculating file size' etc string.
-    if(showing_string) {
-        progress_bar.setString("");
-        showing_string = false;
-    }
+     * @param queue a queue which at the moment should contain a single GShellEvent
+     */
+    public void process(ArrayList queue) {
+    // Retrieve the first event.
+    GShellEvent event = (GShellEvent) queue.get(0);
     // Remove 'import.pl> ' bit
     String line = event.getMessage();
     line = line.substring(line.indexOf(StaticStrings.GREATER_THAN_CHARACTER) + 1);
     line = line.trim();
-    ///ystem.err.println("message = " + line);
     if(line.startsWith(StaticStrings.LESS_THAN_CHARACTER) && line.endsWith(StaticStrings.GREATER_THAN_CHARACTER)) {
-        line = line.substring(1, line.length() - 1);
+        // No original event is passed on, even in the lower modes
+        event.veto();
+        // Create a new element from it
+        GShellElement element = new GShellElement(line);
+        String name = element.getElementName();
         // We may be reading a file. Remember we have to offset process as we recieve this message 'before' a document is processed. Hence the use of 'next_progress_value'
-        if(line.startsWith(FILE)) {
+        if(name.equals(IMPORT_ELEMENT)) {
+        // We're into parsing output, so we don't need the 'calculating file size' etc string.
+        if(showing_string) {
+            progress_bar.setString("");
+            showing_string = false;
+        }
+        if(Gatherer.config.getMode() <= threshold) {
+            queue.add(new GShellEvent(event.getSource(), 0, event.getType(), Dictionary.get("GShell.Import.ImportBegun1"), event.getStatus()));
+        }
+        }
+        else if(name.equals(FILE_ELEMENT)) {
         file_count++;
-        ///ystem.err.println("File #" + file_count);
         // Set the next progress
-        progress_bar.setValue(next_progress_value);
+        if(next_progress_value > 0) {
+            setValue(next_progress_value);
+        }
         // Now we calculate the next progress value
         next_progress_value = CALCULATION + ((PROCESSED * file_count) / num_expected_docs);
+        event.veto(); // Unconditional veto
         }
         // Or we're being told what plugin is actually processing the file
-        else if(line.startsWith(FILE_PROCESSING)) {
+        else if(name.equals(FILEPROCESSING_ELEMENT)) {
         // If we are at lower mode settings fire a new 'dumbed down' event
-        /** @todo */
+        if(Gatherer.config.getMode() <= threshold) {
+            String args[] = new String[2];
+            args[0] = element.getAttribute(NAME_ATTRIBUTE);
+            args[1] = element.getAttribute(PLUGIN_ATTRIBUTE);
+            if(!args[1].equals("")) {
+            queue.add(new GShellEvent(event.getSource(), 0, event.getType(), Dictionary.get("GShell.Import.FileProcessing", args), event.getStatus()));
+            }
+            else {
+            queue.add(new GShellEvent(event.getSource(), 0, event.getType(), Dictionary.get("GShell.Import.FileNotProcessed", args), event.getStatus()));
+            }
+            args = null;
+        }
         }
         // Or the import complete element
-        else if(line.startsWith(IMPORT_COMPLETE)) {
+        else if(name.equals(IMPORTCOMPLETE_ELEMENT)) {
         // Set the next progress
-        progress_bar.setValue(next_progress_value);
-        // Determine the number of documents processed by using the 'p' attribute
-        StringTokenizer tokenizer = new StringTokenizer(line);
-        boolean found = false;
-        String token = tokenizer.nextToken(); // Drop the element name
-        while(tokenizer.hasMoreTokens() && !found) {
-            token = tokenizer.nextToken();
-            if(token.startsWith(P)) {
-            found = true;
-            try {
-                String num_docs_string = token.substring(3, token.length() - 1);
-                num_docs = Integer.parseInt(num_docs_string);
-            }
-            catch(Exception exception) {
-                Gatherer.println("Exception in GImportProgressMonitor.process() - Expected");
-                Gatherer.printStackTrace(exception);
-            }
-            }
-        }
-        tokenizer = null;
+        setValue(next_progress_value);
         // If we are at lower mode settings fire a new 'dumbed down' event
-        /** @todo */
-        }
-
-
-        // We also veto this event to prevent other classes handling it (we ensure progress monitors are called first).
+        if(Gatherer.config.getMode() <= threshold) {
+            queue.add(new GShellEvent(event.getSource(), 0, event.getType(), Dictionary.get("GShell.Import.ImportComplete1"), event.getStatus()));
+            String args[] = new String[1];
+            args[0] = element.getAttribute(CONSIDERED_ATTRIBUTE);
+            queue.add(new GShellEvent(event.getSource(), 0, event.getType(), Dictionary.get("GShell.Import.ImportComplete2", args), event.getStatus()));
+            // The number of documents processed
+            String processed_str = element.getAttribute(PROCESSED_ATTRIBUTE);
+            if(!processed_str.equals(StaticStrings.ZERO_CHARACTER)) {
+            args = new String[3];
+            args[0] = element.getAttribute(PROCESSED_ATTRIBUTE);
+            if(args[0].equals(StaticStrings.ONE_CHARACTER)) {
+                args[1] = Dictionary.get("GShell.Import.Was");
+                args[2] = Dictionary.get("GShell.Import.Is");
+            }
+            else {
+                args[1] = Dictionary.get("GShell.Import.Were");
+                args[2] = Dictionary.get("GShell.Import.Are");
+            }
+            queue.add(new GShellEvent(event.getSource(), 0, event.getType(), Dictionary.get("GShell.Import.ImportComplete.Processed", args), event.getStatus()));
+            }
+            // Try to set num docs
+            try {
+            num_docs = Integer.parseInt(processed_str);
+            }
+            catch(Exception exception) {
+            num_docs = 0;
+            }
+            processed_str = null;
+            // The number of documents blocked
+            String blocked_str = element.getAttribute(BLOCKED_ATTRIBUTE);
+            if(!blocked_str.equals(StaticStrings.ZERO_CHARACTER)) {
+            args = new String[2];
+            args[0] = element.getAttribute(BLOCKED_ATTRIBUTE);
+            if(args[0].equals(StaticStrings.ONE_CHARACTER)) {
+                args[1] = Dictionary.get("GShell.Import.Was");
+            }
+            else {
+                args[1] = Dictionary.get("GShell.Import.Were");
+            }
+            queue.add(new GShellEvent(event.getSource(), 0, event.getType(), Dictionary.get("GShell.Import.ImportComplete.Blocked", args), event.getStatus()));
+            }
+            blocked_str = null;
+            // The number of documents ignored
+            String ignored_str = element.getAttribute(IGNORED_ATTRIBUTE);
+            if(!ignored_str.equals(StaticStrings.ZERO_CHARACTER)) {
+            args = new String[3];
+            args[0] = element.getAttribute(IGNORED_ATTRIBUTE);
+            if(args[0].equals(StaticStrings.ONE_CHARACTER)) {
+                args[1] = Dictionary.get("GShell.Import.Was");
+                args[2] = Dictionary.get("GShell.Import.Is");
+            }
+            else {
+                args[1] = Dictionary.get("GShell.Import.Were");
+                args[2] = Dictionary.get("GShell.Import.Are");
+            }
+            queue.add(new GShellEvent(event.getSource(), 0, event.getType(), Dictionary.get("GShell.Import.ImportComplete.Ignored", args), event.getStatus()));
+            }
+            ignored_str = null;
+            args = null;
+            // Message is finally ready
+            queue.add(new GShellEvent(event.getSource(), 0, event.getType(), Dictionary.get("GShell.Import.ImportComplete3"), event.getStatus()));
+        }
+        }
+        else {
+        // Veto it
+        event.veto();
+        }
+    }
+    else if(Gatherer.config.getMode() <= threshold) {
         event.veto();
     }
+    }
+
+    public void reset() {
+    setValue(MIN);
+    progress_bar.setString(StaticStrings.SPACE_CHARACTER);
+    progress_bar.updateUI();
     }
 
@@ -226 +310 @@
      */
     public void start() {
+    setValue(MIN);
     progress_bar.setString(Dictionary.get("FileActions.Calculating_Size"));
     showing_string = true;
@@ -238 +323 @@
      */
     public void stop() {
-    progress_bar.setValue(CALCULATION + PROCESSED + EXTRACTED);
+    setValue(CALCULATION + PROCESSED + EXTRACTED);
+    }
+
+    int previous_value = -1;
+    private void setValue(int value) {
+    progress_bar.setValue(value);
+    if(value != 0 && value < previous_value) {
+        Gatherer.println("Progress is decreasing! " + previous_value + " -> " + value);
+    }
+    previous_value = value;
     }
 }
+