Changeset 39032

Timestamp:

2024-05-17T23:04:48+12:00 (3 weeks ago)

Author:

anupama

Message:

Rewritten with clearer branch cases: either we're turning off EDT changes (globally with single flag, or locally with byapss param), or we're running with EDT changes and we're either already on the Event Dispatch Thread or need to switch into it. Once more tested it out with the complex createCollection case to ensure that GLI runs fine and testing runs (albeit with progress bar not updating).

File:

• main/trunk/gli/src/org/greenstone/gatherer/Gatherer.java (modified) (3 diffs)

main/trunk/gli/src/org/greenstone/gatherer/Gatherer.java

@@ -275 +275 @@
     }
 
-    // print calling thread's name
+    // print calling thread's name and the thread we run on if we're bypassing EDT changes
+    // or would have bypassed if we *weren't* testing
     if(bypassIfNotTesting) {
         System.err.println("Calling thread name: " + Thread.currentThread().getName()
@@ -285 +286 @@
         }
     }
-    
+
+    // If we're turning off EDT changes globally or on a case by case basis,
+    // we're not running the Runnable code on the EDT any more, but whatever
+    // thread GLI *would* have run the code on if we hadn't made the EDT changes
     if(TURN_OFF_EVENTDISPATCH_CHANGES
-       || (bypassIfNotTesting && !TestingPreparation.TEST_MODE)
-       || EventQueue.isDispatchThread()) {    
-        
+       || (bypassIfNotTesting && !TestingPreparation.TEST_MODE)) {
+                
         if (bypassIfNotTesting && !TestingPreparation.TEST_MODE) {
         System.err.println("@@@@" + callerDescription + " - Bypassing EDT change");
@@ -299 +302 @@
         }
         
-        if(TURN_OFF_EVENTDISPATCH_CHANGES
-           || (bypassIfNotTesting && !TestingPreparation.TEST_MODE)) {
-        
-        // run it as before the EDT changes to GLI:
-        if(runVariant == RUN_IN_THREAD_PARAM_WITH_START) {
-            // start off the param thread to run the runnable in thread of param
-            // instead of whatever the current thread of the calling function is
-            Thread runInThread = (Thread)runnable;
-            runInThread.start(); // async by nature 
-        } else if(runVariant == PROCEED_IN_CURRENT_THREAD) {
-            // run the Runnable code (whether Thread object or not) in
-            // whatever the current thread of the calling function is
-            runnable.run(); // synchronous by nature of runable code running on current thread
-        }
-        } else { // If we want the EDT changes to GLI active and we're in the Dispatch Thread
+        // Run it as before the EDT changes to GLI: one of 2 ways as specified
+        if(runVariant == RUN_IN_THREAD_PARAM_WITH_START) {
+        // start off the param thread to run the runnable in thread of param
+        // instead of whatever the current thread of the calling function is
+        Thread runInThread = (Thread)runnable;
+        // TODO: warning when runnable is not the event dispatch thread
+        runInThread.start(); // async by nature     
+        } else if(runVariant == PROCEED_IN_CURRENT_THREAD) {
+        // run the Runnable code (whether Thread object or not) in
+        // whatever the current thread of the calling function is
+        runnable.run(); // synchronous by nature of runable code running on current thread
+        }       
+        
+    } else { // We want the EDT changes to GLI to be active, meaning we *want* to run
+        // the Runnable code in the Event Dispatch Thread, not in any other Threads
+
+        if (EventQueue.isDispatchThread()) {
+        // We're already in the Dispatch Thread.
         // So just run the Runnable code in the Dispatch thread, regardless of how GLI
         // used run it. Specifically, don't call start() on any Thread param to run
         // the code in the non-EDT thread param
-        runnable.run();     
-        }
-        
-    } else { // whether the Runnable is a new Thread or other Runnable object
-        // whether GLI before EDT changes launched it with start() in its own Thread
-        // or it was code run in whatever the current thread was, we run it on the
-        // Dispatch Thread (Event Dispatch Thread, EDT)
-        if(invokeAs == ASYNC) {
-        SwingUtilities.invokeLater(runnable); // asynchronous
-        } else {
-        try {
-            System.err.println("\tXXXXX SYNC.");
-            SwingUtilities.invokeAndWait(runnable); // synchronous
-        } catch(Exception e) {
-            String message = "@@@ Exception during ";
-            if(callerDescription != null && !callerDescription.equals("")) {
-            message += callerDescription + " - ";
+        runnable.run();
+            
+        } else { // whether the Runnable is a new Thread or other Runnable object
+        // whether GLI before EDT changes launched it with start() in its own Thread
+        // or it was code run in whatever the current thread was, we run it on the
+        // Dispatch Thread (Event Dispatch Thread, EDT)
+        if(invokeAs == ASYNC) {
+            SwingUtilities.invokeLater(runnable); // asynchronous
+        } else {
+            try {
+            SwingUtilities.invokeAndWait(runnable); // synchronous
+            } catch(Exception e) {
+            String message = "@@@ Exception during ";
+            if(callerDescription != null && !callerDescription.equals("")) {
+                message += callerDescription + " - ";
+            }
+            message += "invokeAndWait on EDT: ";
+            System.err.println(message + e.getMessage());
             }
-            message += "invokeAndWait on EDT: ";
-            System.err.println(message + e.getMessage());
         }
         }