diff options
Diffstat (limited to 'src')
44 files changed, 1834 insertions, 542 deletions
diff --git a/src/classes/com/sun/javafx/audio/windows/waveout/TestSpatialization.java b/src/classes/com/sun/javafx/audio/windows/waveout/TestSpatialization.java index e4ade6375..2040c55d1 100755 --- a/src/classes/com/sun/javafx/audio/windows/waveout/TestSpatialization.java +++ b/src/classes/com/sun/javafx/audio/windows/waveout/TestSpatialization.java @@ -44,7 +44,9 @@ public class TestSpatialization { try { // FIXME: this is a hack to get the native library loaded - GLDrawableFactory.getFactory(); + try { + GLDrawableFactory.getFactory(GLDrawableFactory.PROFILE_GLES1, null); + } catch (Exception e) {} // Initialize the audio subsystem Audio audio = Audio.getInstance(); // Create a track diff --git a/src/classes/com/sun/javafx/newt/Display.java b/src/classes/com/sun/javafx/newt/Display.java index 7be9a1b12..5ec2c381a 100755 --- a/src/classes/com/sun/javafx/newt/Display.java +++ b/src/classes/com/sun/javafx/newt/Display.java @@ -33,16 +33,33 @@ package com.sun.javafx.newt; -public class Display { +public abstract class Display { - public Display() { - this(null); + protected static Display create(String type, String name) { + try { + Class displayClass = null; + if (NewtFactory.KD.equals(type)) { + displayClass = Class.forName("com.sun.javafx.newt.kd.KDDisplay"); + } else if (NewtFactory.WINDOWS.equals(type)) { + displayClass = Class.forName("com.sun.javafx.newt.displays.WindowsDisplay"); + } else if (NewtFactory.X11.equals(type)) { + displayClass = Class.forName("com.sun.javafx.newt.x11.X11Display"); + } else if (NewtFactory.MACOSX.equals(type)) { + displayClass = Class.forName("com.sun.javafx.newt.macosx.MacOSXDisplay"); + } else { + throw new RuntimeException("Unknown display type \"" + type + "\""); + } + Display display = (Display) displayClass.newInstance(); + display.name=name; + display.handle=0; + display.initNative(); + return display; + } catch (Exception e) { + throw new RuntimeException(e); + } } - public Display(String name) { - this.name=name; - this.handle=-1; - } + protected abstract void initNative(); public String getName() { return name; @@ -52,17 +69,6 @@ public class Display { return handle; } - /** - * native handle - * - * write once .. - */ - public void setHandle(long handle) { - if(this.handle<0) { - this.handle=handle; - } - } - protected String name; protected long handle; } diff --git a/src/classes/com/sun/javafx/newt/NewtFactory.java b/src/classes/com/sun/javafx/newt/NewtFactory.java new file mode 100755 index 000000000..e0281eafa --- /dev/null +++ b/src/classes/com/sun/javafx/newt/NewtFactory.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2008 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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. + * + */ + +package com.sun.javafx.newt; + +import java.util.ArrayList; +import java.util.Iterator; + +public abstract class NewtFactory { + /** OpenKODE window type */ + public static final String KD = "KD"; + + /** Microsoft Windows window type */ + public static final String WINDOWS = "Windows"; + + /** X11 window type */ + public static final String X11 = "X11"; + + /** Mac OS X window type */ + public static final String MACOSX = "MacOSX"; + + /** Creates a Window of the default type for the current operating system. */ + public static String getWindowType() { + String osName = System.getProperty("os.name"); + String osNameLowerCase = osName.toLowerCase(); + String windowType; + if (osNameLowerCase.startsWith("wind")) { + windowType = WINDOWS; + } else if (osNameLowerCase.startsWith("mac os x")) { + windowType = MACOSX; + } else { + windowType = X11; + } + return windowType; + } + + public static Display createDisplay(String name) { + return Display.create(getWindowType(), name); + } + + public static Screen createScreen(Display display, int index) { + return Screen.create(getWindowType(), display, index); + } + + public static Window createWindow(Screen screen, long visualID) { + return Window.create(getWindowType(), screen, visualID); + } + +} + diff --git a/src/classes/com/sun/javafx/newt/Screen.java b/src/classes/com/sun/javafx/newt/Screen.java index b698a0248..9252b30d4 100755 --- a/src/classes/com/sun/javafx/newt/Screen.java +++ b/src/classes/com/sun/javafx/newt/Screen.java @@ -33,17 +33,34 @@ package com.sun.javafx.newt; -public class Screen { +public abstract class Screen { - public Screen(Display display) { - this(display, 0); + protected static Screen create(String type, Display display, int idx) { + try { + Class screenClass = null; + if (NewtFactory.KD.equals(type)) { + screenClass = Class.forName("com.sun.javafx.newt.kd.KDScreen"); + } else if (NewtFactory.WINDOWS.equals(type)) { + screenClass = Class.forName("com.sun.javafx.newt.screens.WindowsScreen"); + } else if (NewtFactory.X11.equals(type)) { + screenClass = Class.forName("com.sun.javafx.newt.x11.X11Screen"); + } else if (NewtFactory.MACOSX.equals(type)) { + screenClass = Class.forName("com.sun.javafx.newt.macosx.MacOSXScreen"); + } else { + throw new RuntimeException("Unknown window type \"" + type + "\""); + } + Screen screen = (Screen) screenClass.newInstance(); + screen.display = display; + screen.index = idx; + screen.handle = 0; + screen.initNative(); + return screen; + } catch (Exception e) { + throw new RuntimeException(e); + } } - public Screen(Display display, int idx) { - this.display=display; - this.index=idx; - this.handle=-1; - } + protected abstract void initNative(); public Display getDisplay() { return display; @@ -57,17 +74,6 @@ public class Screen { return handle; } - /** - * native handle - * - * write once .. - */ - public void setHandle(long handle) { - if(this.handle<0) { - this.handle=handle; - } - } - protected Display display; protected int index; protected long handle; diff --git a/src/classes/com/sun/javafx/newt/Window.java b/src/classes/com/sun/javafx/newt/Window.java index 27610cdf2..16984d1f3 100755 --- a/src/classes/com/sun/javafx/newt/Window.java +++ b/src/classes/com/sun/javafx/newt/Window.java @@ -33,101 +33,120 @@ package com.sun.javafx.newt; +import javax.media.opengl.NativeWindow; +import javax.media.opengl.NativeWindowException; + import java.util.ArrayList; import java.util.Iterator; -public abstract class Window { +public abstract class Window implements NativeWindow +{ public static final boolean DEBUG_MOUSE_EVENT = false; public static final boolean DEBUG_KEY_EVENT = false; + public static final boolean DEBUG_IMPLEMENTATION = true; - /** OpenKODE window type */ - public static final String KD = "KD"; - - /** Microsoft Windows window type */ - public static final String WINDOWS = "Windows"; - - /** X11 window type */ - public static final String X11 = "X11"; - - /** Mac OS X window type */ - public static final String MACOSX = "MacOSX"; - - /** Creates a Window of the default type for the current operating system. */ - public static Window create(Screen screen, long visualID) { - String osName = System.getProperty("os.name"); - String osNameLowerCase = osName.toLowerCase(); - String windowType; - if (osNameLowerCase.startsWith("wind")) { - windowType = WINDOWS; - } else if (osNameLowerCase.startsWith("mac os x")) { - windowType = MACOSX; - } else { - windowType = X11; - } - Window window = create(windowType); - window.initNative(screen, visualID); - return window; - } - - - public static Window create(String type) { + protected static Window create(String type, Screen screen, long visualID) { try { Class windowClass = null; - if (KD.equals(type)) { + if (NewtFactory.KD.equals(type)) { windowClass = Class.forName("com.sun.javafx.newt.kd.KDWindow"); - } else if (WINDOWS.equals(type)) { + } else if (NewtFactory.WINDOWS.equals(type)) { windowClass = Class.forName("com.sun.javafx.newt.windows.WindowsWindow"); - } else if (X11.equals(type)) { + } else if (NewtFactory.X11.equals(type)) { windowClass = Class.forName("com.sun.javafx.newt.x11.X11Window"); - } else if (MACOSX.equals(type)) { + } else if (NewtFactory.MACOSX.equals(type)) { windowClass = Class.forName("com.sun.javafx.newt.macosx.MacOSXWindow"); } else { throw new RuntimeException("Unknown window type \"" + type + "\""); } - return (Window) windowClass.newInstance(); + Window window = (Window) windowClass.newInstance(); + window.screen = screen; + window.visualID = visualID; + window.windowHandle = 0; + window.locked = false; + window.initNative(); + return window; } catch (Exception e) { throw new RuntimeException(e); } } + protected abstract void initNative(); - /** - * [ display, screen, window ] - */ - public long[] getHandles() { - long[] handles = new long[3]; - handles[0] = getScreen().getDisplay().getHandle(); - handles[1] = getScreen().getHandle(); - handles[2] = getWindowHandle(); - return handles; + public Screen getScreen() { + return screen; } - protected abstract void initNative(Screen screen, long visualID); - - public abstract void setVisible(boolean visible); - public abstract void setSize(int width, int height); - public abstract void setPosition(int x, int y); - public abstract boolean isVisible(); - public abstract int getWidth(); - public abstract int getHeight(); - public abstract int getX(); - public abstract int getY(); - public abstract boolean setFullscreen(boolean fullscreen); - public abstract boolean isFullscreen(); public abstract int getDisplayWidth(); public abstract int getDisplayHeight(); - public abstract Screen getScreen(); - public abstract long getWindowHandle(); - public abstract void pumpMessages(); public String toString() { - return "Window[handle "+getWindowHandle()+ + return "Window[handle "+windowHandle+ ", pos "+getX()+"/"+getY()+", size "+getWidth()+"x"+getHeight()+ ", visible "+isVisible()+"]"; } + protected Screen screen; + protected long visualID; + protected long windowHandle; + protected boolean locked; + + // + // NativeWindow impl + // + + public boolean lockSurface() throws NativeWindowException { + if (locked) { + throw new NativeWindowException("Surface already locked"); + } + locked = true; + return true; + } + + public void unlockSurface() { + if (!locked) { + throw new NativeWindowException("Surface already locked"); + } + locked = false; + } + + public boolean isSurfaceLocked() { + return locked; + } + + public long getDisplayHandle() { + return screen.getDisplay().getHandle(); + } + + public long getScreenHandle() { + return screen.getHandle(); + } + + public int getScreenIndex() { + return screen.getIndex(); + } + + public long getWindowHandle() { + return windowHandle; + } + + public long getVisualID() { + return visualID; + } + + public abstract int getWidth(); + public abstract int getHeight(); + public abstract int getX(); + public abstract int getY(); + public abstract void setVisible(boolean visible); + public abstract void setSize(int width, int height); + public abstract void setPosition(int x, int y); + public abstract boolean isVisible(); + public abstract boolean setFullscreen(boolean fullscreen); + public abstract boolean isFullscreen(); + // // MouseListener Support // diff --git a/src/classes/com/sun/javafx/newt/windows/WindowsDisplay.java b/src/classes/com/sun/javafx/newt/windows/WindowsDisplay.java new file mode 100755 index 000000000..ce2ac8c4a --- /dev/null +++ b/src/classes/com/sun/javafx/newt/windows/WindowsDisplay.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2008 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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. + * + */ + +package com.sun.javafx.newt.windows; + +import com.sun.javafx.newt.*; +import com.sun.opengl.impl.*; + +public class WindowsDisplay extends Display { + public WindowsDisplay() { + } + + public void initNative() { + handle = 0; + } +} diff --git a/src/classes/com/sun/javafx/newt/windows/WindowsScreen.java b/src/classes/com/sun/javafx/newt/windows/WindowsScreen.java new file mode 100755 index 000000000..cf163ce48 --- /dev/null +++ b/src/classes/com/sun/javafx/newt/windows/WindowsScreen.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2008 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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. + * + */ + +package com.sun.javafx.newt.windows; + +import com.sun.javafx.newt.*; +import com.sun.opengl.impl.*; + +public class WindowsScreen extends Screen { + public WindowsScreen() { + } + + public void initNative() { + handle = 0; + } +} diff --git a/src/classes/com/sun/javafx/newt/windows/WindowsWindow.java b/src/classes/com/sun/javafx/newt/windows/WindowsWindow.java index e170f9b56..c392cb20e 100755 --- a/src/classes/com/sun/javafx/newt/windows/WindowsWindow.java +++ b/src/classes/com/sun/javafx/newt/windows/WindowsWindow.java @@ -59,22 +59,14 @@ public class WindowsWindow extends Window { public WindowsWindow() { } - public void initNative(Screen screen, long visualID) { - this.screen = screen; - this.visualID = visualID; + public void initNative() { long wndClass = getWindowClass(); fullscreen=false; visible=false; - window = CreateWindow(WINDOW_CLASS_NAME, getHInstance(), visualID, x, y, width, height); - if (window == 0) { + windowHandle = CreateWindow(WINDOW_CLASS_NAME, getHInstance(), visualID, x, y, width, height); + if (windowHandle == 0) { throw new RuntimeException("Error creating window"); } - screen.setHandle(0); // dummy - screen.getDisplay().setHandle(0); // dummy - } - - public Screen getScreen() { - return screen; } public void setVisible(boolean visible) { @@ -131,10 +123,6 @@ public class WindowsWindow extends Window { return 480; // FIXME } - public long getWindowHandle() { - return window; - } - public void pumpMessages() { DispatchMessages(window); } @@ -175,12 +163,6 @@ public class WindowsWindow extends Window { private native void setSize0(long window, int width, int height); private native boolean setFullScreen0(long window, boolean fullscreen); - private void keyDown(long key) { - } - - private void keyUp(long key) { - } - private void sizeChanged(int newWidth, int newHeight) { width = newWidth; height = newHeight; diff --git a/src/classes/com/sun/javafx/newt/x11/X11Display.java b/src/classes/com/sun/javafx/newt/x11/X11Display.java new file mode 100755 index 000000000..5a4ed8eed --- /dev/null +++ b/src/classes/com/sun/javafx/newt/x11/X11Display.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2008 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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. + * + */ + +package com.sun.javafx.newt.x11; + +import com.sun.javafx.newt.*; +import com.sun.opengl.impl.*; + +public class X11Display extends Display { + static { + NativeLibLoader.loadCore(); + } + + public X11Display() { + } + + public void initNative() { + handle = CreateDisplay(name); + if (handle == 0 ) { + throw new RuntimeException("Error creating display: "+name); + } + } + + //---------------------------------------------------------------------- + // Internals only + // + + private native long CreateDisplay(String name); +} diff --git a/src/classes/com/sun/javafx/newt/x11/X11Screen.java b/src/classes/com/sun/javafx/newt/x11/X11Screen.java new file mode 100755 index 000000000..279507fab --- /dev/null +++ b/src/classes/com/sun/javafx/newt/x11/X11Screen.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2008 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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. + * + */ + +package com.sun.javafx.newt.x11; + +import com.sun.javafx.newt.*; +import com.sun.opengl.impl.*; + +public class X11Screen extends Screen { + static { + NativeLibLoader.loadCore(); + } + + public X11Screen() { + } + + public void initNative() { + handle = GetScreen(display.getHandle(), index); + if (handle == 0 ) { + throw new RuntimeException("Error creating screen: "+index); + } + } + + //---------------------------------------------------------------------- + // Internals only + // + + private native long GetScreen(long dpy, int scrn_idx); +} diff --git a/src/classes/com/sun/javafx/newt/x11/X11Window.java b/src/classes/com/sun/javafx/newt/x11/X11Window.java index 80021dca4..d89cd1169 100755 --- a/src/classes/com/sun/javafx/newt/x11/X11Window.java +++ b/src/classes/com/sun/javafx/newt/x11/X11Window.java @@ -37,10 +37,6 @@ import com.sun.javafx.newt.*; import com.sun.opengl.impl.*; public class X11Window extends Window { - private Screen screen; - private long visualID; - private long dpy, scrn, window; - private int scrn_idx; private static final String WINDOW_CLASS_NAME = "NewtWindow"; // Default width and height -- will likely be re-set immediately by user private int width = 100; @@ -62,36 +58,28 @@ public class X11Window extends Window { public X11Window() { } - public void initNative(Screen screen, long visualID) { - this.screen = screen; - this.visualID = visualID; + public void initNative() { fullscreen=false; visible=false; - long w = CreateWindow(visualID, x, y, width, height); - if (w == 0 || w!=window) { + long w = CreateWindow(getDisplayHandle(), getScreenHandle(), getScreenIndex(), visualID, x, y, width, height); + if (w == 0 || w!=windowHandle) { throw new RuntimeException("Error creating window: "+w); } - screen.setHandle(scrn); - screen.getDisplay().setHandle(dpy); - } - - public Screen getScreen() { - return screen; } public void setVisible(boolean visible) { if(this.visible!=visible) { this.visible=visible; - setVisible0(dpy, window, visible); + setVisible0(getDisplayHandle(), windowHandle, visible); } } public void setSize(int width, int height) { - setSize0(dpy, window, width, height); + setSize0(getDisplayHandle(), windowHandle, width, height); } public void setPosition(int x, int y) { - setPosition0(dpy, window, x, y); + setPosition0(getDisplayHandle(), windowHandle, x, y); } public boolean isVisible() { @@ -120,16 +108,16 @@ public class X11Window extends Window { this.fullscreen=fullscreen; if(this.fullscreen) { x = 0; y = 0; - w = getDisplayWidth0(dpy, scrn_idx)/2; - h = getDisplayHeight0(dpy, scrn_idx)/2; + w = getDisplayWidth0(getDisplayHandle(), getScreenIndex())/2; + h = getDisplayHeight0(getDisplayHandle(), getScreenIndex())/2; } else { x = nfs_x; y = nfs_y; w = nfs_width; h = nfs_height; } - setPosition0(dpy, window, x, y); - setSize0(dpy, window, w, h); + setPosition0(getDisplayHandle(), windowHandle, x, y); + setSize0(getDisplayHandle(), windowHandle, w, h); } return true; } @@ -138,20 +126,16 @@ public class X11Window extends Window { return fullscreen; } - public long getWindowHandle() { - return window; - } - public void pumpMessages() { - DispatchMessages(dpy, window); + DispatchMessages(getDisplayHandle(), windowHandle); } public int getDisplayWidth() { - return getDisplayWidth0(dpy, scrn_idx); + return getDisplayWidth0(getDisplayHandle(), getScreenIndex()); } public int getDisplayHeight() { - return getDisplayHeight0(dpy, scrn_idx); + return getDisplayHeight0(getDisplayHandle(), getScreenIndex()); } //---------------------------------------------------------------------- @@ -159,11 +143,12 @@ public class X11Window extends Window { // private static native boolean initIDs(); - private native long CreateWindow(long visualID, int x, int y, int width, int height); - private native void setVisible0(long display, long window, boolean visible); - private native void DispatchMessages(long display, long window); - private native void setSize0(long display, long window, int width, int height); - private native void setPosition0(long display, long window, int x, int y); + private native long CreateWindow(long display, long screen, int screen_index, + long visualID, int x, int y, int width, int height); + private native void setVisible0(long display, long windowHandle, boolean visible); + private native void DispatchMessages(long display, long windowHandle); + private native void setSize0(long display, long windowHandle, int width, int height); + private native void setPosition0(long display, long windowHandle, int x, int y); private native int getDisplayWidth0(long display, int scrn_idx); private native int getDisplayHeight0(long display, int scrn_idx); @@ -185,11 +170,9 @@ public class X11Window extends Window { } } - private void windowCreated(long dpy, int scrn_idx, long scrn, long window) { - this.dpy = dpy; - this.scrn_idx = scrn_idx; - this.scrn = scrn; - this.window = window; + private void windowCreated(long visualID, long windowHandle) { + this.visualID = visualID; + this.windowHandle = windowHandle; } private void windowClosed() { diff --git a/src/classes/com/sun/opengl/impl/GLContextImpl.java b/src/classes/com/sun/opengl/impl/GLContextImpl.java index 17169ebf2..eb9cf0e55 100644 --- a/src/classes/com/sun/opengl/impl/GLContextImpl.java +++ b/src/classes/com/sun/opengl/impl/GLContextImpl.java @@ -326,7 +326,7 @@ public abstract class GLContextImpl extends GLContext { /** Helper routine which resets a ProcAddressTable generated by the GLEmitter by looking up anew all of its function pointers. */ protected void resetProcAddressTable(Object table) { - ProcAddressHelper.resetProcAddressTable(table, GLDrawableFactoryImpl.getFactoryImpl()); + ProcAddressHelper.resetProcAddressTable(table, (GLDrawableFactoryImpl)getGLDrawable().getFactory()); } /** Indicates whether the underlying OpenGL context has been diff --git a/src/classes/com/sun/opengl/impl/GLDrawableFactoryImpl.java b/src/classes/com/sun/opengl/impl/GLDrawableFactoryImpl.java index d0e9118ea..20616f34d 100644 --- a/src/classes/com/sun/opengl/impl/GLDrawableFactoryImpl.java +++ b/src/classes/com/sun/opengl/impl/GLDrawableFactoryImpl.java @@ -72,10 +72,6 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory implements super(profile); } - public static GLDrawableFactoryImpl getFactoryImpl() { - return (GLDrawableFactoryImpl) getFactory(); - } - // Helper function for more lazily loading the GLU library; // apparently can't use System.loadLibrary on UNIX because it uses // RTLD_LOCAL and we need to call dlsym(RTLD_DEFAULT) diff --git a/src/classes/com/sun/opengl/impl/GLDrawableImpl.java b/src/classes/com/sun/opengl/impl/GLDrawableImpl.java index df1aab796..690bfd88c 100644 --- a/src/classes/com/sun/opengl/impl/GLDrawableImpl.java +++ b/src/classes/com/sun/opengl/impl/GLDrawableImpl.java @@ -42,6 +42,8 @@ package com.sun.opengl.impl; import javax.media.opengl.*; public abstract class GLDrawableImpl implements GLDrawable { + protected GLDrawableFactory factory; + protected NativeWindow component; private GLCapabilities chosenCapabilities; /** For offscreen GLDrawables (pbuffers and "pixmap" drawables), @@ -63,4 +65,16 @@ public abstract class GLDrawableImpl implements GLDrawable { public void setChosenGLCapabilities(GLCapabilities caps) { chosenCapabilities = caps; } + + public NativeWindow getNativeWindow() { + return component; + } + + public GLDrawableFactory getFactory() { + return factory; + } + + public String getProfile() { + return factory.getProfile(); + } } diff --git a/src/classes/com/sun/opengl/impl/NativeLibLoader.java b/src/classes/com/sun/opengl/impl/NativeLibLoader.java index ffe8df3e2..aaf782296 100644 --- a/src/classes/com/sun/opengl/impl/NativeLibLoader.java +++ b/src/classes/com/sun/opengl/impl/NativeLibLoader.java @@ -115,29 +115,6 @@ public class NativeLibLoader { }); } - /* FIXME: refactor Java SE dependencies - public static void loadAWTImpl() { - AccessController.doPrivileged(new PrivilegedAction() { - public Object run() { - // Make sure that awt.dll is loaded before loading jawt.dll. Otherwise - // a Dialog with "awt.dll not found" might pop up. - // See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4481947. - Toolkit.getDefaultToolkit(); - - // Must pre-load JAWT on all non-Mac platforms to - // ensure references from jogl_awt shared object - // will succeed since JAWT shared object isn't in - // default library path - boolean isOSX = System.getProperty("os.name").equals("Mac OS X"); - String[] preload = { "jawt" }; - - loadLibrary("jogl_awt", preload, !isOSX, false); - return null; - } - }); - } - */ - public static void loadCgImpl() { AccessController.doPrivileged(new PrivilegedAction() { public Object run() { diff --git a/src/classes/com/sun/opengl/impl/awt/AWTNativeLibLoader.java b/src/classes/com/sun/opengl/impl/awt/AWTNativeLibLoader.java new file mode 100644 index 000000000..5e39c445f --- /dev/null +++ b/src/classes/com/sun/opengl/impl/awt/AWTNativeLibLoader.java @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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.sun.opengl.impl.awt; + +import com.sun.opengl.impl.*; + +import java.awt.Toolkit; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.security.AccessController; +import java.security.PrivilegedAction; + +public class AWTNativeLibLoader extends NativeLibLoader { + public static void loadAWTImpl() { + AccessController.doPrivileged(new PrivilegedAction() { + public Object run() { + // Make sure that awt.dll is loaded before loading jawt.dll. Otherwise + // a Dialog with "awt.dll not found" might pop up. + // See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4481947. + Toolkit.getDefaultToolkit(); + + // Must pre-load JAWT on all non-Mac platforms to + // ensure references from jogl_awt shared object + // will succeed since JAWT shared object isn't in + // default library path + boolean isOSX = System.getProperty("os.name").equals("Mac OS X"); + String[] preload = { "jawt" }; + + loadLibrary("jogl_awt", preload, !isOSX, false); + return null; + } + }); + } +} diff --git a/src/classes/com/sun/opengl/impl/awt/JAWTWindow.java b/src/classes/com/sun/opengl/impl/awt/JAWTWindow.java new file mode 100644 index 000000000..068088f71 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/awt/JAWTWindow.java @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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.sun.opengl.impl.awt; + +import com.sun.opengl.impl.*; + +import java.awt.Component; +import javax.media.opengl.*; +import com.sun.opengl.impl.*; + +public abstract class JAWTWindow implements NativeWindow { + protected static final boolean DEBUG = Debug.debug("GLDrawable"); + + // lifetime: forever + protected Component component; + protected boolean locked; + + // lifetime: valid while locked + protected long display; + protected long screen; + protected long drawable; + // lifetime: valid after lock, forever + protected long visualID; + protected int screenIndex; + + public JAWTWindow(Object comp) { + init(comp); + } + + protected void init(Object windowObject) throws NativeWindowException { + this.locked = false; + this.component = (Component)comp; + this.display= null; + this.screen= null; + this.screenIndex = -1; + this.drawable= null; + this.visualID = 0; + initNative(); + } + + public abstract boolean initNative() throws NativeWindowException; + + public boolean lockSurface() throws NativeWindowException { + if (locked) { + throw new NativeWindowException("Surface already locked"); + } + locked = true; + } + + public void unlockSurface() { + if (!locked) { + throw new NativeWindowException("Surface already locked"); + } + locked = false; + display= null; + screen= null; + drawable= null; + } + + public boolean isSurfaceLocked() { + return locked; + } + + public long getDisplayHandle() { + return display; + } + public long getScreenHandle() { + return screen; + } + public int getScreenIndex() { + return screenIndex; + } + public long getWindowHandle() { + return drawable; + } + public long getVisualID() { + return visualID; + } + + public void setSize(int width, int height) { + component.setSize(width, height); + } + + public int getWidth() { + return component.getWidth(); + } + + public int getHeight() { + return component.getHeight(); + } + + public int getX() { + return component.getX(); + } + public int getY() { + return component.getY(); + } + + public void setPosition(int x, int y) { + component.setLocation(x,y); + } + + public void setVisible(boolean visible) { + component.setVisible(visible); + } + + public boolean isVisible() { + return component.isVisible(); + } + + public boolean setFullscreen(boolean fullscreen) { + return false; // FIXME + } + + public boolean isFullscreen() { + return false; // FIXME + } + +} diff --git a/src/classes/com/sun/opengl/impl/JAWT_PlatformInfo.java b/src/classes/com/sun/opengl/impl/awt/JAWT_PlatformInfo.java index ca101eff9..cd80c1be9 100644 --- a/src/classes/com/sun/opengl/impl/JAWT_PlatformInfo.java +++ b/src/classes/com/sun/opengl/impl/awt/JAWT_PlatformInfo.java @@ -37,7 +37,9 @@ * and developed by Kenneth Bradley Russell and Christopher John Kline. */ -package com.sun.opengl.impl; +package com.sun.opengl.impl.awt; + +import com.sun.opengl.impl.*; /** Marker class for all window system-specific JAWT data structures. */ diff --git a/src/classes/com/sun/opengl/impl/Java2D.java b/src/classes/com/sun/opengl/impl/awt/Java2D.java index 713effa67..ed0a80f00 100755 --- a/src/classes/com/sun/opengl/impl/Java2D.java +++ b/src/classes/com/sun/opengl/impl/awt/Java2D.java @@ -37,7 +37,9 @@ * and developed by Kenneth Bradley Russell and Christopher John Kline. */ -package com.sun.opengl.impl; +package com.sun.opengl.impl.awt; + +import com.sun.opengl.impl.*; import java.awt.*; import java.awt.image.*; diff --git a/src/classes/com/sun/opengl/impl/Java2DGLContext.java b/src/classes/com/sun/opengl/impl/awt/Java2DGLContext.java index 86bcb6482..48461c116 100644 --- a/src/classes/com/sun/opengl/impl/Java2DGLContext.java +++ b/src/classes/com/sun/opengl/impl/awt/Java2DGLContext.java @@ -37,8 +37,9 @@ * and developed by Kenneth Bradley Russell and Christopher John Kline. */ -package com.sun.opengl.impl; +package com.sun.opengl.impl.awt; +import com.sun.opengl.impl.*; import java.awt.Graphics; /** Provides a construct by which the shared GLJPanel code can @@ -48,4 +49,4 @@ import java.awt.Graphics; public interface Java2DGLContext { public void setGraphics(Graphics g); -}
\ No newline at end of file +} diff --git a/src/classes/com/sun/opengl/impl/egl/EGLContext.java b/src/classes/com/sun/opengl/impl/egl/EGLContext.java index 25ac2c726..ab0fbb304 100755 --- a/src/classes/com/sun/opengl/impl/egl/EGLContext.java +++ b/src/classes/com/sun/opengl/impl/egl/EGLContext.java @@ -122,7 +122,7 @@ public class EGLContext extends GLContextImpl { } } - EGLDrawableFactory factory = (EGLDrawableFactory) GLDrawableFactory.getFactory(); + EGLDrawableFactory factory = (EGLDrawableFactory) drawable.getFactory(); boolean isGLES2 = EGLDrawableFactory.PROFILE_GLES2.equals(factory.getProfile()); int[] contextAttrs = null; // FIXME: need to determine whether to specify the context diff --git a/src/classes/com/sun/opengl/impl/egl/EGLDrawable.java b/src/classes/com/sun/opengl/impl/egl/EGLDrawable.java index 8ac790157..0227ba32f 100755 --- a/src/classes/com/sun/opengl/impl/egl/EGLDrawable.java +++ b/src/classes/com/sun/opengl/impl/egl/EGLDrawable.java @@ -35,12 +35,11 @@ package com.sun.opengl.impl.egl; +import com.sun.opengl.impl.GLDrawableImpl; + import javax.media.opengl.*; -public class EGLDrawable implements GLDrawable { - private long windowHandle; - private long screenHandle; - private long displayHandle; +public class EGLDrawable extends GLDrawableImpl { private long display; private GLCapabilities capabilities; private GLCapabilitiesChooser chooser; @@ -48,21 +47,16 @@ public class EGLDrawable implements GLDrawable { private long surface; private int[] tmp = new int[1]; - public EGLDrawable(long displayHandle, - long screenHandle, - long windowHandle, + public EGLDrawable(EGLDrawableFactory factory, + NativeWindow component, GLCapabilities capabilities, GLCapabilitiesChooser chooser) throws GLException { - this.displayHandle = displayHandle; - this.screenHandle = screenHandle; - this.windowHandle = windowHandle; + this.factory = factory; + this.component = component; this.capabilities = capabilities; this.chooser = chooser; - // Set things up - EGLDrawableFactory factory = (EGLDrawableFactory) GLDrawableFactory.getFactory(); - - display = EGL.eglGetDisplay((displayHandle>0)?displayHandle:EGL.EGL_DEFAULT_DISPLAY); + display = EGL.eglGetDisplay((component.getDisplayHandle()>0)?component.getDisplayHandle():EGL.EGL_DEFAULT_DISPLAY); if (display == EGL.EGL_NO_DISPLAY) { throw new GLException("eglGetDisplay failed"); } @@ -108,7 +102,7 @@ public class EGLDrawable implements GLDrawable { public void setRealized(boolean realized) { if (realized) { // Create the window surface - surface = EGL.eglCreateWindowSurface(display, config, windowHandle, null); + surface = EGL.eglCreateWindowSurface(display, config, component.getWindowHandle(), null); if (surface == EGL.EGL_NO_SURFACE) { throw new GLException("Creation of window surface (eglCreateWindowSurface) failed"); } @@ -153,9 +147,9 @@ public class EGLDrawable implements GLDrawable { } public String toString() { - return "EGLDrawable[ displayHandle " + displayHandle + - ", screenHandle "+ screenHandle + - ", windowHandle "+ windowHandle + + return "EGLDrawable[ displayHandle " + component.getDisplayHandle() + + ", screenHandle "+ component.getScreenHandle() + + ", windowHandle "+ component.getWindowHandle() + ", display " + display + ", config " + config + ", surface " + surface + diff --git a/src/classes/com/sun/opengl/impl/egl/EGLDrawableFactory.java b/src/classes/com/sun/opengl/impl/egl/EGLDrawableFactory.java index 516f6d5a9..bd0f83a3c 100755 --- a/src/classes/com/sun/opengl/impl/egl/EGLDrawableFactory.java +++ b/src/classes/com/sun/opengl/impl/egl/EGLDrawableFactory.java @@ -102,17 +102,10 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { return null; } - public GLDrawable getGLDrawable(Object target, + public GLDrawable createGLDrawable(NativeWindow target, GLCapabilities capabilities, GLCapabilitiesChooser chooser) { - if( !(target instanceof long[]) ) { - throw new GLException("target is not instanceof long[]"); - } - long[] targetHandles = (long[])target; - if(targetHandles.length!=3) { - throw new GLException("target handle array != 3 [display, screen, window]"); - } - return new EGLDrawable(targetHandles[0], targetHandles[1], targetHandles[2], + return new EGLDrawable(this, target, capabilities, chooser); } diff --git a/src/classes/com/sun/opengl/impl/macosx/awt/MacOSXJAWTWindow.java b/src/classes/com/sun/opengl/impl/macosx/awt/MacOSXJAWTWindow.java new file mode 100644 index 000000000..5f676a138 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/macosx/awt/MacOSXJAWTWindow.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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.sun.opengl.impl.macosx.awt; + +import com.sun.opengl.impl.macosx.*; +import com.sun.opengl.impl.awt.*; + +import javax.media.opengl.*; +import com.sun.opengl.impl.*; + +public class MacOSXJAWTWindow extends JAWTWindow { + + // Variables for lockSurface/unlockSurface + //private JAWT_DrawingSurface ds; + //private JAWT_DrawingSurfaceInfo dsi; + //private JAWT_MacOSXDrawingSurfaceInfo x11dsi; + + public MacOSXJAWTWindow(Object comp) { + super(comp); + } + + public int lockSurface() throws NativeWindowException { + super.lockSurface(); + return 0; + } + + public void unlockSurface() { + super.unlockSurface(); + } +} + diff --git a/src/classes/com/sun/opengl/impl/windows/WindowsGLDrawableFactory.java b/src/classes/com/sun/opengl/impl/windows/WindowsGLDrawableFactory.java index ddccfda4f..1ce39ed33 100644 --- a/src/classes/com/sun/opengl/impl/windows/WindowsGLDrawableFactory.java +++ b/src/classes/com/sun/opengl/impl/windows/WindowsGLDrawableFactory.java @@ -70,7 +70,7 @@ public class WindowsGLDrawableFactory extends GLDrawableFactoryImpl { return null; } - public GLDrawable getGLDrawable(Object target, + public GLDrawable createGLDrawable(NativeWindow target, GLCapabilities capabilities, GLCapabilitiesChooser chooser) { if (target == null) { @@ -86,7 +86,7 @@ public class WindowsGLDrawableFactory extends GLDrawableFactoryImpl { if (chooser == null) { chooser = new DefaultGLCapabilitiesChooser(); } - return new WindowsOnscreenGLDrawable((Component) target, capabilities, chooser); + return new WindowsOnscreenGLDrawable(getProfile(), target, capabilities, chooser); } public GLDrawableImpl createOffscreenDrawable(GLCapabilities capabilities, diff --git a/src/classes/com/sun/opengl/impl/windows/awt/WindowsJAWTWindow.java b/src/classes/com/sun/opengl/impl/windows/awt/WindowsJAWTWindow.java new file mode 100644 index 000000000..68ef2702b --- /dev/null +++ b/src/classes/com/sun/opengl/impl/windows/awt/WindowsJAWTWindow.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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.sun.opengl.impl.windows.awt; + +import com.sun.opengl.impl.windows.*; +import com.sun.opengl.impl.awt.*; + +import javax.media.opengl.*; +import com.sun.opengl.impl.*; + +public class WindowsJAWTWindow extends JAWTWindow { + + // Variables for lockSurface/unlockSurface + //private JAWT_DrawingSurface ds; + //private JAWT_DrawingSurfaceInfo dsi; + //private JAWT_WindowsDrawingSurfaceInfo x11dsi; + + public WindowsJAWTWindow(Object comp) { + super(comp); + } + + public int lockSurface() throws NativeWindowException { + super.lockSurface(); + return 0; + } + + public void unlockSurface() { + super.unlockSurface(); + } +} + diff --git a/src/classes/com/sun/opengl/impl/x11/X11GLDrawableFactory.java b/src/classes/com/sun/opengl/impl/x11/X11GLDrawableFactory.java index dcb9a0b37..1505e60d6 100644 --- a/src/classes/com/sun/opengl/impl/x11/X11GLDrawableFactory.java +++ b/src/classes/com/sun/opengl/impl/x11/X11GLDrawableFactory.java @@ -39,11 +39,6 @@ package com.sun.opengl.impl.x11; -import java.awt.Component; -import java.awt.Graphics; -import java.awt.GraphicsConfiguration; -import java.awt.GraphicsDevice; -import java.awt.GraphicsEnvironment; import java.nio.*; import java.security.*; import java.util.*; @@ -59,9 +54,6 @@ public class X11GLDrawableFactory extends GLDrawableFactoryImpl { // in this case private static boolean isVendorATI; - // See whether we're running in headless mode - private static boolean isHeadless; - // Map for rediscovering the GLCapabilities associated with a // particular screen and visualID after the fact private static Map visualToGLCapsMap = Collections.synchronizedMap(new HashMap()); @@ -101,8 +93,6 @@ public class X11GLDrawableFactory extends GLDrawableFactoryImpl { com.sun.opengl.impl.NativeLibLoader.loadCore(); DRIHack.end(); - - isHeadless = GraphicsEnvironment.isHeadless(); } public X11GLDrawableFactory(String profile) { @@ -117,134 +107,18 @@ public class X11GLDrawableFactory extends GLDrawableFactoryImpl { public AbstractGraphicsConfiguration chooseGraphicsConfiguration(GLCapabilities capabilities, GLCapabilitiesChooser chooser, AbstractGraphicsDevice absDevice) { - if (capabilities == null) { - capabilities = new GLCapabilities(); - } - if (chooser == null) { - chooser = new DefaultGLCapabilitiesChooser(); - } - GraphicsDevice device = null; - if (absDevice != null && - !(absDevice instanceof AWTGraphicsDevice)) { - throw new IllegalArgumentException("This GLDrawableFactory accepts only AWTGraphicsDevice objects"); - } - - if ((absDevice == null) || - (((AWTGraphicsDevice) absDevice).getGraphicsDevice() == null)) { - device = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); - } else { - device = ((AWTGraphicsDevice) absDevice).getGraphicsDevice(); - } - - int screen; - if (isXineramaEnabled()) { - screen = 0; - } else { - screen = X11SunJDKReflection.graphicsDeviceGetScreen(device); - } - - // Until we have a rock-solid visual selection algorithm written - // in pure Java, we're going to provide the underlying window - // system's selection to the chooser as a hint - - int[] attribs = glCapabilities2AttribList(capabilities, isMultisampleAvailable(), false, 0, 0); - XVisualInfo[] infos = null; - GLCapabilities[] caps = null; - int recommendedIndex = -1; - lockToolkit(); - try { - long display = getDisplayConnection(); - XVisualInfo recommendedVis = GLX.glXChooseVisual(display, screen, attribs, 0); - if (DEBUG) { - System.err.print("!!! glXChooseVisual recommended "); - if (recommendedVis == null) { - System.err.println("null visual"); - } else { - System.err.println("visual id 0x" + Long.toHexString(recommendedVis.visualid())); - } - } - int[] count = new int[1]; - XVisualInfo template = XVisualInfo.create(); - template.screen(screen); - infos = GLX.XGetVisualInfo(display, GLX.VisualScreenMask, template, count, 0); - if (infos == null) { - throw new GLException("Error while enumerating available XVisualInfos"); - } - caps = new GLCapabilities[infos.length]; - for (int i = 0; i < infos.length; i++) { - caps[i] = xvi2GLCapabilities(display, infos[i]); - // Attempt to find the visual chosen by glXChooseVisual - if (recommendedVis != null && recommendedVis.visualid() == infos[i].visualid()) { - recommendedIndex = i; - } - } - } finally { - unlockToolkit(); - } - // Store these away for later - for (int i = 0; i < infos.length; i++) { - if (caps[i] != null) { - visualToGLCapsMap.put(new ScreenAndVisualIDKey(screen, infos[i].visualid()), - caps[i].clone()); - } - } - int chosen = chooser.chooseCapabilities(capabilities, caps, recommendedIndex); - if (chosen < 0 || chosen >= caps.length) { - throw new GLException("GLCapabilitiesChooser specified invalid index (expected 0.." + (caps.length - 1) + ")"); - } - XVisualInfo vis = infos[chosen]; - if (vis == null) { - throw new GLException("GLCapabilitiesChooser chose an invalid visual"); - } - // FIXME: need to look at glue code and see type of this field - long visualID = vis.visualid(); - // FIXME: the storage for the infos array, as well as that for the - // recommended visual, is leaked; should free them here with XFree() - - // Now figure out which GraphicsConfiguration corresponds to this - // visual by matching the visual ID - GraphicsConfiguration[] configs = device.getConfigurations(); - for (int i = 0; i < configs.length; i++) { - GraphicsConfiguration config = configs[i]; - if (config != null) { - if (X11SunJDKReflection.graphicsConfigurationGetVisualID(config) == visualID) { - return new AWTGraphicsConfiguration(config); - } - } - } - - // Either we weren't able to reflectively introspect on the - // X11GraphicsConfig or something went wrong in the steps above; - // we're going to return null without signaling an error condition - // in this case (although we should distinguish between the two - // and possibly report more of an error in the latter case) return null; } - public GLDrawable getGLDrawable(Object target, - GLCapabilities capabilities, - GLCapabilitiesChooser chooser) { + public GLDrawable createGLDrawable(NativeWindow target, + GLCapabilities capabilities, + GLCapabilitiesChooser chooser) { if (target == null) { throw new IllegalArgumentException("Null target"); } - if (!(target instanceof Component)) { - throw new IllegalArgumentException("GLDrawables not supported for objects of type " + - target.getClass().getName() + " (only Components are supported in this implementation)"); - } - Component comp = (Component) target; - X11OnscreenGLDrawable drawable = new X11OnscreenGLDrawable(comp); - // Figure out the GLCapabilities of this component - GraphicsConfiguration config = comp.getGraphicsConfiguration(); - if (config == null) { - throw new IllegalArgumentException("GLDrawableFactory.chooseGraphicsConfiguration() was not used when creating this Component"); - } - int visualID = X11SunJDKReflection.graphicsConfigurationGetVisualID(config); - int screen; - if (isXineramaEnabled()) { - screen = 0; - } else { - screen = X11SunJDKReflection.graphicsDeviceGetScreen(config.getDevice()); - } + X11OnscreenGLDrawable drawable = new X11OnscreenGLDrawable(getProfile(), target); + int visualID = target.getVisualID(); + int screen = target.getScreenIndex(); drawable.setChosenGLCapabilities((GLCapabilities) visualToGLCapsMap.get(new ScreenAndVisualIDKey(screen, visualID))); return drawable; } @@ -551,29 +425,9 @@ public class X11GLDrawableFactory extends GLDrawableFactoryImpl { } public void lockToolkit() { - if (isHeadless) { - // Workaround for running (to some degree) in headless - // environments but still supporting rendering via pbuffers - // For full correctness, would need to implement a Lock class - return; - } - - if (!Java2D.isOGLPipelineActive() || !Java2D.isQueueFlusherThread()) { - JAWT.getJAWT().Lock(); - } } public void unlockToolkit() { - if (isHeadless) { - // Workaround for running (to some degree) in headless - // environments but still supporting rendering via pbuffers - // For full correctness, would need to implement a Lock class - return; - } - - if (!Java2D.isOGLPipelineActive() || !Java2D.isQueueFlusherThread()) { - JAWT.getJAWT().Unlock(); - } } public void lockAWTForJava2D() { @@ -682,23 +536,6 @@ public class X11GLDrawableFactory extends GLDrawableFactoryImpl { throw new GLException("Unimplemented on this platform"); } - //--------------------------------------------------------------------------- - // Xinerama-related functionality - // - - private boolean checkedXinerama; - private boolean xineramaEnabled; - protected synchronized boolean isXineramaEnabled() { - if (!checkedXinerama) { - checkedXinerama = true; - lockToolkit(); - long display = getDisplayConnection(); - xineramaEnabled = GLX.XineramaEnabled(display); - unlockToolkit(); - } - return xineramaEnabled; - } - //---------------------------------------------------------------------- // Gamma-related functionality // diff --git a/src/classes/com/sun/opengl/impl/x11/X11OnscreenGLDrawable.java b/src/classes/com/sun/opengl/impl/x11/X11OnscreenGLDrawable.java index b1a3ebac7..6ee4d453e 100644 --- a/src/classes/com/sun/opengl/impl/x11/X11OnscreenGLDrawable.java +++ b/src/classes/com/sun/opengl/impl/x11/X11OnscreenGLDrawable.java @@ -39,23 +39,12 @@ package com.sun.opengl.impl.x11; -import java.awt.Component; - import javax.media.opengl.*; import com.sun.opengl.impl.*; public class X11OnscreenGLDrawable extends X11GLDrawable { - public static final int LOCK_SURFACE_NOT_READY = 1; - public static final int LOCK_SURFACE_CHANGED = 2; - public static final int LOCK_SUCCESS = 3; - - protected Component component; + protected NativeWindow component; - // Variables for lockSurface/unlockSurface - private JAWT_DrawingSurface ds; - private JAWT_DrawingSurfaceInfo dsi; - private JAWT_X11DrawingSurfaceInfo x11dsi; - // Indicates whether the component (if an onscreen context) has been // realized. Plausibly, before the component is realized the JAWT // should return an error or NULL object from some of its @@ -68,7 +57,7 @@ public class X11OnscreenGLDrawable extends X11GLDrawable { // addNotify() is called on the component. protected boolean realized; - public X11OnscreenGLDrawable(Component component) { + public X11OnscreenGLDrawable(NativeWindow component) { super(null, null); this.component = component; } @@ -98,7 +87,7 @@ public class X11OnscreenGLDrawable extends X11GLDrawable { try { boolean didLock = false; - if (drawable == 0) { + if (component.getWindowHandle() == 0) { if (lockSurface() == LOCK_SURFACE_NOT_READY) { return; } @@ -106,7 +95,7 @@ public class X11OnscreenGLDrawable extends X11GLDrawable { didLock = true; } - GLX.glXSwapBuffers(display, drawable); + GLX.glXSwapBuffers(component.getDisplayHandle(), component.getWindowHandle()); if (didLock) { unlockSurface(); @@ -120,67 +109,10 @@ public class X11OnscreenGLDrawable extends X11GLDrawable { if (!realized) { return LOCK_SURFACE_NOT_READY; } - if (drawable != 0) { - throw new GLException("Surface already locked"); - } - ds = JAWT.getJAWT().GetDrawingSurface(component); - if (ds == null) { - // Widget not yet realized - return LOCK_SURFACE_NOT_READY; - } - int res = ds.Lock(); - if ((res & JAWTFactory.JAWT_LOCK_ERROR) != 0) { - throw new GLException("Unable to lock surface"); - } - // See whether the surface changed and if so destroy the old - // OpenGL context so it will be recreated (NOTE: removeNotify - // should handle this case, but it may be possible that race - // conditions can cause this code to be triggered -- should test - // more) - int ret = LOCK_SUCCESS; - if ((res & JAWTFactory.JAWT_LOCK_SURFACE_CHANGED) != 0) { - ret = LOCK_SURFACE_CHANGED; - } - dsi = ds.GetDrawingSurfaceInfo(); - if (dsi == null) { - // Widget not yet realized - ds.Unlock(); - JAWT.getJAWT().FreeDrawingSurface(ds); - ds = null; - return LOCK_SURFACE_NOT_READY; - } - x11dsi = (JAWT_X11DrawingSurfaceInfo) dsi.platformInfo(); - display = x11dsi.display(); - drawable = x11dsi.drawable(); - visualID = x11dsi.visualID(); - if (display == 0 || drawable == 0) { - // Widget not yet realized - ds.FreeDrawingSurfaceInfo(dsi); - ds.Unlock(); - JAWT.getJAWT().FreeDrawingSurface(ds); - ds = null; - dsi = null; - x11dsi = null; - display = 0; - drawable = 0; - visualID = 0; - return LOCK_SURFACE_NOT_READY; - } - return ret; + return component.lockSurface(); } public void unlockSurface() { - if (drawable == 0) { - throw new GLException("Surface already unlocked"); - } - ds.FreeDrawingSurfaceInfo(dsi); - ds.Unlock(); - JAWT.getJAWT().FreeDrawingSurface(ds); - ds = null; - dsi = null; - x11dsi = null; - display = 0; - drawable = 0; - visualID = 0; + return component.lockSurface(); } } diff --git a/src/classes/com/sun/opengl/impl/x11/awt/X11AWTGLDrawableFactory.java b/src/classes/com/sun/opengl/impl/x11/awt/X11AWTGLDrawableFactory.java new file mode 100644 index 000000000..de61d2315 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/x11/awt/X11AWTGLDrawableFactory.java @@ -0,0 +1,203 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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.sun.opengl.impl.x11.awt; + +import com.sun.opengl.impl.x11.*; +import java.awt.Graphics; +import java.awt.GraphicsConfiguration; +import java.awt.GraphicsDevice; +import java.awt.GraphicsEnvironment; +import java.nio.*; +import java.security.*; +import java.util.*; +import javax.media.opengl.*; +import com.sun.gluegen.runtime.*; +import com.sun.opengl.impl.*; + +public class X11AWTGLDrawableFactory extends X11GLDrawableFactory { + // See whether we're running in headless mode + private static boolean isHeadless; + + static { + // See DRIHack.java for an explanation of why this is necessary + DRIHack.begin(); + + com.sun.opengl.impl.NativeLibLoader.loadCore(); + + DRIHack.end(); + + isHeadless = GraphicsEnvironment.isHeadless(); + } + + public AbstractGraphicsConfiguration chooseGraphicsConfiguration(GLCapabilities capabilities, + GLCapabilitiesChooser chooser, + AbstractGraphicsDevice absDevice) { + if (capabilities == null) { + capabilities = new GLCapabilities(); + } + if (chooser == null) { + chooser = new DefaultGLCapabilitiesChooser(); + } + GraphicsDevice device = null; + if (absDevice != null && + !(absDevice instanceof AWTGraphicsDevice)) { + throw new IllegalArgumentException("This GLDrawableFactory accepts only AWTGraphicsDevice objects"); + } + + if ((absDevice == null) || + (((AWTGraphicsDevice) absDevice).getGraphicsDevice() == null)) { + device = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); + } else { + device = ((AWTGraphicsDevice) absDevice).getGraphicsDevice(); + } + + int screen; + if (isXineramaEnabled()) { + screen = 0; + } else { + screen = X11SunJDKReflection.graphicsDeviceGetScreen(device); + } + + // Until we have a rock-solid visual selection algorithm written + // in pure Java, we're going to provide the underlying window + // system's selection to the chooser as a hint + + int[] attribs = glCapabilities2AttribList(capabilities, isMultisampleAvailable(), false, 0, 0); + XVisualInfo[] infos = null; + GLCapabilities[] caps = null; + int recommendedIndex = -1; + lockToolkit(); + try { + long display = getDisplayConnection(); + XVisualInfo recommendedVis = GLX.glXChooseVisual(display, screen, attribs, 0); + if (DEBUG) { + System.err.print("!!! glXChooseVisual recommended "); + if (recommendedVis == null) { + System.err.println("null visual"); + } else { + System.err.println("visual id 0x" + Long.toHexString(recommendedVis.visualid())); + } + } + int[] count = new int[1]; + XVisualInfo template = XVisualInfo.create(); + template.screen(screen); + infos = GLX.XGetVisualInfo(display, GLX.VisualScreenMask, template, count, 0); + if (infos == null) { + throw new GLException("Error while enumerating available XVisualInfos"); + } + caps = new GLCapabilities[infos.length]; + for (int i = 0; i < infos.length; i++) { + caps[i] = xvi2GLCapabilities(display, infos[i]); + // Attempt to find the visual chosen by glXChooseVisual + if (recommendedVis != null && recommendedVis.visualid() == infos[i].visualid()) { + recommendedIndex = i; + } + } + } finally { + unlockToolkit(); + } + // Store these away for later + for (int i = 0; i < infos.length; i++) { + if (caps[i] != null) { + visualToGLCapsMap.put(new ScreenAndVisualIDKey(screen, infos[i].visualid()), + caps[i].clone()); + } + } + int chosen = chooser.chooseCapabilities(capabilities, caps, recommendedIndex); + if (chosen < 0 || chosen >= caps.length) { + throw new GLException("GLCapabilitiesChooser specified invalid index (expected 0.." + (caps.length - 1) + ")"); + } + XVisualInfo vis = infos[chosen]; + if (vis == null) { + throw new GLException("GLCapabilitiesChooser chose an invalid visual"); + } + // FIXME: need to look at glue code and see type of this field + long visualID = vis.visualid(); + // FIXME: the storage for the infos array, as well as that for the + // recommended visual, is leaked; should free them here with XFree() + + // Now figure out which GraphicsConfiguration corresponds to this + // visual by matching the visual ID + GraphicsConfiguration[] configs = device.getConfigurations(); + for (int i = 0; i < configs.length; i++) { + GraphicsConfiguration config = configs[i]; + if (config != null) { + if (X11SunJDKReflection.graphicsConfigurationGetVisualID(config) == visualID) { + return new AWTGraphicsConfiguration(config); + } + } + } + + // Either we weren't able to reflectively introspect on the + // X11GraphicsConfig or something went wrong in the steps above; + // we're going to return null without signaling an error condition + // in this case (although we should distinguish between the two + // and possibly report more of an error in the latter case) + return null; + } + + public void lockToolkit() { + if (isHeadless) { + // Workaround for running (to some degree) in headless + // environments but still supporting rendering via pbuffers + // For full correctness, would need to implement a Lock class + return; + } + + if (!Java2D.isOGLPipelineActive() || !Java2D.isQueueFlusherThread()) { + JAWT.getJAWT().Lock(); + } + } + + public void unlockToolkit() { + if (isHeadless) { + // Workaround for running (to some degree) in headless + // environments but still supporting rendering via pbuffers + // For full correctness, would need to implement a Lock class + return; + } + + if (!Java2D.isOGLPipelineActive() || !Java2D.isQueueFlusherThread()) { + JAWT.getJAWT().Unlock(); + } + } + + +} diff --git a/src/classes/com/sun/opengl/impl/x11/awt/X11JAWTWindow.java b/src/classes/com/sun/opengl/impl/x11/awt/X11JAWTWindow.java new file mode 100644 index 000000000..2115f383d --- /dev/null +++ b/src/classes/com/sun/opengl/impl/x11/awt/X11JAWTWindow.java @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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.sun.opengl.impl.x11.awt; + +import com.sun.opengl.impl.x11.*; +import com.sun.opengl.impl.awt.*; + +import javax.media.opengl.*; +import com.sun.opengl.impl.*; + +public class X11JAWTWindow extends JAWTWindow { + + // Variables for lockSurface/unlockSurface + private JAWT_DrawingSurface ds; + private JAWT_DrawingSurfaceInfo dsi; + private JAWT_X11DrawingSurfaceInfo x11dsi; + + //--------------------------------------------------------------------------- + // Xinerama-related functionality + // + + private boolean checkedXinerama; + private boolean xineramaEnabled; + protected synchronized boolean isXineramaEnabled() { + if (!checkedXinerama) { + checkedXinerama = true; + lockToolkit(); + long display = getDisplayConnection(); + xineramaEnabled = GLX.XineramaEnabled(display); + unlockToolkit(); + } + return xineramaEnabled; + } + + public X11JAWTWindow(Object comp) { + super(comp); + } + + public int lockSurface() throws NativeWindowException { + super.lockSurface(); + ds = JAWT.getJAWT().GetDrawingSurface(component); + if (ds == null) { + // Widget not yet realized + return LOCK_SURFACE_NOT_READY; + } + int res = ds.Lock(); + if ((res & JAWTFactory.JAWT_LOCK_ERROR) != 0) { + throw new NativeWindowException("Unable to lock surface"); + } + // See whether the surface changed and if so destroy the old + // OpenGL context so it will be recreated (NOTE: removeNotify + // should handle this case, but it may be possible that race + // conditions can cause this code to be triggered -- should test + // more) + int ret = LOCK_SUCCESS; + if ((res & JAWTFactory.JAWT_LOCK_SURFACE_CHANGED) != 0) { + ret = LOCK_SURFACE_CHANGED; + } + dsi = ds.GetDrawingSurfaceInfo(); + if (dsi == null) { + // Widget not yet realized + ds.Unlock(); + JAWT.getJAWT().FreeDrawingSurface(ds); + ds = null; + return LOCK_SURFACE_NOT_READY; + } + x11dsi = (JAWT_X11DrawingSurfaceInfo) dsi.platformInfo(); + display = x11dsi.display(); + drawable = x11dsi.drawable(); + visualID = x11dsi.visualID(); + screen= null; + if (isXineramaEnabled()) { + screenIndex = 0; + } else { + screenIndex = X11SunJDKReflection.graphicsDeviceGetScreen(config.getDevice()); + } + if (display == 0 || drawable == 0) { + // Widget not yet realized + ds.FreeDrawingSurfaceInfo(dsi); + ds.Unlock(); + JAWT.getJAWT().FreeDrawingSurface(ds); + ds = null; + dsi = null; + x11dsi = null; + display = 0; + drawable = 0; + visualID = 0; + screen= null; + screenIndex = -1; + return LOCK_SURFACE_NOT_READY; + } + return ret; + } + + public void unlockSurface() { + super.unlockSurface(); + ds.FreeDrawingSurfaceInfo(dsi); + ds.Unlock(); + JAWT.getJAWT().FreeDrawingSurface(ds); + ds = null; + dsi = null; + x11dsi = null; + } +} diff --git a/src/classes/com/sun/opengl/impl/x11/X11SunJDKReflection.java b/src/classes/com/sun/opengl/impl/x11/awt/X11SunJDKReflection.java index 0760399ab..5e19bfbb5 100644 --- a/src/classes/com/sun/opengl/impl/x11/X11SunJDKReflection.java +++ b/src/classes/com/sun/opengl/impl/x11/awt/X11SunJDKReflection.java @@ -37,7 +37,9 @@ * and developed by Kenneth Bradley Russell and Christopher John Kline. */ -package com.sun.opengl.impl.x11; +package com.sun.opengl.impl.x11.awt; + +import com.sun.opengl.impl.x11.*; import java.awt.GraphicsConfiguration; import java.awt.GraphicsDevice; diff --git a/src/classes/javax/media/opengl/GLAutoDrawable.java b/src/classes/javax/media/opengl/GLAutoDrawable.java index 40e2603c6..688b78879 100644 --- a/src/classes/javax/media/opengl/GLAutoDrawable.java +++ b/src/classes/javax/media/opengl/GLAutoDrawable.java @@ -52,7 +52,7 @@ import javax.media.opengl.glu.*; GLContext for the GLAutoDrawable to be used both by the event based rendering mechanism as well by end users directly. */ -public interface GLAutoDrawable extends GLDrawable /*, FIXME: ComponentEvents */ { +public interface GLAutoDrawable extends GLDrawable { /** * Returns the context associated with this drawable. The returned * context will be synchronized. diff --git a/src/classes/javax/media/opengl/GLDrawable.java b/src/classes/javax/media/opengl/GLDrawable.java index d57ddc0ee..c7f0ef803 100644 --- a/src/classes/javax/media/opengl/GLDrawable.java +++ b/src/classes/javax/media/opengl/GLDrawable.java @@ -136,4 +136,10 @@ public interface GLDrawable { with the drawable; a best attempt is made to return a reasonable value in this case. */ public GLCapabilities getChosenGLCapabilities(); + + public NativeWindow getNativeWindow(); + + public String getProfile(); + + public GLDrawableFactory getFactory(); } diff --git a/src/classes/javax/media/opengl/GLDrawableFactory.java b/src/classes/javax/media/opengl/GLDrawableFactory.java index 3ed34f86e..2c48e3ceb 100644 --- a/src/classes/javax/media/opengl/GLDrawableFactory.java +++ b/src/classes/javax/media/opengl/GLDrawableFactory.java @@ -77,7 +77,8 @@ import com.sun.opengl.impl.*; */ public abstract class GLDrawableFactory { - private static GLDrawableFactory factory; + private static GLDrawableFactory awtFactory; + private static GLDrawableFactory nwFactory; /** The desktop (OpenGL 2.0) profile */ public static final String PROFILE_GL_20 = "GL20"; @@ -91,9 +92,9 @@ public abstract class GLDrawableFactory { private String profile; /** Initializes the sole GLDrawableFactory instance for the given profile. */ - public static void initialize(String profile) throws GLException { - if (factory != null) { - throw new GLException("Already initialized"); + public static void initializeAWTFactory(String profile) throws GLException { + if (awtFactory != null) { + return; } // See if the user is requesting one of the embedded profiles, @@ -101,9 +102,9 @@ public abstract class GLDrawableFactory { if (PROFILE_GLES1.equals(profile) || PROFILE_GLES2.equals(profile)) { try { - Class clazz = Class.forName("com.sun.opengl.impl.egl.EGLDrawableFactory"); + Class clazz = Class.forName("com.sun.opengl.impl.egl.awt.EGLDrawableFactory"); Constructor c = clazz.getDeclaredConstructor(new Class[] { String.class }); - factory = (GLDrawableFactory) c.newInstance(new Object[] { profile }); + awtFactory = (GLDrawableFactory) c.newInstance(new Object[] { profile }); return; } catch (Exception e) { e.printStackTrace(); @@ -118,7 +119,7 @@ public abstract class GLDrawableFactory { String factoryClassName = (String) AccessController.doPrivileged(new PrivilegedAction() { public Object run() { - return System.getProperty("opengl.factory.class.name"); + return System.getProperty("opengl.awt.factory.class.name"); } }); String osName = System.getProperty("os.name"); @@ -134,6 +135,63 @@ public abstract class GLDrawableFactory { if (factoryClassName != null) { factoryClass = Class.forName(factoryClassName); } else if (osNameLowerCase.startsWith("wind")) { + factoryClass = Class.forName("com.sun.opengl.impl.windows.awt.WindowsAWTGLDrawableFactory"); + } else if (osNameLowerCase.startsWith("mac os x")) { + factoryClass = Class.forName("com.sun.opengl.impl.macosx.awt.MacOSXAWTGLDrawableFactory"); + } else { + // Assume Linux, Solaris, etc. Should probably test for these explicitly. + factoryClass = Class.forName("com.sun.opengl.impl.x11.awt.X11AWTGLDrawableFactory"); + } + + if (factoryClass == null) { + throw new GLException("OS " + osName + " not yet supported"); + } + + Constructor c = factoryClass.getDeclaredConstructor(new Class[] { String.class }); + awtFactory = (GLDrawableFactory) c.newInstance(new Object[] { profile }); + } catch (Exception e) { + throw new GLException(e); + } + } + + /** Initializes the sole GLDrawableFactory instance for the given profile. */ + public static void initializeNWFactory(String profile) throws GLException { + if (nwFactory != null) { + return; + } + + // See if the user is requesting one of the embedded profiles, + // and if so, try to instantiate the EGLDrawableFactory + if (PROFILE_GLES1.equals(profile) || + PROFILE_GLES2.equals(profile)) { + try { + Class clazz = Class.forName("com.sun.opengl.impl.egl.EGLDrawableFactory"); + Constructor c = clazz.getDeclaredConstructor(new Class[] { String.class }); + nwFactory = (GLDrawableFactory) c.newInstance(new Object[] { profile }); + return; + } catch (Exception e) { + e.printStackTrace(); + } + } else if (!PROFILE_GL_20.equals(profile)) { + // We require that the user passes in one of the known profiles + throw new GLException("Unknown or unsupported profile \"" + profile + "\""); + } + + // Use the desktop OpenGL as the fallback always + try { + String factoryClassName = + (String) AccessController.doPrivileged(new PrivilegedAction() { + public Object run() { + return System.getProperty("opengl.factory.class.name"); + } + }); + String osName = System.getProperty("os.name"); + String osNameLowerCase = osName.toLowerCase(); + Class factoryClass = null; + + if (factoryClassName != null) { + factoryClass = Class.forName(factoryClassName); + } else if (osNameLowerCase.startsWith("wind")) { factoryClass = Class.forName("com.sun.opengl.impl.windows.WindowsGLDrawableFactory"); } else if (osNameLowerCase.startsWith("mac os x")) { factoryClass = Class.forName("com.sun.opengl.impl.macosx.MacOSXGLDrawableFactory"); @@ -147,7 +205,8 @@ public abstract class GLDrawableFactory { } Constructor c = factoryClass.getDeclaredConstructor(new Class[] { String.class }); - factory = (GLDrawableFactory) c.newInstance(new Object[] { profile }); + nwFactory = (GLDrawableFactory) c.newInstance(new Object[] { profile }); + return; } catch (Exception e) { throw new GLException(e); } @@ -160,12 +219,34 @@ public abstract class GLDrawableFactory { } /** Returns the sole GLDrawableFactory instance for the specified profile. */ - public static GLDrawableFactory getFactory() { - if (factory == null) { - throw new GLException("Must call initialize() first"); + public static GLDrawableFactory getFactory(String profile, Object target) { + if(null==target) { + throw new IllegalArgumentException("target is null"); } + if(target instanceof NativeWindow) { + return getFactory(profile, false); + } else if (NativeWindowFactory.isAWTComponent(target)) { + return getFactory(profile, true); + } + throw new IllegalArgumentException("Target type is unsupported. Currently supported: \n"+ + "\tjavax.media.opengl.NativeWindow\n"+ + "\tjava.awt.Component\n"); + } - return factory; + public static GLDrawableFactory getFactory(String profile, boolean awt) { + if(awt) { + initializeAWTFactory(profile); + if(awtFactory == null) { + throw new GLException("Could not determine the AWT-GLDrawableFactory"); + } + return awtFactory; + } else { + initializeNWFactory(profile); + if(nwFactory == null) { + throw new GLException("Could not determine the NativeWindow-GLDrawableFactory"); + } + return nwFactory; + } } /** Indicates which profile this GLDrawableFactory was created for. */ @@ -223,14 +304,13 @@ public abstract class GLDrawableFactory { * passed GLCapabilitiesChooser object is null, uses a * DefaultGLCapabilitiesChooser instance. * - * @throws IllegalArgumentException if the passed target is either - * null or its data type is not supported by this GLDrawableFactory. + * @throws IllegalArgumentException if the passed target is null * @throws GLException if any window system-specific errors caused * the creation of the GLDrawable to fail. */ - public abstract GLDrawable getGLDrawable(Object target, - GLCapabilities capabilities, - GLCapabilitiesChooser chooser) + public abstract GLDrawable createGLDrawable(NativeWindow target, + GLCapabilities capabilities, + GLCapabilitiesChooser chooser) throws IllegalArgumentException, GLException; //---------------------------------------------------------------------- diff --git a/src/classes/javax/media/opengl/NativeWindow.java b/src/classes/javax/media/opengl/NativeWindow.java new file mode 100644 index 000000000..98e5edc68 --- /dev/null +++ b/src/classes/javax/media/opengl/NativeWindow.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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 javax.media.opengl; + +public interface NativeWindow { + public static final int LOCK_SURFACE_NOT_READY = 1; + public static final int LOCK_SURFACE_CHANGED = 2; + public static final int LOCK_SUCCESS = 3; + + public boolean lockSurface() throws NativeWindowException ; + public void unlockSurface(); + public boolean isSurfaceLocked(); + + public long getDisplayHandle(); + public long getScreenHandle(); + public int getScreenIndex(); + public long getWindowHandle(); + public long getVisualID(); + + public void setSize(int width, int height); + public void setPosition(int x, int y); + public int getWidth(); + public int getHeight(); + public int getX(); + public int getY(); + + public void setVisible(boolean visible); + public boolean setFullscreen(boolean fullscreen); + public boolean isVisible(); + public boolean isFullscreen(); +} diff --git a/src/classes/javax/media/opengl/NativeWindowException.java b/src/classes/javax/media/opengl/NativeWindowException.java new file mode 100644 index 000000000..cb43d3830 --- /dev/null +++ b/src/classes/javax/media/opengl/NativeWindowException.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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 javax.media.opengl; + +/** A generic exception for OpenGL errors used throughout the binding + as a substitute for {@link RuntimeException}. */ + +public class NativeWindowException extends RuntimeException { + /** Constructs a NativeWindowException object. */ + public NativeWindowException() { + super(); + } + + /** Constructs a NativeWindowException object with the specified detail + message. */ + public NativeWindowException(String message) { + super(message); + } + + /** Constructs a NativeWindowException object with the specified detail + message and root cause. */ + public NativeWindowException(String message, Throwable cause) { + super(message, cause); + } + + /** Constructs a NativeWindowException object with the specified root + cause. */ + public NativeWindowException(Throwable cause) { + super(cause); + } +} diff --git a/src/classes/javax/media/opengl/NativeWindowFactory.java b/src/classes/javax/media/opengl/NativeWindowFactory.java new file mode 100644 index 000000000..c206adb78 --- /dev/null +++ b/src/classes/javax/media/opengl/NativeWindowFactory.java @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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 javax.media.opengl; + +import java.lang.reflect.*; +import java.security.*; +import com.sun.opengl.impl.*; + +public class NativeWindowFactory { + private static Constructor awtFactory = null; + + /** Initializes the sole NativeWindowFactory instance . */ + private static void initializeAWTFactory() throws GLException { + if (awtFactory == null) { + // Use the desktop OpenGL as the fallback always + try { + String osName = System.getProperty("os.name"); + String osNameLowerCase = osName.toLowerCase(); + Class factoryClass = null; + String factoryClassName = null; + + // Because there are some complications with generating all + // platforms' Java glue code on all platforms (among them that we + // would have to include jawt.h and jawt_md.h in the jogl + // sources, which we currently don't have to do) we break the only + // static dependencies with platform-specific code here using reflection. + + if (osNameLowerCase.startsWith("wind")) { + factoryClassName = "com.sun.opengl.impl.windows.awt.WindowsJAWTWindow"; + } else if (osNameLowerCase.startsWith("mac os x")) { + factoryClassName = "com.sun.opengl.impl.macosx.awt.MacOSXJAWTWindow"; + } else { + // Assume Linux, Solaris, etc. Should probably test for these explicitly. + factoryClassName = "com.sun.opengl.impl.x11.awt.X11JAWTWindow"; + } + + if (factoryClassName == null) { + throw new GLException("OS " + osName + " not yet supported"); + } + factoryClass = Class.forName(factoryClassName); + if (factoryClass == null) { + throw new GLException("Factory " + factoryClassName + " not yet implemented"); + } + + try { + awtFactory = factoryClass.getDeclaredConstructor(new Class[] { Object.class }); + } catch(NoSuchMethodException nsme) {} + + } catch (Exception e) { + throw new GLException(e); + } + } + } + + /** + * Returns true, if the given object is an instance of java.awt.Component. + * This check is performed on a Class.getName() basis, + * hence the independency to the java.awt.* package. + */ + public static boolean isAWTComponent(Object target) { + Class clazz = target.getClass(); + do { + if(clazz.getName().equals("java.awt.Component")) { + return true; + } + clazz = clazz.getSuperclass(); + } while (clazz!=null); + return false; + } + + /** + * Returns a NativeWindow. + * + * @throws IllegalArgumentException if the passed target is null + * @throws GLException if any window system-specific errors caused + * the creation of the GLDrawable to fail. + */ + public static NativeWindow getNativeWindow(Object target) + throws IllegalArgumentException, GLException + { + if(null==target) { + throw new IllegalArgumentException("target is null"); + } + if(target instanceof NativeWindow) { + return (NativeWindow)target; + } + if (isAWTComponent(target)) { + initializeAWTFactory(); + if(awtFactory == null) { + throw new GLException("Could not determine an AWT-NativeWindow constructor"); + } + try { + return (NativeWindow) awtFactory.newInstance(new Object[] { target }); + } catch (Exception ie) { + ie.printStackTrace(); + } + } + throw new IllegalArgumentException("Target type is unsupported. Currently supported: \n"+ + "\tjavax.media.opengl.NativeWindow\n"+ + "\tjava.awt.Component\n"); + } +} + diff --git a/src/classes/javax/media/opengl/awt/AWTGLAutoDrawable.java b/src/classes/javax/media/opengl/awt/AWTGLAutoDrawable.java new file mode 100644 index 000000000..ef5a7f2d7 --- /dev/null +++ b/src/classes/javax/media/opengl/awt/AWTGLAutoDrawable.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. 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 + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * 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 javax.media.opengl.awt; + +import javax.media.opengl.*; +import javax.media.opengl.glu.*; + +public interface AWTGLAutoDrawable extends GLAutoDrawable, ComponentEvents { +} diff --git a/src/classes/javax/media/opengl/AWTGraphicsConfiguration.java b/src/classes/javax/media/opengl/awt/AWTGraphicsConfiguration.java index 25647fc62..93f39bc27 100644 --- a/src/classes/javax/media/opengl/AWTGraphicsConfiguration.java +++ b/src/classes/javax/media/opengl/awt/AWTGraphicsConfiguration.java @@ -37,8 +37,9 @@ * and developed by Kenneth Bradley Russell and Christopher John Kline. */ -package javax.media.opengl; +package javax.media.opengl.awt; +import javax.media.opengl.*; import java.awt.GraphicsConfiguration; /** A wrapper for an AWT GraphicsConfiguration allowing it to be diff --git a/src/classes/javax/media/opengl/AWTGraphicsDevice.java b/src/classes/javax/media/opengl/awt/AWTGraphicsDevice.java index 98c7ef2bf..1073aac72 100644 --- a/src/classes/javax/media/opengl/AWTGraphicsDevice.java +++ b/src/classes/javax/media/opengl/awt/AWTGraphicsDevice.java @@ -37,8 +37,9 @@ * and developed by Kenneth Bradley Russell and Christopher John Kline. */ -package javax.media.opengl; +package javax.media.opengl.awt; +import javax.media.opengl.*; import java.awt.GraphicsDevice; /** A wrapper for an AWT GraphicsDevice allowing it to be diff --git a/src/classes/javax/media/opengl/ComponentEvents.java b/src/classes/javax/media/opengl/awt/ComponentEvents.java index bfbbb957b..0c4f63c2d 100644 --- a/src/classes/javax/media/opengl/ComponentEvents.java +++ b/src/classes/javax/media/opengl/awt/ComponentEvents.java @@ -37,8 +37,9 @@ * and developed by Kenneth Bradley Russell and Christopher John Kline. */ -package javax.media.opengl; +package javax.media.opengl.awt; +import javax.media.opengl.*; import java.awt.event.*; import java.beans.PropertyChangeListener; diff --git a/src/classes/javax/media/opengl/GLCanvas.java b/src/classes/javax/media/opengl/awt/GLCanvas.java index 42f3e68f3..8b52c6da4 100644 --- a/src/classes/javax/media/opengl/GLCanvas.java +++ b/src/classes/javax/media/opengl/awt/GLCanvas.java @@ -37,7 +37,9 @@ * and developed by Kenneth Bradley Russell and Christopher John Kline. */ -package javax.media.opengl; +package javax.media.opengl.awt; + +import javax.media.opengl.*; import java.awt.Canvas; import java.awt.Color; @@ -62,7 +64,7 @@ import com.sun.opengl.impl.*; interfaces when adding a heavyweight doesn't work either because of Z-ordering or LayoutManager problems. */ -public class GLCanvas extends Canvas implements GLAutoDrawable { +public class GLCanvas extends Canvas implements AWTGLAutoDrawable { private static final boolean DEBUG = Debug.debug("GLCanvas"); @@ -105,7 +107,8 @@ public class GLCanvas extends Canvas implements GLAutoDrawable { which to create the GLCanvas; the GLDrawableFactory uses the default screen device of the local GraphicsEnvironment if null is passed for this argument. */ - public GLCanvas(GLCapabilities capabilities, + public GLCanvas(String profile, + GLCapabilities capabilities, GLCapabilitiesChooser chooser, GLContext shareWith, GraphicsDevice device) { @@ -139,7 +142,9 @@ public class GLCanvas extends Canvas implements GLAutoDrawable { this.glCaps = capabilities; } if (!Beans.isDesignTime()) { - drawable = GLDrawableFactory.getFactory().getGLDrawable(this, capabilities, chooser); + drawable = GLDrawableFactory.getFactory(profile, true).createGLDrawable(profile, + NativeWindowFactory.getNativeWindow(this), + capabilities, chooser); context = (GLContextImpl) drawable.createContext(shareWith); context.setSynchronized(true); } diff --git a/src/classes/javax/media/opengl/GLJPanel.java b/src/classes/javax/media/opengl/awt/GLJPanel.java index 2d4e84d77..4c1df74da 100644 --- a/src/classes/javax/media/opengl/GLJPanel.java +++ b/src/classes/javax/media/opengl/awt/GLJPanel.java @@ -37,7 +37,9 @@ * and developed by Kenneth Bradley Russell and Christopher John Kline. */ -package javax.media.opengl; +package javax.media.opengl.awt; + +import javax.media.opengl.*; import java.awt.*; import java.awt.geom.*; @@ -79,7 +81,7 @@ import com.sun.opengl.impl.*; */ -public class GLJPanel extends JPanel implements GLAutoDrawable { +public class GLJPanel extends JPanel implements AWTGLAutoDrawable { private static final boolean DEBUG = Debug.debug("GLJPanel"); private static final boolean VERBOSE = Debug.verbose(); diff --git a/src/native/jogl/X11Window.c b/src/native/jogl/X11Window.c index e37525be7..c60fd2f9b 100755 --- a/src/native/jogl/X11Window.c +++ b/src/native/jogl/X11Window.c @@ -44,6 +44,97 @@ #include "MouseEvent.h" #include "KeyEvent.h" +// This is set by DispatchMessages, below, and cleared when it exits +static JNIEnv* env = NULL; + +#define VERBOSE_ON 1 + +#ifdef VERBOSE_ON + +static void _dumpVisualInfo(const char * msg, XVisualInfo *pVisualQuery) { + if(pVisualQuery!=NULL) { + fprintf(stderr, "%s: screen %d, visual: %p, visual-id: 0x%X, depth: %d, class %d, cmap sz: %d, bpp: %d, rgb 0x%X 0x%X 0x%X\n", + msg, + pVisualQuery->screen, + pVisualQuery->visual, + (int)pVisualQuery->visualid, + pVisualQuery->depth, + pVisualQuery->class, + pVisualQuery->colormap_size, + pVisualQuery->bits_per_rgb, + (int)pVisualQuery->red_mask, + (int)pVisualQuery->green_mask, + (int)pVisualQuery->blue_mask + ); + } else { + fprintf(stderr, "%s: NULL XVisualInfo\n", msg); + } +} + +#define DUMP_VISUAL_INFO(a,b) _dumpVisualInfo((a),(b)) + +#else + +#define DUMP_VISUAL_INFO(a,b) + +#endif + +/** + * Display + */ + +/* + * Class: com_sun_javafx_newt_x11_X11Display + * Method: CreateDisplay + * Signature: (Ljava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Display_CreateDisplay + (JNIEnv *env, jobject obj, jstring displayName) +{ + Display * dpy = NULL; + const char * _displayName = NULL; + if(displayName!=0) { + _displayName = (*env)->GetStringUTFChars(env, displayName, 0); + } + dpy = XOpenDisplay(_displayName); + if(dpy==NULL) { + fprintf(stderr, "couldn't open display connection..\n"); + } + return (jlong) (intptr_t) dpy; +} + +/** + * Screen + */ + +/* + * Class: com_sun_javafx_newt_x11_X11Screen + * Method: GetScreen + * Signature: (JI)J + */ +JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Screen_GetScreen + (JNIEnv *env, jobject obj, jlong display, jint screen_index) +{ + Display * dpy = (Display *)(intptr_t)display; + Screen * scrn= NULL; + if(dpy==NULL) { + fprintf(stderr, "[GetScreen] invalid display connection..\n"); + return 0; + } + scrn = ScreenOfDisplay(dpy,screen_index); + if(scrn==NULL) { + scrn=DefaultScreenOfDisplay(dpy); + } + if(scrn==NULL) { + fprintf(stderr, "couldn't get screen ..\n"); + } + return (jlong) (intptr_t) scrn; +} + +/** + * Window + */ + static jmethodID sizeChangedID = NULL; static jmethodID positionChangedID = NULL; static jmethodID windowClosedID = NULL; @@ -52,11 +143,6 @@ static jmethodID windowCreatedID = NULL; static jmethodID sendMouseEventID = NULL; static jmethodID sendKeyEventID = NULL; -// This is set by DispatchMessages, below, and cleared when it exits -static JNIEnv* env = NULL; - -// #define VERBOSE_ON 1 - /* * Class: com_sun_javafx_newt_x11_X11Window * Method: initIDs @@ -69,7 +155,7 @@ JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_x11_X11Window_initIDs positionChangedID = (*env)->GetMethodID(env, clazz, "positionChanged", "(II)V"); windowClosedID = (*env)->GetMethodID(env, clazz, "windowClosed", "()V"); windowDestroyedID = (*env)->GetMethodID(env, clazz, "windowDestroyed", "()V"); - windowCreatedID = (*env)->GetMethodID(env, clazz, "windowCreated", "(JIJJ)V"); + windowCreatedID = (*env)->GetMethodID(env, clazz, "windowCreated", "(JJ)V"); sendMouseEventID = (*env)->GetMethodID(env, clazz, "sendMouseEvent", "(IIIII)V"); sendKeyEventID = (*env)->GetMethodID(env, clazz, "sendKeyEvent", "(IIIC)V"); if (sizeChangedID == NULL || @@ -87,69 +173,116 @@ JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_x11_X11Window_initIDs /* * Class: com_sun_javafx_newt_x11_X11Window * Method: CreateWindow - * Signature: (JIIII)J + * Signature: (JJJIIIII)J */ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Window_CreateWindow - (JNIEnv *env, jobject obj, jlong visualID, + (JNIEnv *env, jobject obj, jlong display, jlong screen, jint screen_index, + jlong visualID, jint x, jint y, jint width, jint height) { - Display * dpy; - Screen * scrn; - int scrn_idx; + Display * dpy = NULL; + Screen * scrn = NULL; + int scrn_idx = (int)screen_index; Window windowParent = 0; Window window = 0; XVisualInfo visualTemplate; XVisualInfo *pVisualQuery = NULL; + Visual *visual = NULL; + int depth; + XSetWindowAttributes xswa; unsigned long attrMask; int n; - dpy = XOpenDisplay(NULL); + dpy = (Display *)(intptr_t)display; if(dpy==NULL) { - fprintf(stderr, "could not open X display ..\n"); + fprintf(stderr, "[CreateWindow] invalid display connection..\n"); return 0; } + scrn = (Screen *)(intptr_t)screen; + if(scrn==NULL) { + fprintf(stderr, "invalid screen connection..\n"); + return 0; + } + + visualID=33; if(visualID>0) { - // try given VisualID + // try given VisualID on screen memset(&visualTemplate, 0, sizeof(XVisualInfo)); + visualTemplate.screen = scrn_idx; visualTemplate.visualid = (VisualID)visualID; - pVisualQuery = XGetVisualInfo(dpy, VisualIDMask, &visualTemplate,&n); + pVisualQuery = XGetVisualInfo(dpy, VisualIDMask|VisualScreenMask, &visualTemplate,&n); + DUMP_VISUAL_INFO("Given VisualID,ScreenIdx", pVisualQuery); + if(pVisualQuery!=NULL) { + visual = pVisualQuery->visual; + depth = pVisualQuery->depth; + visualID = pVisualQuery->visualid; + XFree(pVisualQuery); + pVisualQuery=NULL; + } +#ifdef VERBOSE_ON + fprintf(stderr, "trying given (screen %d, visualID: %d) found: %d\n", scrn_idx, visualID, (visual!=NULL)); +#endif } - if (pVisualQuery==NULL) + if (visual==NULL) { - // try default VisualID - scrn = DefaultScreenOfDisplay(dpy); - visualID = XVisualIDFromVisual(DefaultVisualOfScreen(scrn)); + // try depth >=15 on screen memset(&visualTemplate, 0, sizeof(XVisualInfo)); - visualTemplate.visualid = (VisualID)visualID; - pVisualQuery = XGetVisualInfo(dpy, VisualIDMask, &visualTemplate,&n); + visualTemplate.screen = scrn_idx; + visualTemplate.depth = 15; + pVisualQuery = XGetVisualInfo(dpy, VisualScreenMask|VisualDepthMask, &visualTemplate,&n); + DUMP_VISUAL_INFO("Given VisualID,ScreenIdx", pVisualQuery); + if(pVisualQuery!=NULL) { + visual = pVisualQuery->visual; + depth = pVisualQuery->depth; + visualID = pVisualQuery->visualid; + XFree(pVisualQuery); + pVisualQuery=NULL; + } +#ifdef VERBOSE_ON + fprintf(stderr, "trying (screen %d, depth >= 15) found: %d, id: %d\n", scrn_idx, (visual!=NULL), visualID); +#endif } - if (pVisualQuery==NULL) + if (visual==NULL) { - fprintf(stderr, "could not query any XVisualInfo, bail out!\n"); - return 0; - } + // try default .. + Visual * visual = XDefaultVisualOfScreen(scrn); + if(visual!=NULL) { + visualID = visual->visualid; + // try given VisualID on screen + memset(&visualTemplate, 0, sizeof(XVisualInfo)); + visualTemplate.screen = scrn_idx; + visualTemplate.visualid = (VisualID)visualID; + pVisualQuery = XGetVisualInfo(dpy, VisualIDMask|VisualScreenMask, &visualTemplate,&n); + if(pVisualQuery!=NULL) { + visual = pVisualQuery->visual; + depth = pVisualQuery->depth; + visualID = pVisualQuery->visualid; + XFree(pVisualQuery); + pVisualQuery=NULL; + } else { + visual = NULL; + visualID = 0; + } #ifdef VERBOSE_ON - else { - fprintf(stderr, "choosen visual: id: 0x%X, screen %d, depth: %d, class %d, cmap sz: %d, bpp: %d, rgb 0x%X 0x%X 0x%X\n", - (int)pVisualQuery->visualid, - pVisualQuery->screen, - pVisualQuery->depth, - pVisualQuery->class, - pVisualQuery->colormap_size, - pVisualQuery->bits_per_rgb, - (int)pVisualQuery->red_mask, - (int)pVisualQuery->green_mask, - (int)pVisualQuery->blue_mask - ); - } + fprintf(stderr, "default visual (screen %d, visualID: %d) found: %d\n", scrn_idx, visualID, (visual!=NULL)); #endif + } + } + DUMP_VISUAL_INFO("Choosen", pVisualQuery); + if (visual==NULL) + { + fprintf(stderr, "could not query any Visual, bail out!\n"); + return 0; + } - scrn_idx = pVisualQuery->screen; - scrn = ScreenOfDisplay(dpy, scrn_idx); + if(pVisualQuery!=NULL) { + XFree(pVisualQuery); + pVisualQuery=NULL; + } windowParent = XRootWindowOfScreen(scrn); @@ -160,8 +293,8 @@ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Window_CreateWindow xswa.background_pixel = 0; xswa.event_mask = ExposureMask | StructureNotifyMask | KeyPressMask | KeyReleaseMask; xswa.colormap = XCreateColormap(dpy, - RootWindow(dpy, pVisualQuery->screen), - pVisualQuery->visual, + XRootWindow(dpy, scrn_idx), + visual, AllocNone); window = XCreateWindow(dpy, @@ -169,19 +302,15 @@ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Window_CreateWindow x, y, width, height, 0, // border width - pVisualQuery->depth, + depth, InputOutput, - pVisualQuery->visual, + visual, attrMask, &xswa); - XFree(pVisualQuery); - - //XMapWindow(dpy, window); XClearWindow(dpy, window); XMapRaised(dpy, window); - (*env)->CallVoidMethod(env, obj, windowCreatedID, (jlong) (intptr_t) dpy, - (jint) scrn_idx, (jlong) (intptr_t) scrn, (jlong) window); + (*env)->CallVoidMethod(env, obj, windowCreatedID, (jlong) visualID, (jlong) window); XSelectInput(dpy, window, ExposureMask|ButtonPressMask|ButtonReleaseMask|PointerMotionMask| KeyPressMask|KeyReleaseMask); |