Merge branch 'master' into stash_glyphcache

Conflicts:
	make/scripts/tests.sh
	src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java
	src/jogl/classes/com/jogamp/graph/curve/Region.java
	src/jogl/classes/com/jogamp/graph/curve/opengl/GLRegion.java
	src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java
	src/jogl/classes/com/jogamp/graph/curve/opengl/Renderer.java
	src/jogl/classes/com/jogamp/graph/curve/opengl/TextRenderer.java
	src/jogl/classes/com/jogamp/graph/font/Font.java
	src/jogl/classes/com/jogamp/opengl/math/VectorUtil.java
	src/jogl/classes/jogamp/graph/curve/text/GlyphShape.java
	src/jogl/classes/jogamp/graph/curve/text/GlyphString.java
	src/jogl/classes/jogamp/graph/font/typecast/TypecastFont.java
	src/jogl/classes/jogamp/graph/font/typecast/TypecastGlyph.java
	src/jogl/classes/jogamp/graph/font/typecast/TypecastRenderer.java

1 files changed, 255 insertions, 106 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java b/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java
index f7fc58160..5bd803500 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java
@@ -1,22 +1,22 @@
 /*
  * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
  * Copyright (c) 2010 JogAmp Community. All rights reserved.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
- * 
+ *
  * - Redistribution of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
- * 
+ *
  * - Redistribution in binary form must reproduce the above copyright
  *   notice, this list of conditions and the following disclaimer in the
  *   documentation and/or other materials provided with the distribution.
- * 
+ *
  * Neither the name of Sun Microsystems, Inc. or the names of
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
- * 
+ *
  * This software is provided "AS IS," without a warranty of any kind. ALL
  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
  * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
@@ -29,29 +29,42 @@
  * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
  * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
  * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- * 
+ *
  * You acknowledge that this software is not designed or intended for use
  * in the design, construction, operation or maintenance of any nuclear
  * facility.
- * 
+ *
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
 package com.jogamp.opengl.util;
 
-import java.util.*;
-import javax.media.opengl.*;
+import java.util.Timer;
+import java.util.TimerTask;
 
-/** An Animator subclass which attempts to achieve a target
-frames-per-second rate to avoid using all CPU time. The target FPS
-is only an estimate and is not guaranteed. */
+import javax.media.opengl.GLAutoDrawable;
+import javax.media.opengl.GLException;
+
+/**
+ * An Animator subclass which attempts to achieve a target
+ * frames-per-second rate to avoid using all CPU time. The target FPS
+ * is only an estimate and is not guaranteed.
+ * <p>
+ * The Animator execution thread does not run as a daemon thread,
+ * so it is able to keep an application from terminating.<br>
+ * Call {@link #stop() } to terminate the animation and it's execution thread.
+ * </p>
+ */
 public class FPSAnimator extends AnimatorBase {
     private Timer timer = null;
-    private TimerTask task = null;
+    private MainTask task = null;
     private int fps;
-    private boolean scheduleAtFixedRate;
-    private volatile boolean shouldRun;
+    private final boolean scheduleAtFixedRate;
+    private boolean isAnimating;         // MainTask feedback
+    private volatile boolean shouldRun;  // MainTask trigger
+    private volatile boolean shouldStop; // MainTask trigger
 
+    @Override
     protected String getBaseName(String prefix) {
         return "FPS" + prefix + "Animator" ;
     }
@@ -81,6 +94,7 @@ public class FPSAnimator extends AnimatorBase {
     value, an initial drawable to animate, and a flag indicating
     whether to use fixed-rate scheduling. */
     public FPSAnimator(GLAutoDrawable drawable, int fps, boolean scheduleAtFixedRate) {
+        super();
         this.fps = fps;
         if (drawable != null) {
             add(drawable);
@@ -88,131 +102,266 @@ public class FPSAnimator extends AnimatorBase {
         this.scheduleAtFixedRate = scheduleAtFixedRate;
     }
 
-    public final boolean isStarted() {
-        stateSync.lock();
-        try {
-            return (timer != null);
-        } finally {
-            stateSync.unlock();
+    /**
+     * @param fps
+     * @throws GLException if the animator has already been started
+     */
+    public final synchronized void setFPS(int fps) throws GLException {
+        if ( isStarted() ) {
+            throw new GLException("Animator already started.");
         }
+        this.fps = fps;
     }
+    public final int getFPS() { return fps; }
 
-    public final boolean isAnimating() {
-        stateSync.lock();
-        try {
-            return (timer != null) && (task != null);
-        } finally {
-            stateSync.unlock();
+    class MainTask extends TimerTask {
+        private boolean justStarted;
+        private boolean alreadyStopped;
+        private boolean alreadyPaused;
+
+        public MainTask() {
         }
-    }
 
-    public final boolean isPaused() {
-        stateSync.lock();
-        try {
-            return (timer != null) && (task == null);
-        } finally {
-            stateSync.unlock();
+        public void start(Timer timer) {
+            fpsCounter.resetFPSCounter();
+            shouldRun = true;
+            shouldStop = false;
+
+            justStarted = true;
+            alreadyStopped = false;
+            alreadyPaused = false;
+
+            final long period = 0 < fps ? (long) (1000.0f / fps) : 1; // 0 -> 1: IllegalArgumentException: Non-positive period
+            if (scheduleAtFixedRate) {
+                timer.scheduleAtFixedRate(this, 0, period);
+            } else {
+                timer.schedule(this, 0, period);
+            }
         }
-    }
 
-    private void startTask() {
-        if(null != task) {
-            return;
-        }
-        long delay = (long) (1000.0f / (float) fps);
-        task = new TimerTask() {
-            public void run() {
-                if(FPSAnimator.this.shouldRun) {
-                    FPSAnimator.this.animThread = Thread.currentThread();
-                    // display impl. uses synchronized block on the animator instance
-                    display();
+        public boolean isActive() { return !alreadyStopped && !alreadyPaused; }
+
+        @Override
+        public final String toString() {
+            return "Task[thread "+animThread+", stopped "+alreadyStopped+", paused "+alreadyPaused+" shouldRun "+shouldRun+", shouldStop "+shouldStop+" -- started "+isStarted()+", animating "+isAnimatingImpl()+", paused "+isPaused()+", drawable "+drawables.size()+", drawablesEmpty "+drawablesEmpty+"]";
+        }
+
+        @Override
+        public void run() {
+            if( justStarted ) {
+                justStarted = false;
+                synchronized (FPSAnimator.this) {
+                    animThread = Thread.currentThread();
+                    if(DEBUG) {
+                        System.err.println("FPSAnimator start/resume:" + Thread.currentThread() + ": " + toString());
+                    }
+                    isAnimating = true;
+                    if( drawablesEmpty ) {
+                        shouldRun = false; // isAnimating:=false @ pause below
+                    } else {
+                        shouldRun = true;
+                        setDrawablesExclCtxState(exclusiveContext);
+                        FPSAnimator.this.notifyAll();
+                    }
+                    if(DEBUG) {
+                        System.err.println("FPSAnimator P1:" + Thread.currentThread() + ": " + toString());
+                    }
                 }
             }
-        };
+            if( shouldRun ) {
+                display();
+            } else if( shouldStop ) { // STOP
+                if(DEBUG) {
+                    System.err.println("FPSAnimator P4: "+alreadyStopped+", "+ Thread.currentThread() + ": " + toString());
+                }
+                this.cancel();
 
-        fpsCounter.resetFPSCounter();
-        shouldRun = true;
+                if( !alreadyStopped ) {
+                    alreadyStopped = true;
+                    if( exclusiveContext && !drawablesEmpty ) {
+                        setDrawablesExclCtxState(false);
+                        display(); // propagate exclusive change!
+                    }
+                    synchronized (FPSAnimator.this) {
+                        if(DEBUG) {
+                            System.err.println("FPSAnimator stop " + Thread.currentThread() + ": " + toString());
+                        }
+                        animThread = null;
+                        isAnimating = false;
+                        FPSAnimator.this.notifyAll();
+                    }
+                }
+            } else {
+                if(DEBUG) {
+                    System.err.println("FPSAnimator P5: "+alreadyPaused+", "+ Thread.currentThread() + ": " + toString());
+                }
+                this.cancel();
 
-        if (scheduleAtFixedRate) {
-            timer.scheduleAtFixedRate(task, 0, delay);
-        } else {
-            timer.schedule(task, 0, delay);
+                if( !alreadyPaused ) { // PAUSE
+                    alreadyPaused = true;
+                    if( exclusiveContext && !drawablesEmpty ) {
+                        setDrawablesExclCtxState(false);
+                        display(); // propagate exclusive change!
+                    }
+                    synchronized (FPSAnimator.this) {
+                        if(DEBUG) {
+                            System.err.println("FPSAnimator pause " + Thread.currentThread() + ": " + toString());
+                        }
+                        isAnimating = false;
+                        FPSAnimator.this.notifyAll();
+                    }
+                }
+            }
         }
     }
+    private final boolean isAnimatingImpl() {
+        return animThread != null && isAnimating ;
+    }
+    @Override
+    public final synchronized boolean isAnimating() {
+        return animThread != null && isAnimating ;
+    }
+
+    @Override
+    public final synchronized boolean isPaused() {
+        return animThread != null && ( !shouldRun && !shouldStop ) ;
+    }
+
+    static int timerNo = 0;
 
-    public synchronized boolean  start() {
-        if (timer != null) {
+    @Override
+    public final synchronized boolean start() {
+        if ( null != timer || null != task || isStarted() ) {
             return false;
         }
-        stateSync.lock();
-        try {
-            timer = new Timer();
-            startTask();
-        } finally {
-            stateSync.unlock();
+        timer = new Timer( getThreadName()+"-"+baseName+"-Timer"+(timerNo++) );
+        task = new MainTask();
+        if(DEBUG) {
+            System.err.println("FPSAnimator.start() START: "+task+", "+ Thread.currentThread() + ": " + toString());
         }
-        return true;
+        task.start(timer);
+
+        final boolean res = finishLifecycleAction( drawablesEmpty ? waitForStartedEmptyCondition : waitForStartedAddedCondition,
+                                                   POLLP_WAIT_FOR_FINISH_LIFECYCLE_ACTION);
+        if(DEBUG) {
+            System.err.println("FPSAnimator.start() END: "+task+", "+ Thread.currentThread() + ": " + toString());
+        }
+        if( drawablesEmpty ) {
+            task.cancel();
+            task = null;
+        }
+        return res;
     }
+    private final Condition waitForStartedAddedCondition = new Condition() {
+        @Override
+        public boolean eval() {
+            return !isStarted() || !isAnimating ;
+        } };
+    private final Condition waitForStartedEmptyCondition = new Condition() {
+        @Override
+        public boolean eval() {
+            return !isStarted() || isAnimating ;
+        } };
 
     /** Stops this FPSAnimator. Due to the implementation of the
     FPSAnimator it is not guaranteed that the FPSAnimator will be
     completely stopped by the time this method returns. */
-    public synchronized boolean stop() {
-        if (timer == null) {
+    @Override
+    public final synchronized boolean stop() {
+        if ( null == timer || !isStarted() ) {
             return false;
         }
-        stateSync.lock();
-        try {
+        if(DEBUG) {
+            System.err.println("FPSAnimator.stop() START: "+task+", "+ Thread.currentThread() + ": " + toString());
+        }
+        final boolean res;
+        if( null == task ) {
+            // start/resume case w/ drawablesEmpty
+            res = true;
+        } else {
             shouldRun = false;
-            if(null != task) {
-                task.cancel();
-                task = null;
-            }
-            if(null != timer) {
-                timer.cancel();
-                timer = null;
-            }
-            animThread = null;
-            try {
-                Thread.sleep(20); // ~ 1/60 hz wait, since we can't ctrl stopped threads
-            } catch (InterruptedException e) { }
-        } finally {
-            stateSync.unlock();
-        }
-        return true;
+            shouldStop = true;
+            res = finishLifecycleAction(waitForStoppedCondition, POLLP_WAIT_FOR_FINISH_LIFECYCLE_ACTION);
+        }
+
+        if(DEBUG) {
+            System.err.println("FPSAnimator.stop() END: "+task+", "+ Thread.currentThread() + ": " + toString());
+        }
+        if(null != task) {
+            task.cancel();
+            task = null;
+        }
+        if(null != timer) {
+            timer.cancel();
+            timer = null;
+        }
+        animThread = null;
+        return res;
     }
+    private final Condition waitForStoppedCondition = new Condition() {
+        @Override
+        public boolean eval() {
+            return isStarted();
+        } };
 
-    public synchronized boolean pause() {
-        if (timer == null) {
+    @Override
+    public final synchronized boolean pause() {
+        if ( !isStarted() || ( null != task && isPaused() ) ) {
             return false;
         }
-        stateSync.lock();
-        try {
+        if(DEBUG) {
+            System.err.println("FPSAnimator.pause() START: "+task+", "+ Thread.currentThread() + ": " + toString());
+        }
+        final boolean res;
+        if( null == task ) {
+            // start/resume case w/ drawablesEmpty
+            res = true;
+        } else {
             shouldRun = false;
-            if(null != task) {
-                task.cancel();
-                task = null;
-            }
-            animThread = null;
-            try {
-                Thread.sleep(20); // ~ 1/60 hz wait, since we can't ctrl stopped threads
-            } catch (InterruptedException e) { }
-        } finally {
-            stateSync.unlock();
-        }
-        return true;
+            res = finishLifecycleAction(waitForPausedCondition, POLLP_WAIT_FOR_FINISH_LIFECYCLE_ACTION);
+        }
+
+        if(DEBUG) {
+            System.err.println("FPSAnimator.pause() END: "+task+", "+ Thread.currentThread() + ": " + toString());
+        }
+        if(null != task) {
+            task.cancel();
+            task = null;
+        }
+        return res;
     }
+    private final Condition waitForPausedCondition = new Condition() {
+        @Override
+        public boolean eval() {
+            // end waiting if stopped as well
+            return isAnimating && isStarted();
+        } };
 
-    public synchronized boolean resume() {
-        if (timer == null) {
+    @Override
+    public final synchronized boolean resume() {
+        if ( null != task || !isStarted() || !isPaused() ) {
             return false;
         }
-        stateSync.lock();
-        try {
-            startTask();
-        } finally {
-            stateSync.unlock();
+        if(DEBUG) {
+            System.err.println("FPSAnimator.resume() START: "+ Thread.currentThread() + ": " + toString());
+        }
+        final boolean res;
+        if( drawablesEmpty ) {
+            res = true;
+        } else {
+            task = new MainTask();
+            task.start(timer);
+            res = finishLifecycleAction(waitForResumeCondition, POLLP_WAIT_FOR_FINISH_LIFECYCLE_ACTION);
+        }
+        if(DEBUG) {
+            System.err.println("FPSAnimator.resume() END: "+task+", "+ Thread.currentThread() + ": " + toString());
         }
-        return true;
+        return res;
     }
+    private final Condition waitForResumeCondition = new Condition() {
+        @Override
+        public boolean eval() {
+            // end waiting if stopped as well
+            return !drawablesEmpty && !isAnimating && isStarted();
+        } };
 }