/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* OGL-specific implementation of RenderQueue. This class provides a
* single (daemon) thread that is responsible for periodically flushing
* the queue, thus ensuring that only one thread communicates with the native
* OpenGL libraries for the entire process.
*/
private OGLRenderQueue() {
/*
* The thread must be a member of a thread group
* which will not get GCed before VM exit.
*/
public QueueFlusher run() {
}
return new QueueFlusher(rootThreadGroup);
}
});
}
/**
* Returns the single OGLRenderQueue instance. If it has not yet been
* initialized, this method will first construct the single instance
* before returning it.
*/
if (theInstance == null) {
theInstance = new OGLRenderQueue();
}
return theInstance;
}
/**
* Flushes the single OGLRenderQueue instance synchronously. If an
* OGLRenderQueue has not yet been instantiated, this method is a no-op.
* This method is useful in the case of Toolkit.sync(), in which we want
* to flush the OGL pipeline, but only if the OGL pipeline is currently
* enabled. Since this class has few external dependencies, callers need
* not be concerned that calling this method will trigger initialization
* of the OGL pipeline and related classes.
*/
public static void sync() {
if (theInstance != null) {
theInstance.lock();
try {
} finally {
}
}
}
/**
* Disposes the native memory associated with the given native
* graphics config info pointer on the single queue flushing thread.
*/
try {
// make sure we make the context associated with the given
// GraphicsConfig current before disposing the native resources
// this call is expected to complete synchronously, so flush now
} finally {
}
}
/**
* Returns true if the current thread is the OGL QueueFlusher thread.
*/
public static boolean isQueueFlusherThread() {
}
public void flushNow() {
// assert lock.isHeldByCurrentThread();
try {
} catch (Exception e) {
e.printStackTrace();
}
}
// assert lock.isHeldByCurrentThread();
try {
} catch (Exception e) {
e.printStackTrace();
}
}
private void flushBuffer() {
// assert lock.isHeldByCurrentThread();
if (limit > 0) {
// process the queue
}
// reset the buffer position
// clear the set of references, since we no longer need them
}
private boolean needsFlush;
super(threadGroup, "Java2D Queue Flusher");
setDaemon(true);
start();
}
public synchronized void flushNow() {
// wake up the flusher
needsFlush = true;
notify();
// wait for flush to complete
while (needsFlush) {
try {
wait();
} catch (InterruptedException e) {
}
}
// re-throw any error that may have occurred during the flush
throw error;
}
}
flushNow();
}
public synchronized void run() {
boolean timedOut = false;
while (true) {
while (!needsFlush) {
try {
timedOut = false;
/*
* Wait until we're woken up with a flushNow() call,
* or the timeout period elapses (so that we can
* flush the queue periodically).
*/
wait(100);
/*
* We will automatically flush the queue if the
* following conditions apply:
* - the wait() timed out
* - we can lock the queue (without blocking)
* - there is something in the queue to flush
* Otherwise, just continue (we'll flush eventually).
*/
needsFlush = true;
} else {
unlock();
}
}
} catch (InterruptedException e) {
}
}
try {
// reset the throwable state
// flush the buffer now
flushBuffer();
// if there's a task, invoke that now as well
}
} catch (Error e) {
error = e;
} catch (Exception x) {
x.printStackTrace();
} finally {
if (timedOut) {
unlock();
}
// allow the waiting thread to continue
needsFlush = false;
notify();
}
}
}
}
}