GLAutoDrawable: setAnimator/getAnimator/invoke/display changes; NEWT: Adding native repaint; NewtCanvasAWT focus fix

Support for native repaint, which shall call display() in case no animator is running.
GLAutoDrawable invoke(GLRunnable) impl. handles case if invoked on animator thread,
or no animator thread is running (issueing a display() call).
The impl resides in GLDrawableHelper.

GLEventListener's init() and glViewport()/reshape() method must be called before the 1st display()
and after a dispose() call. It could miss the 1st display() call if added
after the setVisible(true) call - due to the native repainting.
The impl resides in GLDrawableHelper.

The Animator un-/registers itself at the GLAutoDrawable via setAnimator.

NEWT Window reparent always issues a resize() and display() call.

NEWT native Window uses direct send.*Event for input events (again),
instead of enqueueing it for performance.

NEWT Window implements all status change and Java native event callbacks,
instead of having duplicated code in all implementations.

NewtCanvasAWT if the Newt window is focused, the AWT/Swing component[s] will loose the focus.

3 files changed, 95 insertions, 37 deletions

diff --git a/src/jogl/classes/javax/media/opengl/GLAutoDrawable.java b/src/jogl/classes/javax/media/opengl/GLAutoDrawable.java
index 7236aa533..1b5c56c95 100644
--- a/src/jogl/classes/javax/media/opengl/GLAutoDrawable.java
+++ b/src/jogl/classes/javax/media/opengl/GLAutoDrawable.java
@@ -161,14 +161,49 @@ public interface GLAutoDrawable extends GLDrawable {
       during this update cycle. */
   public void removeGLEventListener(GLEventListener listener);
 
+  /**
+   * <p>
+   * Indicates whether a running animator thread is periodically issuing {@link #display()} calls or not.</p><br>
+   * <p>
+   * This method shall be called by an animator implementation only,<br>
+   * e.g. {@link com.jogamp.opengl.util.Animator#start()}, passing the animator thread,<br>
+   * and {@link com.jogamp.opengl.util.Animator#start()}, passing <code>null</code>.</p><br>
+   * <p>
+   * Impacts {@link #display()} and {@link #invoke(boolean, GLRunnable)} semantics.</p><br>
+   *
+   * @param animator <code>null</code> reference indicates no running animator thread 
+   *                 issues {@link #display()} calls on this <code>GLAutoDrawable</code>,<br>
+   *                 a valid reference indicates a running animator thread 
+   *                 periodically issuing {@link #display()} calls.
+   *
+   * @throws GLException if a running animator thread is already registered and you try to register a different one without unregistering the previous one.
+   * @see #display()
+   * @see #invoke(boolean, GLRunnable)
+   */ 
+  public void setAnimator(Thread animator) throws GLException;
+
+  /**
+   * @return the value of the registered animator thread
+   *
+   * @see #setAnimator(Thread)
+   */
+  public Thread getAnimator();
+
   /** 
-   * Enqueues the one-shot {@link javax.media.opengl.GLRunnable} into the queue,
-   * which will be executed at the next {@link #display()} call.
    * <p>
-   * Warning: We cannot verify if the caller runs in the same thread 
-   * as the display caller, hence we cannot avoid a deadlock
-   * in such case. You have to know what you are doing, 
-   * ie call this only in a I/O event listener, or such.<br></p>
+   * Enqueues a one-shot {@link javax.media.opengl.GLRunnable},
+   * which will be executed with the next {@link #display()} call.</p><br>
+   * <p>
+   * If {@link #setAnimator(Thread)} has not registered no running animator thread, the default,<br>
+   * or if the current thread is the animator thread,<br>
+   * a {@link #display()} call has to be issued after enqueueing the <code>GLRunnable</code>.<br>
+   * No extra synchronization must be performed in case <code>wait</code> is true, since it is executed in the current thread.</p><br>
+   * <p>
+   * If {@link #setAnimator(Thread)} has registered a valid animator thread,<br>
+   * no call of {@link #display()} must be issued, since the animator thread performs it.<br>
+   * If <code>wait</code> is true, the implementation must wait until the <code>GLRunnable</code> is excecuted.</p><br>
+   *
+   * @see #setAnimator(Thread)
    * @see #display()
    * @see javax.media.opengl.GLRunnable
    */   
@@ -190,28 +225,37 @@ public interface GLAutoDrawable extends GLDrawable {
       routine may be called manually. */
   public void destroy();
 
-  /** <p>Causes OpenGL rendering to be performed for this GLAutoDrawable
-      in the following order:
-      <ul>
-        <li> Calling {@link GLEventListener#display display(..)} for all
-             registered {@link GLEventListener}s. </li>
-        <li> Execute and dismiss all one-shot {@link javax.media.opengl.GLRunnable},
-             enqueued via {@link #invoke(boolean, GLRunnable)}.</li>
-      </ul></p>
-      <p> 
-      Called automatically by the
-      window system toolkit upon receiving a repaint() request.</p> 
-      <p> 
-      This routine may be called manually for better control over the
-      rendering process. It is legal to call another GLAutoDrawable's
-      display method from within the {@link GLEventListener#display
-      display(..)} callback.</p>
-      <p>
-      In case of a new generated OpenGL context, 
-      the implementation shall call {@link GLEventListener#init init(..)} for all
-      registered {@link GLEventListener}s <i>before</i> making the 
-      actual {@link GLEventListener#display display(..)} calls,
-      in case this has not been done yet.</p> */
+  /** 
+   * <p>
+   * Causes OpenGL rendering to be performed for this GLAutoDrawable
+   * in the following order:
+   * <ul>
+   *     <li> Calling {@link GLEventListener#display display(..)} for all
+   *          registered {@link GLEventListener}s. </li>
+   *     <li> Executes all one-shot {@link javax.media.opengl.GLRunnable},
+   *          enqueued via {@link #invoke(boolean, GLRunnable)}.</li>
+   * </ul></p>
+   * <p> 
+   * Called automatically by the
+   * window system toolkit upon receiving a repaint() request, 
+   * except a running animator thread is registered with {@link #setAnimator(Thread)}.</p> <br>
+   * <p> 
+   * Maybe called periodically by a running animator thread,<br>
+   * which must register itself with {@link #setAnimator(Thread)}.</p> <br>
+   * <p> 
+   * This routine may be called manually for better control over the
+   * rendering process. It is legal to call another GLAutoDrawable's
+   * display method from within the {@link GLEventListener#display
+   * display(..)} callback.</p>
+   * <p>
+   * In case of a new generated OpenGL context, 
+   * the implementation shall call {@link GLEventListener#init init(..)} for all
+   * registered {@link GLEventListener}s <i>before</i> making the 
+   * actual {@link GLEventListener#display display(..)} calls,
+   * in case this has not been done yet.</p>
+   *
+   * @see #setAnimator(Thread)
+   */
   public void display();
 
   /** Enables or disables automatic buffer swapping for this drawable.
diff --git a/src/jogl/classes/javax/media/opengl/awt/GLCanvas.java b/src/jogl/classes/javax/media/opengl/awt/GLCanvas.java
index 2dafd691a..f150b2507 100644
--- a/src/jogl/classes/javax/media/opengl/awt/GLCanvas.java
+++ b/src/jogl/classes/javax/media/opengl/awt/GLCanvas.java
@@ -378,7 +378,9 @@ public class GLCanvas extends Canvas implements AWTGLAutoDrawable {
       return;
     }
 
-    display();
+    if( null == getAnimator() ) {
+        display();
+    }
   }
 
   /** Overridden to track when this component is added to a container.
@@ -492,8 +494,16 @@ public class GLCanvas extends Canvas implements AWTGLAutoDrawable {
     drawableHelper.removeGLEventListener(listener);
   }
 
+  public void setAnimator(Thread animator) {
+    drawableHelper.setAnimator(animator);
+  }
+
+  public Thread getAnimator() {
+    return drawableHelper.getAnimator();
+  }
+
   public void invoke(boolean wait, GLRunnable glRunnable) {
-    drawableHelper.invoke(wait, glRunnable);
+    drawableHelper.invoke(this, wait, glRunnable);
   }
 
   public void setContext(GLContext ctx) {
@@ -640,10 +650,7 @@ public class GLCanvas extends Canvas implements AWTGLAutoDrawable {
       if (sendReshape) {
         // Note: we ignore the given x and y within the parent component
         // since we are drawing directly into this heavyweight component.
-        int width = getWidth();
-        int height = getHeight();
-        getGL().glViewport(0, 0, width, height);
-        drawableHelper.reshape(GLCanvas.this, 0, 0, width, height);
+        drawableHelper.reshape(GLCanvas.this, 0, 0, getWidth(), getHeight());
         sendReshape = false;
       }
 
diff --git a/src/jogl/classes/javax/media/opengl/awt/GLJPanel.java b/src/jogl/classes/javax/media/opengl/awt/GLJPanel.java
index 73962e979..d0d97fe31 100644
--- a/src/jogl/classes/javax/media/opengl/awt/GLJPanel.java
+++ b/src/jogl/classes/javax/media/opengl/awt/GLJPanel.java
@@ -380,8 +380,16 @@ public class GLJPanel extends JPanel implements AWTGLAutoDrawable {
     drawableHelper.removeGLEventListener(listener);
   }
 
+  public void setAnimator(Thread animator) {
+    drawableHelper.setAnimator(animator);
+  }
+
+  public Thread getAnimator() {
+    return drawableHelper.getAnimator();
+  }
+
   public void invoke(boolean wait, GLRunnable glRunnable) {
-    drawableHelper.invoke(wait, glRunnable);
+    drawableHelper.invoke(this, wait, glRunnable);
   }
 
   public GLContext createContext(GLContext shareWith) {
@@ -585,9 +593,8 @@ public class GLJPanel extends JPanel implements AWTGLAutoDrawable {
       }
       if (sendReshape) {
         if (DEBUG||VERBOSE) {
-          System.err.println("display: glViewport(" + viewportX + "," + viewportY + " " + panelWidth + "x" + panelHeight + ")");
+          System.err.println("display: reshape(" + viewportX + "," + viewportY + " " + panelWidth + "x" + panelHeight + ")");
         }
-        getGL().getGL2().glViewport(viewportX, viewportY, panelWidth, panelHeight);
         drawableHelper.reshape(GLJPanel.this, viewportX, viewportY, panelWidth, panelHeight);
         sendReshape = false;
       }