DrawableFigureGL.java

Go to the documentation of this file.

/*
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) 2007 - INRIA - Jean-Baptiste Silvy
 * Copyright (C) 2008 - INRIA - Vincent Couvert
 * desc : Class containing the driver dependant routines to draw a 
 * figure object with JoGL
 * 
 * This file must be used under the terms of the CeCILL.
 * This source file is licensed as described in the file COPYING, which
 * you should have received as part of this distribution.  The terms
 * are also available at    
 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 *
 */

package org.scilab.modules.renderer.figureDrawing;

import java.lang.reflect.InvocationTargetException;

import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.swing.SwingUtilities;

import org.scilab.modules.renderer.ObjectGL;
import org.scilab.modules.renderer.FigureMapper;
import org.scilab.modules.renderer.arcDrawing.ArcRendererFactory;
import org.scilab.modules.renderer.arcDrawing.NurbsArcRendererFactory;
import org.scilab.modules.renderer.polylineDrawing.JOGLShadeFacetDrawer;
import org.scilab.modules.renderer.polylineDrawing.ShadeFacetDrawer;
import org.scilab.modules.renderer.utils.CoordinateTransformation;
import org.scilab.modules.renderer.utils.TexturedColorMap;
import org.scilab.modules.renderer.utils.glTools.ClipPlane3DManager;
import org.scilab.modules.renderer.utils.selection.RubberBox;
import org.scilab.modules.renderer.utils.textRendering.JOGLTextRendererFactory;
import org.scilab.modules.renderer.utils.textRendering.TextRendererFactory;
import org.scilab.modules.renderer.utils.textRendering.TextRendererManager;
import org.scilab.modules.renderer.ObjectGLCleaner;




public class DrawableFigureGL extends ObjectGL {
        
        private static final int[] LOGICAL_OPS = {GL.GL_CLEAR,
                                                                                          GL.GL_AND,
                                                                                          GL.GL_AND_REVERSE,
                                                                                          GL.GL_COPY,
                                                                                          GL.GL_AND_INVERTED,
                                                                                          GL.GL_NOOP,
                                                                                          GL.GL_XOR,
                                                                                          GL.GL_OR,
                                                                                          GL.GL_NOR,
                                                                                          GL.GL_EQUIV,
                                                                                          GL.GL_INVERT,
                                                                                          GL.GL_OR_REVERSE,
                                                                                          GL.GL_COPY_INVERTED,
                                                                                          GL.GL_OR_INVERTED,
                                                                                          GL.GL_NAND,
                                                                                          GL.GL_SET};
        
        
        private RendererProperties guiProperties;
        private int figureId;
        private ObjectGLCleaner destroyedObjects;
        
        private GLAutoDrawable renderingTarget;

        private ArcRendererFactory arcRendererFactory;
        
        private int backGroundColorIndex;
        
        private RubberBox rubberBox;
        
        private ShadeFacetDrawer shadeFacetDrawer;
        
        private TextRendererManager textRendererCreator;
        
        private ClipPlane3DManager clipPlaneManager;
        
        private boolean renderRequested;
        
        private CoordinateTransformation transform;
        
        private int nbSubwins;
        
        public DrawableFigureGL() {
                super();
        guiProperties = null;
        setColorMap(TexturedColorMap.create());
        figureId = -1; // figure ids should be greater than 0.
        destroyedObjects = new ObjectGLCleaner();
        renderingTarget = null;
        textRendererCreator = new TextRendererManager();
        setDefaultTextRenderer();
        setDefaultArcRendererFactory();
        setDefaultShadeFacetDrawer();
        backGroundColorIndex = 0;
        rubberBox = null;
        renderRequested = false;
        transform = new CoordinateTransformation();
        clipPlaneManager = new ClipPlane3DManager();
        nbSubwins = 0;
    }
        
        public void setDefaultTextRenderer() {
                this.setTextRendererFactory(new JOGLTextRendererFactory());
        }
        
        public void setDefaultArcRendererFactory() {
                arcRendererFactory = new NurbsArcRendererFactory();
        }
        
        public void setDefaultShadeFacetDrawer() {
                shadeFacetDrawer = new JOGLShadeFacetDrawer();
        }
        
        public CoordinateTransformation getCoordinateTransformation() {
                return transform;
        }
        
        public ClipPlane3DManager getClipPlaneManager() {
                return clipPlaneManager;
        }
        
        public void setFigureIndex(int figureId) {
                // a chack will be performed to see if the figure is alraedy here
                FigureMapper.addMapping(figureId, this);
                this.figureId = figureId;
        }
        
        public int getFigureId() {
                return figureId;
        }
        
        public void setRendererProperties(RendererProperties prop) {
                guiProperties = prop;
        }
        
        public void initializeDrawing(int parentFigureIndex) {
                // destroy all the objects stored in the destroy list
                destroyedObjects.destroyAll(parentFigureIndex);
                
                super.initializeDrawing(parentFigureIndex);
                
                GL gl = getGL();
                // don't clear the color buffer as usual, we may need to keep it
                // depending on the pixel mode
                gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
                gl.glClearDepth(1.0f);
        }
        
        public void endDrawing() {
                super.endDrawing();
        }
  
        public String getInfoMessage() {
                return guiProperties.getInfoMessage();
        }
        
        public void setInfoMessage(String infoMessage) {
                guiProperties.setInfoMessage(infoMessage);
        }

        public String getTitle() {
                return guiProperties.getTitle();
        }
        
        public void setTitle(String title) {
                guiProperties.setTitle(title);
        }

        public void drawCanvas() {
                setRenderingRequested(true);
                guiProperties.forceDisplay();
        }
        
        public void setNbSubwins(int nbSubwins) {
                this.nbSubwins = nbSubwins;
        }
        
        public int getNbSubwins() {
                return nbSubwins;
        }
        
        public synchronized boolean getRenderingRequested() {
                return renderRequested;
        }
        
        public synchronized void setRenderingRequested(boolean requested) {
                this.renderRequested = requested;
        }

        public void closeRenderingCanvas() {
                guiProperties = null;
        }
  
        public void setColorMapData(double[] rgbMat) {
                getColorMap().setData(rgbMat);
        }
        
        public double[] getColorMapData() {
                return getColorMap().getData();
        }
  
  public int getColorMapSize() {
    return getColorMap().getSize();
  }
        
        public void getColorMapData(double[] data) {
                getColorMap().getData(data);
        }
        
        public ObjectGLCleaner getObjectCleaner() {
                return destroyedObjects;
        }
        
        public RendererProperties getRendererProperties() { return guiProperties; }
        
        
        public void setBackgroundColor(int colorIndex) {
                backGroundColorIndex = colorIndex;
                double[] color = getBackgroundColor();
                getRendererProperties().setBackgroundColor(color[0], color[1], color[2]);
        }
        
        public double[] getBackgroundColor() {
                return getColorMap().getColor(backGroundColorIndex);
        }
        
        public void drawBackground() {
                GL gl = getGL();
                double[] color = getBackgroundColor();
                // not really needed actually
                gl.glClearColor((float) color[0], (float) color[1], (float) color[2], 1.0f); // alpha is set to 1
                gl.glClear(GL.GL_COLOR_BUFFER_BIT);
        }
        
        
        public void setLogicalOp(int logicOpIndex) {
                // convert to OpenGL value
                GL gl = getGL();
                gl.glEnable(GL.GL_COLOR_LOGIC_OP); // to use pixel drawing mode
                gl.glLogicOp(LOGICAL_OPS[logicOpIndex]);
        }
        
        @Override
        public void destroy(int parentFigureIndex) {
                getRendererProperties().disableCanvas();
                setRenderingRequested(false);
                // destroy all the objects stored in the destroy list
                destroyedObjects = null;
                FigureMapper.removeMapping(figureId);
        
                // blocking call. So graphic synchrnonization must be desactivated here.
                try {
                        SwingUtilities.invokeAndWait(new Runnable() {
                                public void run() {
                                        getRendererProperties().closeCanvas();
                                }
                        });
                } catch (InterruptedException e) {
                        e.printStackTrace();
                } catch (InvocationTargetException e) {
                        e.printStackTrace();
                }
                
        }
        
        
        public int getCanvasWidth() {
                return guiProperties.getCanvasWidth();
        }
        
        public int getCanvasHeight() {
                return guiProperties.getCanvasHeight();
        }
        
        public int setCanvasSize(int width, int height) {
                return guiProperties.setCanvasSize(width, height);
        }
        
        public int getWindowWidth() {
                return guiProperties.getWindowWidth();
        }
        
        public int getWindowHeight() {
                return guiProperties.getWindowHeight();
        }
        
        public void setWindowSize(int width, int height) {
                guiProperties.setWindowSize(width, height);
        }
        
        public int getWindowPosX() {
                return guiProperties.getWindowPosX();
        }
        
        public int getWindowPosY() {
                return guiProperties.getWindowPosY();
        }
        
        public void setWindowPosition(int posX, int posY) {
                guiProperties.setWindowPosition(posX, posY);
        }
        
        @Override
        public GL getGL() {
                return guiProperties.getGLPipeline();
        }
        
        
    public void setAutoResizeMode(boolean onOrOff) {
        getRendererProperties().setAutoResizeMode(onOrOff);
    }
    
    public boolean getAutoResizeMode() {
        return getRendererProperties().getAutoResizeMode();
    }
    
   public int[] getViewport() {
           return getRendererProperties().getViewport();
   }
   
        public void setViewport(int posX, int posY, int width, int height) {
                getRendererProperties().setViewport(posX, posY, width, height);
        }
        
        public void setRenderingTarget(GLAutoDrawable target) {
                this.renderingTarget = target;
        }
        
        public GLAutoDrawable getRenderingTarget() {
                return renderingTarget;
        }
        
        public void setTextRendererFactory(TextRendererFactory textRendererFactory) {
                textRendererCreator.setTextRendererFactory(textRendererFactory);
        }
        
        public void setArcRendererFactory(ArcRendererFactory arcRendererFactory) {
                this.arcRendererFactory = arcRendererFactory;
        }
        
        public ArcRendererFactory getArcRendererFactory() {
                return arcRendererFactory;
                
        }
        
        public ShadeFacetDrawer getShadeFacetDrawer() {
                return shadeFacetDrawer;
        }

        public void setShadeFacetDrawer(ShadeFacetDrawer shadeFacetDrawer) {
                this.shadeFacetDrawer = shadeFacetDrawer;
        }
        
        public synchronized void setRubberBox(RubberBox rb) {
                this.rubberBox = rb;
        }
        
        public synchronized void removeRubberBox() {
                this.rubberBox = null;
        }
        
        public synchronized RubberBox getRubberBox() {
                return this.rubberBox;
        }
        
        public synchronized boolean isRubberBoxModeOn() {
                return this.rubberBox != null;
        }
        
        public int[] rubberBox(boolean isClick, boolean isZoom, int[] initialRect) {
                
                // giws is unable to pass null pointers
                // we found a 0 sized array instead
                int[] realIntialRect;
                if (initialRect == null || initialRect.length == 0) {
                        realIntialRect = null;
                } else {
                        realIntialRect = initialRect;
                }
                
                int[] res = {0, 0, 0, 0, 0};
                
                // get [x1,y1,x2,y2] in res and button
                int button = getRendererProperties().rubberBox(isClick, isZoom, realIntialRect, res);
                res[res.length - 1] = button;
                return res;
        }
        
        public int[] getRotationDisplacement() {
                int[] res = new int[2 + 1];
                
                // get [dx, dy] displacement
                boolean stop = getRendererProperties().getRotationDisplacement(res);
                
                if (stop) {
                        res[2] = 1;
                } else {
                        res[2] = 0;
                }
                
                return res;
        }
        
        public void stopRotationRecording() {
                getRendererProperties().stopRotationRecording();
        }
        
        public TextRendererManager getTextRendererCreator() {
                return textRendererCreator;
        }
        
        public void showWindow() {
                getRendererProperties().showWindow();
        }
        
}

---