Fix Bug 616: X11: Remove XInitThreads() dependency while cleaning up device locking, resulting in a native-lock-free impl.

The X11 implementation details of NativeWindow and NEWT used the X11 implicit locking facility
XLockDisplay/XUnlockDisplay, enabled via XInitThreads().
The latter useage is complicated within an unsure environment where the initialization point of JOGL
is unknown, but XInitThreads() requires to be called once and before any other X11 calls.

The solution is simple and thorough, replace native X11 locking w/ 'application level' locking.
Following this pattern actually cleans up a pretty messy part of X11 NativeWindow and NEWT,
since the generalization of platform independent locking simplifies code.
Simply using our RecursiveLock also speeds up locking, since it doesn't require JNI calls down to X11 anymore.
It allows us to get rid of X11ToolkitLock and X11JAWTToolkitLock.

Using the RecursiveLock also allows us to remove the shortcut of explicitly createing
a NullToolkitLocked device for 'private' display connections.
All devices use proper locking as claimed in their toolkit util 'requiresToolkitLock()' in X11Util, OSXUtil, ..

Further more a bug has been fixed of X11ErrorHandler usage, i.e. we need to keep our handler alive at all times
due to async X11 messaging behavior. This allows to remove the redundant code in X11/NEWT.

The AbstractGraphicsDevice lifecycle has been fixed as well, i.e. called when closing NEWT's Display
for all driver implementations.

On the NEWT side the Display's AbstractGraphicsDevice semantics has been clarified,
i.e. it's usage for EDT and lifecycle operations.
Hence the X11 Display 2nd device for rendering operations has been moved to X11 Window
where it belongs - and the X11 Display's default device used for EDT/lifecycle-ops as it should be.
This allows running X11/NEWT properly with the default usage, where the Display instance
and hence the EDT thread is shared with many Screen and Window.
Rendering using NEWT Window is decoupled from it's shared Display lock
via it's own native X11 display.

Lock free AbstractGraphicsDevice impl. (Windows, OSX, ..) don't require any attention in this regard
since they use NullToolkitLock.

Tests:
======
This implementation has been tested manually with Mesa3d (soft, Intel), ATI and Nvidia
on X11, Windows and OSX w/o any regressions found in any unit test.

Issues on ATI:
==============
Only on ATI w/o a composite renderer the unit tests expose a driver or WM bug where XCB
claims a lack of locking. Setting env. var 'LIBXCB_ALLOW_SLOPPY_LOCK=true' is one workaround
if users refuse to enable compositing. We may investigate this issue in more detail later on.

3 files changed, 26 insertions, 13 deletions

diff --git a/src/newt/classes/com/jogamp/newt/Display.java b/src/newt/classes/com/jogamp/newt/Display.java
index 1e9a0e9eb..391bccf3d 100644
--- a/src/newt/classes/com/jogamp/newt/Display.java
+++ b/src/newt/classes/com/jogamp/newt/Display.java
@@ -113,17 +113,23 @@ public abstract class Display {
      */
     public abstract int removeReference();
 
+    /** 
+     * Return the {@link AbstractGraphicsDevice} used for depending resources lifecycle, 
+     * i.e. {@link Screen} and {@link Window}, as well as the event dispatching (EDT). */ 
     public abstract AbstractGraphicsDevice getGraphicsDevice();
 
     /**
-     * @return the fully qualified Display name,
-     * which is a key of {@link #getType()} + {@link #getName()} + {@link #getId()}
+     * Return the handle of the {@link AbstractGraphicsDevice} as returned by {@link #getGraphicsDevice()}.
      */
-    public abstract String getFQName();
-
     public abstract long getHandle();
 
     /**
+     * @return The fully qualified Display name,
+     * which is a key of {@link #getType()} + {@link #getName()} + {@link #getId()}.
+     */
+    public abstract String getFQName();
+
+    /**
      * @return this display internal serial id
      */
     public abstract int getId();
@@ -141,6 +147,9 @@ public abstract class Display {
      */
     public abstract String getType();
 
+    /** Return true if this instance is exclusive, i.e. will not be shared. */
+    public abstract boolean isExclusive();
+
     /**
      * Sets a new {@link EDTUtil} and returns the previous one.
      * <p>
@@ -183,11 +192,12 @@ public abstract class Display {
      * 
      * @param type
      * @param name
-     * @param fromIndex start index, then increasing until found or end of list     * 
+     * @param fromIndex start index, then increasing until found or end of list
+     * @paran shared if true, only shared instances are found, otherwise also exclusive 
      * @return 
      */
-    public static Display getFirstDisplayOf(String type, String name, int fromIndex) {
-        return getDisplayOfImpl(type, name, fromIndex, 1);
+    public static Display getFirstDisplayOf(String type, String name, int fromIndex, boolean shared) {
+        return getDisplayOfImpl(type, name, fromIndex, 1, shared);
     }
 
     /**
@@ -195,19 +205,22 @@ public abstract class Display {
      * @param type
      * @param name
      * @param fromIndex start index, then decreasing until found or end of list. -1 is interpreted as size - 1.
+     * @paran shared if true, only shared instances are found, otherwise also exclusive 
      * @return
      */
-    public static Display getLastDisplayOf(String type, String name, int fromIndex) {
-        return getDisplayOfImpl(type, name, fromIndex, -1);
+    public static Display getLastDisplayOf(String type, String name, int fromIndex, boolean shared) {
+        return getDisplayOfImpl(type, name, fromIndex, -1, shared);
     }
 
-    private static Display getDisplayOfImpl(String type, String name, int fromIndex, int incr) {
+    private static Display getDisplayOfImpl(String type, String name, int fromIndex, int incr, boolean shared) {
         synchronized(displayList) {
             int i = fromIndex >= 0 ? fromIndex : displayList.size() - 1 ;
             while( ( incr > 0 ) ? i < displayList.size() : i >= 0 ) {
                 Display display = (Display) displayList.get(i);
                 if( display.getType().equals(type) &&
-                    display.getName().equals(name) ) {
+                    display.getName().equals(name) &&
+                    ( !shared || shared && !display.isExclusive() ) 
+                  ) {
                     return display;
                 }
                 i+=incr;
diff --git a/src/newt/classes/com/jogamp/newt/NewtFactory.java b/src/newt/classes/com/jogamp/newt/NewtFactory.java
index abae94ab6..1bf47f4aa 100644
--- a/src/newt/classes/com/jogamp/newt/NewtFactory.java
+++ b/src/newt/classes/com/jogamp/newt/NewtFactory.java
@@ -305,7 +305,7 @@ public class NewtFactory {
      * Instantiate a Display entity using the native handle.
      */
     public static Display createDisplay(String type, long handle, boolean reuse) {
-      return DisplayImpl.create(type, null, handle, false);
+      return DisplayImpl.create(type, null, handle, reuse);
     }
 
     public static boolean isScreenCompatible(NativeWindow parent, Screen childScreen) {
diff --git a/src/newt/classes/com/jogamp/newt/Screen.java b/src/newt/classes/com/jogamp/newt/Screen.java
index 26f19ad6b..cfbcc988a 100644
--- a/src/newt/classes/com/jogamp/newt/Screen.java
+++ b/src/newt/classes/com/jogamp/newt/Screen.java
@@ -145,7 +145,7 @@ public abstract class Screen {
     public abstract Display getDisplay();
 
     /** 
-     * @return the screen fully qualified Screen name,
+     * @return The screen fully qualified Screen name,
      * which is a key of {@link com.jogamp.newt.Display#getFQName()} + {@link #getIndex()}.
      */
     public abstract String getFQName();