- Fix GLProcAddressResolver regression: Use GLProcAddressResolver !

- X11GLXDrawableFactory:
    - Move shared resource creation/destruction into it's own thread
    - Remove the ATI hack (no XDisplay closing) for every Display,
      this is only necessary for the shared XDisplay and in case of AWT.

- Newt
    - Display: Only pumpMessages if device is ready.
    - X11Display: Verify handle not null at DispatchMessage.

- Common recursive ToolkitLock implementation, from
    src/nativewindow/classes/com/jogamp/nativewindow/impl/LockingNativeWindowFactory.java and
    src/newt/classes/com/jogamp/newt/Window.java,
    -> com.jogamp.nativewindow.impl.RecursiveToolkitLock

- Unique XLockDisplay/XUnlockDisplay call via X11Util to simplify debugging.
  X11Util: Added debug code for XLockDisplay/XUnlockDisplay.
           Added fast LongObjectHashMap
           Added static lib loading and initialization.
           Removed active and passive list, as well as unused methods,
           to easy maintenance. Possible since the only 'uncloseable' Display
           might be the shareable one.
- X11Lib: Added static initialization via X11Util

Test:
    junit/com/jogamp/test/junit/jogl/demos/gl2/gears/TestGears*
        - Add WindowListener for quit ..

7 files changed, 35 insertions, 152 deletions

diff --git a/src/newt/classes/com/jogamp/newt/Display.java b/src/newt/classes/com/jogamp/newt/Display.java
index df4d5b4f8..951b8b172 100755
--- a/src/newt/classes/com/jogamp/newt/Display.java
+++ b/src/newt/classes/com/jogamp/newt/Display.java
@@ -148,7 +148,9 @@ public abstract class Display {
                                                   "Display_"+display.getName()+"-"+current.getName(),
                                                   new Runnable() {
                                                     public void run() {
-                                                        f_dpy.pumpMessagesImpl();
+                                                        if(null!=f_dpy.getGraphicsDevice()) {
+                                                            f_dpy.pumpMessagesImpl();
+                                                        }
                                                     } } );
                     display.edt = display.edtUtil.start();
                     display.edtUtil.invokeAndWait(new Runnable() {
diff --git a/src/newt/classes/com/jogamp/newt/Window.java b/src/newt/classes/com/jogamp/newt/Window.java
index db1b694b9..1802cab8e 100755
--- a/src/newt/classes/com/jogamp/newt/Window.java
+++ b/src/newt/classes/com/jogamp/newt/Window.java
@@ -39,6 +39,7 @@ import com.jogamp.newt.util.EDTUtil;
 
 import com.jogamp.common.util.*;
 import javax.media.nativewindow.*;
+import com.jogamp.nativewindow.impl.RecursiveToolkitLock;
 
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -283,7 +284,6 @@ public abstract class Window implements NativeWindow
     /** Recursive and unblocking unlockSurface() implementation */
     public synchronized void unlockSurface() throws NativeWindowException {
         surfaceLock.unlock( new Runnable() {
-                                final Screen f_screen = screen;
                                 public void run() {
                                     screen.getDisplay().unlockDisplay();
                                 }
@@ -956,78 +956,7 @@ public abstract class Window implements NativeWindow
         return sb.toString();
     }
 
-    //
-    // Reentrance locking toolkit
-    // 
-    public static class WindowToolkitLock implements ToolkitLock {
-            private Thread owner;
-            private int recursionCount;
-            private Exception lockedStack = null;
-
-            public Exception getLockedStack() {
-                return lockedStack;
-            }
-
-            public Thread getOwner() {
-                return owner;
-            }
-
-            public boolean isOwner() {
-                return isOwner(Thread.currentThread());
-            }
-
-            public synchronized boolean isOwner(Thread thread) {
-                return owner == thread ;
-            }
-
-            public synchronized boolean isLocked() {
-                return null != owner;
-            }
-
-            /** Recursive and blocking lockSurface() implementation */
-            public synchronized void lock() {
-                Thread cur = Thread.currentThread();
-                if (owner == cur) {
-                    ++recursionCount;
-                    return;
-                }
-                while (owner != null) {
-                    try {
-                        wait();
-                    } catch (InterruptedException e) {
-                        throw new RuntimeException(e);
-                    }
-                }
-                owner = cur;
-                lockedStack = new Exception("Previously locked by "+owner);
-            }
-            
-
-            /** Recursive and unblocking unlockSurface() implementation */
-            public synchronized void unlock() {
-                unlock(null);
-            }
-
-            /** Recursive and unblocking unlockSurface() implementation */
-            public synchronized void unlock(Runnable releaseAfterUnlockBeforeNotify) {
-                Thread cur = Thread.currentThread();
-                if (owner != cur) {
-                    lockedStack.printStackTrace();
-                    throw new RuntimeException(cur+": Not owner, owner is "+owner);
-                }
-                if (recursionCount > 0) {
-                    --recursionCount;
-                    return;
-                }
-                owner = null;
-                lockedStack = null;
-                if(null!=releaseAfterUnlockBeforeNotify) {
-                    releaseAfterUnlockBeforeNotify.run();
-                }
-                notifyAll();
-            }
-    }
-    private WindowToolkitLock destructionLock = new WindowToolkitLock();
-    private WindowToolkitLock surfaceLock = new WindowToolkitLock();
+    private RecursiveToolkitLock destructionLock = new RecursiveToolkitLock();
+    private RecursiveToolkitLock surfaceLock = new RecursiveToolkitLock();
 }
 
diff --git a/src/newt/classes/com/jogamp/newt/impl/macosx/MacWindow.java b/src/newt/classes/com/jogamp/newt/impl/macosx/MacWindow.java
index 8fb095661..963c0c0a7 100755
--- a/src/newt/classes/com/jogamp/newt/impl/macosx/MacWindow.java
+++ b/src/newt/classes/com/jogamp/newt/impl/macosx/MacWindow.java
@@ -34,6 +34,7 @@
 package com.jogamp.newt.impl.macosx;
 
 import javax.media.nativewindow.*;
+import com.jogamp.nativewindow.impl.RecursiveToolkitLock;
 
 import com.jogamp.newt.util.MainThread;
 import com.jogamp.newt.*;
@@ -213,7 +214,7 @@ public class MacWindow extends Window {
         }
     }
 
-    private WindowToolkitLock nsViewLock = new WindowToolkitLock();
+    private RecursiveToolkitLock nsViewLock = new RecursiveToolkitLock();
 
     public synchronized int lockSurface() throws NativeWindowException {
         nsViewLock.lock();
diff --git a/src/newt/classes/com/jogamp/newt/impl/x11/X11Display.java b/src/newt/classes/com/jogamp/newt/impl/x11/X11Display.java
index 94d568f55..c2de0fe18 100755
--- a/src/newt/classes/com/jogamp/newt/impl/x11/X11Display.java
+++ b/src/newt/classes/com/jogamp/newt/impl/x11/X11Display.java
@@ -79,16 +79,19 @@ public class X11Display extends Display {
     }
 
     protected void dispatchMessagesNative() {
+        if(0==getHandle()) {
+            throw new RuntimeException("display handle null");
+        }
         DispatchMessages(getHandle(), javaObjectAtom, windowDeleteAtom);
     }
 
     protected void lockDisplay() {
         super.lockDisplay();
-        LockDisplay(getHandle());
+        X11Util.XLockDisplay(getHandle());
     }
 
     protected void unlockDisplay() {
-        UnlockDisplay(getHandle());
+        X11Util.XUnlockDisplay(getHandle());
         super.unlockDisplay();
     }
 
@@ -100,9 +103,6 @@ public class X11Display extends Display {
     //
     private static native boolean initIDs();
 
-    private native void LockDisplay(long handle);
-    private native void UnlockDisplay(long handle);
-
     private native void CompleteDisplay(long handle);
 
     private native void DispatchMessages(long display, long javaObjectAtom, long windowDeleteAtom);
diff --git a/src/newt/classes/com/jogamp/newt/util/EDTUtil.java b/src/newt/classes/com/jogamp/newt/util/EDTUtil.java
index f852bcf5c..2550eef82 100644
--- a/src/newt/classes/com/jogamp/newt/util/EDTUtil.java
+++ b/src/newt/classes/com/jogamp/newt/util/EDTUtil.java
@@ -62,27 +62,17 @@ public class EDTUtil {
 
     public ThreadGroup getThreadGroup() { return threadGroup; }
 
-    public Thread start() {
-        return start(false);
-    }
-
     /**
-     * @param externalStimuli true indicates that another thread stimulates, 
-     *                        ie. calls this TaskManager's run() loop method.
-     *                        Hence no own thread is started in this case.
-     *
      * @return The started Runnable, which handles the run-loop.
-     *         Usefull in combination with externalStimuli=true,
-     *         so an external stimuli can call it.
      */
-    public Thread start(boolean externalStimuli) {
+    public Thread start() {
         synchronized(edtLock) { 
             if(null==edt) {
                 edt = new EventDispatchThread(threadGroup, name);
             }
             if(!edt.isRunning()) {
                 shouldStop = false;
-                edt.start(externalStimuli);
+                edt.start();
             }
             edtLock.notifyAll();
         }
@@ -166,7 +156,6 @@ public class EDTUtil {
 
     class EventDispatchThread extends Thread {
         boolean isRunning = false;
-        boolean externalStimuli = false;
 
         public EventDispatchThread(ThreadGroup tg, String name) {
             super(tg, name);
@@ -176,14 +165,11 @@ public class EDTUtil {
             return isRunning;
         }
 
-        public void start(boolean externalStimuli) throws IllegalThreadStateException {
+        public void start() throws IllegalThreadStateException {
             synchronized(this) {
-                this.externalStimuli = externalStimuli;
                 isRunning = true;
             }
-            if(!externalStimuli) {
-                super.start();
-            }
+            super.start();
         }
 
         /** 
@@ -194,8 +180,8 @@ public class EDTUtil {
             if(DEBUG) {
                 System.out.println(Thread.currentThread()+": EDT run() START");
             }
-            while(!shouldStop) {
-                try {
+            try {
+                while(!shouldStop) {
                     // wait for something todo
                     while(!shouldStop && tasks.size()==0) {
                         synchronized(edtLock) {
@@ -219,24 +205,23 @@ public class EDTUtil {
                         }
                         pumpMessages.run(); // event dispatch
                     }
-                } catch (Throwable t) {
-                    // handle errors ..
-                    t.printStackTrace();
-                } finally {
-                    // epilog - unlock locked stuff
                 }
-                if(externalStimuli) break; // no loop if called by external stimuli
-            }
-            synchronized(this) {
-                isRunning = !shouldStop;
-            }
-            if(!isRunning) {
-                synchronized(edtLock) {
-                    edtLock.notifyAll();
+            } catch (Throwable t) {
+                // handle errors ..
+                shouldStop = true;
+                throw new RuntimeException(t);
+            } finally {
+                synchronized(this) {
+                    isRunning = !shouldStop;
+                }
+                if(!isRunning) {
+                    synchronized(edtLock) {
+                        edtLock.notifyAll();
+                    }
+                }
+                if(DEBUG) {
+                    System.out.println(Thread.currentThread()+": EDT run() EXIT");
                 }
-            }
-            if(DEBUG) {
-                System.out.println(Thread.currentThread()+": EDT run() EXIT");
             }
         }
     }
diff --git a/src/newt/native/MacWindow.m b/src/newt/native/MacWindow.m
index a4a5da7fc..21bc9b2ad 100644
--- a/src/newt/native/MacWindow.m
+++ b/src/newt/native/MacWindow.m
@@ -160,7 +160,7 @@ JNIEXPORT jboolean JNICALL Java_com_jogamp_newt_impl_macosx_MacDisplay_initNSApp
  * Signature: ()V
  */
 JNIEXPORT void JNICALL Java_com_jogamp_newt_impl_macosx_MacDisplay_dispatchMessages0
-  (JNIEnv *env, jobject unused, jlong window, jint eventMask)
+  (JNIEnv *env, jobject unused)
 {
     NSEvent* event = NULL;
     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
diff --git a/src/newt/native/X11Window.c b/src/newt/native/X11Window.c
index 8d5920f65..70fc421e8 100755
--- a/src/newt/native/X11Window.c
+++ b/src/newt/native/X11Window.c
@@ -280,40 +280,6 @@ JNIEXPORT jboolean JNICALL Java_com_jogamp_newt_impl_x11_X11Display_initIDs
 
 /*
  * Class:     com_jogamp_newt_impl_x11_X11Display
- * Method:    LockDisplay
- * Signature: (J)V
- */
-JNIEXPORT void JNICALL Java_com_jogamp_newt_impl_x11_X11Display_LockDisplay
-  (JNIEnv *env, jobject obj, jlong display)
-{
-    Display * dpy = (Display *)(intptr_t)display;
-    if(dpy==NULL) {
-        _FatalError(env, "invalid display connection..");
-    }
-    XLockDisplay(dpy) ;
-    // DBG_PRINT1( "X11: LockDisplay 0x%X\n", dpy); 
-}
-
-
-/*
- * Class:     com_jogamp_newt_impl_x11_X11Display
- * Method:    UnlockDisplay
- * Signature: (J)V
- */
-JNIEXPORT void JNICALL Java_com_jogamp_newt_impl_x11_X11Display_UnlockDisplay
-  (JNIEnv *env, jobject obj, jlong display)
-{
-    Display * dpy = (Display *)(intptr_t)display;
-    if(dpy==NULL) {
-        _FatalError(env, "invalid display connection..");
-    }
-    XUnlockDisplay(dpy) ;
-    // DBG_PRINT1( "X11: UnlockDisplay 0x%X\n", dpy); 
-}
-
-
-/*
- * Class:     com_jogamp_newt_impl_x11_X11Display
  * Method:    CompleteDisplay
  * Signature: (J)V
  */