Fix Bug 761 (part 1/2): Move GLDrawableFactory.shutdownHook -> NativeWindowFactory.shutdownHook, the latter handles customShutdownHooks for NativeWindow, JOGL and NEWT.

Unifying our shutdown mechanism is required to provide a controlled shutdown sequence.
NativeWindowFactory is chosen to be the new central entry point, since it is the lowest denominator (common module).

- Move GLDrawableFactory.shutdownHook -> NativeWindowFactory.shutdownHook
  Reverse the shutdown dependency for clarity and availability to all modules,
  i.e. NEWT may not know about JOGL.

  Remove the 'gamma' shutdown hook,
  instead simply call GLDrawableFactoryImpl.resetDisplayGamma() before destroy.

NativeWindowFactory.shutdownHook handles customShutdownHooks for NativeWindow, JOGL and NEWT
  - Modules can register their shutdown runnable at head or tail of list.
  - Allows controlled shutdown across all modules.

1 files changed, 75 insertions, 23 deletions

diff --git a/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java b/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java
index b6a052253..bf37b8d0c 100644
--- a/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java
+++ b/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java
@@ -37,8 +37,10 @@ import java.io.File;
 import java.lang.reflect.Method;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import jogamp.nativewindow.Debug;
@@ -108,7 +110,9 @@ public abstract class NativeWindowFactory {
     private static boolean requiresToolkitLock;
     private static boolean desktopHasThreadingIssues;
 
+    // Shutdown hook mechanism for the factory
     private static volatile boolean isJVMShuttingDown = false;
+    private static final List<Runnable> customShutdownHooks = new ArrayList<Runnable>();
     
     /** Creates a new NativeWindowFactory instance. End users do not
         need to call this method. */
@@ -160,6 +164,11 @@ public abstract class NativeWindowFactory {
                 Platform.initSingleton(); // last resort ..
                 _DEBUG[0] = Debug.debug("NativeWindow");
                 _tmp[0] = Debug.getProperty("nativewindow.ws.name", true);
+                Runtime.getRuntime().addShutdownHook(
+                    new Thread(new Runnable() {
+                                public void run() {
+                                    NativeWindowFactory.shutdown(true);
+                                } }, "NativeWindowFactory_ShutdownHook" ) ) ;                        
                 return null;
             } } ) ;
         
@@ -204,6 +213,72 @@ public abstract class NativeWindowFactory {
         }
     }
 
+    /** Returns true if the JVM is shutting down, otherwise false. */ 
+    public static final boolean isJVMShuttingDown() { return isJVMShuttingDown; }
+    
+    /** 
+     * Add a custom shutdown hook to be performed at JVM shutdown before shutting down NativeWindowFactory instance.
+     *  
+     * @param head if true add runnable at the start, otherwise at the end
+     * @param runnable runnable to be added.
+     */
+    public static void addCustomShutdownHook(boolean head, Runnable runnable) {
+        synchronized( customShutdownHooks ) {
+            if( !customShutdownHooks.contains( runnable ) ) {
+                if( head ) {
+                    customShutdownHooks.add(0, runnable);
+                } else {
+                    customShutdownHooks.add( runnable );
+                }
+            }
+        }
+    }
+
+    /** 
+     * Cleanup resources at JVM shutdown
+     */
+    public static synchronized void shutdown(boolean _isJVMShuttingDown) {
+        isJVMShuttingDown = _isJVMShuttingDown;
+        if(DEBUG) {
+            System.err.println("NativeWindowFactory.shutdown() START: JVM Shutdown "+isJVMShuttingDown+", on thread "+Thread.currentThread().getName());
+        }
+        synchronized(customShutdownHooks) {
+            final int cshCount = customShutdownHooks.size();
+            for(int i=0; i < cshCount; i++) {
+                try {
+                    if( DEBUG ) { 
+                        System.err.println("NativeWindowFactory.shutdown - customShutdownHook #"+(i+1)+"/"+cshCount);
+                    }
+                    customShutdownHooks.get(i).run();
+                } catch(Throwable t) {
+                    System.err.println("NativeWindowFactory.shutdown: Catched "+t.getClass().getName()+" during customShutdownHook #"+(i+1)+"/"+cshCount);
+                    if( DEBUG ) { 
+                        t.printStackTrace(); 
+                    }
+                }
+            }
+            customShutdownHooks.clear();
+        }
+        if(DEBUG) {
+            System.err.println("NativeWindowFactory.shutdown(): Post customShutdownHook");
+        }
+        
+        if(initialized) {
+            initialized = false;
+            if(null != registeredFactories) {
+                registeredFactories.clear();
+                registeredFactories = null;
+            }
+            GraphicsConfigurationFactory.shutdown();
+        }
+        
+        shutdownNativeImpl(NativeWindowFactory.class.getClassLoader()); // always re-shutdown
+        // SharedResourceToolkitLock.shutdown(DEBUG); // not used yet
+        if(DEBUG) {
+            System.err.println(Thread.currentThread().getName()+" - NativeWindowFactory.shutdown() END JVM Shutdown "+isJVMShuttingDown);
+        }
+    }
+    
     private static void shutdownNativeImpl(final ClassLoader cl) {
         final String clazzName;
         if( TYPE_X11 == nativeWindowingTypePure ) {
@@ -310,29 +385,6 @@ public abstract class NativeWindowFactory {
         }
     }
 
-    public static synchronized void shutdown(boolean _isJVMShuttingDown) {
-        isJVMShuttingDown = _isJVMShuttingDown;
-        if(DEBUG) {
-            System.err.println(Thread.currentThread().getName()+" - NativeWindowFactory.shutdown() START: JVM Shutdown "+isJVMShuttingDown);                
-        }
-        if(initialized) {
-            initialized = false;
-            if(null != registeredFactories) {
-                registeredFactories.clear();
-                registeredFactories = null;
-            }
-            GraphicsConfigurationFactory.shutdown();
-        }
-        shutdownNativeImpl(NativeWindowFactory.class.getClassLoader()); // always re-shutdown
-        // SharedResourceToolkitLock.shutdown(DEBUG); // not used yet
-        if(DEBUG) {
-            System.err.println(Thread.currentThread().getName()+" - NativeWindowFactory.shutdown() END JVM Shutdown "+isJVMShuttingDown);
-        }
-    }
-    
-    /** Returns true if the JVM is shutting down, otherwise false. */ 
-    public static final boolean isJVMShuttingDown() { return isJVMShuttingDown; }
-    
     /** @return true if the underlying toolkit requires locking, otherwise false. */
     public static boolean requiresToolkitLock() {
         return requiresToolkitLock;