Fix bug 3115.
Jean-baptiste Silvy [Fri, 20 Jun 2008 13:09:32 +0000 (13:09 +0000)]
Also return real ticks labels in logarithmic mode.

26 files changed:
scilab/modules/graphics/includes/BasicAlgos.h
scilab/modules/graphics/includes/GetProperty.h
scilab/modules/graphics/src/c/BasicAlgos.c
scilab/modules/graphics/src/c/GetProperty.c
scilab/modules/graphics/src/c/getHandleProperty/getPropertyAssignedValue.c
scilab/modules/graphics/src/c/getHandleProperty/get_ticks_utils.c
scilab/modules/graphics/src/c/getHandleProperty/get_x_ticks_property.c
scilab/modules/graphics/src/c/getHandleProperty/get_y_ticks_property.c
scilab/modules/graphics/src/c/getHandleProperty/get_z_ticks_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_x_ticks_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_y_ticks_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_z_ticks_property.c
scilab/modules/graphics/tests/nonreg_tests/bug_3115.tst [new file with mode: 0644]
scilab/modules/renderer/graphics_Import.def
scilab/modules/renderer/includes/GetJavaProperty.h
scilab/modules/renderer/src/cpp/GetJavaProperty.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/ComputeBoundsStrategy.hxx
scilab/modules/renderer/src/cpp/subwinDrawing/ConcreteDrawableSubwin.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/ConcreteDrawableSubwin.hxx
scilab/modules/renderer/src/cpp/subwinDrawing/DrawableSubwin.h
scilab/modules/renderer/src/cpp/subwinDrawing/LinearBoundsComputer.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/LinearBoundsComputer.hxx
scilab/modules/renderer/src/cpp/subwinDrawing/LogarithmicBoundsComputer.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/LogarithmicBoundsComputer.hxx
scilab/modules/renderer/src/cpp/subwinDrawing/TicksDrawer.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/TicksDrawer.hxx

index 6556b97..5a9e33d 100644 (file)
@@ -99,6 +99,11 @@ int * createIntArrayCopy( const int src[], int nbElement ) ;
  * allocate a copy of a string array
  */
 char ** createStringArrayCopy( char * src[], int nbElement ) ;
+
+/**
+ * allocate a string array and set all its element to NULL
+ */
+char ** createStringArray(int nbElement);
 /*--------------------------------------------------------------------------*/
 
 #endif /* _BASIC_ALGOS_H_ */
index 19d0a74..7904917 100644 (file)
@@ -268,6 +268,13 @@ BOOL sciGetUseNurbs(sciPointObj * pObj); /* GET */
 
 BOOL sciGetIsUsingFractionalMetrics(sciPointObj * pObj); /* GET */
 
+int sciGetNbXTicks(sciPointObj * pSubwin);
+void sciGetXTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels);
+int sciGetNbYTicks(sciPointObj * pSubwin);
+void sciGetYTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels);
+int sciGetNbZTicks(sciPointObj * pSubwin);
+void sciGetZTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels);
+
 void printSetGetErrorMessage(const char * propertyName);
 
 #endif /* __SCI_GET_PROPERTY__ */
index e191fb1..59fadad 100644 (file)
@@ -207,6 +207,21 @@ int * createIntArrayCopy( const int src[], int nbElement )
 /*--------------------------------------------------------------------------*/
 char ** createStringArrayCopy( char * src[], int nbElement )
 {
+  char ** res = createStringArray(nbElement);
+
+  if ( res == NULL )
+  {
+    return NULL ;
+  }
+
+  stringArrayCopy( res, src, nbElement ) ;
+
+  return res ;
+
+}
+/*--------------------------------------------------------------------------*/
+char ** createStringArray(int nbElement)
+{
   int i ;
   char ** res = MALLOC( nbElement * sizeof(char *) ) ;
 
@@ -220,9 +235,6 @@ char ** createStringArrayCopy( char * src[], int nbElement )
     res[i] = NULL ;
   }
 
-  stringArrayCopy( res, src, nbElement ) ;
-
   return res ;
-
 }
 /*--------------------------------------------------------------------------*/
index 2fc03db..309332b 100644 (file)
@@ -4437,6 +4437,57 @@ BOOL sciGetIsUsingFractionalMetrics(sciPointObj * pObj)
 }
 /*----------------------------------------------------------------------------------*/
 /**
+ * Get number of ticks along X axis of a subwindow.
+ */
+int sciGetNbXTicks(sciPointObj * pSubwin)
+{
+  return sciGetJavaNbXTicks(pSubwin);
+}
+/*----------------------------------------------------------------------------------*/
+/**
+ * Get the labels and positions of ticks along X axis.
+ * String composing ticksLabels are allocated with MALLOC.
+ */
+void sciGetXTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
+{
+  sciGetJavaXTicksPos(pSubwin, ticksPos, ticksLabels);
+}
+/*----------------------------------------------------------------------------------*/
+/**
+ * Get number of ticks along Y axis of a subwindow.
+ */
+int sciGetNbYTicks(sciPointObj * pSubwin)
+{
+  return sciGetJavaNbYTicks(pSubwin);
+}
+/*----------------------------------------------------------------------------------*/
+/**
+ * Get the labels and positions of ticks along Y axis.
+ * String composing ticksLabels are allocated with C++ new.
+ */
+void sciGetYTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
+{
+  sciGetJavaYTicksPos(pSubwin, ticksPos, ticksLabels);
+}
+/*----------------------------------------------------------------------------------*/
+/**
+ * Get number of ticks along Z axis of a subwindow.
+ */
+int sciGetNbZTicks(sciPointObj * pSubwin)
+{
+  return sciGetJavaNbZTicks(pSubwin);
+}
+/*----------------------------------------------------------------------------------*/
+/**
+ * Get the labels and positions of ticks along Z axis.
+ * String composing ticksLabels are allocated with C++ new.
+ */
+void sciGetZTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
+{
+  sciGetJavaZTicksPos(pSubwin, ticksPos, ticksLabels);
+}
+/*----------------------------------------------------------------------------------*/
+/**
  * Print the message "This object has no xxx property." in Scilab.
  */
 void printSetGetErrorMessage(const char * propertyName)
index f3d5eca..43701ca 100644 (file)
@@ -312,8 +312,7 @@ double * createCopyDoubleMatrixFromList( AssignedList * list, int * nbRow, int *
 /*--------------------------------------------------------------------------*/
 char ** createCopyStringMatrixFromList( AssignedList * list, int * nbRow, int * nbCol )
 {
-  /* get the matrix */
-  char ** stackValues = getCurrentStringMatrixFromList( list, nbRow, nbCol ) ;
+  char ** stackValues = NULL; 
   int nbElement = (*nbRow) * (*nbCol) ;
 
   if ( nbElement == 0 )
@@ -321,6 +320,9 @@ char ** createCopyStringMatrixFromList( AssignedList * list, int * nbRow, int *
     return NULL ;
   }
 
+  /* get the matrix */
+  stackValues = getCurrentStringMatrixFromList( list, nbRow, nbCol ) ;
+
   return createStringArrayCopy( stackValues, nbElement ) ;
 }
 /*--------------------------------------------------------------------------*/
index 5851653..0f869f2 100644 (file)
@@ -27,9 +27,18 @@ int buildTListForTicks( const double * locations, char * labels[], int nbTics )
 
   returnedList * tList = createReturnedList( 2, variable_tlist ) ;
 
-  addColVectorToReturnedList( tList, locations, nbTics ) ;
-  addStringColVectorToReturnedList( tList, labels, nbTics ) ;
-
+  if (nbTics == 0)
+  {
+    // two empty matrices
+    addColVectorToReturnedList( tList, NULL, 0 ) ;
+    addColVectorToReturnedList( tList, NULL, 0 ) ;
+  }
+  else
+  {
+    addColVectorToReturnedList( tList, locations, nbTics ) ;
+    addStringColVectorToReturnedList( tList, labels, nbTics ) ;
+  }
+  
   destroyReturnedList( tList ) ;
 
   return 0;
index 03736bc..3191f32 100644 (file)
 /*------------------------------------------------------------------------*/
 int get_x_ticks_property( sciPointObj * pobj )
 {
-  sciSubWindow * ppSubWin = NULL ;
-  BOOL autoTicks[3];
-  char c_format[5];
+
+  int nbTicks;
+
   if ( sciGetEntityType( pobj ) != SCI_SUBWIN )
   {
     sciprint(_("%s property does not exist for this label.\n"),"x_ticks") ;
     return -1 ;
   }
 
-  ppSubWin = pSUBWIN_FEATURE( pobj ) ;
-
-  /* compute the c_format used for convert double to char (for labels) */
-  ChooseGoodFormat( c_format, ppSubWin->logflags[0], ppSubWin->axes.xgrads, ppSubWin->axes.nxgrads ) ;
-
-  sciGetAutoTicks(pobj, autoTicks);
-  if( autoTicks[0] )
+  /* retrieve number of ticks */
+  nbTicks = sciGetNbXTicks(pobj);
+  if (nbTicks == 0)
   {
-    int       nbtics        = ppSubWin->axes.nxgrads ;
-    char   ** tickslabel    = NULL                   ;
-    double *  ticksPosition = NULL                   ;
-    
-    ticksPosition = ReBuildTicksLog2Lin( ppSubWin->logflags[0], nbtics, ppSubWin->axes.xgrads ) ;
-    
-    /* convert double to strings */
-    tickslabel = copyFormatedArray( ticksPosition, nbtics, c_format, 100 ) ;
-    
-    /* construction de la tlist */
-    buildTListForTicks( ticksPosition, tickslabel, nbtics ) ;
-    
-    /* free tickslabel */
-    destroyStringArray( tickslabel, nbtics ) ;
-    FREE( ticksPosition ) ;
-    return 0 ;
+    /* return empty matrices */
+    buildTListForTicks( NULL, NULL, 0) ;
   }
-  else /* we display the x tics specified by the user*/
+  else
   {
-    int      nbtics        = ppSubWin->axes.u_nxgrads ;
-    double * ticksPosition = ReBuildTicksLog2Lin(ppSubWin->logflags[0],nbtics,ppSubWin->axes.u_xgrads) ;
-    
-    buildTListForTicks( ticksPosition, ppSubWin->axes.u_xlabels, nbtics ) ;
-    
-    FREE( ticksPosition ) ;
-    return 0 ;
+    char ** labels;
+    double * positions;
+    /* allocate arrays */
+    positions = MALLOC(nbTicks * sizeof(double));
+    labels = createStringArray(nbTicks);
+
+    sciGetXTicksPos(pobj, positions, labels);
+
+    buildTListForTicks( positions, labels, nbTicks ) ;
+
+    /* free arrays */
+    destroyStringArray(labels, nbTicks);
+    FREE(positions);
   }
 
+  return 0;
 }
 /*------------------------------------------------------------------------*/
index d9d5786..8b0cfed 100644 (file)
 /*------------------------------------------------------------------------*/
 int get_y_ticks_property( sciPointObj * pobj )
 {
-  sciSubWindow * ppSubWin = NULL ;
-  BOOL autoTicks[3];
-  char c_format[5];
+  
+  int nbTicks;
+
   if ( sciGetEntityType( pobj ) != SCI_SUBWIN )
   {
-    sciprint(_("%s property does not exist for this label.\n"),"y_ticks") ;
+    sciprint(_("%s property does not exist for this label.\n"),"x_ticks") ;
     return -1 ;
   }
 
-  ppSubWin = pSUBWIN_FEATURE( pobj ) ;
-
-  /* compute the c_format used for convert double to char (for labels) */
-  ChooseGoodFormat( c_format, ppSubWin->logflags[1], ppSubWin->axes.ygrads, ppSubWin->axes.nygrads ) ;
-
-  sciGetAutoTicks(pobj, autoTicks);
-  if( autoTicks[1] )
+  /* retrieve number of ticks */
+  nbTicks = sciGetNbYTicks(pobj);
+  if (nbTicks == 0)
   {
-    int       nbtics        = ppSubWin->axes.nygrads ;
-    char   ** ticklabel     = NULL                   ;
-    double *  ticksPosition = NULL                   ;
-
-    ticksPosition = ReBuildTicksLog2Lin( ppSubWin->logflags[1], nbtics, ppSubWin->axes.ygrads ) ;
-
-    /* convert double to strings */
-    ticklabel = copyFormatedArray( ticksPosition, nbtics, c_format, 100 ) ;
-
-    /* construction de la tlist */
-    buildTListForTicks( ticksPosition, ticklabel, nbtics ) ;
-
-    /* free ticklabel */
-    destroyStringArray( ticklabel, nbtics ) ;
-    FREE( ticksPosition ) ;
-    return 0 ;
+    /* return empty matrices */
+    buildTListForTicks( NULL, NULL, 0) ;
   }
-  else /* we display the x tics specified by the user*/
+  else
   {
-    int      nbtics        = ppSubWin->axes.u_nygrads ;
-    double * ticksPosition = ReBuildTicksLog2Lin( ppSubWin->logflags[1], nbtics, ppSubWin->axes.u_ygrads ) ;
+    char ** labels;
+    double * positions;
+    /* allocate arrays */
+    positions = MALLOC(nbTicks * sizeof(double));
+    labels = createStringArray(nbTicks);
 
-    buildTListForTicks( ticksPosition, ppSubWin->axes.u_ylabels, nbtics ) ;
+    sciGetYTicksPos(pobj, positions, labels);
 
-    FREE( ticksPosition ) ;
-    return 0 ;
+    buildTListForTicks( positions, labels, nbTicks ) ;
+
+    /* free arrays */
+    destroyStringArray(labels, nbTicks);
+    FREE(positions);
   }
 
+  return 0;
+
 }
 /*------------------------------------------------------------------------*/
index 46b15f6..c5d6f24 100644 (file)
 /*------------------------------------------------------------------------*/
 int get_z_ticks_property( sciPointObj * pobj )
 {
-  sciSubWindow * ppSubWin = NULL ;
-  BOOL autoTicks[3];
-  char c_format[5];
+ int nbTicks;
+
   if ( sciGetEntityType( pobj ) != SCI_SUBWIN )
   {
-    sciprint(_("%s property does not exist for this label.\n"),"z_ticks") ;
+    sciprint(_("%s property does not exist for this label.\n"),"x_ticks") ;
     return -1 ;
   }
 
-  ppSubWin = pSUBWIN_FEATURE( pobj ) ;
-
-  /* compute the c_format used for convert double to char (for labels) */
-  ChooseGoodFormat( c_format, ppSubWin->logflags[2], ppSubWin->axes.zgrads, ppSubWin->axes.nzgrads ) ;
-
-  sciGetAutoTicks(pobj, autoTicks);
-  if( autoTicks[2] )
+  /* retrieve number of ticks */
+  nbTicks = sciGetNbZTicks(pobj);
+  if (nbTicks == 0)
   {
-    int       nbtics        = ppSubWin->axes.nzgrads ;
-    char   ** ticklabel     = NULL                   ;
-    double *  ticksPosition = NULL                   ;
-
-    ticksPosition = ReBuildTicksLog2Lin( ppSubWin->logflags[2], nbtics, ppSubWin->axes.zgrads ) ;
-
-    /* convert double to strings */
-    ticklabel = copyFormatedArray( ticksPosition, nbtics, c_format, 100 ) ;
-
-    /* construction de la tlist */
-    buildTListForTicks( ticksPosition, ticklabel, nbtics ) ;
-
-    /* free ticklabel */
-    destroyStringArray( ticklabel, nbtics ) ;
-    FREE( ticksPosition ) ;
-    return 0 ;
+    /* return empty matrices */
+    buildTListForTicks( NULL, NULL, 0) ;
   }
-  else /* we display the x tics specified by the user*/
+  else
   {
-    int      nbtics        = ppSubWin->axes.u_nzgrads ;
-    double * ticksPosition = ReBuildTicksLog2Lin( ppSubWin->logflags[2], nbtics, ppSubWin->axes.u_zgrads ) ;
+    char ** labels;
+    double * positions;
+    /* allocate arrays */
+    positions = MALLOC(nbTicks * sizeof(double));
+    labels = createStringArray(nbTicks);
 
-    buildTListForTicks( ticksPosition, ppSubWin->axes.u_zlabels, nbtics ) ;
+    sciGetZTicksPos(pobj, positions, labels);
 
-    FREE( ticksPosition ) ;
-    return 0 ;
+    buildTListForTicks( positions, labels, nbTicks ) ;
+
+    /* free arrays */
+    destroyStringArray(labels, nbTicks);
+    FREE(positions);
   }
 
+  return 0;
+
 }
 /*------------------------------------------------------------------------*/
index f321a24..c699bc1 100644 (file)
@@ -70,21 +70,16 @@ int set_x_ticks_property( sciPointObj * pobj, int stackPointer, int valueType, i
 
   ppSubWin->axes.u_xgrads = createCopyDoubleMatrixFromList( tlist, &nbTicsRow, &nbTicsCol ) ;
 
-  if ( ppSubWin->axes.u_xgrads == NULL )
+  if ( ppSubWin->axes.u_xgrads == NULL && nbTicsRow == -1 )
   {
-    if ( nbTicsRow == -1 )
-    {
-      sciprint(_("%s: No more memory.\n"),"set_x_ticks_property");
-      return SET_PROPERTY_ERROR ;
-    }
-    /* empty matrix nothing to do*/
-    return SET_PROPERTY_SUCCEED ;
+    sciprint(_("%s: No more memory.\n"),"set_x_ticks_property");
+    return SET_PROPERTY_ERROR ;
   }
 
   if ( ppSubWin->logflags[0] == 'l' )
   {
     int  i ;
-    for ( i = 0 ; i < nbTicsCol * nbTicsCol ; i++ )
+    for ( i = 0 ; i < nbTicsCol * nbTicsRow ; i++ )
     {
       ppSubWin->axes.u_xgrads[i] = log10( ppSubWin->axes.u_xgrads[i] ) ;
     }
index f4294c8..bdabf68 100644 (file)
@@ -70,15 +70,10 @@ int set_y_ticks_property( sciPointObj * pobj, int stackPointer, int valueType, i
 
   ppSubWin->axes.u_ygrads = createCopyDoubleMatrixFromList( tlist, &nbTicsRow, &nbTicsCol ) ;
 
-  if ( ppSubWin->axes.u_ygrads == NULL )
+  if ( ppSubWin->axes.u_ygrads == NULL && nbTicsRow == -1 )
   {
-    if ( nbTicsRow == -1 )
-    {
-               sciprint(_("%s: No more memory.\n"),"set_y_ticks_property");
+      sciprint(_("%s: No more memory.\n"),"set_y_ticks_property");
       return SET_PROPERTY_ERROR ;
-    }
-    /* empty matrix nothing to do*/
-    return SET_PROPERTY_SUCCEED ;
   }
 
   if ( ppSubWin->logflags[1] == 'l' )
index 345db6e..c183fb6 100644 (file)
@@ -70,15 +70,11 @@ int set_z_ticks_property( sciPointObj * pobj, int stackPointer, int valueType, i
 
   ppSubWin->axes.u_zgrads = createCopyDoubleMatrixFromList( tlist, &nbTicsRow, &nbTicsCol ) ;
 
-  if ( ppSubWin->axes.u_zgrads == NULL )
+  if ( ppSubWin->axes.u_zgrads == NULL && nbTicsRow == -1 )
   {
-    if ( nbTicsRow == -1 )
-    {
-      sciprint(_("%s: No more memory.\n"),"set_z_ticks_property");
-      return SET_PROPERTY_ERROR ;
-    }
-    /* empty matrix nothing to do*/
-    return SET_PROPERTY_SUCCEED ;
+    // if nbTicsRow = 0, it's just an empty matrix
+    sciprint(_("%s: No more memory.\n"),"set_z_ticks_property");
+    return SET_PROPERTY_ERROR ;
   }
 
   if ( ppSubWin->logflags[2] == 'l' )
diff --git a/scilab/modules/graphics/tests/nonreg_tests/bug_3115.tst b/scilab/modules/graphics/tests/nonreg_tests/bug_3115.tst
new file mode 100644 (file)
index 0000000..bf2485a
--- /dev/null
@@ -0,0 +1,27 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008-2008 - INRIA - Jean-Baptiste Silvy
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- TEST WITH GRAPHIC -->
+
+// <-- Non-regression test for bug 3115 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=3115
+//
+// <-- Short Description -->
+// In log mode the ticks locations properties are wrong in scilab5:
+
+clf()
+plot([0.01,100],[1,10]);a=gca();a.log_flags='lln';
+
+// check that ticks loacations are right
+if ( a.x_ticks.locations <> [0.01;0.1;1;10;100] ) then pause; end
+if ( a.y_ticks.locations <> [1;10] ) then pause; end
+
+
+
index f896d1c..6c25c9c 100644 (file)
@@ -141,3 +141,4 @@ sciSetZooming
 sciSetVisibility
 sciGetUseNurbs
 sciGetIsUsingFractionalMetrics
+stringArrayCopy
index def4e1b..27ae198 100644 (file)
@@ -95,6 +95,40 @@ BOOL sciGetJavaAutoResizeMode(sciPointObj * pFigure);
  */
 void sciGetJavaViewport(sciPointObj * pFigure, int viewport[4]);
 
+/**
+ * Get number of ticks along X axis of a subwindow.
+ */
+int sciGetJavaNbXTicks(sciPointObj * pSubwin);
+
+/**
+ * Get the labels and positions of ticks along X axis.
+ * String composing ticksLabels are allocated with MALLOC.
+ */
+void sciGetJavaXTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels);
+
+/**
+ * Get number of ticks along Y axis of a subwindow.
+ */
+int sciGetJavaNbYTicks(sciPointObj * pSubwin);
+
+/**
+ * Get the labels and positions of ticks along Y axis.
+ * String composing ticksLabels are allocated with MALLOC.
+ */
+void sciGetJavaYTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels);
+
+/**
+ * Get number of ticks along Z axis of a subwindow.
+ */
+int sciGetJavaNbZTicks(sciPointObj * pSubwin);
+
+/**
+ * Get the labels and positions of ticks along Z axis.
+ * String composing ticksLabels are allocated with MALLOC.
+ */
+void sciGetJavaZTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels);
+
+
 #ifdef __cplusplus
 }
 #endif
index aa30903..851bd91 100644 (file)
 #include "GetJavaProperty.h"
 #include "getHandleDrawer.h"
 #include "figureDrawing/DrawableFigure.h"
+#include "BasicAlgos.hxx"
+
+extern "C"
+{
+#include "BasicAlgos.h"
+}
 
 using namespace sciGraphics ;
 
@@ -92,3 +98,63 @@ void sciGetJavaViewport(sciPointObj * pFigure, int viewport[4])
   getFigureDrawer(pFigure)->getViewport(viewport);
 }
 /*---------------------------------------------------------------------------------*/
+int sciGetJavaNbXTicks(sciPointObj * pSubwin)
+{
+  return getSubwinDrawer(pSubwin)->getNbXTicks();
+}
+/*---------------------------------------------------------------------------------*/
+void sciGetJavaXTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
+{
+  // ticksLabels comes from graphics so is allocated with MALLOC
+  // however getTicksPos will use new to allocate
+  int nbTicks = sciGetJavaNbXTicks(pSubwin);
+  char ** javaLabels = BasicAlgos::createStringArray(nbTicks);
+  
+  getSubwinDrawer(pSubwin)->getXTicksPos(ticksPos, javaLabels);
+
+  // copy it into ticksLabels
+  stringArrayCopy(ticksLabels, javaLabels, nbTicks);
+
+  BasicAlgos::destroyStringArray(javaLabels, nbTicks);
+}
+/*---------------------------------------------------------------------------------*/
+int sciGetJavaNbYTicks(sciPointObj * pSubwin)
+{
+  return getSubwinDrawer(pSubwin)->getNbYTicks();
+}
+/*---------------------------------------------------------------------------------*/
+void sciGetJavaYTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
+{
+  // ticksLabels comes from graphics so is allocated with MALLOC
+  // however getTicksPos will use new to allocate
+  int nbTicks = sciGetJavaNbYTicks(pSubwin);
+  char ** javaLabels = BasicAlgos::createStringArray(nbTicks);
+  
+  getSubwinDrawer(pSubwin)->getYTicksPos(ticksPos, javaLabels);
+
+  // copy it into ticksLabels
+  stringArrayCopy(ticksLabels, javaLabels, nbTicks);
+
+  BasicAlgos::destroyStringArray(javaLabels, nbTicks);
+}
+/*---------------------------------------------------------------------------------*/
+int sciGetJavaNbZTicks(sciPointObj * pSubwin)
+{
+  return getSubwinDrawer(pSubwin)->getNbZTicks();
+}
+/*---------------------------------------------------------------------------------*/
+void sciGetJavaZTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
+{
+  // ticksLabels comes from graphics so is allocated with MALLOC
+  // however getTicksPos will use new to allocate
+  int nbTicks = sciGetJavaNbZTicks(pSubwin);
+  char ** javaLabels = BasicAlgos::createStringArray(nbTicks);
+  
+  getSubwinDrawer(pSubwin)->getZTicksPos(ticksPos, javaLabels);
+
+  // copy it into ticksLabels
+  stringArrayCopy(ticksLabels, javaLabels, nbTicks);
+
+  BasicAlgos::destroyStringArray(javaLabels, nbTicks);
+}
+/*---------------------------------------------------------------------------------*/
index 3cb9d12..9c35553 100644 (file)
@@ -51,6 +51,11 @@ public:
   virtual void pointScale(double vector[], int vectorLength) = 0;
 
   /**
+   * Apply inverse scale on a vector.
+   */
+  virtual void inversePointScale(double vector[], int vectorLength) = 0;
+
+  /**
    * Apply non linear scaling on direction vector (opposite as point vector).
    * Since scaling is non linear, we need to have a starting point of the vector.
    */
index 0d5b9fe..ff80dbd 100644 (file)
@@ -224,6 +224,75 @@ void ConcreteDrawableSubwin::updateScale(void)
   sciSetXorMode(parentFigure, pixelMode);
 }
 /*------------------------------------------------------------------------------------------*/
+int ConcreteDrawableSubwin::getNbXTicks(void)
+{
+  if (m_pXTicksDrawer != NULL)
+  {
+    return m_pXTicksDrawer->getInitNbTicks();
+  }
+  else
+  {
+    return 0;
+  }
+}
+/*------------------------------------------------------------------------------------------*/
+void ConcreteDrawableSubwin::getXTicksPos(double ticksPositions[], char ** ticksLabels)
+{
+  if (m_pXTicksDrawer != NULL)
+  {
+    m_pXTicksDrawer->getInitTicksPos(ticksPositions, ticksLabels);
+
+    // revert log scale if needed
+    m_pXBoundsStrategy->inversePointScale(ticksPositions, getNbXTicks());
+  }
+}
+/*------------------------------------------------------------------------------------------*/
+int ConcreteDrawableSubwin::getNbYTicks(void)
+{
+  if (m_pYTicksDrawer != NULL)
+  {
+    return m_pYTicksDrawer->getInitNbTicks();
+  }
+  else
+  {
+    return 0;
+  }
+}
+/*------------------------------------------------------------------------------------------*/
+void ConcreteDrawableSubwin::getYTicksPos(double ticksPositions[], char ** ticksLabels)
+{
+  if (m_pYTicksDrawer != NULL)
+  {
+    m_pYTicksDrawer->getInitTicksPos(ticksPositions, ticksLabels);
+
+    // revert log scale if needed
+    m_pYBoundsStrategy->inversePointScale(ticksPositions, getNbYTicks());
+  }
+}
+/*------------------------------------------------------------------------------------------*/
+int ConcreteDrawableSubwin::getNbZTicks(void)
+{
+  if (m_pZTicksDrawer != NULL)
+  {
+    return m_pZTicksDrawer->getInitNbTicks();
+  }
+  else
+  {
+    return 0;
+  }
+}
+/*------------------------------------------------------------------------------------------*/
+void ConcreteDrawableSubwin::getZTicksPos(double ticksPositions[], char ** ticksLabels)
+{
+  if (m_pZTicksDrawer != NULL)
+  {
+    m_pZTicksDrawer->getInitTicksPos(ticksPositions, ticksLabels);
+
+    // revert log scale if needed
+    m_pZBoundsStrategy->inversePointScale(ticksPositions, getNbZTicks());
+  }
+}
+/*------------------------------------------------------------------------------------------*/
 void ConcreteDrawableSubwin::drawBox(void)
 {
   // If axes is not displayed m_pAxesbox is not drawn.
index 7492e1e..5bfc84c 100644 (file)
@@ -89,6 +89,39 @@ public:
    */
   virtual void updateScale(void);
 
+  /**
+   * Get the initial number of ticks (with no reduction) that will be drawn.
+   */
+  virtual int getNbXTicks(void);
+
+  /**
+   * Get the initial ticks positions and labels (with no reduction) that will be drawn.
+   * To be used to know the positions and labels from outside the rendering process
+   */
+  virtual void getXTicksPos(double ticksPositions[], char ** ticksLabels);
+
+  /**
+   * Get the initial number of ticks (with no reduction) that will be drawn.
+   */
+  virtual int getNbYTicks(void);
+
+  /**
+   * Get the initial ticks positions and labels (with no reduction) that will be drawn.
+   * To be used to know the positions and labels from outside the rendering process
+   */
+  virtual void getYTicksPos(double ticksPositions[], char ** ticksLabels);
+
+  /**
+   * Get the initial number of ticks (with no reduction) that will be drawn.
+   */
+  virtual int getNbZTicks(void);
+
+  /**
+   * Get the initial ticks positions and labels (with no reduction) that will be drawn.
+   * To be used to know the positions and labels from outside the rendering process
+   */
+  void getZTicksPos(double ticksPositions[], char ** ticksLabels);
+
 
 protected:
 
index d4476e3..4496237 100644 (file)
@@ -64,6 +64,39 @@ public:
    */
   virtual void updateScale(void) = 0;
 
+  /**
+   * Get the initial number of ticks (with no reduction) that will be drawn.
+   */
+  virtual int getNbXTicks(void) = 0;
+
+  /**
+   * Get the initial ticks positions and labels (with no reduction) that will be drawn.
+   * To be used to know the positions and labels from outside the rendering process
+   */
+  virtual void getXTicksPos(double ticksPositions[], char ** ticksLabels) = 0;
+
+  /**
+   * Get the initial number of ticks (with no reduction) that will be drawn.
+   */
+  virtual int getNbYTicks(void) = 0;
+
+  /**
+   * Get the initial ticks positions and labels (with no reduction) that will be drawn.
+   * To be used to know the positions and labels from outside the rendering process
+   */
+  virtual void getYTicksPos(double ticksPositions[], char ** ticksLabels) = 0;
+
+  /**
+   * Get the initial number of ticks (with no reduction) that will be drawn.
+   */
+  virtual int getNbZTicks(void) = 0;
+
+  /**
+   * Get the initial ticks positions and labels (with no reduction) that will be drawn.
+   * To be used to know the positions and labels from outside the rendering process
+   */
+  virtual void getZTicksPos(double ticksPositions[], char ** ticksLabels) = 0;
+
 protected:
 
   /**
index fa45fcc..9fef023 100644 (file)
@@ -64,6 +64,11 @@ void LinearBoundsComputer::pointScale(double vector[], int vectorLength)
   // nothing to do, this is linear
 }
 /*------------------------------------------------------------------------------------------*/
+void LinearBoundsComputer::inversePointScale(double vector[], int vectorLength)
+{
+  // nothing to do, this is linear
+}
+/*------------------------------------------------------------------------------------------*/
 void LinearBoundsComputer::directionScale(double coord,  double startingPoint, double * scaledCoord)
 
 {
index b5e16bb..dc599d4 100644 (file)
@@ -54,6 +54,11 @@ public:
   virtual void pointScale(double vector[], int vectorLength);
 
   /**
+   * Apply inverse scale on a vector.
+   */
+  virtual void inversePointScale(double vector[], int vectorLength);
+
+  /**
    * Apply non linear scaling on direction vector (opposite as point vector).
    * Since scaling is non linear, we need to have a starting point of the vector.
    */
index 4feb86f..2e862da 100644 (file)
@@ -65,7 +65,6 @@ void LogarithmicBoundsComputer::pointScale(double coord, double * scaledCoord)
 /*------------------------------------------------------------------------------------------*/
 void LogarithmicBoundsComputer::inversePointScale(double scaledCoord, double * coord)
 {
-  // nothing to do, this is linear
   *coord = exp10(scaledCoord);
 }
 /*------------------------------------------------------------------------------------------*/
@@ -77,6 +76,14 @@ void LogarithmicBoundsComputer::pointScale(double vector[], int vectorLength)
   }
 }
 /*------------------------------------------------------------------------------------------*/
+void LogarithmicBoundsComputer::inversePointScale(double vector[], int vectorLength)
+{
+  for (int i = 0; i < vectorLength; i++)
+  {
+    vector[i] = exp10(vector[i]);
+  }
+}
+/*------------------------------------------------------------------------------------------*/
 void LogarithmicBoundsComputer::directionScale(double coord,  double startingPoint, double * scaledCoord)
 {
   // I guess that "/" is faster than "log10"
index a7c5cbd..1c7b476 100644 (file)
@@ -55,6 +55,11 @@ public:
   virtual void pointScale(double vector[], int vectorLength);
 
   /**
+   * Apply inverse scale on a vector.
+   */
+  virtual void inversePointScale(double vector[], int vectorLength);
+
+  /**
    * Apply non linear scaling on direction vector (opposite as point vector).
    * Since scaling is non linear, we need to have a starting point of the vector.
    */
index 2e6c5ab..bc791d4 100644 (file)
@@ -64,6 +64,55 @@ double TicksDrawer::draw(void)
   return dist;
 }
 /*------------------------------------------------------------------------------------------*/
+int TicksDrawer::getInitNbTicks(void)
+{
+  m_pTicksComputer->reinit();
+  return m_pTicksComputer->getNbTicks();
+}
+/*------------------------------------------------------------------------------------------*/
+void TicksDrawer::getInitTicksPos(double ticksPositions[], char ** ticksLabels)
+{
+  m_pTicksComputer->reinit();
+  
+
+  if (m_pTicksComputer->isDisplayingLabelsExponents())
+  {
+    int nbTicks = m_pTicksComputer->getNbTicks();
+    char ** labels = BasicAlgos::createStringArray(nbTicks);
+    char ** labelsExponents = BasicAlgos::createStringArray(nbTicks);
+
+    // get positions, labels and exponents
+    m_pTicksComputer->getTicksPosition(ticksPositions, labels, labelsExponents);
+
+    // concatenate labels and exponents
+    for (int i = 0; i < nbTicks; i++)
+    {
+      int labelLength = strlen(labels[i]);
+      int exponentLength = strlen(labelsExponents[i]);
+
+      // +1 for the e and +1 for the null terminating character
+      if (ticksLabels[i] != NULL)
+      {
+        delete[] ticksLabels[i];
+      }
+      ticksLabels[i] = new char[labelLength + exponentLength + 2];
+
+      // copy all inside res
+      sprintf(ticksLabels[i], "%se%s", labels[i], labelsExponents[i]);
+    }
+
+    BasicAlgos::destroyStringArray(labelsExponents, nbTicks);
+    BasicAlgos::destroyStringArray(labels, nbTicks);
+
+  }
+  else
+  {
+    // no exponents, everything is in labels
+    m_pTicksComputer->getTicksPosition(ticksPositions, ticksLabels, NULL);
+  }
+
+}
+/*------------------------------------------------------------------------------------------*/
 double TicksDrawer::drawTicks(void)
 {
   m_pTicksComputer->reinit();
index 9b3d549..94dcb61 100644 (file)
@@ -44,6 +44,17 @@ public:
    */
   virtual double showTicks(void) = 0;
 
+  /**
+   * Get the initial number of ticks (with no reduction) that will be drawn
+   */
+  int getInitNbTicks(void);
+
+  /**
+   * Get the initial ticks positions and labels (with no reduction) that will be drawn.
+   * To be used to know the positions and labels from outside the rendering process
+   */
+  void getInitTicksPos(double ticksPositions[], char ** ticksLabels);
+
 protected:
 
   /*----------------------------------------------------------------------*/