Attachment 215 Details for Bug 455 – main class of the test case

main class of the test case

DummyRCPViewer3D.java (text/x-java), 16.36 KB, created by Julien Gouesse on 2011-01-06 17:13:32 CET

(hide)

Description:

Filename:

MIME Type:

Creator: Julien Gouesse

Created: 2011-01-06 17:13:32 CET

Size: 16.36 KB

patch

obsolete

>import java.awt.BorderLayout;
>import java.awt.EventQueue;
>import java.awt.Frame;
>import java.awt.event.ActionEvent;
>import java.awt.event.ActionListener;
>import java.awt.event.ComponentAdapter;
>import java.awt.event.ComponentEvent;
>import java.awt.event.KeyAdapter;
>import java.awt.event.KeyEvent;
>import java.lang.reflect.Field;
>import java.lang.reflect.Method;
>
>import javax.media.opengl.DebugGL2;
>import javax.media.opengl.DebugGL3;
>import javax.media.opengl.DebugGL3bc;
>import javax.media.opengl.DebugGL4;
>import javax.media.opengl.DebugGL4bc;
>import javax.media.opengl.GL;
>import javax.media.opengl.GL2;
>import javax.media.opengl.GL2ES1;
>import javax.media.opengl.GL2GL3;
>import javax.media.opengl.GL3;
>import javax.media.opengl.GL3bc;
>import javax.media.opengl.GL4;
>import javax.media.opengl.GL4bc;
>import javax.media.opengl.GLAutoDrawable;
>import javax.media.opengl.GLCapabilities;
>import javax.media.opengl.GLContext;
>import javax.media.opengl.GLEventListener;
>import javax.media.opengl.GLProfile;
>import javax.media.opengl.awt.GLCanvas;
>import javax.media.opengl.fixedfunc.GLLightingFunc;
>import javax.media.opengl.fixedfunc.GLMatrixFunc;
>import javax.media.opengl.glu.GLU;
>import javax.swing.Timer;
>
>import org.eclipse.swt.SWT;
>import org.eclipse.swt.awt.SWT_AWT;
>import org.eclipse.swt.layout.FillLayout;
>import org.eclipse.swt.widgets.Composite;
>import org.eclipse.ui.part.ViewPart;
>
>import com.jogamp.opengl.util.Animator;
>
>public class DummyRCPViewer3D extends ViewPart {
>
>    /** identifier of the view used in the extension point */
>    public static final String ID = DummyRCPViewer3D.class.getCanonicalName();
>
>    /** SWT component embedding AWT components */
>    private Composite embedded;
>
>    private static final boolean isWindows = System.getProperty("os.name").equalsIgnoreCase(
>            "windows");
>
>    @Override
>    public void createPartControl(final Composite parent) {
>        // we can't use the default Composite because using the AWT bridge
>        // requires the SWT.EMBEDDED style
>        embedded = new Composite(parent, SWT.EMBEDDED);
>        // set the layout so our canvas fills the whole control
>        embedded.setLayout(new FillLayout());
>        // workaround for the bug 6678385 under Linux
>        final Frame frame = SWT_AWT_FrameHelper.new_Frame(embedded);
>        // the canvas has to be created once the size of the frame that contains it is no more zero,
>        // that is why it is called when the frame is resized
>        frame.addComponentListener(new ComponentAdapter() {
>
>            @Override
>            public void componentResized(ComponentEvent e) {
>                // use Display.getDefault().asyncExec to initialize SWT GUI elements there
>
>                // get the profile
>                GLProfile profile = GLProfile.getDefault();
>                // this allows us to set particular properties for the GLCanvas
>                GLCapabilities glCapabilities = new GLCapabilities(profile);
>                // anti aliasing
>                glCapabilities.setNumSamples(8);
>                glCapabilities.setSampleBuffers(true);
>
>                // we don't need either of these, just an example
>                glCapabilities.setDoubleBuffered(true);
>                glCapabilities.setHardwareAccelerated(true);
>
>                final GLCanvas canvas = new GLCanvas(glCapabilities);
>                canvas.setAutoSwapBufferMode(false);
>                canvas.addKeyListener(new KeyAdapter() {
>
>                    @Override
>                    public void keyReleased(KeyEvent e) {
>                        if (e.getKeyCode() == KeyEvent.VK_B) {
>                            canvas.setAutoSwapBufferMode(!canvas.getAutoSwapBufferMode());
>                        }
>                    }
>                });
>                canvas.addGLEventListener(new GLEventListener() {
>
>                    private float pyramidRotation;
>
>                    private int frameIndex = 0;
>
>                    @Override
>                    public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
>                        final GL2 gl = GLContext.getCurrentGL().getGL2();
>                        final GLU glu = new GLU();
>
>                        gl.glViewport(0, 0, width, height);
>                        gl.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
>                        gl.glLoadIdentity();
>
>                        glu.gluPerspective(45.0f, (double) width / (double) height, 0.1f, 1000.0f);
>
>                        gl.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
>                        gl.glLoadIdentity();
>                    }
>
>                    @Override
>                    public void init(GLAutoDrawable drawable) {
>                        // always get a fresh instance of GL to avoid using an invalidated GL one
>                        final GL2 gl = GLContext.getCurrentGL().getGL2();
>                        // enable V-sync
>                        gl.setSwapInterval(1);
>
>                        gl.glShadeModel(GLLightingFunc.GL_SMOOTH);
>                        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
>                        gl.glClearDepth(1.0f);
>                        gl.glEnable(GL.GL_DEPTH_TEST);
>                        gl.glDepthFunc(GL.GL_LEQUAL);
>                        gl.glHint(GL2ES1.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
>
>                        // set the debug pipeline
>                        if (drawable.getGL().isGL4bc()) {
>                            final GL4bc gl4bc = drawable.getGL().getGL4bc();
>                            drawable.setGL(new DebugGL4bc(gl4bc));
>                        }
>                        else {
>                            if (drawable.getGL().isGL4()) {
>                                final GL4 gl4 = drawable.getGL().getGL4();
>                                drawable.setGL(new DebugGL4(gl4));
>                            }
>                            else {
>                                if (drawable.getGL().isGL3bc()) {
>                                    final GL3bc gl3bc = drawable.getGL().getGL3bc();
>                                    drawable.setGL(new DebugGL3bc(gl3bc));
>                                }
>                                else {
>                                    if (drawable.getGL().isGL3()) {
>                                        final GL3 gl3 = drawable.getGL().getGL3();
>                                        drawable.setGL(new DebugGL3(gl3));
>                                    }
>                                    else {
>                                        if (drawable.getGL().isGL2()) {
>                                            final GL2 gl2 = drawable.getGL().getGL2();
>                                            drawable.setGL(new DebugGL2(gl2));
>                                        }
>                                    }
>                                }
>                            }
>                        }
>                    }
>
>                    @Override
>                    public void dispose(GLAutoDrawable drawable) {
>
>                    }
>
>                    @Override
>                    public void display(GLAutoDrawable drawable) {
>                        final GL2 gl = GLContext.getCurrentGL().getGL2();
>                        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
>                        gl.glLoadIdentity();
>                        gl.glTranslatef(-1.5f, 0.0f, -6.0f);
>                        gl.glRotatef(pyramidRotation, 0.0f, 1.0f, 0.0f);
>                        gl.glBegin(GL.GL_TRIANGLES);
>                        gl.glColor3f(1.0f, 0.0f, 0.0f);
>                        gl.glVertex3f(0.0f, 1.0f, 0.0f);
>                        gl.glColor3f(0.0f, 1.0f, 0.0f);
>                        gl.glVertex3f(-1.0f, -1.0f, 1.0f);
>                        gl.glColor3f(0.0f, 0.0f, 1.0f);
>                        gl.glVertex3f(1.0f, -1.0f, 1.0f);
>                        gl.glColor3f(1.0f, 0.0f, 0.0f);
>                        gl.glVertex3f(0.0f, 1.0f, 0.0f);
>                        gl.glColor3f(0.0f, 0.0f, 1.0f);
>                        gl.glVertex3f(1.0f, -1.0f, 1.0f);
>                        gl.glColor3f(0.0f, 1.0f, 0.0f);
>                        gl.glVertex3f(1.0f, -1.0f, -1.0f);
>                        gl.glColor3f(1.0f, 0.0f, 0.0f);
>                        gl.glVertex3f(0.0f, 1.0f, 0.0f);
>                        gl.glColor3f(0.0f, 1.0f, 0.0f);
>                        gl.glVertex3f(1.0f, -1.0f, -1.0f);
>                        gl.glColor3f(0.0f, 0.0f, 1.0f);
>                        gl.glVertex3f(-1.0f, -1.0f, -1.0f);
>                        gl.glColor3f(1.0f, 0.0f, 0.0f);
>                        gl.glVertex3f(0.0f, 1.0f, 0.0f);
>                        gl.glColor3f(0.0f, 0.0f, 1.0f);
>                        gl.glVertex3f(-1.0f, -1.0f, -1.0f);
>                        gl.glColor3f(0.0f, 1.0f, 0.0f);
>                        gl.glVertex3f(-1.0f, -1.0f, 1.0f);
>                        gl.glEnd();
>                        pyramidRotation += 0.2f;
>                        if (!canvas.getAutoSwapBufferMode()) {
>                            // this hack is only required under Windows
>                            if (isWindows) {
>                                // copy the colored content of the back buffer into the front buffer
>                                gl.glPushAttrib(GL.GL_COLOR_BUFFER_BIT);
>                                gl.glReadBuffer(GL.GL_BACK);
>                                gl.glDrawBuffer(GL.GL_FRONT);
>                                gl.glCopyPixels(0, 0, canvas.getWidth(), canvas.getHeight(),
>                                        GL2GL3.GL_COLOR);
>                                gl.glPopAttrib();
>                            }
>                            /**
>                             * when the buffers are not swapped there, the memory consumption
>                             * increases a lot
>                             */
>                            if (frameIndex % 10 == 0) {
>                                canvas.swapBuffers();
>                            }
>                            frameIndex = (frameIndex + 1) % 10;
>                        }
>                    }
>                });
>
>                // finally, add our canvas as a child of the frame
>                frame.add(canvas, BorderLayout.CENTER);
>
>                /*
>                 * Laying out the components before starting the animator is necessary because
>                 * the width of the canvas cannot be equal to zero and the SWT/AWT helper returns
>                 * AWT frames with a strange behavior (width and height equal to zero, lazy layout 
>                 * and validation). This call is not necessary in plain Swing/AWT applications.
>                 * */
>                frame.doLayout();
>
>                Animator animator = new Animator(canvas);
>                animator.start();
>
>                final ComponentAdapter thatComponentAdapter = this;
>                /*
>                 * This is a "one shot" listener, it should be called only once. Remove it
>                 * so that it will never be called while disposing or changing the viewer.
>                 * */
>                EventQueue.invokeLater(new Runnable() {
>
>                    @Override
>                    public final void run() {
>                        frame.removeComponentListener(thatComponentAdapter);
>                    }
>                });
>            }
>        });
>    }
>
>    @Override
>    public void setFocus() {
>
>    }
>
>    private static final class SWT_AWT_FrameHelper {
>
>        private static boolean x11ErrorHandlerFixInstalled = false;
>
>        /**
>         * this fix is required for GTK but not for Motif
>         */
>        private static final boolean x11ErrorHandlerFixRequiredForThisPlatform = "gtk".equals(SWT
>                .getPlatform());
>
>        /**
>         * this fix is not necessary in Java 1.7
>         */
>        private static final boolean x11ErrorHandlerFixRequiredForThisJavaVersion = isX11ErrorHandlerFixRequired();
>
>        private static final boolean isX11ErrorHandlerFixRequired() {
>            final String javaVersionWithoutUpdateNumber = System.getProperty("java.version")
>                    .substring(0, 3);
>            return (javaVersionWithoutUpdateNumber.equals("1.0")
>                    || javaVersionWithoutUpdateNumber.equals("1.1")
>                    || javaVersionWithoutUpdateNumber.equals("1.2")
>                    || javaVersionWithoutUpdateNumber.equals("1.3")
>                    || javaVersionWithoutUpdateNumber.equals("1.4")
>                    || javaVersionWithoutUpdateNumber.equals("1.5") || javaVersionWithoutUpdateNumber
>                    .equals("1.6"));
>        }
>
>        /**
>         * Workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=171432
>         */
>        private static final void initX11ErrorHandlerFix() {
>            assert EventQueue.isDispatchThread();
>
>            try {
>                // get XlibWrapper.SetToolkitErrorHandler() and XSetErrorHandler() methods
>                Class xlibwrapperClass = Class.forName("sun.awt.X11.XlibWrapper");
>                final Method setToolkitErrorHandlerMethod = xlibwrapperClass.getDeclaredMethod(
>                        "SetToolkitErrorHandler", null);
>                final Method setErrorHandlerMethod = xlibwrapperClass.getDeclaredMethod(
>                        "XSetErrorHandler", new Class[] { Long.TYPE });
>                setToolkitErrorHandlerMethod.setAccessible(true);
>                setErrorHandlerMethod.setAccessible(true);
>
>                // get XToolkit.saved_error_handler field
>                Class xtoolkitClass = Class.forName("sun.awt.X11.XToolkit");
>                final Field savedErrorHandlerField = xtoolkitClass
>                        .getDeclaredField("saved_error_handler");
>                savedErrorHandlerField.setAccessible(true);
>
>                // determine the current error handler and the value of
>                // XLibWrapper.ToolkitErrorHandler
>                // (XlibWrapper.SetToolkitErrorHandler() sets the X11 error handler to
>                // XLibWrapper.ToolkitErrorHandler and returns the old error handler)
>                final Object defaultErrorHandler = setToolkitErrorHandlerMethod.invoke(null, null);
>                final Object toolkitErrorHandler = setToolkitErrorHandlerMethod.invoke(null, null);
>                setErrorHandlerMethod.invoke(null, new Object[] { defaultErrorHandler });
>
>                // create timer that watches XToolkit.saved_error_handler whether its value is equal
>                // to XLibWrapper.ToolkitErrorHandler, which indicates the start of the trouble
>                Timer timer = new Timer(200, new ActionListener() {
>                    public void actionPerformed(ActionEvent e) {
>                        try {
>                            Object savedErrorHandler = savedErrorHandlerField.get(null);
>                            if (toolkitErrorHandler.equals(savedErrorHandler)) {
>                                // Last saved error handler in XToolkit.WITH_XERROR_HANDLER
>                                // is XLibWrapper.ToolkitErrorHandler, which will cause
>                                // the StackOverflowError when the next X11 error occurs.
>                                // Workaround: restore the default error handler.
>                                // Also update XToolkit.saved_error_handler so that
>                                // this is done only once.
>                                setErrorHandlerMethod.invoke(null,
>                                        new Object[] { defaultErrorHandler });
>                                savedErrorHandlerField.setLong(null,
>                                        ((Long) defaultErrorHandler).longValue());
>                            }
>                        }
>                        catch (Exception ex) {
>                            // ignore
>                        }
>
>                    }
>                });
>                timer.start();
>            }
>            catch (Exception ex) {
>                // ignore
>            }
>        }
>
>        private static final Frame new_Frame(Composite parent) {
>            final Frame frame = SWT_AWT.new_Frame(parent);
>            if (x11ErrorHandlerFixRequiredForThisJavaVersion
>                    && x11ErrorHandlerFixRequiredForThisPlatform && !x11ErrorHandlerFixInstalled) {
>                x11ErrorHandlerFixInstalled = true;
>                EventQueue.invokeLater(new Runnable() {
>                    public void run() {
>                        initX11ErrorHandlerFix();
>                    }
>                });
>            }
>            return (frame);
>        }
>    }
>}

Actions: View

Attachments on bug 455: 215 | 216