-plot2d function adapted to the MVC framework 17/2217/5
Manuel Juliachs [Wed, 6 Oct 2010 14:31:59 +0000 (16:31 +0200)]
 (the legend, Nax-specified user grads, and Axes hierarchy auto-clear
 are not implemented yet).

Change-Id: I8a911a1b907401776181bdd3a32e591ec26fc6be

scilab/modules/graphics/includes/Axes.h
scilab/modules/graphics/src/c/Axes.c
scilab/modules/graphics/src/c/BuildObjects.c
scilab/modules/graphics/src/c/DrawObjects.c
scilab/modules/graphics/src/c/Plo2dEch.c
scilab/modules/graphics/src/c/Plo2dn.c

index 5ba17cc..1d1761a 100644 (file)
@@ -1,6 +1,7 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
+ * Copyright (C) 2010 - DIGITEO - Manuel Juliachs
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
@@ -55,5 +56,15 @@ GRAPHICS_IMPEXP sciPointObj * getClickedSubwin(sciPointObj * pFigure, int xCoord
  */
 GRAPHICS_IMPEXP sciLegendPlace propertyNameToLegendPlace(const char * string);
 
+/*
+ * Converts a boolean log flag to the character format
+ */
+GRAPHICS_IMPEXP char getTextLogFlag(int logFlag);
+
+/*
+ * Converts a character log flag to the equivalent boolean
+ */
+GRAPHICS_IMPEXP int getBooleanLogFlag(char logFlag);
+
 /*-----------------------------------------------------------------------------*/
 #endif /*__SCI_AXES_H_*/
index 359fde3..80de287 100644 (file)
@@ -2,6 +2,7 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 1998-2000 - ENPC - Jean-Philippe Chancelier
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
+ * Copyright (C) 2010 - DIGITEO - Manuel Juliachs
  *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
 #include "GetProperty.h"
 #include "HandleManagement.h"
 
+#include "getGraphicObjectProperty.h"
+#include "setGraphicObjectProperty.h"
+#include "graphicObjectProperties.h"
+
 /*--------------------------------------------------------------------------------*/
 static int getSqDistanceToCenter(sciPointObj * pSubwin, int xCoord, int yCoord);
 static BOOL isSubwinUnderPixel(sciPointObj * pSubwin, int xCoord, int yCoord);
@@ -57,35 +62,58 @@ void clearSubWin( sciPointObj * pSubWin )
 }
 /*--------------------------------------------------------------------------------*/
 /* reinit a subwindow (but don't change position ) */
+/*
+ * To be implemented using the MVC (clearSubWin)
+ */
 void reinitSubWin( sciPointObj * pSubWin )
 {
-  sciSubWindow * ppSubWin  = pSUBWIN_FEATURE (pSubWin) ;
+  int visible;
+  int firstPlot;
+  int axisLocation;
 
-  clearSubWin( pSubWin ) ;
+  /*
+   * Deletes the Axes' hierarchy
+   * To be implemented within the MVC
+   */
+#if 0
+  clearSubWin(pSubWin);
+#endif
 
-  initSubWinBounds( pSubWin ) ;
-  ppSubWin->axes.xdir = 'd' ;
-  ppSubWin->axes.ydir = 'l' ;
+  initSubWinBounds(pSubWin);
 
-  ppSubWin->visible = TRUE;
-
-  initSubWinAngles( pSubWin ) ;
-
-  ppSubWin->FirstPlot = TRUE;
+  /* bottom */
+  axisLocation = 0;
+  setGraphicObjectProperty(pSubWin->UID, __GO_X_AXIS_LOCATION__, &axisLocation, jni_int, 1);
+  /* left */
+  axisLocation = 4;
+  setGraphicObjectProperty(pSubWin->UID, __GO_Y_AXIS_LOCATION__, &axisLocation, jni_int, 1);
 
+  visible = 1;
+  setGraphicObjectProperty(pSubWin->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
+  firstPlot = 1;
+  setGraphicObjectProperty(pSubWin->UID, __GO_FIRST_PLOT__, &firstPlot, jni_bool, 1);
 
+  initSubWinAngles(pSubWin);
 }
 /*--------------------------------------------------------------------------------*/
 /* reinit the viewing angles of a subwindow */
 void initSubWinAngles( sciPointObj * pSubWin )
 {
-  sciSubWindow * ppSubWin  = pSUBWIN_FEATURE (pSubWin ) ;
-  sciSubWindow * ppAxesMdl = pSUBWIN_FEATURE (getAxesModel()) ;
-  ppSubWin->is3d     = ppAxesMdl->is3d     ;
-  ppSubWin->alpha_kp = ppAxesMdl->alpha_kp ;
-  ppSubWin->theta_kp = ppAxesMdl->theta_kp ;
-  ppSubWin->alpha    = ppAxesMdl->alpha    ;
-  ppSubWin->theta    = ppAxesMdl->theta    ;
+    int* viewType;
+    double* rotationAngles;
+    sciPointObj* axesModel = getAxesModel();
+
+    viewType = (int*) getGraphicObjectProperty(axesModel->UID, __GO_VIEW__, jni_int);
+    setGraphicObjectProperty(pSubWin->UID, __GO_VIEW__, viewType, jni_int, 1);
+
+    rotationAngles = (double*) getGraphicObjectProperty(axesModel->UID, __GO_ROTATION_ANGLES__, jni_double_vector);
+    setGraphicObjectProperty(pSubWin->UID, __GO_ROTATION_ANGLES__, rotationAngles, jni_double_vector, 2);
+
+   /* To be implemented: last known values of the rotation angles when VIEW was equal to 3D */
+#if 0
+    ppSubWin->alpha_kp = ppAxesMdl->alpha_kp ;
+    ppSubWin->theta_kp = ppAxesMdl->theta_kp ;
+#endif
 }
 
 /*--------------------------------------------------------------------------------*/
@@ -104,38 +132,47 @@ void initSubWinSize( sciPointObj * pSubWin )
 /* set the data_bounds of the axes to the default value */
 void initSubWinBounds( sciPointObj * pSubWin )
 {
-  sciSubWindow * ppSubWin  = pSUBWIN_FEATURE (pSubWin ) ;
-  sciSubWindow * ppAxesMdl = pSUBWIN_FEATURE (getAxesModel()) ;
-  ppSubWin->FRect[0] = ppAxesMdl->FRect[0] ;
-  ppSubWin->FRect[1] = ppAxesMdl->FRect[1] ;
-  ppSubWin->FRect[2] = ppAxesMdl->FRect[2] ;
-  ppSubWin->FRect[3] = ppAxesMdl->FRect[3] ;
-  ppSubWin->FRect[4] = ppAxesMdl->FRect[4] ;
-  ppSubWin->FRect[5] = ppAxesMdl->FRect[5] ;
-
-  ppSubWin->SRect[0] = ppAxesMdl->SRect[0] ;
-  ppSubWin->SRect[1] = ppAxesMdl->SRect[1] ;
-  ppSubWin->SRect[2] = ppAxesMdl->SRect[2] ;
-  ppSubWin->SRect[3] = ppAxesMdl->SRect[3] ;
-  ppSubWin->SRect[4] = ppAxesMdl->SRect[4] ;
-  ppSubWin->SRect[5] = ppAxesMdl->SRect[5] ;
+  double* dataBounds;
+  double* realDataBounds;
+  sciPointObj* axesModel;
+
+  axesModel = getAxesModel();
+
+  dataBounds = (double*) getGraphicObjectProperty(pSubWin->UID, __GO_DATA_BOUNDS__, jni_double_vector);
+  setGraphicObjectProperty(pSubWin->UID, __GO_DATA_BOUNDS__, dataBounds, jni_double_vector, 6);
+
+  realDataBounds = (double*) getGraphicObjectProperty(pSubWin->UID, __GO_REAL_DATA_BOUNDS__, jni_double_vector);
+  setGraphicObjectProperty(pSubWin->UID, __GO_REAL_DATA_BOUNDS__, realDataBounds, jni_double_vector, 6);
 }
 /*--------------------------------------------------------------------------------*/
 /* reinit the selected subwindow if the auto_clear property is set to on */
 /* return TRUE if the window has been redrawn */
 BOOL checkRedrawing( void )
 {
+  int* autoClear;
+
   //  nbCheckRedraw++;
   //  fprintf(stderr, "[DEBUG] checkRedrawing : %d\n", nbCheckRedraw);
-  sciPointObj * pSubWin = sciGetCurrentSubWin() ;
-  if ( !sciGetAddPlot( pSubWin ) )
+  sciPointObj * pSubWin = sciGetCurrentSubWin();
+
+  autoClear = (int*) getGraphicObjectProperty(pSubWin->UID, __GO_AUTO_CLEAR__, jni_bool);
+
+  if (*autoClear)
   {
-      /* redraw the axis */
-      reinitSubWin( pSubWin ) ;
-      forceRedraw(pSubWin);
-      return TRUE ;
+    reinitSubWin(pSubWin);
+
+   /*
+    * Deactivated for now: forces redrawing by telling the renderer module
+    * that the Axes object has changed
+    * To be implemented
+    */
+#if 0
+    forceRedraw(pSubWin);
+#endif
+    return TRUE;
   }
-  return FALSE ;
+
+  return FALSE;
 }
 /*--------------------------------------------------------------------------------*/
 /**
@@ -287,3 +324,34 @@ sciLegendPlace propertyNameToLegendPlace(const char * string)
        }
 }
 /*--------------------------------------------------------------------------------*/
+/*
+ * Converts a boolean log flag to the character format
+ */
+char getTextLogFlag(int logFlag)
+{
+    if (logFlag)
+    {
+        return 'l';
+    }
+    else
+    {
+        return 'n';
+    }
+}
+/*--------------------------------------------------------------------------------*/
+/*
+ * Converts a character log flag to the equivalent boolean
+ */
+int getBooleanLogFlag(char logFlag)
+{
+    if (logFlag == 'l')
+    {
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
+}
+/*--------------------------------------------------------------------------------*/
+
index 07555d0..51524ba 100644 (file)
@@ -2375,65 +2375,89 @@ ConstructSegs ( sciPointObj * pparentsubwin, int type,
 
 
 /**sciConstructCompound
- * constructes an Compound of entities
+ * constructs a Compound of entities
  * do only a association with a parent and a handle reservation !
  * check for valid handle can be done using CheckForCompound
  */
 sciPointObj *
 ConstructCompound (long *handelsvalue, int number) /* Conflicting types with definition */
 {
-  /* sciSons *sons, *sonsnext; */
-  sciPointObj * pobj       ;
-  sciAgreg    * ppCompound ;
+  sciPointObj* compound;
+  sciPointObj* firstMovedObject;
+  /* Now useless */
+#if 0
+  sciAgreg    * ppCompound;
+#endif
   int i;
-  long xtmp;
-
-
-  if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
-    return (sciPointObj *) NULL;
+  int* parentVisible;
+  char* parentAxes;
 
-  sciSetEntityType (pobj, SCI_AGREG);
-  if ((pobj->pfeatures = MALLOC ((sizeof (sciAgreg)))) == NULL)
+  if ((compound = MALLOC ((sizeof (sciPointObj)))) == NULL)
+  {
     return (sciPointObj *) NULL;
+  }
 
-  /* get the pointer on features */
-  ppCompound = pAGREG_FEATURE (pobj) ;
+  compound->UID = createGraphicObject(__GO_COMPOUND__);
 
-  if ( sciStandardBuildOperations( pobj, sciGetParent(sciGetPointerFromHandle( (long) handelsvalue[0])) ) == NULL )
+  /* To be deleted */
+#if 0
+  if ( sciStandardBuildOperations( compound, sciGetParent(sciGetPointerFromHandle( (long) handelsvalue[0])) ) == NULL )
   {
-    FREE( pobj->pfeatures ) ;
-    FREE( pobj ) ;
+    FREE( compound->pfeatures ) ;
+    FREE( compound) ;
     return NULL ;
   }
+#endif
 
-  ppCompound->callback = (char *)NULL;
-  ppCompound->callbacklen = 0;
-  ppCompound->visible = sciGetVisibility(sciGetParentSubwin(pobj));
+  /* Adding the Compound's handle was previously done by sciStandardBuildOperations */
+  if (sciAddNewHandle(compound) == -1)
+  {
+    deleteGraphicObject(compound->UID);
+    FREE(compound);
+    return NULL;
+  }
 
-  /* sonsnext = (sciSons *) NULL */
+  /* The Compound's parent Axes is considered to be the Compound's first child's own parent */
+  firstMovedObject = sciGetPointerFromHandle( (long) handelsvalue[0]);
+  parentAxes = (char*) getGraphicObjectProperty(firstMovedObject->UID, __GO_PARENT__, jni_string);
 
-  /* initialisation with the first son */
-  xtmp = (long) handelsvalue[0];
+  /* Set the parent-child relationship between the Compound and each aggregated object */
   for ( i = 0 ; i < number ; i++ )
-    {
+  {
+    sciPointObj* movedObject = sciGetPointerFromHandle( (long) handelsvalue[i]);
 
+    setGraphicObjectRelationship(compound->UID, movedObject->UID);
+  }
 
-      /* jb Silvy 10/01/06 */
-      /* the handle id moved from the current parent (ex axis) to the compund */
-      sciPointObj * movedObject ;
-      xtmp = handelsvalue[i] ;
-      movedObject = sciGetPointerFromHandle(xtmp) ;
-      if ( movedObject != NULL )
-      {
-        sciDelThisToItsParent( movedObject, sciGetParent(movedObject) ) ;
-        sciAddThisToItsParent( movedObject, pobj ) ;
-      }
-    }
+  /* Sets the parent-child relationship for the Compound */
+  setGraphicObjectRelationship(parentAxes, compound->UID);
+
+  /* Deactivated */
+#if 0
+  ppCompound->callback = (char *)NULL;
+  ppCompound->callbacklen = 0;
+#endif
+
+  /*
+   * To be checked: difference between sciGetParentSubwin and directly getting
+   * the Compound's parent's visible property
+   */
+#if 0
+  ppCompound->visible = sciGetVisibility(sciGetParentSubwin(compound));
+#endif
+
+  parentVisible = (int*) getGraphicObjectProperty(parentAxes, __GO_VISIBLE__, jni_bool);
+  setGraphicObjectProperty(compound->UID, __GO_VISIBLE__, parentVisible, jni_bool, 1);
 
- /*  ppCompound->relationship.psons = sons; */
+ /*
+  * Not implemented within the MVC yet
+  * To be implemented
+  */
+#if 0
   ppCompound->isselected = TRUE;
+#endif
 
-  return (sciPointObj *)pobj;
+  return (sciPointObj *) compound;
 }
 
 /**sciConstructCompoundSeq
index 422a54b..502eb8a 100644 (file)
  *    The main functions is sciDrawObj that draws the objects recursively.
  ------------------------------------------------------------------------/-*/
 
+#include <stdio.h>
+#include <string.h>
+
+#ifdef _MSC_VER
+#include "strdup_Windows.h"
+#endif
+
 #include "DrawObjects.h"
 #include "GetProperty.h"
 #include "SetProperty.h"
 #include "localization.h"
 
 #include "math.h" /* fabs, floor, log10, pow */
+#include "BasicAlgos.h"
+
+#include "getGraphicObjectProperty.h"
+#include "setGraphicObjectProperty.h"
+#include "graphicObjectProperties.h"
+
+//#include "../../../tclsci/includes/GedManagement.h"
 
 
 #define round(a)  (int)(((a)<0.0)?(a)-.5:(a)+.5)
 
+/* Specifies the ticks labels buffer size */
+#define LABEL_BUFFER_LENGTH    128
+
 
+static void computeCoordinatesFromLogExponents(double* coordinates, int numCoordinates);
+static void printLabels(char** stringVector, double* ticksLocations, int numTicks, BOOL logFlag);
 
 static BOOL subwinNeedsDisplay(sciPointObj * pSubwin);
 
@@ -108,35 +127,41 @@ void sciGetDisplayedBounds( sciPointObj * pSubWin,
                             double      * zmin   ,
                             double      * zmax    )
 {
-  sciSubWindow * ppsubwin =  pSUBWIN_FEATURE ( pSubWin ) ;
     /*****************************************************************
      * get initial bounds
    *****************************************************************/
-  if( sciGetZooming( pSubWin ) )
+
+  int* tmp;
+  int* zoomEnabled;
+  double* bounds;
+  int logFlag;
+
+  zoomEnabled = (int*) getGraphicObjectProperty(pSubWin->UID, __GO_ZOOM_ENABLED__, jni_bool);
+
+  if (*zoomEnabled)
   {
-    *xmin = ppsubwin->ZRect[0] ;
-    *ymin = ppsubwin->ZRect[2] ;
-    *xmax = ppsubwin->ZRect[1] ;
-    *ymax = ppsubwin->ZRect[3] ;
-    *zmin = ppsubwin->ZRect[4] ;
-    *zmax = ppsubwin->ZRect[5] ;
+    bounds = (double*) getGraphicObjectProperty(pSubWin->UID, __GO_ZOOM_BOX__, jni_double_vector);
   }
   else
   {
-    *xmin = ppsubwin->SRect[0] ;
-    *ymin = ppsubwin->SRect[2] ;
-    *xmax = ppsubwin->SRect[1] ;
-    *ymax = ppsubwin->SRect[3] ;
-    *zmin = ppsubwin->SRect[4] ;
-    *zmax = ppsubwin->SRect[5] ;
+    bounds = (double*) getGraphicObjectProperty(pSubWin->UID, __GO_DATA_BOUNDS__, jni_double_vector);
   }
 
-
+  *xmin = bounds[0];
+  *xmax = bounds[1];
+  *ymin = bounds[2];
+  *ymax = bounds[3];
+  *zmin = bounds[4];
+  *zmax = bounds[5];
 
   /*****************************************************************
    * modify  bounds and aaint  if using log scaling X axis
    *****************************************************************/
-  if ( ppsubwin->logflags[0] == 'l' )
+
+  tmp = (int*) getGraphicObjectProperty(pSubWin->UID, __GO_X_AXIS_LOG_FLAG__, jni_bool);
+  logFlag = *tmp;
+
+  if (logFlag == 1)
   {
     if ( sciGetLogExponent( *xmin, *xmax, xmin, xmax ) != 0 )
     {
@@ -147,7 +172,11 @@ void sciGetDisplayedBounds( sciPointObj * pSubWin,
   /*****************************************************************
    * modify  bounds and aaint  if using log scaling Y axis
    *****************************************************************/
-  if ( ppsubwin->logflags[1] == 'l' )
+
+  tmp = (int*) getGraphicObjectProperty(pSubWin->UID, __GO_Y_AXIS_LOG_FLAG__, jni_bool);
+  logFlag = *tmp;
+
+  if (logFlag == 1)
   {
     if ( sciGetLogExponent( *ymin, *ymax, ymin, ymax ) != 0 )
     {
@@ -158,7 +187,11 @@ void sciGetDisplayedBounds( sciPointObj * pSubWin,
   /*****************************************************************
    * modify  bounds and aaint  if using log scaling Z axis
    *****************************************************************/
-  if ( ppsubwin->logflags[2] == 'l' )
+
+  tmp = (int*) getGraphicObjectProperty(pSubWin->UID, __GO_Z_AXIS_LOG_FLAG__, jni_bool);
+  logFlag = *tmp;
+
+  if (logFlag == 1)
   {
     if ( sciGetLogExponent( *zmin, *zmax, zmin, zmax ) != 0 )
     {
@@ -172,82 +205,219 @@ void sciGetDisplayedBounds( sciPointObj * pSubWin,
 /*** F.Leray 02.04.04 */
 /* FUNCTION FOR 2D UPDATE ONLY !!!!! <=> beginning of axis_3ddraw (in 2d HERE of course! ) */
 /* Copy on update_frame_bounds */
+/*
+ * This function has been adapted to the MVC framework.
+ */
 BOOL sci_update_frame_bounds_2d(sciPointObj *pobj)
 {
   double xmax, xmin, ymin, ymax, zmin, zmax ;
   double hx,hy,hx1,hy1;
   int i;
 
-  sciSubWindow * ppsubwin =  pSUBWIN_FEATURE (pobj);
-  double FRect[4],WRect[4],ARect[4];
+  double FRect[4],WRect[4],ARect[4]; 
   char logscale[2];
 
   /* Temp variables only used when called from update_specification_bounds */
   /* to know if we have to redraw all the figure */
-  double ExistingFRect[4]; /* the Existing FRect at start to be compared at the end of this routine */
-  /* in order to determine wheter or not the bounds have changed... */
+
+  double* previousDataBounds;
+  double updatedDataBounds[6];
+  int logFlags[2];
+
+  int tightLimits;
+  int isoview;
+
+  /* in order to determine whether or not the bounds have changed... */
   int nbsubtics[2];
   int nbgrads[2];
+  int updatedNbsubtics[2];
+
+  /* Temporary variables for ticks computation */
+  double xGrads[20];
+  double yGrads[20];
+
+  int updatedNxgrads;
+  int updatedNygrads;
+
+  int nbxsubticks;
+  int nbysubticks;
+
+  /* Used to print labels */
+  char** stringVector;
+
+  int* tmp;
   /* End of Temp variables */
 
-  for(i=0;i<4;i++) ExistingFRect[i] =  ppsubwin->FRect[i]; /* store old initial bounds*/
+  /* Get the initial data bounds, number of ticks and number of subticks */
 
-  for(i=0;i<2;i++) nbsubtics[i] = ppsubwin->axes.nbsubtics[i];
-  nbgrads[0] = ppsubwin->axes.nxgrads;
-  nbgrads[1] = ppsubwin->axes.nygrads;
+  /* Formerly FRect */
+  previousDataBounds = (double*) getGraphicObjectProperty(pobj->UID, __GO_REAL_DATA_BOUNDS__, jni_double_vector);
 
-  /* nbtics on z put to 0 */
-  /*   ppsubwin->axes.nzgrads = 0; */
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_X_AXIS_SUBTICKS__, jni_int);
+  nbsubtics[0] = *tmp;
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_SUBTICKS__, jni_int);
+  nbsubtics[1] = *tmp;
 
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_X_AXIS_NUMBER_TICKS__, jni_int);
+  nbgrads[0] = *tmp;
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_NUMBER_TICKS__, jni_int);
+  nbgrads[1] = *tmp;
 
-  sciGetDisplayedBounds( pobj, &xmin, &xmax, &ymin, &ymax, &zmin, &zmax ) ;
+  /* Sets the z-axis number of ticks to 0 */
+  setGraphicObjectProperty(pobj->UID, __GO_Z_AXIS_TICKS_LOCATIONS__, NULL, jni_double_vector, 0);
 
+  sciGetDisplayedBounds( pobj, &xmin, &xmax, &ymin, &ymax, &zmin, &zmax ) ;
 
   /* _grad Init. to 0. */
-  for(i=0;i<20;i++)
-    {
-      ppsubwin->axes.xgrads[i] = 0.;
-      ppsubwin->axes.ygrads[i] = 0.;
-    }
+  for(i = 0; i < 20; i++)
+  {
+    xGrads[i] = 0.0;
+    yGrads[i] = 0.0;
+  }
 
+  /*
+   * The code generating labels should be moved inside the Java Model.
+   * Ticks labels were previously generated in the C++ Renderer module
+   * (see AutomaticTicksComputer and AutoLogTicksComputer)
+   * using the C-computed locations.
+   * This is temporarily done here in order to get updated labels according
+   * to the data bounds.
+   */
 
-  if ( ppsubwin->logflags[0]=='n') { /* x-axis */
-    TheTicks(&xmin, &xmax, &(ppsubwin->axes.xgrads[0]), &ppsubwin->axes.nxgrads, FALSE);
-    ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'n',NULL,ppsubwin->axes.nbsubtics[0]); /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_X_AXIS_LOG_FLAG__, jni_bool);
+  logFlags[0] = *tmp;
+
+  /* x-axis */
+  if (logFlags[0] == 0)
+  {
+    tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_X_AXIS_SUBTICKS__, jni_int);
+    nbxsubticks = *tmp;
+
+    TheTicks(&xmin, &xmax, &xGrads[0], &updatedNxgrads, FALSE);
+
+    /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
+    nbxsubticks = ComputeNbSubTics(pobj,updatedNxgrads,'n',NULL, nbxsubticks);
+
+    stringVector = createStringArray(updatedNxgrads);
+    printLabels(stringVector, xGrads, updatedNxgrads, 0);
   }
-  else{ /* log. case */
-    GradLog(xmin,xmax,ppsubwin->axes.xgrads,&ppsubwin->axes.nxgrads, FALSE );
-    ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'l',ppsubwin->axes.xgrads,0);
+  else
+  {
+    tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_X_AXIS_SUBTICKS__, jni_int);
+    nbxsubticks = *tmp;
+
+    GradLog(xmin, xmax, &xGrads[0], &updatedNxgrads, FALSE);
+
+    /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
+    nbxsubticks = ComputeNbSubTics(pobj, updatedNxgrads, 'l', xGrads, 0);
+
+    stringVector = createStringArray(updatedNxgrads);
+    printLabels(stringVector, xGrads, updatedNxgrads, TRUE);
+
+    /* Transform back exponents to non-log coordinates to set positions */
+    computeCoordinatesFromLogExponents(xGrads, updatedNxgrads);
   }
 
-  if ( ppsubwin->logflags[1]=='n') { /* y-axis */
-    TheTicks(&ymin, &ymax, &(ppsubwin->axes.ygrads[0]), &ppsubwin->axes.nygrads, FALSE);
-    ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'n',NULL, ppsubwin->axes.nbsubtics[1]); /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
+  setGraphicObjectProperty(pobj->UID, __GO_X_AXIS_TICKS_LOCATIONS__, xGrads, jni_double_vector, updatedNxgrads);
+  setGraphicObjectProperty(pobj->UID, __GO_X_AXIS_TICKS_LABELS__, stringVector, jni_string_vector, updatedNxgrads);
+
+  setGraphicObjectProperty(pobj->UID, __GO_X_AXIS_SUBTICKS__, &nbxsubticks, jni_int, 1);
+
+  destroyStringArray(stringVector, updatedNxgrads);
+
+
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_LOG_FLAG__, jni_bool);
+  logFlags[1] = *tmp;
+
+  /* y-axis */
+  if (logFlags[1] == 0)
+  {
+    tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_SUBTICKS__, jni_int);
+    nbysubticks = *tmp;
+
+    TheTicks(&ymin, &ymax, &yGrads[0], &updatedNygrads, FALSE);
+
+    /* Nb of subtics computation and storage */
+    /* F.Leray 07.10.04 */
+    nbysubticks = ComputeNbSubTics(pobj,updatedNygrads,'n',NULL, nbysubticks);
+
+    stringVector = createStringArray(updatedNygrads);
+    printLabels(stringVector, yGrads, updatedNygrads, 0);
   }
-  else{ /* log. case */
-    GradLog(ymin,ymax,ppsubwin->axes.ygrads,&ppsubwin->axes.nygrads, FALSE );
-    ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'l',ppsubwin->axes.ygrads,0);
+  else
+  {
+    tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_SUBTICKS__, jni_int);
+    nbysubticks = *tmp;
+
+    GradLog(ymin, ymax, &yGrads[0], &updatedNygrads, FALSE);
+
+    /* Nb of subtics computation and storage */
+    /* F.Leray 07.10.04 */
+    nbysubticks = ComputeNbSubTics(pobj, updatedNygrads, 'l', yGrads, 0);
+
+    stringVector = createStringArray(updatedNygrads);
+    printLabels(stringVector, yGrads, updatedNygrads, TRUE);
+
+    /* Transform back exponents to non-log coordinates to set positions */
+    computeCoordinatesFromLogExponents(yGrads, updatedNygrads);
   }
 
-  if(ppsubwin->tight_limits == FALSE )
-    {
-      xmin = ppsubwin->axes.xgrads[0];
-      xmax = ppsubwin->axes.xgrads[ ppsubwin->axes.nxgrads - 1];
-      ymin = ppsubwin->axes.ygrads[0];
-      ymax = ppsubwin->axes.ygrads[ ppsubwin->axes.nygrads - 1];
-    }
+  setGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_TICKS_LOCATIONS__, yGrads, jni_double_vector, updatedNygrads);
+  setGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_TICKS_LABELS__, stringVector, jni_string_vector, updatedNygrads);
+
+  setGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_SUBTICKS__, &nbysubticks, jni_int, 1);
+
+  destroyStringArray(stringVector, updatedNygrads);
+
+
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_TIGHT_LIMITS__, jni_bool);
+  tightLimits = *tmp;
+
+  if (tightLimits == FALSE)
+  {
+    xmin = xGrads[0];
+    xmax = xGrads[updatedNxgrads - 1];
+    ymin = yGrads[0];
+    ymax = yGrads[updatedNygrads - 1];
+  }
 
   /*****************************************************************
    * modify  bounds if  isoview requested
    *****************************************************************/
-  if ( ppsubwin->isoview == TRUE) {
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_ISOVIEW__, jni_bool);
+  isoview = *tmp;
+
+  /*
+   * Depending on the high-level function calling update_specification_bounds, this section
+   * may not be useful. Considering for example Plo2dn, the isoview property is initialized within
+   * the strflag2properties function, called from Plo2dn after update_specification_bounds has returned.
+   * Furthermore, in the previous version of the renderer, the C++ part recomputes the "real" data bounds
+   * and sets them again.
+   */
+  if (isoview)
+  {
     int wdim[2];
+    char* parentId;
+    int* figureDimensions;
+
+    parentId = (char*) getGraphicObjectProperty(pobj->UID, __GO_PARENT__, jni_string);
+
+    /*
+     * Window width and height are currently 0 (default Figure values)
+     * To be implemented within the MVC (by copying the Figure model's values)
+     */
+    figureDimensions = (int*) getGraphicObjectProperty(parentId, __GO_SIZE__, jni_int_vector);
+    wdim[0] = figureDimensions[0];
+    wdim[1] = figureDimensions[1];
 
+#if 0
     wdim[0] = sciGetWindowWidth(sciGetParentFigure(pobj));
     wdim[1] = sciGetWindowHeight(sciGetParentFigure(pobj));
+#endif
 
     hx=xmax-xmin;
     hy=ymax-ymin;
+
     getscale2d(WRect,FRect,logscale,ARect);
 
     wdim[0]=linint((double)wdim[0] *WRect[2]);
@@ -267,59 +437,109 @@ BOOL sci_update_frame_bounds_2d(sciPointObj *pobj)
     /* F.Leray 28.09.04 */
     /* I need to recompute the correct xgrads and ygrads vector to have a good display */
 
-    if ( ppsubwin->logflags[0]=='n') { /* x-axis */
-      TheTicks(&xmin, &xmax, &(ppsubwin->axes.xgrads[0]), &ppsubwin->axes.nxgrads, FALSE);
-      ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'n',NULL, ppsubwin->axes.nbsubtics[0]); /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
+    /* x-axis */
+    if (logFlags[0] == 0)
+    {
+      TheTicks(&xmin, &xmax, xGrads, &updatedNxgrads, FALSE);
+      /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
+      nbxsubticks = ComputeNbSubTics(pobj, updatedNxgrads, 'n', NULL, nbxsubticks);
+
+      stringVector = createStringArray(updatedNxgrads);
+      printLabels(stringVector, xGrads, updatedNxgrads, FALSE);
     }
     else{ /* log. case */
-      GradLog(xmin,xmax,ppsubwin->axes.xgrads,&ppsubwin->axes.nxgrads, FALSE);
-      ppsubwin->axes.nbsubtics[0] = ComputeNbSubTics(pobj,ppsubwin->axes.nxgrads,'l',ppsubwin->axes.xgrads,0);
+      GradLog(xmin, xmax, xGrads, &updatedNxgrads, FALSE);
+      nbxsubticks = ComputeNbSubTics(pobj, updatedNxgrads, 'l',xGrads,0);
+
+      stringVector = createStringArray(updatedNxgrads);
+      printLabels(stringVector, xGrads, updatedNxgrads, TRUE);
+
+      /* Transform back exponents to non-log coordinates to set positions */
+      computeCoordinatesFromLogExponents(xGrads, updatedNxgrads);
     }
 
+    setGraphicObjectProperty(pobj->UID, __GO_X_AXIS_TICKS_LOCATIONS__, xGrads, jni_double_vector, updatedNxgrads);
+    setGraphicObjectProperty(pobj->UID, __GO_X_AXIS_TICKS_LABELS__, stringVector, jni_string_vector, updatedNxgrads);
+
+    setGraphicObjectProperty(pobj->UID, __GO_X_AXIS_SUBTICKS__, &nbxsubticks, jni_int, 1);
 
+    destroyStringArray(stringVector, updatedNxgrads);
 
-    if ( ppsubwin->logflags[1]=='n') { /* y-axis */
-      TheTicks(&ymin, &ymax, &(ppsubwin->axes.ygrads[0]), &ppsubwin->axes.nygrads, FALSE);
-      ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'n',NULL, ppsubwin->axes.nbsubtics[1]); /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
+    /* y-axis */
+    if (logFlags[1] == 0)
+    {
+      TheTicks(&ymin, &ymax, yGrads, &updatedNygrads, FALSE);
+      /* Nb of subtics computation and storage */ /* F.Leray 07.10.04 */
+      nbysubticks = ComputeNbSubTics(pobj, updatedNygrads, 'n', NULL, nbysubticks);
+
+      stringVector = createStringArray(updatedNygrads);
+      printLabels(stringVector, yGrads, updatedNygrads, FALSE);
     }
     else{ /* log. case */
-      GradLog(ymin,ymax,ppsubwin->axes.ygrads,&ppsubwin->axes.nygrads, FALSE );
-      ppsubwin->axes.nbsubtics[1] = ComputeNbSubTics(pobj,ppsubwin->axes.nygrads,'l',ppsubwin->axes.ygrads,0);
-    }
+      GradLog(ymin, ymax, yGrads, &updatedNygrads, FALSE);
+      nbysubticks = ComputeNbSubTics(pobj, updatedNygrads, 'l',yGrads,0);
 
+      stringVector = createStringArray(updatedNygrads);
+      printLabels(stringVector, yGrads, updatedNygrads, TRUE);
 
-    /* END ISO if */
-  }
+      /* Transform back exponents to non-log coordinates to set positions */
+      computeCoordinatesFromLogExponents(yGrads, updatedNygrads);
+    }
 
+    setGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_TICKS_LOCATIONS__, yGrads, jni_double_vector, updatedNygrads);
+    setGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_TICKS_LABELS__, stringVector, jni_string_vector, updatedNygrads);
 
+    setGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_SUBTICKS__, &nbysubticks, jni_int, 1);
 
+    destroyStringArray(stringVector, updatedNygrads);
+
+    /* END ISO if */
+  }
 
   /*****************************************************************
-   * set the actual bounds in subwindow data structure
+   * set the actual bounds in the Axes object
    *****************************************************************/
 
+  updatedDataBounds[0] = xmin;
+  updatedDataBounds[1] = xmax;
+  updatedDataBounds[2] = ymin;
+  updatedDataBounds[3] = ymax;
+  updatedDataBounds[4] = zmin;
+  updatedDataBounds[5] = zmax;
 
-  ppsubwin->FRect[0]=xmin;
-  ppsubwin->FRect[2]=xmax;
-  ppsubwin->FRect[1]=ymin;
-  ppsubwin->FRect[3]=ymax;
-
+  setGraphicObjectProperty(pobj->UID, __GO_REAL_DATA_BOUNDS__, updatedDataBounds, jni_double_vector, 6);
 
   for(i=0;i<4;i++)
-    if(ppsubwin->FRect[i] != ExistingFRect[i]){
+  {
+    if (updatedDataBounds[i] != previousDataBounds[i])
+    {
       return TRUE;
       break;
     }
+  }
 
-  for(i=0;i<2;i++)
-    if(nbsubtics[i] != ppsubwin->axes.nbsubtics[i]){
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_X_AXIS_SUBTICKS__, jni_int);
+  updatedNbsubtics[0] = *tmp;
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_SUBTICKS__, jni_int);
+  updatedNbsubtics[1] = *tmp;
+   
+  for(i=0;i<2;i++) 
+  {
+    if(nbsubtics[i] != updatedNbsubtics[i])
+    {
       return TRUE;
       break;
     }
+  }
 
-  if(nbgrads[0] != ppsubwin->axes.nxgrads) return TRUE;
-  if(nbgrads[1] != ppsubwin->axes.nygrads) return TRUE;
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_X_AXIS_NUMBER_TICKS__, jni_int);
+  updatedNxgrads = *tmp;
+  tmp = (int*) getGraphicObjectProperty(pobj->UID, __GO_Y_AXIS_NUMBER_TICKS__, jni_int);
+  updatedNygrads = *tmp;
 
+  if(nbgrads[0] != updatedNxgrads) return TRUE;
+  if(nbgrads[1] != updatedNygrads) return TRUE;
+   
   return FALSE;
 }
 
@@ -470,7 +690,11 @@ int ComputeNbSubTics(sciPointObj * pobj, int nbtics, char logflag, const double
   double grads_diff;        /* Used for computing spacing between major ticks. */
   int nbtics_safe = nbtics; /* nbtics clamped to the range 0 to subticsval_len-1. Safe as an index into subticsval. */
 
+#if 0
   sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj);
+#endif
+
+  int* autoSubticks;
 
   if (nbtics_safe < 0 )
   {
@@ -540,7 +764,14 @@ int ComputeNbSubTics(sciPointObj * pobj, int nbtics, char logflag, const double
   }
   else /* linear scaling case */
   {
+    autoSubticks = (int*) getGraphicObjectProperty(pobj->UID, __GO_AUTO_SUBTICKS__, jni_bool);
+
+#if 0
     if(ppsubwin->flagNax == FALSE) /* if auto subtics mode == ON */
+#endif
+
+    /* if auto subtics mode == ON */
+    if (*autoSubticks)
     {
       double intbase10 = 0.;
       /* Without graduations, use the heuristic */
@@ -781,4 +1012,65 @@ static BOOL subwinNeedsDisplay(sciPointObj * pSubwin)
   }
 }
 /*---------------------------------------------------------------------------------*/
+/*
+ * Utility function which transforms back positions (logarithmic exponents) to non-log coordinates
+ * Required to be able to display correct coordinate values in the console.
+ */
+static void computeCoordinatesFromLogExponents(double* coordinates, int numCoordinates)
+{
+    int i;
+    double loginit = 1.0;
+
+    for (i = 0; i < coordinates[0]; i++)
+    {
+      loginit *= 10.0;
+    }
+
+    for (i = 0; i < numCoordinates; i++)
+    {
+      coordinates[i] = loginit;
+      loginit *= 10.0;
+    }
+}
+/*---------------------------------------------------------------------------------*/
+/*
+ * Utility function which generates label strings
+ * Its code is equivalent to that of the renderer module's TicksComputers' getTicksPosition
+ * methods. It is temporarily located there, in order to be able to initialize labels strings,
+ * and should reside within the Java Model.
+ */
+static void printLabels(char** stringVector, double* ticksLocations, int numTicks, BOOL logFlag)
+{
+    char labelBuffer[LABEL_BUFFER_LENGTH];
+    char format[5];
+    char* logPrefix = "10e";
+    int i;
+    int prefixLength;
+
+    ChoixFormatE(format, ticksLocations[0], ticksLocations[numTicks-1],
+        (ticksLocations[numTicks-1] - ticksLocations[0]) / (numTicks-1));
+
+    if (logFlag == FALSE)
+    {
+        for (i = 0; i < numTicks; i++)
+        {
+            sprintf(labelBuffer, format, ticksLocations[i]);
+            stringVector[i] = strdup(labelBuffer);
+        }
+    }
+    else
+    {
+        prefixLength = strlen(logPrefix);
+
+        for (i = 0; i < numTicks; i++)
+        {
+            strcpy(labelBuffer, logPrefix);
+
+            sprintf(labelBuffer+prefixLength, format, ticksLocations[i]);
+            stringVector[i] = strdup(labelBuffer);
+        }
+    }
+
+}
+/*---------------------------------------------------------------------------------*/
 #undef round
index 152ad46..fcc85ec 100644 (file)
@@ -5,6 +5,7 @@
  * Copyright (C) 2002 - INRIA - Serge Steer
  * Copyright (C) 2004-2006 - INRIA - Fabrice Leray
  * Copyright (C) 2005 - INRIA - Jean-Baptiste Silvy
+ * Copyright (C) 2010 - DIGITEO - Manuel Juliachs
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
 #include "DrawingBridge.h"
 #include "GraphicSynchronizerInterface.h"
 #include "HandleManagement.h"
+#include "Axes.h"
 
 #include "MALLOC.h" /* MALLOC */
 
+#include "getGraphicObjectProperty.h"
+#include "graphicObjectProperties.h"
+
 /*-------------------------------------------
  * setscale2d 
  * uses WRect,ARect,FRect,logscale to update 
@@ -129,24 +134,33 @@ int setscale2d(double WRect[4],
 int getscale2d( double WRect[4], double FRect[4], char logscale[2], double ARect[4] )
 {
   int i;
-       sciPointObj * curSubwin = sciGetCurrentSubWin();
-       
-       char logFlags[3];
-       sciGetLogFlags(curSubwin, logFlags);
-       logscale[0] = logFlags[0];
-       logscale[1] = logFlags[1];
-  
-       for ( i=0; i < 4 ; i++) 
+  int* tmp;
+  double* axesBounds;
+  double* margins;
+  double* realDataBounds;
+  sciPointObj * curSubwin = sciGetCurrentSubWin();
+
+  tmp = (int*) getGraphicObjectProperty(curSubwin->UID, __GO_X_AXIS_LOG_FLAG__, jni_bool);
+  logscale[0] = getTextLogFlag(*tmp);
+
+  tmp = (int*) getGraphicObjectProperty(curSubwin->UID, __GO_Y_AXIS_LOG_FLAG__, jni_bool);
+  logscale[1] = getTextLogFlag(*tmp);
+
+  axesBounds = (double*) getGraphicObjectProperty(curSubwin->UID, __GO_AXES_BOUNDS__, jni_double_vector);
+  margins = (double*) getGraphicObjectProperty(curSubwin->UID, __GO_MARGINS__, jni_double_vector);
+  realDataBounds = (double*) getGraphicObjectProperty(curSubwin->UID, __GO_REAL_DATA_BOUNDS__, jni_double_vector);
+
+  for ( i=0; i < 4 ; i++)
   {
-               WRect[i] = pSUBWIN_FEATURE(curSubwin)->WRect[i];
-    ARect[i] = pSUBWIN_FEATURE(curSubwin)->ARect[i];
+    WRect[i] = axesBounds[i];
+    ARect[i] = margins[i];
   }
 
-       /* Frect is [xMin, yMin, xMax, yMax] */
-       FRect[0] = pSUBWIN_FEATURE(curSubwin)->FRect[0];
-       FRect[1] = pSUBWIN_FEATURE(curSubwin)->FRect[2];
-       FRect[2] = pSUBWIN_FEATURE(curSubwin)->FRect[1];
-       FRect[3] = pSUBWIN_FEATURE(curSubwin)->FRect[3];
+  /* Frect is [xMin, yMin, xMax, yMax] whereas data bounds are [xmin, xmax, ymin, ymax] */
+  FRect[0] = realDataBounds[0];
+  FRect[1] = realDataBounds[2];
+  FRect[2] = realDataBounds[1];
+  FRect[3] = realDataBounds[3];
 
   return(0);
 }
index 078d517..4dfa260 100644 (file)
@@ -2,6 +2,7 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2002-2004 - INRIA - Djalel Abdemouche
  * Copyright (C) 2004-2006 - INRIA - Fabrice Leray
+ * Copyright (C) 2010 - DIGITEO - Manuel Juliachs
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
 #include "HandleManagement.h"
 #include "freeArrayOfString.h"
 
+#include "getGraphicObjectProperty.h"
+#include "setGraphicObjectProperty.h"
+#include "graphicObjectProperties.h"
+
 /*--------------------------------------------------------------------
  *  plot2dn(ptype,Logflags,x,y,n1,n2,style,strflag,legend,brect,aaint,lstr1,lstr2)
  *  
@@ -98,21 +103,52 @@ int plot2dn(int ptype,char *logflags,double *x,double *y,int *n1,int *n2,int *st
   int with_leg;
   double drect[6];
   char dataflag;
+  /* To be removed */
+#if 0
   sciSubWindow * ppsubwin = NULL;
+#endif
   BOOL bounds_changed = FALSE;
   BOOL axes_properties_changed = FALSE;
 
+  double rotationAngles[2];
+  int clipState;
+  int autoScale;
+  int logFlags[3];
+  int* tmp;
+  char textLogFlags[3];
+  int firstPlot;
+  int newFirstPlot;
+  int autoSubticks;
+
+  /* Deactivated since it uses synchronization */
+#if 0
   startGraphicDataWriting();
+#endif
+
   curFigure = sciGetCurrentFigure();
   psubwin = sciGetCurrentSubWin();
+
+#if 0
   ppsubwin = pSUBWIN_FEATURE(psubwin);
-  endGraphicDataWriting();
+#endif
 
+#if 0
+  endGraphicDataWriting();
   startFigureDataWriting(curFigure);
-
-  /* check if the auto_clear property is on and then erase everything */
-  checkRedrawing() ;
-  
+#endif
+  /*
+   * Check if the auto_clear property is on and then erase everything
+   * To be implemented
+   */
+  checkRedrawing();
+
+  /*
+   * Deactivated for now
+   * Searches the object hierarchy until it finds a Surface object
+   * in order to specify the view type (2D or 3D)
+   * To be implemented
+   */
+#if 0
   if (sciGetSurface(psubwin) == (sciPointObj *) NULL) /* F.Leray 18.05.04 */
     {
       ppsubwin->is3d = FALSE;
@@ -123,24 +159,37 @@ int plot2dn(int ptype,char *logflags,double *x,double *y,int *n1,int *n2,int *st
       ppsubwin->theta_kp=ppsubwin->theta;
       ppsubwin->alpha_kp=ppsubwin->alpha;
     }
-  
-  ppsubwin->alpha  = 0.0;
-  ppsubwin->theta  = 270.0;
+#endif
+
+  rotationAngles[0] = 0.0;
+  rotationAngles[1] = 270.0;
+
+  setGraphicObjectProperty(psubwin->UID, __GO_ROTATION_ANGLES__, rotationAngles, jni_double_vector, 2);
 
-  /* Force psubwin->logflags to those given by argument*/
-  if ( ppsubwin->FirstPlot )
+  /* Force logflags to those given by argument */
+
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_FIRST_PLOT__, jni_bool);
+  firstPlot = *tmp;
+
+  /* Reset x and y logflags */
+  if (firstPlot)
   {
-    char newLogFlags[3];
-    sciGetLogFlags(psubwin, newLogFlags);
-    newLogFlags[0] = logflags[1];
-    newLogFlags[1] = logflags[2];
-    sciSetLogFlags(psubwin, newLogFlags);
+    logFlags[0] = getBooleanLogFlag(logflags[1]);
+    logFlags[1] = getBooleanLogFlag(logflags[2]);
+
+    setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_LOG_FLAG__, &logFlags[0], jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_LOG_FLAG__, &logFlags[1], jni_bool, 1);
   }
 
-  /* Force "cligrf" clipping */
-  sciSetIsClipping (psubwin,0); 
+  /* Forces "clipgrf" clipping (1) */
+  clipState = 1;
+  setGraphicObjectProperty(psubwin->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
 
-  if (sciGetGraphicMode (psubwin)->autoscaling) {
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_AUTO_SCALE__, jni_bool);
+  autoScale = *tmp;
+
+  if (autoScale)
+  {
     /* compute and merge new specified bounds with psubwin->Srect */
     switch (strflag[1])  {
     case '0': 
@@ -153,64 +202,116 @@ int plot2dn(int ptype,char *logflags,double *x,double *y,int *n1,int *n2,int *st
     case '2' : case '4' : case '6' : case '8': case '9':
       /* Force psubwin->Srect to the x and y bounds */
       if ( (int)strlen(logflags) < 1) dataflag='g' ; else dataflag=logflags[0];
-      compute_data_bounds2(0,dataflag,ppsubwin->logflags,x,y,*n1,*n2,drect);
+
+      tmp = getGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_LOG_FLAG__, jni_bool);
+      logFlags[0] = *tmp;
+      tmp = getGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_LOG_FLAG__, jni_bool);
+      logFlags[1] = *tmp;
+      tmp = getGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_LOG_FLAG__, jni_bool);
+      logFlags[2] = *tmp;
+
+      /* Conversion required by compute_data_bounds2 */
+      textLogFlags[0] = getTextLogFlag(logFlags[0]);
+      textLogFlags[1] = getTextLogFlag(logFlags[1]);
+      textLogFlags[2] = getTextLogFlag(logFlags[2]);
+
+      compute_data_bounds2(0,dataflag,textLogFlags,x,y,*n1,*n2,drect);
+
       break;
     }
-    if (!pSUBWIN_FEATURE(psubwin)->FirstPlot && 
-       (strflag[1] == '5' || strflag[1] == '7' || strflag[1] == '8' || strflag[1] == '9')) { /* merge psubwin->Srect and drect */
-      
-      drect[0] = Min(ppsubwin->SRect[0],drect[0]); /*xmin*/
-      drect[2] = Min(ppsubwin->SRect[2],drect[2]); /*ymin*/
-      drect[1] = Max(ppsubwin->SRect[1],drect[1]); /*xmax*/
-      drect[3] = Max(ppsubwin->SRect[3],drect[3]); /*ymax*/
-      
+
+    /* merge psubwin->Srect and drect */
+    if ( !firstPlot &&
+        (strflag[1] == '5' || strflag[1] == '7' || strflag[1] == '8' || strflag[1] == '9'))
+    {
+      double* dataBounds = (double*) getGraphicObjectProperty(psubwin->UID, __GO_DATA_BOUNDS__, jni_double_vector);
+
+      drect[0] = Min(dataBounds[0],drect[0]); /*xmin*/
+      drect[2] = Min(dataBounds[2],drect[2]); /*ymin*/
+      drect[1] = Max(dataBounds[1],drect[1]); /*xmax*/
+      drect[3] = Max(dataBounds[3],drect[3]); /*ymax*/
     }
+
     if (strflag[1] != '0')
+    {
       bounds_changed = update_specification_bounds(psubwin, drect,2);
-  } 
-  
-  if(ppsubwin->FirstPlot == TRUE) bounds_changed = TRUE;
-  
+    }
+  }
+
+  if (firstPlot)
+  {
+    bounds_changed = TRUE;
+  }
+
+  /* Adapted to the MVC */
   axes_properties_changed = strflag2axes_properties(psubwin, strflag);
-     
-  ppsubwin->FirstPlot = FALSE; /* just after strflag2axes_properties */
-   
+
+  /* just after strflag2axes_properties */
+  newFirstPlot = 0;
+  setGraphicObjectProperty(psubwin->UID, __GO_FIRST_PLOT__, &newFirstPlot, jni_bool, 1);
+
   with_leg= (strflag[0] == '1');
 
   /* F.Leray 07.10.04 : trigger algo to init. manual graduation u_xgrads and 
      u_ygrads if nax (in matdes.c which is == aaint HERE) was specified */
-  
-  ppsubwin->flagNax = flagNax; /* store new value for flagNax */
 
-  if(ppsubwin->flagNax == TRUE){
-    if(ppsubwin->logflags[0] == 'n' && ppsubwin->logflags[1] == 'n')
+  /* The MVC AUTO_SUBTICKS property corresponds to !flagNax */
+  autoSubticks = !flagNax;
+  setGraphicObjectProperty(psubwin->UID, __GO_AUTO_SUBTICKS__, &autoSubticks, jni_bool, 1);
+
+  if (flagNax == TRUE)
+  {
+      tmp = getGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_LOG_FLAG__, jni_bool);
+      logFlags[0] = *tmp;
+      tmp = getGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_LOG_FLAG__, jni_bool);
+      logFlags[1] = *tmp;
+
+      if (logFlags[0] == 0 && logFlags[1] == 0)
       {
-        BOOL autoTicks[3];
-        sciGetAutoTicks(psubwin, autoTicks);
-        /* x and y graduations are imposed by Nax */
-        sciSetAutoTicks(psubwin, FALSE, FALSE, autoTicks[2]);
-       
-       CreatePrettyGradsFromNax(psubwin,aaint);
+          int autoTicks;
+
+          autoTicks = 0;
+          setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
+          setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
+
+          /*
+           * Creates user-defined ticks using the Nax values
+           * The MVC does not distinguish yet between automatically computed ticks
+           * and user-defined ones.
+           * To be implemented using the MVC framework
+           */
+#if 0
+         CreatePrettyGradsFromNax(psubwin,aaint);
+#endif
       }
-    else
-    {
-      sciprint(_("Warning: Nax does not work with logarithmic scaling.\n"));
-    }
+      else
+      {
+          sciprint(_("Warning: Nax does not work with logarithmic scaling.\n"));
+      }
+
   }
+
+  /* Deactivated (synchronization) */
+#if 0
   endFigureDataWriting(curFigure);
-  
+#endif
+
+  /*
+   * This was already commented out
+   * To be removed.
+   */
   /*if(bounds_changed == TRUE || axes_properties_changed == TRUE)
   {
     
     sciDrawObj(sciGetCurrentFigure());
   }*/
-  
+
   /*---- Drawing the curves and the legends ----*/
   if ( *n1 != 0 ) {
          if ((hdltab = MALLOC ((*n1+1) * sizeof (long))) == NULL) {
                  Scierror(999, _("%s: No more memory.\n"),"plot2d");
                  return -1;
-    }
+          }
     if (with_leg) {
       /* tabofhandles allocated for legends */
       if ((tabofhandles = MALLOC((*n1)*sizeof(long long))) == NULL) {
@@ -220,9 +321,17 @@ int plot2dn(int ptype,char *logflags,double *x,double *y,int *n1,int *n2,int *st
       }
     }
 
+    /* Deactivated */
+#if 0
     startFigureDataWriting(curFigure);
-    for (jj = 0;jj < *n1; jj++) {/*A.Djalel 3D axes*/
+#endif
+
+
+    /*A.Djalel 3D axes*/
+    for (jj = 0;jj < *n1; jj++)
+    {
       sciPointObj * pobj = NULL;
+
       if (style[jj] > 0) { 
        BOOL isline = TRUE;
        if (ptype==3)
@@ -247,9 +356,8 @@ int plot2dn(int ptype,char *logflags,double *x,double *y,int *n1,int *n2,int *st
       }
       else
       {
-        
         sciSetCurrentObj(pobj);
-      
+
         /*sciDrawObjIfRequired(pobj);*/
         hdl=sciGetHandle(pobj);
         if (with_leg)
@@ -262,10 +370,20 @@ int plot2dn(int ptype,char *logflags,double *x,double *y,int *n1,int *n2,int *st
       }
       
     }
+
+    /* Deactivated since it involves drawing */
+#if 0
     endFigureDataWriting(curFigure);
     forceRedraw(psubwin);
+#endif
     
     /*---- Drawing the Legends ----*/
+    /*
+     * Deactivated for now, the Legend is not fully implemented yet
+     * within the MVC
+     * To be implemented
+     */
+#if 0
     startFigureDataWriting(curFigure);
 
     if (with_leg) {
@@ -288,11 +406,12 @@ int plot2dn(int ptype,char *logflags,double *x,double *y,int *n1,int *n2,int *st
            sciSetCurrentObj (Leg); 
          }
 
-    freeArrayOfString(Str, nleg);  
+      freeArrayOfString(Str, nleg);
 
        FREE(tabofhandles);
        /* }*/
     }
+#endif
 
     /*---- construct Compound ----*/
     if (cmpt > 0)
@@ -300,11 +419,22 @@ int plot2dn(int ptype,char *logflags,double *x,double *y,int *n1,int *n2,int *st
       sciSetCurrentObj(ConstructCompound (hdltab, cmpt));
     }
     FREE(hdltab);
+
+    /* Deactivated (synchronization) */
+#if 0
     endFigureDataWriting(curFigure);
-    
+#endif
+
   }
-  
+  /* End of the curves and legend block */
+
+  /*
+   * Deactivated since it involves drawing operations
+   * To be implemented
+   */
+#if 0
   sciDrawObj(curFigure);
+#endif
   return(0);
 }
 
@@ -388,24 +518,29 @@ void compute_data_bounds2(int cflag,char dataflag, char * logflags, double *x,do
 
 BOOL update_specification_bounds(sciPointObj  *psubwin,double rect[6],int flag)
 {
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (psubwin);
   BOOL haschanged = FALSE;
-  
-  ppsubwin->SRect[0] = rect[0];
-  ppsubwin->SRect[1] = rect[1];
-  ppsubwin->SRect[2] = rect[2];
-  ppsubwin->SRect[3] = rect[3];
-  if (flag==3) {
-    ppsubwin->SRect[4] = rect[4];
-    ppsubwin->SRect[5] = rect[5];
+  double* dataBounds;
+
+  /*
+   * 2D: keep the existing zmin and zmax
+   * which is why they must be fetched
+   */
+  if (flag != 3)
+  {
+    dataBounds = (double*) getGraphicObjectProperty(psubwin->UID, __GO_DATA_BOUNDS__, jni_double_vector);
+
+    rect[4] = dataBounds[4];
+    rect[5] = dataBounds[5];
   }
-  
+
+  setGraphicObjectProperty(psubwin->UID, __GO_DATA_BOUNDS__, rect, jni_double_vector, 6);
+
+  /* To be modified */
   if(flag != 3)
     haschanged = sci_update_frame_bounds_2d(psubwin);
   else
     haschanged = sci_update_frame_bounds_3d(psubwin);
-  
-  
+
   return haschanged;
 }
 
@@ -427,18 +562,52 @@ int re_index_brect(double * brect, double * drect)
 /* F.Leray 07.05.04 */
 /* Dispatch info contained in strflag to all the flag available in
    sciSubwin object (tight_limits, isoview, isaxes...) */
+/*
+ * This function has been adapted to the MVC framework
+ */
 BOOL strflag2axes_properties(sciPointObj * psubwin, char * strflag)
 {
   BOOL haschanged = FALSE;
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (psubwin);
-       BOOL axesVisiblePrev[3] = {ppsubwin->axes.axes_visible[0],
-                                  ppsubwin->axes.axes_visible[1],
-                                  ppsubwin->axes.axes_visible[2]};
-       EAxesBoxType boxPrev = ppsubwin->axes.rect;
-       char xLocPrev = ppsubwin->axes.xdir;
-       char yLocPrev = ppsubwin->axes.ydir;
-       BOOL tightLimitsPrev = ppsubwin->tight_limits;
-       BOOL isoviewPrev = ppsubwin->isoview;
+  BOOL tightLimitsPrev;
+  BOOL isoviewPrev;
+  char xLocPrev;
+  char yLocPrev;
+  int boxPrev;
+  int tightLimits;
+  int firstPlot;
+  int axisVisible;
+  int boxType;
+  int xLocationPrev;
+  int yLocationPrev;
+  int xLocation;
+  int yLocation;
+  int isoview;
+  int axesVisiblePrev[3];
+  int axesVisible[3];
+
+  int* tmp;
+
+
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_VISIBLE__, jni_bool);
+  axesVisiblePrev[0] = *tmp;
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_VISIBLE__, jni_bool);
+  axesVisiblePrev[1] = *tmp;
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_VISIBLE__, jni_bool);
+  axesVisiblePrev[2] = *tmp;
+
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_BOX_TYPE__, jni_int);
+  boxPrev = *tmp;
+
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_LOCATION__, jni_int);
+  xLocationPrev = *tmp;
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_LOCATION__, jni_int);
+  yLocationPrev = *tmp;
+
+
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_TIGHT_LIMITS__, jni_bool);
+  tightLimitsPrev = *tmp;
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_ISOVIEW__, jni_bool);
+  isoviewPrev = *tmp;
 
   /* F.Leray 07.05.04 */
   /* strflag[1] Isoview & tight_limits flags management*/
@@ -447,90 +616,157 @@ BOOL strflag2axes_properties(sciPointObj * psubwin, char * strflag)
     /* no changes */
     break;
   case '1' : case '2' : case '7' : case '8' :
-    ppsubwin->tight_limits = TRUE;
+    tightLimits = 1;
+    setGraphicObjectProperty(psubwin->UID, __GO_TIGHT_LIMITS__, &tightLimits, jni_bool, 1);
     break;
   case '3' : case '4' :
-    ppsubwin->isoview = TRUE;
+    isoview = 1;
+    setGraphicObjectProperty(psubwin->UID, __GO_ISOVIEW__, &isoview, jni_bool, 1);
     break;
   case '5' : case '6' :
-    ppsubwin->tight_limits = FALSE; /* pretty axes */
+    /* pretty axes */
+    tightLimits = 0;
+    setGraphicObjectProperty(psubwin->UID, __GO_TIGHT_LIMITS__, &tightLimits, jni_bool, 1);
     break;
   }
-      
+
   /* F.Leray 07.05.04 */
   /* strflag[2] */
   switch (strflag[2])  {
-  case '0': 
-    if(ppsubwin->FirstPlot == TRUE){
-      ppsubwin->axes.axes_visible[0] = FALSE;
-      ppsubwin->axes.axes_visible[1] = FALSE;
-      ppsubwin->axes.axes_visible[2] = FALSE; /* also trigger z axis */
-      ppsubwin->axes.rect = BT_OFF;
+
+  case '0':
+    tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_FIRST_PLOT__, jni_bool);
+    firstPlot = *tmp;
+
+    if(firstPlot)
+    {
+      axisVisible = 0;
+      /* 0: OFF */
+      boxType = 0;
+
+      setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+      setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+      /* also trigger z axis */
+      setGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+      setGraphicObjectProperty(psubwin->UID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
     }
     /*else no changes : the isaxes properties is driven by the previous plot */
     break;
   case '1' : 
-    ppsubwin->axes.axes_visible[0] = TRUE;
-    ppsubwin->axes.axes_visible[1] = TRUE;
-    ppsubwin->axes.axes_visible[2] = TRUE; /* also trigger z axis */
-    ppsubwin->axes.ydir ='l';
-    ppsubwin->axes.rect = BT_ON;
+    axisVisible = 1;
+    /* 1: ON */
+    boxType = 1;
+    /* 4: LEFT */
+    yLocation = 4;
+
+    setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_LOCATION__, &yLocation, jni_int, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
+
     break;
   case '2' : 
-    ppsubwin->axes.axes_visible[0] = FALSE;
-    ppsubwin->axes.axes_visible[1] = FALSE;
-    ppsubwin->axes.axes_visible[2] = FALSE; /* also trigger z axis */
-    ppsubwin->axes.rect = BT_ON;
+    axisVisible = 0;
+    boxType = 1;
+
+    setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    /* also trigger z axis */
+    setGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
+
     break;
   case '3' : 
-    ppsubwin->axes.axes_visible[0] = TRUE;
-    ppsubwin->axes.axes_visible[1] = TRUE;
-    ppsubwin->axes.axes_visible[2] = TRUE; /* also trigger z axis */
-               ppsubwin->axes.rect = BT_OFF;
-    ppsubwin->axes.ydir ='r';
+    axisVisible = 1;
+    boxType = 0;
+    /* 5: RIGHT */
+    yLocation = 5;
+
+    setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_LOCATION__, &yLocation, jni_int, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
+
     break;
   case '4' :
-    ppsubwin->axes.axes_visible[0] = TRUE;
-    ppsubwin->axes.axes_visible[1] = TRUE;
-    ppsubwin->axes.axes_visible[2] = TRUE; /* also trigger z axis */
-               ppsubwin->axes.xdir ='c';
-    ppsubwin->axes.ydir ='c';
-               ppsubwin->axes.rect = BT_OFF;
+    axisVisible = 1;
+    /* 2: MIDDLE */
+    xLocation = 2;
+    yLocation = 2;
+    boxType = 0;
+
+    setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    /* also trigger z axis */
+    setGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_LOCATION__, &xLocation, jni_int, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_LOCATION__, &yLocation, jni_int, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
+
     break;
   case '5' :
-    ppsubwin->axes.axes_visible[0] = TRUE;
-    ppsubwin->axes.axes_visible[1] = TRUE;
-    ppsubwin->axes.axes_visible[2] = TRUE; /* also trigger z axis */
-    ppsubwin->axes.xdir ='c';
-    ppsubwin->axes.ydir ='c';
-    ppsubwin->axes.rect = BT_ON;
+    axisVisible = 1;
+    xLocation = 2;
+    yLocation = 2;
+    boxType = 1;
+
+    setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    /* also trigger z axis */
+    setGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_LOCATION__, &xLocation, jni_int, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_LOCATION__, &yLocation, jni_int, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
+
     break;
   case '9' :
-    ppsubwin->axes.axes_visible[0] = TRUE;
-    ppsubwin->axes.axes_visible[1] = TRUE;
-    ppsubwin->axes.axes_visible[2] = TRUE; /* also trigger z axis */
-  }
+    axisVisible = 1;
 
-       /* Find if something has changed */
-       if (   ppsubwin->axes.axes_visible[0] != axesVisiblePrev[0]
-           || ppsubwin->axes.axes_visible[1] != axesVisiblePrev[1]
-                       || ppsubwin->axes.axes_visible[2] != axesVisiblePrev[2]
-                       || ppsubwin->axes.rect != boxPrev
-                       || ppsubwin->axes.xdir != xLocPrev
-                       || ppsubwin->axes.ydir != yLocPrev
-                       || ppsubwin->tight_limits != tightLimitsPrev
-                       || ppsubwin->isoview != isoviewPrev)
-       {
-               haschanged = TRUE;
-       }
-       else
-       {
-               haschanged = FALSE;
-       }
+    setGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    setGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+    /* also trigger z axis */
+    setGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
+  }
 
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_VISIBLE__, jni_bool);
+  axesVisible[0] = *tmp;
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_VISIBLE__, jni_bool);
+  axesVisible[1] = *tmp;
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_Z_AXIS_VISIBLE__, jni_bool);
+  axesVisible[2] = *tmp;
+
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_BOX_TYPE__, jni_int);
+  boxType = *tmp;
+
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_X_AXIS_LOCATION__, jni_int);
+  xLocation = *tmp;
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_Y_AXIS_LOCATION__, jni_int);
+  yLocation = *tmp;
+
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_TIGHT_LIMITS__, jni_bool);
+  tightLimits = *tmp;
+  tmp = (int*) getGraphicObjectProperty(psubwin->UID, __GO_ISOVIEW__, jni_bool);
+  isoview = *tmp;
+
+  /* Find if something has changed */
+  if (axesVisible[0] != axesVisiblePrev[0]
+    || axesVisible[1] != axesVisiblePrev[1]
+    || axesVisible[2] != axesVisiblePrev[2]
+    || xLocation != xLocationPrev
+    || yLocation != yLocationPrev
+    || boxType != boxPrev
+    || tightLimits != tightLimitsPrev
+    || isoview != isoviewPrev)
+  {
+    haschanged = TRUE;
+  }
+  else
+  {
+    haschanged = FALSE;
+  }
 
   return haschanged;
 }
 
-
-