Merge remote-tracking branch 'origin/6.1'
[scilab.git] / 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  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15
16 package org.scilab.modules.renderer;
17
18 import org.scilab.modules.graphic_objects.ScilabNativeView;
19 import org.scilab.modules.graphic_objects.axes.Axes;
20 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
21 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject;
22 import org.scilab.modules.graphic_objects.textObject.Text;
23 import org.scilab.modules.graphic_objects.datatip.Datatip;
24
25 import org.scilab.modules.renderer.JoGLView.DrawerVisitor;
26 import org.scilab.modules.renderer.JoGLView.axes.AxesDrawer;
27 import org.scilab.modules.renderer.JoGLView.text.TextManager;
28 import org.scilab.modules.renderer.JoGLView.datatip.DatatipTextDrawer;
29
30 /**
31  * This is a static class to access the renderer module directly
32  * from C/C++ code through JNI.
33  * See SCI/modules/renderer/src/jni/renderer.giws.xml for other details.
34  **/
35 public final class CallRenderer {
36
37     /**
38      * Start an interactive zoom.
39      * @param id the uid of the figure where the zoom happen.
40      */
41     public static void startInteractiveZoom(int id) {
42         DrawerVisitor visitor = DrawerVisitor.getVisitor(id);
43         if (visitor != null) {
44             visitor.getInteractionManager().startInteractiveZoom();
45         }
46     }
47
48     public static void start_zoom(int figureId) {
49         startInteractiveZoom(ScilabNativeView.ScilabNativeView__getFigureFromIndex(figureId));
50     }
51
52     public static double[] clickRubberBox(int id, double initialRect[]) {
53         DrawerVisitor visitor = DrawerVisitor.getVisitor(id);
54         if (visitor != null) {
55             return visitor.getInteractionManager().startClickRubberBox(initialRect);
56         }
57         return new double[] { -1, -1, -1, -1, -1, -1, -1};
58     }
59
60     public static double[] dragRubberBox(int id) {
61         DrawerVisitor visitor = DrawerVisitor.getVisitor(id);
62         if (visitor != null) {
63             return visitor.getInteractionManager().startDragRubberBox();
64         }
65         return new double[] { -1, -1, -1, -1, -1, -1, -1};
66     }
67     /**
68      * Updates the coordinate transformation of the Axes object given by the identifier.
69      * @param id the Axes' identifier.
70      */
71     public static void updateSubwinScale(int id) {
72         GraphicObject object = GraphicController.getController().getObjectFromId(id);
73
74         if (object != null && object instanceof Axes) {
75             AxesDrawer.updateAxesTransformation((Axes) object);
76         }
77     }
78
79     /**
80      * Updates the corners of the text object corresponding to the identifier.
81      * @param id the text object's identifier.
82      */
83     public static void updateTextBounds(int id) {
84         GraphicObject object = GraphicController.getController().getObjectFromId(id);
85
86         if (object != null) {
87             if (object instanceof Datatip) {
88                 DatatipTextDrawer.updateTextCorners((Datatip) object);
89             } else if (object instanceof Text) {
90                 TextManager.updateTextCorners((Text) object);
91             }
92         }
93     }
94
95     /**
96      * Computes and returns the coordinates of a point projected onto the default 2d view plane.
97      * The obtained coordinates correspond to the point's object coordinates in the default 2d view
98      * coordinate frame (the point's position being fixed in window coordinates).
99      * The projected point's z coordinate is set to 0, as only x and y are relevant.
100      * @param id the identifier of the Axes object.
101      * @param coords the input object coordinates (3-element array).
102      * @return the 2d view coordinates (3-element array).
103      */
104     public static double[] get2dViewCoordinates(int id, double[] coords) {
105         double[] point2d = new double[] {0.0, 0.0, 0.0};
106
107         GraphicObject object = GraphicController.getController().getObjectFromId(id);
108
109         if (object != null && object instanceof Axes) {
110             double[] tmp = AxesDrawer.compute2dViewCoordinates((Axes) object, coords);
111
112             point2d[0] = tmp[0];
113             point2d[1] = tmp[1];
114         }
115
116         return point2d;
117     }
118
119     /**
120      * Computes and returns the pixel coordinates from a point's coordinates expressed
121      * in the default 2d view coordinate frame, using the given Axes.
122      * The returned pixel coordinates are expressed in the AWT's 2d coordinate frame.
123      * @param id the Axes' identifier.
124      * @param coords the 2d view coordinates (3-element array: x, y, z).
125      * @return the pixel coordinates (2-element array: x, y).
126      */
127     public static double[] getPixelFrom2dViewCoordinates(int id, double[] coords) {
128         double[] pointPix = new double[] {0.0, 0.0};
129
130         GraphicObject object = GraphicController.getController().getObjectFromId(id);
131
132         if (object != null && object instanceof Axes) {
133             double[] tmp = AxesDrawer.computePixelFrom2dViewCoordinates((Axes) object, coords);
134
135             pointPix[0] = tmp[0];
136             pointPix[1] = tmp[1];
137         }
138
139         return pointPix;
140     }
141
142     /**
143      * Computes and returns the coordinates of a point projected onto the default 2d view plane
144      * from its pixel coordinates, using the given Axes. The pixel coordinates are expressed in
145      * the AWT's 2d coordinate frame.
146      * The returned point's z component is set to 0, as we only have x and y as an input.
147      * @param id the Axes' identifier.
148      * @param coords the pixel coordinates (2-element array: x, y).
149      * @return the 2d view coordinates (3-element array: x, y, z).
150      */
151     public static double[] get2dViewFromPixelCoordinates(int id, double[] coords) {
152         double[] point2d = new double[] {0.0, 0.0, 0.0};
153
154         GraphicObject object = GraphicController.getController().getObjectFromId(id);
155
156         if (object != null && object instanceof Axes) {
157             double[] tmp = AxesDrawer.compute2dViewFromPixelCoordinates((Axes) object, coords);
158
159             point2d[0] = tmp[0];
160             point2d[1] = tmp[1];
161         }
162
163         return point2d;
164     }
165
166     public static double[][] getPixelFrom3dCoordinates(int id, double[] coordsX, double[] coordsY, double[] coordsZ) {
167         GraphicObject object = GraphicController.getController().getObjectFromId(id);
168         if (object instanceof Axes) {
169             return AxesDrawer.computePixelFrom3dCoordinates((Axes) object, coordsX, coordsY, coordsZ);
170         }
171
172         return null;
173     }
174
175     public static double[] getPixelFrom3dCoordinates(int id, double[] coord) {
176         GraphicObject object = GraphicController.getController().getObjectFromId(id);
177         if (object instanceof Axes) {
178             return AxesDrawer.computePixelFrom3dCoordinates((Axes) object, coord);
179         }
180
181         return null;
182     }
183
184     /**
185      * Computes and returns the viewing area of the Axes object given by the identifier.
186      * The viewing area is defined by its upper-left corner and its dimensions, all values
187      * are in pixels. It is expressed in the AWT's 2d coordinate frame.
188      * @param id the Axes' identifier.
189      * @return the Axes' viewing area (4-element array: x, y, width, height).
190      */
191     public static double[] getViewingArea(int id) {
192         double[] viewingArea = new double[] {0.0, 0.0, 0.0, 0.0};
193         GraphicObject object = GraphicController.getController().getObjectFromId(id);
194
195         if (object != null && object instanceof Axes) {
196             double[] tmp = AxesDrawer.getViewingArea((Axes) object);
197
198             viewingArea[0] = tmp[0];
199             viewingArea[1] = tmp[1];
200             viewingArea[2] = tmp[2];
201             viewingArea[3] = tmp[3];
202         }
203
204         return viewingArea;
205     }
206
207 }