scilab/modules/graphics/src/c/axesScale.c

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2004-2006 - INRIA - Fabrice Leray
   4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
   5  *
   6  * This file must be used under the terms of the CeCILL.
   7  * This source file is licensed as described in the file COPYING, which
   8  * you should have received as part of this distribution.  The terms
   9  * are also available at
  10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  11  *
  12  */
  13
  14 /*------------------------------------------------------------------------*/
  15 /* file: axesScale.c                                                      */
  16 /* desc : Contains functions to compute scale changes in a specific       */
  17 /*        subwindow.                                                      */
  18 /*------------------------------------------------------------------------*/
  19
  20 #include <string.h>
  21
  22 #include "axesScale.h"
  23 #include "math_graphics.h"
  24 #include "GetProperty.h"
  25 #include "SetProperty.h"
  26 #include "Scierror.h"
  27 #include "localization.h"
  28 #include "SetPropertyStatus.h"
  29 #include "SetJavaProperty.h"
  30 #include "Interaction.h"
  31 #include "JavaInteraction.h"
  32 #include "HandleManagement.h"
  33
  34 #include "setGraphicObjectProperty.h"
  35 #include "getGraphicObjectProperty.h"
  36 #include "graphicObjectProperties.h"
  37
  38 /*------------------------------------------------------------------------------*/
  39 /**
  40  * Specify new zoom box for a subwin object.
  41  * @param subwinUID the subwin's identifier.
  42  * @param zoomRect vector [xMin, yMin, xMax, yMax].
  43  */
  44 int sciZoom2D(int iSubwinUID, const double zoomRect[4])
  45 {
  46     if (iSubwinUID != 0)
  47     {
  48         double* zoomBox = NULL;
  49         // add Z scale to data bounds.
  50         getGraphicObjectProperty(iSubwinUID, __GO_DATA_BOUNDS__, jni_double_vector, (void **) &zoomBox);
  51
  52         zoomBox[0] = zoomRect[0];
  53         zoomBox[1] = zoomRect[1];
  54         zoomBox[2] = zoomRect[2];
  55         zoomBox[3] = zoomRect[3];
  56
  57         return sciZoom3D(iSubwinUID, zoomBox);
  58     }
  59     else
  60     {
  61         return SET_PROPERTY_ERROR;
  62     }
  63 }
  64 /*------------------------------------------------------------------------------*/
  65 /**
  66  * Specify a new zoom box for a subwin object
  67  * @param subwinUID the subwin's identifier.
  68  * @param zoomBox vector [xMin, yMin, xMax, yMax, zMin, zMax].
  69  */
  70 int sciZoom3D(int iSubwinUID, const double zoomBox[6])
  71 {
  72     BOOL status = FALSE;
  73     int zoomEnabled = 1;
  74
  75     // convert zoomBox to [xMin, xMax, yMin, yMax, zMin, zMax]
  76     double zoomBox3D[6];
  77     zoomBox3D[0] = zoomBox[0];
  78     zoomBox3D[1] = zoomBox[2];
  79     zoomBox3D[2] = zoomBox[1];
  80     zoomBox3D[3] = zoomBox[3];
  81     zoomBox3D[4] = zoomBox[4];
  82     zoomBox3D[5] = zoomBox[5];
  83
  84     if (!checkDataBounds(iSubwinUID, zoomBox3D[0], zoomBox3D[1], zoomBox3D[2],
  85                          zoomBox3D[3], zoomBox3D[4], zoomBox3D[5]))
  86     {
  87         return SET_PROPERTY_ERROR;
  88     }
  89
  90     status = setGraphicObjectProperty(iSubwinUID, __GO_ZOOM_BOX__, zoomBox3D, jni_double_vector, 6);
  91
  92     if (status != TRUE)
  93     {
  94         Scierror(999, _("'%s' property does not exist for this handle.\n"), "zoom_box");
  95         return SET_PROPERTY_ERROR;
  96     }
  97
  98     status = setGraphicObjectProperty(iSubwinUID, __GO_ZOOM_ENABLED__, &zoomEnabled, jni_bool, 1);
  99
 100     if (status == TRUE)
 101     {
 102         return SET_PROPERTY_SUCCEED;
 103     }
 104     else
 105     {
 106         return SET_PROPERTY_ERROR;
 107     }
 108
 109 }
 110 /*------------------------------------------------------------------------------*/
 111 int sciZoomRect(int iObjUID, const double zoomRect[4])
 112 {
 113     int iType = -1;
 114     int *piType = &iType;
 115     getGraphicObjectProperty(iObjUID, __GO_TYPE__, jni_int, (void **) &piType);
 116     if (iType == __GO_FIGURE__)
 117     {
 118         return sciFigureZoom2D(iObjUID, zoomRect);
 119     }
 120     else if (iType == __GO_AXES__)
 121     {
 122         return sciZoom2D(iObjUID, zoomRect);
 123     }
 124     else
 125     {
 126         return SET_PROPERTY_ERROR;
 127     }
 128 }
 129 /*------------------------------------------------------------------------------*/
 130 int sciFigureZoom2D(int iFigureUID, const double zoomRect[4])
 131 {
 132     int i = 0;
 133     int childrenCount = 0;
 134     int* pChildrenCount = &childrenCount;
 135
 136     int* piChildren = NULL;
 137
 138     getGraphicObjectProperty(iFigureUID, __GO_CHILDREN_COUNT__, jni_int, (void **) &pChildrenCount);
 139
 140     if ((pChildrenCount != NULL) && (childrenCount > 0))
 141     {
 142         getGraphicObjectProperty(iFigureUID, __GO_CHILDREN__, jni_int_vector, (void **) &piChildren);
 143         for (i = 0; i < childrenCount; i++)
 144         {
 145             sciZoomRect(piChildren[i], zoomRect);
 146         }
 147     }
 148
 149     return SET_PROPERTY_SUCCEED;
 150 }
 151 /*------------------------------------------------------------------------------*/
 152 /**
 153  * Check if the following data bounds can be used as new data bounds for the subwin object
 154  * @param subwinUID the subwin's identifier.
 155  * @param the lower x bound.
 156  * @param the upper x bound.
 157  * @param the lower y bound.
 158  * @param the upper y bound.
 159  * @param the lower z bound.
 160  * @param the upper z bound.
 161  * @return TRUE if values can be used, false otherwise
 162  */
 163 BOOL checkDataBounds(int iSubwinUID, double xMin, double xMax,
 164                      double yMin, double yMax, double zMin, double zMax)
 165 {
 166     char logFlags[3];
 167
 168     sciGetLogFlags(iSubwinUID, logFlags);
 169
 170     /* check if there is not an inf within the values */
 171     /* since this has not any meaning */
 172     if (   !finite(xMin) || !finite(xMax)
 173             || !finite(yMin) || !finite(yMax)
 174             || !finite(zMin) || !finite(zMax))
 175     {
 176         Scierror(999, "Error : data bounds values must be finite.");
 177         return FALSE;
 178     }
 179
 180     /* check if the bounds are correct */
 181     /* allows equality with bounds since it is working */
 182     if (xMin > xMax || yMin > yMax || zMin > zMax)
 183     {
 184         Scierror(999, "Error : Min and Max values for one axis do not verify Min <= Max.\n");
 185         return FALSE;
 186     }
 187
 188     /* check for logflags that values are greater than 0 */
 189     if (  (logFlags[0] == 'l' && xMin <= 0.0)
 190             || (logFlags[1] == 'l' && yMin <= 0.0)
 191             || (logFlags[2] == 'l' && zMin <= 0.0))
 192     {
 193         Scierror(999, "Error: Bounds on axis must be strictly positive to use logarithmic mode.\n");
 194         return FALSE;
 195     }
 196
 197     return TRUE;
 198 }
 199 /*------------------------------------------------------------------------------*/
 200 /**
 201  * Unzoom a single subwindow
 202  */
 203 void sciUnzoomSubwin(int iSubwinUID)
 204 {
 205     int iParentFigure = 0;
 206     int* piParent = &iParentFigure;
 207     int zoomEnabled = 0;
 208
 209     getGraphicObjectProperty(iSubwinUID, __GO_PARENT_FIGURE__, jni_int, (void **) &piParent);
 210
 211     if (iSubwinUID == 0 || iParentFigure == 0)
 212     {
 213         return;
 214     }
 215
 216     setGraphicObjectProperty(iSubwinUID, __GO_ZOOM_ENABLED__, (void **) &zoomEnabled, jni_bool, 1);
 217 }
 218 /*------------------------------------------------------------------------------*/
 219 /**
 220  * Unzoom all the subwindows contained in a figure
 221  */
 222 void sciUnzoomFigure(int iFigureUID)
 223 {
 224     int iType = -1;
 225     int *piType = &iType;
 226     int* piChildrenUID = NULL;
 227
 228     int i = 0;
 229     int zoomEnabled = 0;
 230     int childrenCount = 0;
 231     int* piChildrenCount = &childrenCount;
 232
 233     getGraphicObjectProperty(iFigureUID, __GO_CHILDREN__, jni_int_vector, (void **) &piChildrenUID);
 234     getGraphicObjectProperty(iFigureUID, __GO_CHILDREN_COUNT__, jni_int, (void **) &piChildrenCount);
 235
 236     if (piChildrenCount != NULL)
 237     {
 238
 239         for (i = 0; i < childrenCount; i++)
 240         {
 241             getGraphicObjectProperty(piChildrenUID[i], __GO_TYPE__, jni_int, (void **) &piType);
 242             if (iType == __GO_AXES__)
 243             {
 244                 setGraphicObjectProperty(piChildrenUID[i], __GO_ZOOM_ENABLED__, (void **) &zoomEnabled, jni_bool, 1);
 245             }
 246         }
 247     }
 248 }
 249 /*------------------------------------------------------------------------------*/
 250 /**
 251  * Unzoom a set of subwindows and figures
 252  * @param objectsUID array of figure and subwindow objects id.
 253  * @param nbObjects number of objects.
 254  */
 255 void sciUnzoomArray(int* piObjUID, int nbObjects)
 256 {
 257     /* object type */
 258     int iType = -1;
 259     int *piType = &iType;
 260     int i = 0;
 261     for (i = 0; i < nbObjects; i++)
 262     {
 263         getGraphicObjectProperty(piObjUID[i], __GO_TYPE__, jni_int, (void **) &piType);
 264         if (iType == __GO_FIGURE__)
 265         {
 266             /* Unzoom all subwindows of the figure */
 267             sciUnzoomFigure(piObjUID[i]);
 268         }
 269         else if (iType == __GO_AXES__)
 270         {
 271             /* Unzoom the axes */
 272             sciUnzoomSubwin(piObjUID[i]);
 273         }
 274
 275     }
 276 }
 277 /*--------------------------------------------------------------------------------*/
 278 void updateSubwinScale(int iSubwinUID)
 279 {
 280     sciJavaUpdateSubwinScale(iSubwinUID);
 281 }
 282 /*------------------------------------------------------------------------------*/
 283 void updateTextBounds(int iTextUID)
 284 {
 285     int iParentAxes = 0;
 286     int* piParent = &iParentAxes;
 287
 288     /* Update coordinate transformation if needed */
 289     getGraphicObjectProperty(iTextUID, __GO_PARENT_AXES__, jni_int, (void **) &piParent);
 290     updateSubwinScale(iParentAxes);
 291
 292     /* Compute the bounding box of the text */
 293     sciJavaUpdateTextBoundingBox(iTextUID);
 294 }
 295 /*------------------------------------------------------------------------------*/