scilab/modules/renderer/src/java/org/scilab/modules/renderer/CallRenderer.java

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2012 - DIGITEO - Manuel Juliachs
   4  *
   5  * This file must be used under the terms of the CeCILL.
   6  * This source file is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at
   9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12
  13 package org.scilab.modules.renderer;
  14
  15 import org.scilab.modules.graphic_objects.axes.Axes;
  16 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
  17 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject;
  18 import org.scilab.modules.graphic_objects.textObject.Text;
  19
  20 import org.scilab.modules.renderer.JoGLView.DrawerVisitor;
  21 import org.scilab.modules.renderer.JoGLView.axes.AxesDrawer;
  22 import org.scilab.modules.renderer.JoGLView.text.TextManager;
  23
  24 /**
  25  * This is a static class to access the renderer module directly
  26  * from C/C++ code through JNI.
  27  * See SCI/modules/renderer/src/jni/renderer.giws.xml for other details.
  28  **/
  29 public final class CallRenderer {
  30
  31     /**
  32      * Start an interactive zoom.
  33      * @param id the uid of the figure where the zoom happen.
  34      */
  35     public static void startInteractiveZoom(String id) {
  36         DrawerVisitor visitor = DrawerVisitor.getVisitor(id);
  37         if (visitor != null) {
  38             visitor.getInteractionManager().startInteractiveZoom();
  39         }
  40     }
  41
  42     public static double[] clickRubberBox(String id, double initialRect[]) {
  43         DrawerVisitor visitor = DrawerVisitor.getVisitor(id);
  44         if (visitor != null) {
  45             return visitor.getInteractionManager().startClickRubberBox(initialRect);
  46         }
  47         return new double[] {-1,-1,-1,-1,-1,-1,-1};
  48     }
  49
  50     public static double[] dragRubberBox(String id) {
  51         DrawerVisitor visitor = DrawerVisitor.getVisitor(id);
  52         if (visitor != null) {
  53             return visitor.getInteractionManager().startDragRubberBox();
  54         }
  55         return new double[] {-1,-1,-1,-1,-1,-1,-1};
  56     }
  57     /**
  58      * Updates the coordinate transformation of the Axes object given by the identifier.
  59      * @param id the Axes' identifier.
  60      */
  61     public static void updateSubwinScale(String id) {
  62         GraphicObject object = GraphicController.getController().getObjectFromId(id);
  63
  64         if (object != null && object instanceof Axes) {
  65             AxesDrawer.updateAxesTransformation((Axes) object);
  66         }
  67     }
  68
  69     /**
  70      * Updates the corners of the text object corresponding to the identifier.
  71      * @param id the text object's identifier.
  72      */
  73     public static void updateTextBounds(String id) {
  74         GraphicObject object = GraphicController.getController().getObjectFromId(id);
  75
  76         if (object != null && object instanceof Text) {
  77             TextManager.updateTextCorners((Text) object);
  78         }
  79     }
  80
  81     /**
  82      * Computes and returns the coordinates of a point projected onto the default 2d view plane.
  83      * The obtained coordinates correspond to the point's object coordinates in the default 2d view
  84      * coordinate frame (the point's position being fixed in window coordinates).
  85      * The projected point's z coordinate is set to 0, as only x and y are relevant.
  86      * @param id the identifier of the Axes object.
  87      * @param coords the input object coordinates (3-element array).
  88      * @return the 2d view coordinates (3-element array).
  89      */
  90     public static double[] get2dViewCoordinates(String id, double[] coords) {
  91         double[] point2d = new double[]{0.0, 0.0, 0.0};
  92
  93         GraphicObject object = GraphicController.getController().getObjectFromId(id);
  94
  95         if (object != null && object instanceof Axes) {
  96             double[] tmp = AxesDrawer.compute2dViewCoordinates((Axes) object, coords);
  97
  98             point2d[0] = tmp[0];
  99             point2d[1] = tmp[1];
 100         }
 101
 102         return point2d;
 103     }
 104
 105     /**
 106      * Computes and returns the pixel coordinates from a point's coordinates expressed
 107      * in the default 2d view coordinate frame, using the given Axes.
 108      * The returned pixel coordinates are expressed in the AWT's 2d coordinate frame.
 109      * @param id the Axes' identifier.
 110      * @param coords the 2d view coordinates (3-element array: x, y, z).
 111      * @return the pixel coordinates (2-element array: x, y).
 112      */
 113     public static double[] getPixelFrom2dViewCoordinates(String id, double[] coords) {
 114         double[] pointPix = new double[]{0.0, 0.0};
 115
 116         GraphicObject object = GraphicController.getController().getObjectFromId(id);
 117
 118         if (object != null && object instanceof Axes) {
 119             double[] tmp = AxesDrawer.computePixelFrom2dViewCoordinates((Axes) object, coords);
 120
 121             pointPix[0] = tmp[0];
 122             pointPix[1] = tmp[1];
 123         }
 124
 125         return pointPix;
 126     }
 127
 128     /**
 129      * Computes and returns the coordinates of a point projected onto the default 2d view plane
 130      * from its pixel coordinates, using the given Axes. The pixel coordinates are expressed in
 131      * the AWT's 2d coordinate frame.
 132      * The returned point's z component is set to 0, as we only have x and y as an input.
 133      * @param id the Axes' identifier.
 134      * @param coords the pixel coordinates (2-element array: x, y).
 135      * @return the 2d view coordinates (3-element array: x, y, z).
 136      */
 137     public static double[] get2dViewFromPixelCoordinates(String id, double[] coords) {
 138         double[] point2d = new double[]{0.0, 0.0, 0.0};
 139
 140         GraphicObject object = GraphicController.getController().getObjectFromId(id);
 141
 142         if (object != null && object instanceof Axes) {
 143             double[] tmp = AxesDrawer.compute2dViewFromPixelCoordinates((Axes) object, coords);
 144
 145             point2d[0] = tmp[0];
 146             point2d[1] = tmp[1];
 147         }
 148
 149         return point2d;
 150     }
 151
 152     /**
 153      * Computes and returns the viewing area of the Axes object given by the identifier.
 154      * The viewing area is defined by its upper-left corner and its dimensions, all values
 155      * are in pixels. It is expressed in the AWT's 2d coordinate frame.
 156      * @param id the Axes' identifier.
 157      * @return the Axes' viewing area (4-element array: x, y, width, height).
 158      */
 159     public static double[] getViewingArea(String id) {
 160         double[] viewingArea = new double[]{0.0, 0.0, 0.0, 0.0};
 161         GraphicObject object = GraphicController.getController().getObjectFromId(id);
 162
 163         if (object != null && object instanceof Axes) {
 164             double[] tmp = AxesDrawer.getViewingArea((Axes) object);
 165
 166             viewingArea[0] = tmp[0];
 167             viewingArea[1] = tmp[1];
 168             viewingArea[2] = tmp[2];
 169             viewingArea[3] = tmp[3];
 170         }
 171
 172         return viewingArea;
 173     }
 174
 175 }