Jogamp
ae99b74654a12f653a03ed059d4c7fe4e3642850
[jogl.git] / src / newt / classes / com / jogamp / newt / opengl / GLWindow.java
1 /*
2  * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
3  * Copyright (c) 2010 JogAmp Community. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  * - Redistribution of source code must retain the above copyright
10  *   notice, this list of conditions and the following disclaimer.
11  *
12  * - Redistribution in binary form must reproduce the above copyright
13  *   notice, this list of conditions and the following disclaimer in the
14  *   documentation and/or other materials provided with the distribution.
15  *
16  * Neither the name of Sun Microsystems, Inc. or the names of
17  * contributors may be used to endorse or promote products derived from
18  * this software without specific prior written permission.
19  *
20  * This software is provided "AS IS," without a warranty of any kind. ALL
21  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
22  * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
23  * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
24  * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
25  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
26  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
27  * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
28  * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
29  * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
30  * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
31  * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
32  *
33  */
34
35 package com.jogamp.newt.opengl;
36
37 import java.security.AccessController;
38 import java.security.PrivilegedAction;
39 import java.util.List;
40
41 import javax.media.nativewindow.AbstractGraphicsConfiguration;
42 import javax.media.nativewindow.CapabilitiesChooser;
43 import javax.media.nativewindow.CapabilitiesImmutable;
44 import javax.media.nativewindow.NativeSurface;
45 import javax.media.nativewindow.NativeWindow;
46 import javax.media.nativewindow.NativeWindowException;
47 import javax.media.nativewindow.SurfaceUpdatedListener;
48 import javax.media.nativewindow.util.InsetsImmutable;
49 import javax.media.nativewindow.util.Point;
50 import javax.media.nativewindow.util.Rectangle;
51 import javax.media.opengl.FPSCounter;
52 import javax.media.opengl.GL;
53 import javax.media.opengl.GL3;
54 import javax.media.opengl.GL4ES3;
55 import javax.media.opengl.GLAnimatorControl;
56 import javax.media.opengl.GLAutoDrawable;
57 import javax.media.opengl.GLCapabilities;
58 import javax.media.opengl.GLCapabilitiesImmutable;
59 import javax.media.opengl.GLContext;
60 import javax.media.opengl.GLDrawable;
61 import javax.media.opengl.GLDrawableFactory;
62 import javax.media.opengl.GLES2;
63 import javax.media.opengl.GLES3;
64 import javax.media.opengl.GLEventListener;
65 import javax.media.opengl.GLException;
66 import javax.media.opengl.GLProfile;
67 import javax.media.opengl.GLRunnable;
68
69 import jogamp.newt.WindowImpl;
70 import jogamp.opengl.GLAutoDrawableBase;
71 import jogamp.opengl.GLContextImpl;
72 import jogamp.opengl.GLDrawableImpl;
73
74 import com.jogamp.common.GlueGenVersion;
75 import com.jogamp.common.util.VersionUtil;
76 import com.jogamp.common.util.locks.RecursiveLock;
77 import com.jogamp.newt.MonitorDevice;
78 import com.jogamp.newt.NewtFactory;
79 import com.jogamp.newt.Screen;
80 import com.jogamp.newt.Window;
81 import com.jogamp.newt.Display.PointerIcon;
82 import com.jogamp.newt.event.GestureHandler;
83 import com.jogamp.newt.event.KeyListener;
84 import com.jogamp.newt.event.MouseListener;
85 import com.jogamp.newt.event.NEWTEvent;
86 import com.jogamp.newt.event.NEWTEventConsumer;
87 import com.jogamp.newt.event.NEWTEventListener;
88 import com.jogamp.newt.event.WindowAdapter;
89 import com.jogamp.newt.event.WindowEvent;
90 import com.jogamp.newt.event.WindowListener;
91 import com.jogamp.newt.event.WindowUpdateEvent;
92 import com.jogamp.opengl.JoglVersion;
93 import com.jogamp.opengl.GLStateKeeper;
94
95 /**
96  * An implementation of {@link GLAutoDrawable} and {@link Window} interface,
97  * using a delegated {@link Window} instance, which may be an aggregation (lifecycle: created and destroyed).
98  * <P>
99  * This implementation supports {@link GLStateKeeper GL state preservation},
100  * hence {@link #isGLStatePreservationSupported()} returns <code>true</code>.
101  * </P>
102  * <P>
103  * This implementation does not make the OpenGL context current<br>
104  * before calling the various input EventListener callbacks, ie {@link MouseListener} etc.<br>
105  * This design decision is made in favor of a more performant and simplified
106  * implementation. Also the event dispatcher shall be implemented OpenGL agnostic.<br>
107  * To be able to use OpenGL commands from within such input {@link NEWTEventListener},<br>
108  * you can inject {@link GLRunnable} objects
109  * via {@link #invoke(boolean, GLRunnable)} to the OpenGL command stream.<br>
110  * </p>
111  */
112 public class GLWindow extends GLAutoDrawableBase implements GLAutoDrawable, Window, NEWTEventConsumer, FPSCounter {
113     private final WindowImpl window;
114
115     /**
116      * Constructor. Do not call this directly -- use {@link #create()} instead.
117      */
118     protected GLWindow(Window window) {
119         super(null, null, false /* always handle device lifecycle ourselves */);
120         this.window = (WindowImpl) window;
121         this.window.setWindowDestroyNotifyAction( new Runnable() {
122             @Override
123             public void run() {
124                 defaultWindowDestroyNotifyOp();
125             } } );
126         window.addWindowListener(new WindowAdapter() {
127                 @Override
128                 public void windowRepaint(WindowUpdateEvent e) {
129                     defaultWindowRepaintOp();
130                 }
131
132                 @Override
133                 public void windowResized(WindowEvent e) {
134                     defaultWindowResizedOp(getSurfaceWidth(), getSurfaceHeight());
135                 }
136
137             });
138         this.window.setLifecycleHook(new GLLifecycleHook());
139     }
140
141     @Override
142     public final Object getUpstreamWidget() {
143         return window;
144     }
145
146     /**
147      * Creates a new GLWindow attaching a new Window referencing a
148      * new default Screen and default Display with the given GLCapabilities.
149      * <p>
150      * The lifecycle of this Window's Screen and Display is handled via {@link Screen#addReference()}
151      * and {@link Screen#removeReference()}.
152      * </p>
153      * The default Display will be reused if already instantiated.
154      */
155     public static GLWindow create(GLCapabilitiesImmutable caps) {
156         return new GLWindow(NewtFactory.createWindow(caps));
157     }
158
159     /**
160      * Creates a new GLWindow attaching a new Window referencing the given Screen
161      * with the given GLCapabilities.
162      * <p>
163      * The lifecycle of this Window's Screen and Display is handled via {@link Screen#addReference()}
164      * and {@link Screen#removeReference()}.
165      * </p>
166      */
167     public static GLWindow create(Screen screen, GLCapabilitiesImmutable caps) {
168         return new GLWindow(NewtFactory.createWindow(screen, caps));
169     }
170
171     /**
172      * Creates a new GLWindow attaching the given window.
173      * <p>
174      * The lifecycle of this Window's Screen and Display is handled via {@link Screen#addReference()}
175      * and {@link Screen#removeReference()}.
176      * </p>
177      */
178     public static GLWindow create(Window window) {
179         return new GLWindow(window);
180     }
181
182     /**
183      * Creates a new GLWindow attaching a new child Window
184      * of the given <code>parentNativeWindow</code> with the given GLCapabilities.
185      * <p>
186      * The Display/Screen will be compatible with the <code>parentNativeWindow</code>,
187      * or even identical in case it's a Newt Window.
188      * An already instantiated compatible Display will be reused.
189      * </p>
190      * <p>
191      * The lifecycle of this Window's Screen and Display is handled via {@link Screen#addReference()}
192      * and {@link Screen#removeReference()}.
193      * </p>
194      */
195     public static GLWindow create(NativeWindow parentNativeWindow, GLCapabilitiesImmutable caps) {
196         return new GLWindow(NewtFactory.createWindow(parentNativeWindow, caps));
197     }
198
199     //----------------------------------------------------------------------
200     // WindowClosingProtocol implementation
201     //
202     @Override
203     public WindowClosingMode getDefaultCloseOperation() {
204         return window.getDefaultCloseOperation();
205     }
206
207     @Override
208     public WindowClosingMode setDefaultCloseOperation(WindowClosingMode op) {
209         return window.setDefaultCloseOperation(op);
210     }
211
212     //----------------------------------------------------------------------
213     // Window Access
214     //
215
216     @Override
217     public CapabilitiesChooser setCapabilitiesChooser(CapabilitiesChooser chooser) {
218         return window.setCapabilitiesChooser(chooser);
219     }
220
221     @Override
222     public final CapabilitiesImmutable getChosenCapabilities() {
223         final GLDrawable _drawable = drawable;
224         return null != _drawable ? _drawable.getChosenGLCapabilities() : window.getChosenCapabilities();
225     }
226
227     @Override
228     public final CapabilitiesImmutable getRequestedCapabilities() {
229         return window.getRequestedCapabilities();
230     }
231
232     @Override
233     public final Window getDelegatedWindow() {
234         return window.getDelegatedWindow();
235     }
236
237     @Override
238     public final NativeWindow getParent() {
239         return window.getParent();
240     }
241
242     @Override
243     public final Screen getScreen() {
244         return window.getScreen();
245     }
246
247     @Override
248     public final MonitorDevice getMainMonitor() {
249         return window.getMainMonitor();
250     }
251
252     @Override
253     public final void setTitle(String title) {
254         window.setTitle(title);
255     }
256
257     @Override
258     public final String getTitle() {
259         return window.getTitle();
260     }
261
262     @Override
263     public final boolean isPointerVisible() {
264         return window.isPointerVisible();
265     }
266
267     @Override
268     public final void setPointerVisible(boolean mouseVisible) {
269         window.setPointerVisible(mouseVisible);
270     }
271
272     @Override
273     public final PointerIcon getPointerIcon() {
274         return window.getPointerIcon();
275     }
276
277     @Override
278     public final void setPointerIcon(final PointerIcon pi) {
279         window.setPointerIcon(pi);
280     }
281
282     @Override
283     public final boolean isPointerConfined() {
284         return window.isPointerConfined();
285     }
286
287     @Override
288     public final void confinePointer(boolean grab) {
289         window.confinePointer(grab);
290     }
291
292     @Override
293     public final void setUndecorated(boolean value) {
294         window.setUndecorated(value);
295     }
296
297     @Override
298     public final void warpPointer(int x, int y) {
299         window.warpPointer(x, y);
300     }
301     @Override
302     public final boolean isUndecorated() {
303         return window.isUndecorated();
304     }
305
306     @Override
307     public final void setAlwaysOnTop(boolean value) {
308         window.setAlwaysOnTop(value);
309     }
310
311     @Override
312     public final boolean isAlwaysOnTop() {
313         return window.isAlwaysOnTop();
314     }
315
316     @Override
317     public final void setFocusAction(FocusRunnable focusAction) {
318         window.setFocusAction(focusAction);
319     }
320
321     @Override
322     public void setKeyboardFocusHandler(KeyListener l) {
323         window.setKeyboardFocusHandler(l);
324     }
325
326     @Override
327     public final void requestFocus() {
328         window.requestFocus();
329     }
330
331     @Override
332     public final void requestFocus(boolean wait) {
333         window.requestFocus(wait);
334     }
335
336     @Override
337     public boolean hasFocus() {
338         return window.hasFocus();
339     }
340
341     @Override
342     public final InsetsImmutable getInsets() {
343         return window.getInsets();
344     }
345
346     @Override
347     public final int getX() {
348         return window.getX();
349     }
350
351     @Override
352     public final int getY() {
353         return window.getY();
354     }
355
356     @Override
357     public final int getWidth() {
358         return window.getWidth();
359     }
360
361     @Override
362     public final int getHeight() {
363         return window.getHeight();
364     }
365
366     @Override
367     public final Rectangle getBounds() {
368         return window.getBounds();
369     }
370
371     @Override
372     public final int getSurfaceWidth() {
373         return window.getSurfaceWidth();
374     }
375
376     @Override
377     public final int getSurfaceHeight() {
378         return window.getSurfaceHeight();
379     }
380
381     @Override
382     public final Rectangle getSurfaceBounds() {
383         return window.getSurfaceBounds();
384     }
385
386     @Override
387     public final int[] convertToWindowUnits(final int[] pixelUnitsAndResult) {
388         return window.convertToWindowUnits(pixelUnitsAndResult);
389     }
390
391     @Override
392     public final int[] convertToPixelUnits(final int[] windowUnitsAndResult) {
393         return window.convertToPixelUnits(windowUnitsAndResult);
394     }
395
396     @Override
397     public final Rectangle convertToWindowUnits(final Rectangle pixelUnitsAndResult) {
398         return window.convertToWindowUnits(pixelUnitsAndResult);
399     }
400
401     @Override
402     public final Rectangle convertToPixelUnits(final Rectangle windowUnitsAndResult) {
403         return window.convertToPixelUnits(windowUnitsAndResult);
404     }
405
406     @Override
407     public final int[] setSurfaceScale(final int[] result, final int[] pixelScale) {
408         return window.setSurfaceScale(result, pixelScale);
409     }
410
411     @Override
412     public final int[] getSurfaceScale(final int[] result) {
413         return window.getSurfaceScale(result);
414     }
415
416     @Override
417     public final void setPosition(int x, int y) {
418         window.setPosition(x, y);
419     }
420     @Override
421     public void setTopLevelPosition(int x, int y) {
422         window.setTopLevelPosition(x, y);
423     }
424
425     @Override
426     public final boolean setFullscreen(boolean fullscreen) {
427         return window.setFullscreen(fullscreen);
428     }
429
430     @Override
431     public boolean setFullscreen(List<MonitorDevice> monitors) {
432         return window.setFullscreen(monitors);
433     }
434
435     @Override
436     public final boolean isFullscreen() {
437         return window.isFullscreen();
438     }
439
440     @Override
441     public final boolean isVisible() {
442         return window.isVisible();
443     }
444
445     @Override
446     public final String toString() {
447         return "NEWT-GLWindow[ \n\tHelper: " + helper + ", \n\tDrawable: " + drawable +
448                ", \n\tContext: " + context + ", \n\tWindow: "+window+ /** ", \n\tFactory: "+factory+ */ "]";
449     }
450
451     @Override
452     public final ReparentOperation reparentWindow(NativeWindow newParent) {
453         return window.reparentWindow(newParent);
454     }
455
456     @Override
457     public final ReparentOperation reparentWindow(NativeWindow newParent, int x, int y, boolean forceDestroyCreate) {
458         return window.reparentWindow(newParent, x, y, forceDestroyCreate);
459     }
460
461     @Override
462     public final ReparentOperation reparentWindow(NativeWindow newParent, int x, int y, int hints) {
463         return window.reparentWindow(newParent, x, y, hints);
464     }
465
466     @Override
467     public final boolean removeChild(NativeWindow win) {
468         return window.removeChild(win);
469     }
470
471     @Override
472     public final boolean addChild(NativeWindow win) {
473         return window.addChild(win);
474     }
475
476     //----------------------------------------------------------------------
477     // Window.LifecycleHook Implementation
478     //
479
480     @Override
481     public final void destroy() {
482         window.destroy();
483     }
484
485     @Override
486     public void setWindowDestroyNotifyAction(Runnable r) {
487         window.setWindowDestroyNotifyAction(r);
488     }
489
490     @Override
491     public final void setVisible(boolean visible) {
492         window.setVisible(visible);
493     }
494
495     @Override
496     public void setVisible(boolean wait, boolean visible) {
497         window.setVisible(wait, visible);
498     }
499
500     @Override
501     public final void setSize(int width, int height) {
502         window.setSize(width, height);
503     }
504     @Override
505     public final void setSurfaceSize(int pixelWidth, int pixelHeight) {
506         window.setSurfaceSize(pixelWidth, pixelHeight);
507     }
508     @Override
509     public void setTopLevelSize(int width, int height) {
510         window.setTopLevelSize(width, height);
511     }
512
513     @Override
514     public final boolean isNativeValid() {
515         return window.isNativeValid();
516     }
517
518     @Override
519     public Point getLocationOnScreen(Point storage) {
520         return window.getLocationOnScreen(storage);
521     }
522
523     // Hide methods here ..
524     protected class GLLifecycleHook implements WindowImpl.LifecycleHook {
525
526         @Override
527         public void preserveGLStateAtDestroy(boolean value) {
528             GLWindow.this.preserveGLStateAtDestroy(value);
529         }
530
531         @Override
532         public synchronized void destroyActionPreLock() {
533             // nop
534         }
535
536         @Override
537         public synchronized void destroyActionInLock() {
538             if(Window.DEBUG_IMPLEMENTATION) {
539                 String msg = "GLWindow.destroy() "+WindowImpl.getThreadName()+", start";
540                 System.err.println(msg);
541                 //Exception e1 = new Exception(msg);
542                 //e1.printStackTrace();
543             }
544
545             destroyImplInLock();
546
547             if(Window.DEBUG_IMPLEMENTATION) {
548                 System.err.println("GLWindow.destroy() "+WindowImpl.getThreadName()+", fin");
549             }
550         }
551
552         @Override
553         public synchronized void resetCounter() {
554             if(Window.DEBUG_IMPLEMENTATION) {
555                 System.err.println("GLWindow.resetCounter() "+WindowImpl.getThreadName());
556             }
557             GLWindow.this.resetFPSCounter();
558             final GLAnimatorControl animator = GLWindow.this.getAnimator();
559             if( null != animator ) {
560                 animator.resetFPSCounter();
561             }
562         }
563
564         @Override
565         public synchronized void setVisibleActionPost(boolean visible, boolean nativeWindowCreated) {
566             long t0;
567             if(Window.DEBUG_IMPLEMENTATION) {
568                 t0 = System.nanoTime();
569                 System.err.println("GLWindow.setVisibleActionPost("+visible+", "+nativeWindowCreated+") "+WindowImpl.getThreadName()+", start");
570             } else {
571                 t0 = 0;
572             }
573
574             if (null == drawable && visible && 0 != window.getWindowHandle() && 0<getSurfaceWidth()*getSurfaceHeight()) {
575                 if( ( null != context ) ) {
576                     throw new InternalError("GLWindow.LifecycleHook.setVisiblePost: "+WindowImpl.getThreadName()+" - Null drawable, but valid context - "+GLWindow.this);
577                 }
578                 final GLContext[] shareWith = { null };
579                 if( !helper.isSharedGLContextPending(shareWith) ) {
580                     final NativeSurface ns;
581                     {
582                         final NativeSurface wrapped_ns = window.getWrappedSurface();
583                         ns = null != wrapped_ns ? wrapped_ns : window;
584                     }
585                     final GLCapabilitiesImmutable glCaps = (GLCapabilitiesImmutable) ns.getGraphicsConfiguration().getChosenCapabilities();
586                     if(null==factory) {
587                         factory = GLDrawableFactory.getFactory(glCaps.getGLProfile());
588                     }
589                     drawable = (GLDrawableImpl) factory.createGLDrawable(ns);
590                     drawable.setRealized(true);
591
592                     if( !GLWindow.this.restoreGLEventListenerState() ) {
593                         context = (GLContextImpl) drawable.createContext(shareWith[0]);
594                         context.setContextCreationFlags(additionalCtxCreationFlags);
595                     }
596                 }
597             }
598             if(Window.DEBUG_IMPLEMENTATION) {
599                 System.err.println("GLWindow.setVisibleActionPost("+visible+", "+nativeWindowCreated+") "+WindowImpl.getThreadName()+", fin: dt "+ (System.nanoTime()-t0)/1e6 +"ms");
600             }
601         }
602
603         private GLAnimatorControl savedAnimator = null;
604
605         @Override
606         public synchronized boolean pauseRenderingAction() {
607             boolean animatorPaused = false;
608             savedAnimator = GLWindow.this.getAnimator();
609             if ( null != savedAnimator ) {
610                 animatorPaused = savedAnimator.pause();
611             }
612             return animatorPaused;
613         }
614
615         @Override
616         public synchronized void resumeRenderingAction() {
617             if ( null != savedAnimator && savedAnimator.isPaused() ) {
618                 savedAnimator.resume();
619             }
620         }
621
622         @SuppressWarnings("deprecation")
623         @Override
624         public void shutdownRenderingAction() {
625             final GLAnimatorControl anim = GLWindow.this.getAnimator();
626             if ( null != anim && anim.isAnimating() ) {
627                 final Thread animThread = anim.getThread();
628                 if( animThread == Thread.currentThread() ) {
629                     anim.stop(); // on anim thread, non-blocking
630                 } else {
631                     AccessController.doPrivileged(new PrivilegedAction<Object>() {
632                         @Override
633                         public Object run() {
634                             if( anim.isAnimating() && null != animThread ) {
635                                 try {
636                                     animThread.stop();
637                                 } catch(Throwable t) {
638                                     if( DEBUG ) {
639                                         System.err.println("Catched "+t.getClass().getName()+": "+t.getMessage());
640                                         t.printStackTrace();
641                                     }
642                                 }
643                             }
644                             return null;
645                         } } );
646                 }
647             }
648         }
649     }
650
651     //----------------------------------------------------------------------
652     // OpenGL-related methods and state
653     //
654
655     @Override
656     protected final RecursiveLock getLock() {
657         return window.getLock();
658     }
659
660     @Override
661     public void display() {
662         if( !isNativeValid() || !isVisible() ) { return; }
663
664         if(sendDestroy || ( window.hasDeviceChanged() && GLAutoDrawable.SCREEN_CHANGE_ACTION_ENABLED ) ) {
665             sendDestroy=false;
666             destroy();
667             return;
668         }
669
670         final boolean done;
671         final RecursiveLock lock = window.getLock();
672         lock.lock(); // sync: context/drawable could have been recreated/destroyed while animating
673         try {
674             if( null != context ) {
675                 // surface is locked/unlocked implicit by context's makeCurrent/release
676                 helper.invokeGL(drawable, context, defaultDisplayAction, defaultInitAction);
677                 done = true;
678             } else {
679                 done = false;
680             }
681         } finally {
682             lock.unlock();
683         }
684         if( !done && ( 0 < getSurfaceWidth() && 0 < getSurfaceHeight() ) ) {
685             // retry drawable and context creation, will itself issue resize -> display
686             setVisible(true);
687         }
688     }
689
690     /**
691      * {@inheritDoc}
692      * <p>
693      * GLWindow supports GL state preservation, hence returns <code>true</code>.
694      * </p>
695      */
696     @Override
697     public final boolean isGLStatePreservationSupported() { return true; }
698
699     //----------------------------------------------------------------------
700     // GLDrawable methods
701     //
702     private GLDrawableFactory factory;
703
704     @Override
705     public final GLDrawableFactory getFactory() {
706         return factory;
707     }
708
709     @Override
710     public final void swapBuffers() throws GLException {
711          defaultSwapBuffers();
712     }
713
714     //----------------------------------------------------------------------
715     // NEWTEventConsumer
716     //
717     @Override
718     public boolean consumeEvent(NEWTEvent event) {
719         return window.consumeEvent(event);
720     }
721
722     //----------------------------------------------------------------------
723     // Window completion
724     //
725     @Override
726     public final void windowRepaint(int x, int y, int width, int height) {
727         window.windowRepaint(x, y, width, height);
728     }
729
730     @Override
731     public final void enqueueEvent(boolean wait, com.jogamp.newt.event.NEWTEvent event) {
732         window.enqueueEvent(wait, event);
733     }
734
735     @Override
736     public final void runOnEDTIfAvail(boolean wait, final Runnable task) {
737         window.runOnEDTIfAvail(wait, task);
738     }
739
740     @Override
741     public void sendWindowEvent(int eventType) {
742         window.sendWindowEvent(eventType);
743     }
744
745     @Override
746     public final WindowListener getWindowListener(int index) {
747         return window.getWindowListener(index);
748     }
749
750     @Override
751     public final WindowListener[] getWindowListeners() {
752         return window.getWindowListeners();
753     }
754
755     @Override
756     public final void removeWindowListener(WindowListener l) {
757         window.removeWindowListener(l);
758     }
759
760     @Override
761     public final void addWindowListener(WindowListener l) {
762         window.addWindowListener(l);
763     }
764
765     @Override
766     public final void addWindowListener(int index, WindowListener l) throws IndexOutOfBoundsException {
767         window.addWindowListener(index, l);
768     }
769
770     @Override
771     public final void setKeyboardVisible(boolean visible) {
772         window.setKeyboardVisible(visible);
773     }
774
775     @Override
776     public final boolean isKeyboardVisible() {
777         return window.isKeyboardVisible();
778     }
779
780     @Override
781     public final void addKeyListener(KeyListener l) {
782         window.addKeyListener(l);
783     }
784
785     @Override
786     public final void addKeyListener(int index, KeyListener l) {
787         window.addKeyListener(index, l);
788     }
789
790     @Override
791     public final void removeKeyListener(KeyListener l) {
792         window.removeKeyListener(l);
793     }
794
795     @Override
796     public final KeyListener getKeyListener(int index) {
797         return window.getKeyListener(index);
798     }
799
800     @Override
801     public final KeyListener[] getKeyListeners() {
802         return window.getKeyListeners();
803     }
804
805     @Override
806     public final void addMouseListener(MouseListener l) {
807         window.addMouseListener(l);
808     }
809
810     @Override
811     public final void addMouseListener(int index, MouseListener l) {
812         window.addMouseListener(index, l);
813     }
814
815     @Override
816     public final void removeMouseListener(MouseListener l) {
817         window.removeMouseListener(l);
818     }
819
820     @Override
821     public final MouseListener getMouseListener(int index) {
822         return window.getMouseListener(index);
823     }
824
825     @Override
826     public final MouseListener[] getMouseListeners() {
827         return window.getMouseListeners();
828     }
829
830     @Override
831     public void setDefaultGesturesEnabled(boolean enable) {
832         window.setDefaultGesturesEnabled(enable);
833     }
834     @Override
835     public boolean areDefaultGesturesEnabled() {
836         return window.areDefaultGesturesEnabled();
837     }
838     @Override
839     public final void addGestureHandler(GestureHandler gh) {
840         window.addGestureHandler(gh);
841     }
842     @Override
843     public final void addGestureHandler(int index, GestureHandler gh) {
844         window.addGestureHandler(index, gh);
845     }
846     @Override
847     public final void removeGestureHandler(GestureHandler gh) {
848         window.removeGestureHandler(gh);
849     }
850     @Override
851     public final void addGestureListener(GestureHandler.GestureListener gl) {
852         window.addGestureListener(-1, gl);
853     }
854     @Override
855     public final void addGestureListener(int index, GestureHandler.GestureListener gl) {
856         window.addGestureListener(index, gl);
857     }
858     @Override
859     public final void removeGestureListener(GestureHandler.GestureListener gl) {
860         window.removeGestureListener(gl);
861     }
862
863     //----------------------------------------------------------------------
864     // NativeWindow completion
865     //
866
867     @Override
868     public final int lockSurface() throws NativeWindowException, RuntimeException {
869         return window.lockSurface();
870     }
871
872     @Override
873     public final void unlockSurface() {
874         window.unlockSurface();
875     }
876
877     @Override
878     public final boolean isSurfaceLockedByOtherThread() {
879         return window.isSurfaceLockedByOtherThread();
880     }
881
882     @Override
883     public final Thread getSurfaceLockOwner() {
884         return window.getSurfaceLockOwner();
885
886     }
887
888     @Override
889     public final boolean surfaceSwap() {
890         return window.surfaceSwap();
891     }
892
893     @Override
894     public final void removeSurfaceUpdatedListener(SurfaceUpdatedListener l) {
895         window.removeSurfaceUpdatedListener(l);
896     }
897
898     @Override
899     public final void addSurfaceUpdatedListener(SurfaceUpdatedListener l) {
900         window.addSurfaceUpdatedListener(l);
901     }
902
903     @Override
904     public final void addSurfaceUpdatedListener(int index, SurfaceUpdatedListener l) throws IndexOutOfBoundsException {
905         window.addSurfaceUpdatedListener(index, l);
906     }
907
908     @Override
909     public final void surfaceUpdated(Object updater, NativeSurface ns, long when) {
910         window.surfaceUpdated(updater, ns, when);
911     }
912
913     @Override
914     public final long getWindowHandle() {
915         return window.getWindowHandle();
916
917     }
918
919     @Override
920     public final long getSurfaceHandle() {
921         return window.getSurfaceHandle();
922
923     }
924
925     @Override
926     public final AbstractGraphicsConfiguration getGraphicsConfiguration() {
927         return window.getGraphicsConfiguration();
928     }
929
930     @Override
931     public final long getDisplayHandle() {
932         return window.getDisplayHandle();
933     }
934
935     @Override
936     public final int  getScreenIndex() {
937         return window.getScreenIndex();
938     }
939
940     /**
941      * A most simple JOGL AWT test entry
942      */
943     public static void main(String args[]) {
944         final boolean forceES2;
945         final boolean forceES3;
946         final boolean forceGL3;
947         final boolean forceGL4ES3;
948         {
949             boolean _forceES2 = false;
950             boolean _forceES3 = false;
951             boolean _forceGL3 = false;
952             boolean _forceGL4ES3 = false;
953             if( null != args ) {
954                 for(int i=0; i<args.length; i++) {
955                     if(args[i].equals("-es2")) {
956                         _forceES2 = true;
957                     } else if(args[i].equals("-es3")) {
958                         _forceES3 = true;
959                     } else if(args[i].equals("-gl3")) {
960                         _forceGL3 = true;
961                     } else if(args[i].equals("-gl4es3")) {
962                         _forceGL4ES3 = true;
963                     }
964                 }
965             }
966             forceES2 = _forceES2;
967             forceES3 = _forceES3;
968             forceGL3 = _forceGL3;
969             forceGL4ES3 = _forceGL4ES3;
970         }
971         System.err.println("forceES2    "+forceES2);
972         System.err.println("forceES3    "+forceES3);
973         System.err.println("forceGL3    "+forceGL3);
974         System.err.println("forceGL4ES3 "+forceGL4ES3);
975
976         System.err.println(VersionUtil.getPlatformInfo());
977         System.err.println(GlueGenVersion.getInstance());
978         System.err.println(JoglVersion.getInstance());
979
980         System.err.println(JoglVersion.getDefaultOpenGLInfo(null, null, true).toString());
981
982         final GLProfile glp;
983         if(forceGL4ES3) {
984             glp = GLProfile.get(GLProfile.GL4ES3);
985         } else if(forceGL3) {
986             glp = GLProfile.get(GLProfile.GL3);
987         } else if(forceES3) {
988             glp = GLProfile.get(GLProfile.GLES3);
989         } else if(forceES2) {
990             glp = GLProfile.get(GLProfile.GLES2);
991         } else {
992             glp = GLProfile.getDefault();
993         }
994         final GLCapabilitiesImmutable caps = new GLCapabilities( glp );
995         System.err.println("Requesting: "+caps);
996
997         GLWindow glWindow = GLWindow.create(caps);
998         glWindow.setSize(128, 128);
999
1000         glWindow.addGLEventListener(new GLEventListener() {
1001             @Override
1002             public void init(GLAutoDrawable drawable) {
1003                 GL gl = drawable.getGL();
1004                 System.err.println(JoglVersion.getGLInfo(gl, null));
1005                 System.err.println("Requested: "+drawable.getNativeSurface().getGraphicsConfiguration().getRequestedCapabilities());
1006                 System.err.println("Chosen   : "+drawable.getChosenGLCapabilities());
1007                 System.err.println("GL impl. class "+gl.getClass().getName());
1008                 if( gl.isGL4ES3() ) {
1009                     GL4ES3 _gl = gl.getGL4ES3();
1010                     System.err.println("GL4ES3 retrieved, impl. class "+_gl.getClass().getName());
1011                 }
1012                 if( gl.isGL3() ) {
1013                     GL3 _gl = gl.getGL3();
1014                     System.err.println("GL3 retrieved, impl. class "+_gl.getClass().getName());
1015                 }
1016                 if( gl.isGLES3() ) {
1017                     GLES3 _gl = gl.getGLES3();
1018                     System.err.println("GLES3 retrieved, impl. class "+_gl.getClass().getName());
1019                 }
1020                 if( gl.isGLES2() ) {
1021                     GLES2 _gl = gl.getGLES2();
1022                     System.err.println("GLES2 retrieved, impl. class "+_gl.getClass().getName());
1023                 }
1024             }
1025
1026             @Override
1027             public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
1028             }
1029
1030             @Override
1031             public void display(GLAutoDrawable drawable) {
1032             }
1033
1034             @Override
1035             public void dispose(GLAutoDrawable drawable) {
1036             }
1037         });
1038
1039         glWindow.setVisible(true);
1040         glWindow.destroy();
1041     }
1042 }
http://JogAmp.org git info: FAQ, tutorial and man pages.