Speed up stringbox (and consequently old xstringl):
Jean-baptiste Silvy [Thu, 14 Aug 2008 16:31:58 +0000 (16:31 +0000)]
 - Avoid requesting a redraw to obtain the bounding box.
 - Remove move stringbox from a macro to a primitive.

This speed up metanet (around  4 times).

50 files changed:
scilab/modules/graphics/includes/DrawObjects.h
scilab/modules/graphics/includes/sci_StringBox.h
scilab/modules/graphics/macros/stringbox.sci [deleted file]
scilab/modules/graphics/sci_gateway/c/gw_graphics.c
scilab/modules/graphics/sci_gateway/c/sci_StringBox.c
scilab/modules/graphics/sci_gateway/graphics_gateway.xml
scilab/modules/graphics/src/c/DrawObjects.c
scilab/modules/graphics/src/c/GetProperty.c
scilab/modules/graphics/src/c/StringBox.c
scilab/modules/graphics/src/c/StringBox.h
scilab/modules/metanet/macros/editor/ge_draw_graph.sci
scilab/modules/renderer/graphics_Import.def
scilab/modules/renderer/includes/GetJavaProperty.h
scilab/modules/renderer/renderer_header.def
scilab/modules/renderer/src/cpp/GetJavaProperty.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/Camera.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/Camera.h
scilab/modules/renderer/src/cpp/subwinDrawing/CameraBridge.h
scilab/modules/renderer/src/cpp/subwinDrawing/CameraJoGL.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/CameraJoGL.h
scilab/modules/renderer/src/cpp/textDrawing/CenteredTextDrawerJavaMapper.cpp
scilab/modules/renderer/src/cpp/textDrawing/CenteredTextDrawerJavaMapper.hxx
scilab/modules/renderer/src/cpp/textDrawing/CenteredTextDrawerJoGL.cpp
scilab/modules/renderer/src/cpp/textDrawing/ConcreteDrawableText.cpp
scilab/modules/renderer/src/cpp/textDrawing/ConcreteDrawableText.hxx
scilab/modules/renderer/src/cpp/textDrawing/DrawableText.cpp
scilab/modules/renderer/src/cpp/textDrawing/DrawableText.h
scilab/modules/renderer/src/cpp/textDrawing/FilledTextDrawerJavaMapper.cpp
scilab/modules/renderer/src/cpp/textDrawing/FilledTextDrawerJavaMapper.hxx
scilab/modules/renderer/src/cpp/textDrawing/FilledTextDrawerJoGL.cpp
scilab/modules/renderer/src/cpp/textDrawing/StandardTextDrawerJavaMapper.cpp
scilab/modules/renderer/src/cpp/textDrawing/StandardTextDrawerJavaMapper.hxx
scilab/modules/renderer/src/cpp/textDrawing/StandardTextDrawerJoGL.cpp
scilab/modules/renderer/src/cpp/textDrawing/TextContentDrawerJavaMapper.hxx
scilab/modules/renderer/src/cpp/textDrawing/TextContentDrawerJoGL.cpp
scilab/modules/renderer/src/cpp/textDrawing/TextContentDrawerJoGL.hxx
scilab/modules/renderer/src/java/org/scilab/modules/renderer/ObjectGL.java
scilab/modules/renderer/src/java/org/scilab/modules/renderer/subwinDrawing/TicksDrawerGL.java
scilab/modules/renderer/src/java/org/scilab/modules/renderer/textDrawing/FixedFontTextDrawerGL.java
scilab/modules/renderer/src/java/org/scilab/modules/renderer/textDrawing/TextContentDrawerGL.java
scilab/modules/renderer/src/java/org/scilab/modules/renderer/utils/textRendering/TextRendererManager.java
scilab/modules/renderer/src/jni/CenteredTextDrawerGL.cpp
scilab/modules/renderer/src/jni/CenteredTextDrawerGL.giws.xml
scilab/modules/renderer/src/jni/CenteredTextDrawerGL.hxx
scilab/modules/renderer/src/jni/FilledTextDrawerGL.cpp
scilab/modules/renderer/src/jni/FilledTextDrawerGL.giws.xml
scilab/modules/renderer/src/jni/FilledTextDrawerGL.hxx
scilab/modules/renderer/src/jni/StandardTextDrawerGL.cpp
scilab/modules/renderer/src/jni/StandardTextDrawerGL.giws.xml
scilab/modules/renderer/src/jni/StandardTextDrawerGL.hxx

index cae8525..3fed0c6 100644 (file)
@@ -115,9 +115,6 @@ extern void sciAxesVerticesIndices( integer insideU[4],
 
 extern void matrixLine2String( char ** matrix, int matrixSize[2], int numLine, char * dest ) ;
 
-
-void computeLabelAutoPos( sciPointObj * pLabel, int axisStart[2], int axisEnd[2], int offsets[2] ) ;
-
 void sciDrawFigure( int numFigure ) ;
 
 
index 444068f..5d5835e 100644 (file)
 
 /**
 * interface function for the StringBox routine :
-* rect = StringBox( handle )
+* rect = stringbox( handle )
+* rect = stringbox(str, x, y, [angle, [fontId, [fontSize]]])
 *
 * @param[in] fname     name of the routine (ie StringBox)
 * @param[in] fname_len length of fname
 * @return 0 if success, -1 otherwise
 */
-int sci_StringBox( char * fname, unsigned long fname_len ) ;
+int sci_stringbox( char * fname, unsigned long fname_len ) ;
 
 #endif /* _INT_STRINGBOX_H_ */
diff --git a/scilab/modules/graphics/macros/stringbox.sci b/scilab/modules/graphics/macros/stringbox.sci
deleted file mode 100644 (file)
index 6a0e85e..0000000
+++ /dev/null
@@ -1,89 +0,0 @@
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2005 - INRIA - Jean-Baptiste Silvy
-// This file must be used under the terms of the CeCILL.
-// This source file is licensed as described in the file COPYING, which
-// you should have received as part of this distribution.  The terms
-// are also available at    
-// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-
-
-//=======================================================================
-// File   : stringbox.sci
-// Desc   : Compute the 4 corners of a displayed string bounding rect
-//======================================================================
-
-function [corners] = stringbox( varargin )
-
-// the call is stringBox(handle) or stringBox(text,posX,posY,[angle,[fontId,[fontSize]]]) ;
-
-[lhs,rhs] = argn(0) ;
-ListArg = varargin ;
-
-if ( rhs == 1 ) then
-  textHandle = ListArg(1) ;
-  corners = StringBox( textHandle ) ;
-else
-  
-  
-  oldHandle = gce() ;
-  axes = gca()  ;
-  fig = gcf();
-  // initialize values ;
-  text     = '' ;
-  angle    = 0  ;
-  posX     = 0  ;
-  posY     = 0  ;
-  fontId   = axes.font_style ;
-  fontSize = axes.font_size  ;
-
-  select rhs,
-    
-  case 3 then
-    text = ListArg( 1 ) ;
-    posX = ListArg( 2 ) ;
-    posY = ListArg( 3 ) ;
-    
-  case 4 then
-    text  = ListArg( 1 ) ;
-    posX  = ListArg( 2 ) ;
-    posY  = ListArg( 3 ) ;
-    angle = ListArg( 4 ) ;
-    
-  case 5 then
-    text   = ListArg( 1 ) ;
-    posX   = ListArg( 2 ) ;
-    posY   = ListArg( 3 ) ;
-    angle  = ListArg( 4 ) ;
-    fontId = ListArg( 5 ) ;
-    
-  case 6 then
-    text     = ListArg( 1 ) ;
-    posX     = ListArg( 2 ) ;
-    posY     = ListArg( 3 ) ;
-    angle    = ListArg( 4 ) ;
-    fontId   = ListArg( 5 ) ; 
-    fontSize = ListArg( 6 ) ;
-    
-  else
-    error(39);
-    return ;
-  end
-    
-  // create an object get is bb and then destroy it
-  immediateDrawingMode = fig.immediate_drawing;
-  f.immediate_drawing = "off";
-  xstring( posX, posY, text, angle ) ;
-  textHandle = gce() ;
-  textHandle.visible = "off"; // to prevent it from appearing
-  textHandle.font_style = fontId ;
-  textHandle.font_size = fontSize ;
-
-  corners = StringBox( textHandle ) ;
-  
-  delete( textHandle ) ;
-  set( 'current_entity', oldHandle ) ;
-  f.immediate_drawing = immediateDrawingMode;
-
-end;
-
-endfunction
index 062b689..07328a2 100644 (file)
@@ -80,7 +80,7 @@ static gw_generic_table Tab[]={
        {sci_set_posfig_dim,"set_posfig_dim"},
        {sci_zoom_rect,"zoom_rect"},
        {sci_unzoom,"unzoom"},
-       {sci_StringBox,"StringBox"},
+       {sci_stringbox,"stringbox"},
        {sci_move,"move"},
        {sci_glue,"glue"},
        {sci_unglue,"unglue"}, 
index 7e8536d..f3687ed 100644 (file)
 #include "GetProperty.h"
 #include "BuildObjects.h"
 #include "gw_graphics.h"
-#include "DrawObjects.h"
 #include "StringBox.h"
 #include "localization.h"
-#include "DrawingBridge.h"
 #include "axesScale.h"
-/*--------------------------------------------------------------------------*/
-int sci_StringBox( char * fname, unsigned long fname_len )
-{
-  integer    two   = 2     ;
-  integer    four  = 4     ;
-  integer    m,n           ;
-  integer    stackPointer  ;
-  double     corners[4][2] ; /* the four edges of the boundingRect */
-  sciPointObj * pText = NULL ;
+#include "getPropertyAssignedValue.h"
+#include "CurrentObjectsManagement.h"
 
-  /* The function should be called with stringbox( handle ) */
-  CheckRhs( 1, 1 ) ;
-  CheckLhs( 0, 1 ) ;
+#define DEFAULT_ANGLE 0.0
 
-  if ( VarType(1) != sci_handles )
+/*--------------------------------------------------------------------------*/
+static int getScalarFromStack(int paramIndex, char * funcName, double * res);
+/*--------------------------------------------------------------------------*/
+static int getScalarFromStack(int paramIndex, char * funcName, double * res)
+{
+  int m;
+  int n;
+  int stackPointer;
+  if ( VarType(paramIndex) != sci_matrix )
   {
-    Scierror(999,_("%s: Wrong type for input argument #%d: Only one text handle expected.\n"),fname, 1);
-    return 0 ;
+    Scierror(999,_("%s: Wrong type for input argument #%d: Real scalar expected.\n"), funcName, paramIndex);
+    return -1 ;
   }
 
   /* get the handle */
-  GetRhsVar( 1,GRAPHICAL_HANDLE_DATATYPE, &m, &n, &stackPointer );
+  GetRhsVar( paramIndex, MATRIX_OF_DOUBLE_DATATYPE, &m, &n, &stackPointer );
 
   if ( m * n != 1 )
   {
-         Scierror(999,_("%s: Wrong type for input argument #%d: Only one text handle expected.\n"),fname, 1);
-    return 0 ;
+    Scierror(999,_("%s: Wrong size for input argument #%d: Real scalar expected.\n"), funcName, paramIndex);
+    return -1 ;
   }
 
-  pText = sciGetPointerFromHandle( (unsigned long) *hstk( stackPointer ) ) ;
+  *res = getDoubleFromStack(stackPointer);
+  return 0;
+}
+/*--------------------------------------------------------------------------*/
+int sci_stringbox( char * fname, unsigned long fname_len )
+{
+  int two   = 2;
+  int four  = 4;
+  int stackPointer;
+  double corners[4][2]; /* the four edges of the boundingRect */
+  
 
-  if ( pText == NULL )
-  {
-    Scierror(999,_("%s: The handle is not valid.\n"),fname);
-    return 0 ;
-  }
+  /* The function should be called with stringbox( handle ) */
+  CheckRhs( 1, 6 ) ;
+  CheckLhs( 0, 1 ) ;
 
-  if ( sciGetEntityType( pText ) == SCI_LABEL )
+  if (Rhs == 1)
   {
-    pText = pLABEL_FEATURE( pText )->text ;
+    int m;
+    int n;
+    /* A text handle should be specified */
+    sciPointObj * pText = NULL ;
+    if ( VarType(1) != sci_handles )
+    {
+      Scierror(999,_("%s: Wrong type for input argument #%d: A 'Text' handle expected.\n"), fname, 1);
+      return 0 ;
+    }
+
+    /* get the handle */
+    GetRhsVar( 1,GRAPHICAL_HANDLE_DATATYPE, &m, &n, &stackPointer );
+    if ( m * n != 1 )
+    {
+      Scierror(999,_("%s: Wrong size for input argument #%d: A 'Text' handle expected.\n"), fname, 1);
+      return 0 ;
+    }
+
+    /* Get the handle and check that this is a text handle */
+    pText = sciGetPointerFromHandle( getHandleFromStack(stackPointer) ) ;
+
+    if ( pText == NULL )
+    {
+      Scierror(999,_("%s: The handle is not valid.\n"),fname);
+      return 0 ;
+    }
+
+    if ( sciGetEntityType( pText ) == SCI_LABEL )
+    {
+      // a label, get the real text
+      pText = pLABEL_FEATURE( pText )->text ;
+    }
+    else if ( sciGetEntityType( pText ) != SCI_TEXT )
+    {
+      Scierror(999,_("%s: Wrong type for input argument #%d: A 'Text' handle expected.\n"), fname, 1);
+      return 0 ;
+    }
+
+    /* update stringbox */
+    updateTextBounds(pText);
+
+    /* get the string box */
+    sciGet2dViewBoundingBox( pText, corners[0], corners[1], corners[2], corners[3]) ;
+    
   }
-  else if ( sciGetEntityType( pText ) != SCI_TEXT )
+  else if (Rhs == 2)
   {
-         Scierror(999,_("%s: Wrong type for input argument #%d: Only one text handle expected.\n"),fname, 1);
-    return 0 ;
+     Scierror(999,_("%s: Wrong number of input arguments: %d or %d to %d expected.\n"),fname, 1, 3, 6);
+     return 0 ;
   }
+  else
+  {
+    sciPointObj * parentSubwin = sciGetCurrentSubWin();
+    char ** text = NULL;
+    int textNbRow;
+    int textNbCol;
+    double xPos;
+    double yPos;
+    double angle = DEFAULT_ANGLE;
+    int fontId = sciGetFontStyle(parentSubwin);
+    double fontSize = sciGetFontSize(parentSubwin);
+
+    /* Check that first argument is a string */
+    if ( VarType(1) != sci_strings )
+    {
+      Scierror(999,_("%s: Wrong type for input argument #%d: 2D array of strings expected.\n"), fname, 1);
+      return 0 ;
+    }
+    GetRhsVar( 1, MATRIX_OF_STRING_DATATYPE, &textNbRow, &textNbCol, &stackPointer );
+    /* retrieve it */
+    text = getStringMatrixFromStack(stackPointer);
 
-  /* create a window if needed to initialize the X11 graphic context  */
+    /* Second and third argument should be scalars */
+    if (getScalarFromStack(2, fname, &xPos) < 0) { return 0; }
+    if (getScalarFromStack(3, fname, &yPos) < 0) { return 0; }
 
-  /* update stringbox */
-  updateTextBounds(pText);
+    if (Rhs >= 4)
+    {
+      /* angle is defined */
+      if (getScalarFromStack(4, fname, &angle) < 0) { return 0; }
+    }
 
-  /* get the string box */
-  sciGet2dViewBoundingBox( pText, corners[0], corners[1], corners[2], corners[3]) ;
+    if (Rhs >= 5)
+    {
+      double fontIdD;
+      /* font style is defined */
+      if (getScalarFromStack(5, fname, &fontIdD) < 0) { return 0; }
+      fontId = (int) fontIdD;
+    }
+
+    if (Rhs >= 6)
+    {
+      /* font size is defined */
+      if (getScalarFromStack(6, fname, &fontSize) < 0) { return 0; }
+    }
+
+    /* compute the box */
+    getTextBoundingBox(text, textNbRow, textNbCol, xPos, yPos, angle, fontId, fontSize, corners);
+  }
+  
 
   /* copy everything into the lhs */
   CreateVar( Rhs + 1,MATRIX_OF_DOUBLE_DATATYPE, &two, &four, &stackPointer );
@@ -97,3 +187,4 @@ int sci_StringBox( char * fname, unsigned long fname_len )
 }
 
 /*--------------------------------------------------------------------------*/
+#undef DEFAULT_ANGLE
index cd9e699..e11e03f 100644 (file)
@@ -79,7 +79,7 @@
 <PRIMITIVE gatewayId="7" primitiveId="53" primitiveName="set_posfig_dim" />
 <PRIMITIVE gatewayId="7" primitiveId="54" primitiveName="zoom_rect" />
 <PRIMITIVE gatewayId="7" primitiveId="55" primitiveName="unzoom" />
-<PRIMITIVE gatewayId="7" primitiveId="56" primitiveName="StringBox" />
+<PRIMITIVE gatewayId="7" primitiveId="56" primitiveName="stringbox" />
 <PRIMITIVE gatewayId="7" primitiveId="57" primitiveName="move" />
 <PRIMITIVE gatewayId="7" primitiveId="58" primitiveName="glue" />
 <PRIMITIVE gatewayId="7" primitiveId="59" primitiveName="unglue" />
index d9b147e..7abd8f8 100644 (file)
@@ -978,89 +978,6 @@ void sciAxesVerticesIndices( integer insideU[4],
          
 }
 /*---------------------------------------------------------------------------------*/
-/**
- * Update the coordinates of a label to put it in the middle of a segment (normally an axis)
- * but with a little orthogonal offset.
- * Let Ri i=0:3 be the four corners of the label boudinbg box. The algorithm will put the
- * center of the bounding box C on the middle of the segment I. Then we compute for each corner
- * the needed translation to put them at a distance given by offset. The translation is done
- * along an axis orthogonal to the segment. Finally we transalte the box from I with the longest
- * translation, so each corner is at least at the wanted distance.
- * @param pLabel pointer to the label to place.
- * @param axisStart Starting point of the segment.
- * @param axisEnd   The other end of the segment. The order of the two points determine the
- *                  side in which the label will be placed.
- * @param offsets   The label is not put exactly on the middle of the segment. It is moved
- *                  from a little offset orthogonally from the segment.
- */
-void computeLabelAutoPos( sciPointObj * pLabel, int axisStart[2], int axisEnd[2], int offsets[2] )
-{
-  /* computation are done in double to avoid loss of data */
-  double centerDir[2]  ; /* give the direction of the line on which is the center. */
-                         /* it is orthogonal with the axis direction */
-  double axisMiddle[2] ; /* middle of the axis = ( axisStart + axisEnd ) / 2 */
-  int    bbox[4][2]    ; /* real bounding box of the label */
-  double corners[4][2] ; /* the four corners of the boundign box */
-  double centerDist    ; /* final distance between the center and the axis */
-  int wantedBlPoint[2] ; /* the position we want for the bottom left point of the axis */
-  double distance      ;
-  double rectCenter[2] ;
-
-  if ( axisStart[0] == axisEnd[0] && axisStart[1] == axisEnd[1] )
-  {
-    /* the axis is invisible. Its label is not displayed also. */
-    return ;
-  }
-
-  /* normalized vector orthogonal to the axe */
-  /* its direction (+ or -) determines on which side will be displayed the axis */
-  centerDir[0] = axisStart[1] - axisEnd[1]   ;
-  centerDir[1] = axisEnd[0]   - axisStart[0] ;
-  normalize2d( centerDir ) ;
-
-  /* the distance between the aabb and the axis is offsets[0] if the axis is vertical, */
-  /* offest[1] if horizontal and something in between otherwise */
-  distance = Abs( (double)offsets[0] * centerDir[0] ) + Abs( (double)offsets[1] * centerDir[1] ) ;
-
-  axisMiddle[0] = ( axisStart[0] + axisEnd[0] ) / 2.0 ;
-  axisMiddle[1] = ( axisStart[1] + axisEnd[1] ) / 2.0 ;
-  
-  /* get the size of the label axis aligned bouding box. */
-  getTextBoundingBox( pLABEL_FEATURE(pLabel)->text, bbox, NULL ) ;
-
-  /* get the center of the rectangle */
-  rectCenter[0] = ( bbox[0][0] + bbox[1][0] + bbox[2][0] + bbox[3][0] ) / 4.0 ;
-  rectCenter[1] = ( bbox[0][1] + bbox[1][1] + bbox[2][1] + bbox[3][1] ) / 4.0 ;
-
-  /* We suppose the box is centered on I and we compute IRi, i=0:3 */
-  corners[0][0] = bbox[0][0] - rectCenter[0] ;
-  corners[0][1] = bbox[0][1] - rectCenter[1] ;
-  corners[1][0] = bbox[1][0] - rectCenter[0] ;
-  corners[1][1] = bbox[1][1] - rectCenter[1] ;
-  corners[2][0] = bbox[2][0] - rectCenter[0] ;
-  corners[2][1] = bbox[2][1] - rectCenter[1] ;
-  corners[3][0] = bbox[3][0] - rectCenter[0] ;
-  corners[3][1] = bbox[3][1] - rectCenter[1] ;
-
-  /* compute IRi.v, i=0:3 to get the current distance between Ri and the axis. */
-  /* Then for each Ri we can compute the need displacment along the centerDir to push it */
-  /* at distance dist of the axis. Finally, the needed displacement is the maximum of the 4. */
-  centerDist = distance - DOT_PROD_2D( corners[0], centerDir ) ;
-  centerDist = Max( centerDist, distance - DOT_PROD_2D( corners[1], centerDir ) ) ;
-  centerDist = Max( centerDist, distance - DOT_PROD_2D( corners[2], centerDir ) ) ;
-  centerDist = Max( centerDist, distance - DOT_PROD_2D( corners[3], centerDir ) ) ;
-
-  /* the wanted center is C = I + a.v */
-  wantedBlPoint[0] = round( axisMiddle[0] + centerDist * centerDir[0] + corners[0][0] ) ;
-  wantedBlPoint[1] = round( axisMiddle[1] + centerDist * centerDir[1] + corners[0][1] ) ;
-
-  sciSetTextPos( pLabel,
-                 XPixel2Double( wantedBlPoint[0] ),
-                 YPixel2Double( wantedBlPoint[1] ),
-                 0.0 ) ;
-
-}
-/*---------------------------------------------------------------------------------*/
 void showPixmap(sciPointObj * pFigure)
 {
   /* Hack here. Pixmap has same action as drawlater() */
index ee7bde5..78ed438 100644 (file)
@@ -862,7 +862,7 @@ BOOL sciisTextEmpty( sciPointObj * pobj)
     }
     else if (firstElement[0] == 0)
     {
-      // empty string
+      /* empty string */
       return TRUE;
     }
   }
@@ -4356,18 +4356,7 @@ void sciGetTextBoundingBox(sciPointObj * pObj, double corner1[3], double corner2
 void sciGetPixelBoundingBox(sciPointObj * pObj, int corner1[2], int corner2[2],
                             int corner3[2], int corner4[2])
 {
-
-  double corners3d[4][3];
-  sciPointObj * parentSubwin = sciGetParentSubwin(pObj);
-
-  // get pixel bounding box
-  sciGetTextBoundingBox(pObj, corners3d[0], corners3d[1], corners3d[2], corners3d[3]);
-
-  // convert them to user coordinates
-  sciGetPixelCoordinate(parentSubwin, corners3d[0], corner1);
-  sciGetPixelCoordinate(parentSubwin, corners3d[1], corner2);
-  sciGetPixelCoordinate(parentSubwin, corners3d[2], corner3);
-  sciGetPixelCoordinate(parentSubwin, corners3d[3], corner4);
+  sciGetJavaPixelBoundingBox(pObj, corner1, corner2, corner3, corner4);
 }
 /*----------------------------------------------------------------------------------*/
 /**
@@ -4376,17 +4365,18 @@ void sciGetPixelBoundingBox(sciPointObj * pObj, int corner1[2], int corner2[2],
 void sciGet2dViewBoundingBox(sciPointObj * pObj, double corner1[2], double corner2[2],
                              double corner3[2], double corner4[2])
 {
-  int pixCorners[4][2];
   sciPointObj * parentSubwin = sciGetParentSubwin(pObj);
+  double corners3d[4][3];
 
-  // get pixel bounding box
-  sciGetPixelBoundingBox(pObj, pixCorners[0], pixCorners[1], pixCorners[2], pixCorners[3]);
+  /* get bounding box */
+  sciGetTextBoundingBox(pObj, corners3d[0], corners3d[1], corners3d[2], corners3d[3]);
+  
+  /* convert it to 2d view coordinates */
+  sciGetJava2dViewCoordinates(parentSubwin, corners3d[0], corner1);
+  sciGetJava2dViewCoordinates(parentSubwin, corners3d[1], corner2);
+  sciGetJava2dViewCoordinates(parentSubwin, corners3d[2], corner3);
+  sciGetJava2dViewCoordinates(parentSubwin, corners3d[3], corner4);
 
-  // convert them to user coordinates
-  sciGetJava2dViewCoordFromPixel(parentSubwin, pixCorners[0], corner1);
-  sciGetJava2dViewCoordFromPixel(parentSubwin, pixCorners[1], corner2);
-  sciGetJava2dViewCoordFromPixel(parentSubwin, pixCorners[2], corner3);
-  sciGetJava2dViewCoordFromPixel(parentSubwin, pixCorners[3], corner4);
 }
 /*----------------------------------------------------------------------------------*/
 /**
index 4d6fe35..ace8330 100644 (file)
 
 #include "StringBox.h"
 #include "GetProperty.h"
-#include "Axes.h"
+#include "axesScale.h"
 #include "math_graphics.h"
-#include "PloEch.h"
 #include "MALLOC.h"
 #include "CurrentObjectsManagement.h"
 #include "ObjectSelection.h"
+#include "BuildObjects.h"
+#include "DestroyObjects.h"
+#include "GraphicSynchronizerInterface.h"
+#include "SetProperty.h"
 
 /*-------------------------------------------------------------------------------*/
-void getStringBbox( char * string, int center[2], int rect[4] )
+void getTextBoundingBox(char ** text, int nbRow, int nbCol,
+                        double xPos, double yPos,
+                        double angle, int fontId, double fontSize,
+                        double corners[4][2])
 {
-  center[0] = 0;
-  center[1] = 0;
-  rect[0] = 0;
-  rect[1] = 0;
-  rect[2] = 0;
-  rect[3] = 0;
-}
-/*-------------------------------------------------------------------------------*/
-void callXstringL( char * string, int posX, int posY, int boundingRect[4] )
-{
-  //sciPointObj * parentSubWin = sciGetFirstTypedSelectedSon( sciGetCurrentFigure(), SCI_SUBWIN ) ;
-
-  /* now we can call xstringl */
-  boundingRect[0] = 0;
-  boundingRect[1] = 0;
-  boundingRect[2] = 0;
-  boundingRect[3] = 0;
+  /* first step, create at text object */
+  sciPointObj * parentFigure = sciGetCurrentFigure();
+  sciPointObj * parentSubwin = sciGetCurrentSubWin();
+  int defaultColor = 0; /* color does not matter */
+  sciPointObj * pText = NULL;
 
-}
-/*-------------------------------------------------------------------------------*/
-void getStringBox( char   ** text         ,
-                  double    textPos[2]   ,
-                  int       textDim[2]   ,
-                  BOOL      autoSize     ,
-                  double    userSize[2]  ,
-                  double    angle        ,
-                  int       fontId       ,
-                  int       fontSize     ,
-                  double    corners[4][2] )
-{
-  int pos[2] ;
-  int textSize[2] = {0,0} ;
-  int corn[4][2] ;
-  StringMatrix * strings = newCompleteMatrix( (void **) text, textDim[0], textDim[1] ) ;
+  startFigureDataWriting(parentFigure);
+  
+  pText = allocateText(parentSubwin,
+                       text, nbRow, nbCol,
+                       xPos, yPos,
+                       TRUE,
+                       NULL,
+                       FALSE,
+                       &defaultColor, &defaultColor,
+                       FALSE, FALSE, FALSE,
+                       ALIGN_LEFT);
 
-  /* take coordinates in pixels */
-  pos[0] = XDouble2Pixel( textPos[0] ) ;
-  pos[1] = YDouble2Pixel( textPos[1] ) ;
+  /* make it invisible to be sure */
+  sciSetVisibility(pText, FALSE);
 
-  if ( !autoSize )
-  {
-    textSize[0] = WDouble2Pixel( textPos[0], userSize[0] ) ;
-    textSize[1] = HDouble2Pixel( textPos[1], userSize[1] ) ;
-  }
+  sciSetFontOrientation(pText, DEG2RAD(angle));
 
-  /* NULL because we don't need the position of each string */
-  getStringsPositions( strings, &fontId, &fontSize, pos, autoSize, textSize, FALSE, angle, NULL, corn ) ;
+  sciSetFontSize(pText, fontSize);
+  sciSetFontStyle(pText, fontId);
 
-  /* take everything back to user coordinates */
-  /* to retrieve exactly the first corner as in stringl we take the input */
-  corners[0][0] = XDPixel2Double( corn[0][0] ) ;
-  corners[0][1] = YDPixel2Double( corn[0][1] ) ;
+  /* Then get its bounding box */
+  /* update stringbox */
+  updateTextBounds(pText);
 
-  corners[1][0] = XDPixel2Double( corn[1][0] ) ;
-  corners[1][1] = YDPixel2Double( corn[1][1] ) ;
+  /* get the string box */
+  sciGet2dViewBoundingBox( pText, corners[0], corners[1], corners[2], corners[3]) ;
 
-  corners[2][0] = XDPixel2Double( corn[2][0] ) ;
-  corners[2][1] = YDPixel2Double( corn[2][1] ) ;
+  /* Finally destroy it */
+  deallocateText(pText);
 
-  corners[3][0] = XDPixel2Double( corn[3][0] ) ;
-  corners[3][1] = YDPixel2Double( corn[3][1] ) ;
-
-  /* we don't need the matrix anymore, but the text is needed */
-  desallocateMatrix( strings ) ;
+  endFigureDataWriting(parentFigure);
 
 }
 /*-------------------------------------------------------------------------------*/
-void getStringsRect( StringMatrix  * strMat            ,
-                    int             textPos[2]        ,
-                    Vect2iMatrix  * stringPosition    ,
-                    int             boundingBox[4][2]  )
-{
-  /* the space size between two consecutive strings in a row */
-  int hSpace = getStringHorizontalSpace() ;
-  int vSpace = getStringVerticalSpace()   ;
-  int * rowHeight ; /* vectors containing height and width of column of the array*/
-  int * colWidth  ;
-
-  int i ;
-  int j ;
-  int nbRow = getMatNbRow( strMat ) ;
-  int nbCol = getMatNbCol( strMat ) ;
-  int rect[4] ;
-  int curHeight = 0 ; /* height in pixels of the current row */
-  int curWidth  = 0 ; /* lenght of the longest row in pixels */
-
-
-  /* initialize arrays */
-  rowHeight = MALLOC( (nbRow + 1) * sizeof( int ) ) ;
-  colWidth  = MALLOC( (nbCol + 1) * sizeof( int ) ) ;
-
-  /* the tricky part */
-
-  /* we first compute the width of each row  of the array */
-  /* The width is given by the tallest string of each row */
-
-  rowHeight[nbRow] = textPos[1] ;
-
-  /* begin with the lower left string which is at position textPos */
-  for ( i = nbRow - 1 ; i >= 0 ; i-- )
-  {
-    for ( j = 0 ; j < nbCol ; j++ )
-    {
-      getStringBbox( getStrMatElement( strMat, i, j ), textPos, rect ) ;
-      curHeight = Max( curHeight, rect[3] ) ;
-    }
-    /* the height of the current column is the max of the height its tallest string + vSpace */
-    rowHeight[i] = rowHeight[i+1] - curHeight - vSpace ;
-    curHeight = 0 ;
-  }
-
-  /* same for columns */
-  colWidth[0] = textPos[0] ;
-
-  for ( j = 0 ; j < nbCol ; j++ )
-  {
-    for ( i = nbRow - 1 ; i >= 0 ; i-- )
-    {
-      getStringBbox( getStrMatElement( strMat, i, j ), textPos, rect ) ;
-      curWidth = Max( curWidth, rect[2] ) ;
-    }
-    colWidth[j+1] = colWidth[j] + curWidth + hSpace ;
-    curWidth = 0 ;
-  }
-
-  /* now fill the matrix */
-  if ( stringPosition != NULL )
-  {
-    for ( i = 0 ; i <= nbRow ; i++ )
-    {
-      for ( j = 0 ; j <= nbCol ; j++ )
-      {
-        int intersect[2] = { colWidth[j], rowHeight[i] } ;
-        copyVect2iMatElement( stringPosition, i, j, intersect ) ;
-      }
-    }
-  }
-
-  /* get the bounding box */
-  boundingBox[0][0] = textPos[0] ;
-  boundingBox[0][1] = textPos[1] ;
-
-  boundingBox[1][0] = boundingBox[0][0] ;
-  boundingBox[1][1] = rowHeight[0] ;
-
-  boundingBox[2][0] = colWidth[nbCol] ;
-  boundingBox[2][1] = boundingBox[1][1] ;
-
-  boundingBox[3][0] = boundingBox[2][0] ;
-  boundingBox[3][1] = boundingBox[0][1] ;
-
-  FREE( rowHeight ) ;
-  FREE( colWidth  ) ;
-
-}
-/*-------------------------------------------------------------------------------*/
-void getStringsRectSized( StringMatrix  * strMat           ,
-                          int             textPos[2]       ,
-                          Vect2iMatrix  * stringPosition   ,
-                          int             boundingBox[4][2],
-                          int             userSize[2]      ,
-                          int           * newFontSize       )
-{
-  //integer curFont[2] = {0,0}  ;
-  //integer fontSizeOne = 1 ;
-  double homothFactors[2] ;
-
-  /* first get the automatic array with font 1 */
-
-  /* get the current font */
-  /* we need to change the defaut font before using xstringl */
-  /* C2F(dr)("xget","font",&verbose,curFont,&v,PI0,PI0,PI0,PD0,PD0,PD0,PD0,5L,5L); */
-
-  /* set the new font */
-  /* C2F(dr)("xset","font",&(curFont[0]),&fontSizeOne,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); */
-
-  /* get the displaying array */
-  getStringsRect( strMat, textPos, stringPosition, boundingBox ) ;
-
-  /* get the homothety factors */
-  /* horizontal : userWidth / bbWidth */
-  homothFactors[0] = ((double) userSize[0]) / ( boundingBox[2][0] - boundingBox[0][0] ) ;
-  homothFactors[1] = ((double) userSize[1]) / ( boundingBox[0][1] - boundingBox[2][1] ) ;
-
-  /* apply homothety on the matrix and boundingbox */
-  iHomothety2D( boundingBox[1], boundingBox[0], homothFactors, boundingBox[1] ) ;
-  iHomothety2D( boundingBox[2], boundingBox[0], homothFactors, boundingBox[2] ) ;
-  iHomothety2D( boundingBox[3], boundingBox[0], homothFactors, boundingBox[3] ) ;
-
-  /* we must tkae the min from both direction to avoid strings to go over the lines. */
-  if ( stringPosition != NULL )
-  {
-    homothVect2iMatrix( stringPosition, boundingBox[0], homothFactors ) ;
-    *newFontSize = computeSuitableFont( strMat, stringPosition ) ;
-  }
-
-  /* return to the previous font */
-  /* C2F(dr)("xset","font",&curFont[0],&curFont[1],PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); */
-}
-/*-------------------------------------------------------------------------------*/
-void getStringsPositions( StringMatrix  * strMat        ,
-                          int           * fontId        ,
-                          int           * fontSize      ,
-                          int             textPos[2]    ,
-                          BOOL            autoSize      ,
-                          int             textSize[2]   ,
-                          BOOL            centerPos     ,
-                          double          angle         ,
-                          Vect2iMatrix  * stringPosition,
-                          int             boundingBox[4][2] )
-{
-  //integer curFont[2] = {0, 0}  ;
-  int trans[2] ;
-
-  if ( autoSize )
-  {
-    /* get the current font */
-    /* we need to change the defaut font before using xstringl */
-    /* C2F(dr)("xget","font",&verbose,curFont,&v,PI0,PI0,PI0,PD0,PD0,PD0,PD0,5L,5L); */
-
-    /* set the new font */
-    /* C2F(dr)("xset","font",fontId,fontSize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); */
-
-    /* compute the stringPosition and bounding box in pixels without rotation */
-    getStringsRect( strMat, textPos, stringPosition, boundingBox ) ;
-
-    /* return to the previous font */
-    /* C2F(dr)("xset","font",&curFont[0],&curFont[1],PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); */
-  }
-  else
-  {
-    getStringsRectSized( strMat, textPos, stringPosition, boundingBox, textSize, fontSize ) ;
-  }
-
-  /* for now we have computes the matrix as if its position was corresponding to its */
-  /* lower-left vertice. */
-  /* we must now translate the points depending on where is really the center relatively */
-  /* to the array. */
-  getStringPositionTranslation( centerPos, textSize, boundingBox, trans ) ;
-  if ( stringPosition != NULL )
-  {
-    translateVect2iMatrix( stringPosition, trans ) ;
-  }
-  translateBoundingBox( boundingBox, trans ) ;
-
-  /* then turn everything, we need to turn them in pixels because of logarithmic scale */
-  if ( Abs( angle ) > EPSILON )
-  {
-    if ( stringPosition != NULL )
-    {
-      rotateVect2iMatrix( stringPosition, textPos, angle ) ;
-    }
-    rotateBoundingBox( boundingBox, textPos, angle ) ;
-  }
-
-}
-/*-------------------------------------------------------------------------------*/
-void getTextBoundingBox( sciPointObj * pText        ,
-                        int           cornPix[4][2],
-                        double        corners[4][2] )
-{
-  int           fontId   = sciGetFontStyle( pText ) ;
-  int           fontSize = (int) sciGetFontSize( pText ) ;
-  double        angle    = sciGetFontOrientation(pText); 
-  int           position[2] ;
-  double        textPos[3]  ;
-  double        userSize[2] ;
-  int           textSize[2] ;
-  sciText     * ppText   = pTEXT_FEATURE( pText ) ;
-  sciPointObj * parentSW = sciGetParentSubwin( pText ) ;
-
-  /* transform the position in pixels */
-  /* we don't take the axes reverse into account. This has obviously no meaning for text.*/
-  textPos[0] = ppText->x ;
-  textPos[1] = ppText->y ;
-  textPos[2] = ppText->z ;
-
-  if ( sciGetIs3d( pText ) )
-  {
-    /* normal case */
-    getPixelCoordinates( parentSW, textPos, position ) ;
-  }
-  else
-  {
-    /* special for label, use of the 2d scale */
-    position[0] = XDouble2Pixel( textPos[0] ) ;
-    position[1] = YDouble2Pixel( textPos[1] ) ;
-  }
 
-  sciGetUserSize( pText, &(userSize[0]), &(userSize[1]) ) ;
-
-  /* We take the size in 2d. */
-  textSize[0] = PixelWidth2d(  parentSW, ppText->x, userSize[0] ) ;
-  textSize[1] = PixelHeight2d( parentSW, ppText->y, userSize[1] ) ;
-
-  if ( cornPix == NULL )
-  {
-    int corn[4][2] ;
-    /* NULL because we don't need the position of each string */
-    getStringsPositions( sciGetText( pText )     ,
-      &fontId                 ,
-      &fontSize               ,
-      position                ,
-      sciGetAutoSize( pText ) ,
-      textSize                ,
-      sciGetCenterPos( pText ),
-      angle                   ,
-      NULL                    ,
-      corn                     ) ;
-    if ( corners != NULL )
-    {
-      /* take everything back to user coordinates */
-      /* to retrieve exactly the first corner as in stringl we take the input */
-      corners[0][0] = XDPixel2Double( corn[0][0] ) ;
-      corners[0][1] = YDPixel2Double( corn[0][1] ) ;
-
-      corners[1][0] = XDPixel2Double( corn[1][0] ) ;
-      corners[1][1] = YDPixel2Double( corn[1][1] ) ;
-
-      corners[2][0] = XDPixel2Double( corn[2][0] ) ;
-      corners[2][1] = YDPixel2Double( corn[2][1] ) ;
-
-      corners[3][0] = XDPixel2Double( corn[3][0] ) ;
-      corners[3][1] = YDPixel2Double( corn[3][1] ) ;
-    }
-  }
-  else
-  {
-    /* NULL because we don't need the position of each string */
-    getStringsPositions( sciGetText( pText )     ,
-      &fontId                 ,
-      &fontSize               ,
-      position                ,
-      sciGetAutoSize( pText ) ,
-      textSize                ,
-      sciGetCenterPos( pText ),
-      angle                   ,
-      NULL                    ,
-      cornPix                  ) ;
-
-    if ( corners != NULL )
-    {
-      /* take everything back to user coordinates */
-      /* to retrieve exactly the first corner as in stringl we take the input */
-      corners[0][0] = XDPixel2Double( cornPix[0][0] ) ;
-      corners[0][1] = YDPixel2Double( cornPix[0][1] ) ;
-
-      corners[1][0] = XDPixel2Double( cornPix[1][0] ) ;
-      corners[1][1] = YDPixel2Double( cornPix[1][1] ) ;
-
-      corners[2][0] = XDPixel2Double( cornPix[2][0] ) ;
-      corners[2][1] = YDPixel2Double( cornPix[2][1] ) ;
-
-      corners[3][0] = XDPixel2Double( cornPix[3][0] ) ;
-      corners[3][1] = YDPixel2Double( cornPix[3][1] ) ;
-    }
-  }
-
-}
-/*-------------------------------------------------------------------------------*/
-void getTextAabb( sciPointObj * pText        ,
-                 int           rectPix[4]   ,
-                 int           cornPix[4][2] )
-{
-  if ( cornPix == NULL )
-  {
-
-    getTextBoundingBox( pText, cornPix, NULL ) ;
-
-    if ( rectPix != NULL )
-    {
-      rectPix[0] = Min( cornPix[0][0], Min( cornPix[1][0], Min( cornPix[2][0], cornPix[3][0] ) ) ) ;
-      /* in pixel the bottom left point has the maximal y value */
-      rectPix[1] = Max( cornPix[0][1], Max( cornPix[1][1], Max( cornPix[2][1], cornPix[3][1] ) ) ) ;
-      rectPix[2] = Max( abs( cornPix[2][0] - cornPix[0][0] ), abs( cornPix[3][0] - cornPix[1][0] ) ) ;
-      rectPix[3] = Max( abs( cornPix[2][1] - cornPix[0][1] ), abs( cornPix[3][1] - cornPix[1][1] ) ) ;
-    }
-  }
-  else
-  {
-    getTextBoundingBox( pText, cornPix, NULL ) ;
-
-    if ( rectPix != NULL )
-    {
-      rectPix[0] = Min( cornPix[0][0], Min( cornPix[1][0], Min( cornPix[2][0], cornPix[3][0] ) ) ) ;
-      /* in pixel the bottom left point has the maximal y value */
-      rectPix[1] = Max( cornPix[0][1], Max( cornPix[1][1], Max( cornPix[2][1], cornPix[3][1] ) ) ) ;
-      rectPix[2] = Max( abs( cornPix[2][0] - cornPix[0][0] ), abs( cornPix[3][0] - cornPix[1][0] ) ) ;
-      rectPix[3] = Max( abs( cornPix[2][1] - cornPix[0][1] ), abs( cornPix[3][1] - cornPix[1][1] ) ) ;
-    }
-  }
-
-}
-/*-------------------------------------------------------------------------------*/
-
-void rotateBoundingBox( int boundingBox[4][2], int center[2], double angle )
-{
-  if ( Abs( angle ) > EPSILON )
-  {
-    double cosAngle = cos( angle ) ;
-    double sinAngle = sin( angle ) ;
-    iRotate2Dim( boundingBox[0], center, cosAngle, sinAngle, boundingBox[0] ) ;
-    iRotate2Dim( boundingBox[1], center, cosAngle, sinAngle, boundingBox[1] ) ;
-    iRotate2Dim( boundingBox[2], center, cosAngle, sinAngle, boundingBox[2] ) ;
-    iRotate2Dim( boundingBox[3], center, cosAngle, sinAngle, boundingBox[3] ) ;
-  }
-}
-/*-------------------------------------------------------------------------------*/
-void translateBoundingBox( int boundingBox[4][2], int trans[2] )
-{
-  iTranslate2D( boundingBox[0], trans, boundingBox[0] ) ;
-  iTranslate2D( boundingBox[1], trans, boundingBox[1] ) ;
-  iTranslate2D( boundingBox[2], trans, boundingBox[2] ) ;
-  iTranslate2D( boundingBox[3], trans, boundingBox[3] ) ;
-
-}
-/*-------------------------------------------------------------------------------*/
-int getStringVerticalSpace( void )
-{
-  int rect[4] ;
-  int pos[2] = {0,0} ;
-  getStringBbox( " ", pos, rect ) ;
-  return rect[3] ;
-}
-/*-------------------------------------------------------------------------------*/
-int getStringHorizontalSpace( void )
-{
-  int rect[4] ;
-  int pos[2] = {0,0} ;
-  /* return the width of a space */
-  getStringBbox( " ", pos, rect ) ;
-  return rect[2] ;
-}
-/*-------------------------------------------------------------------------------*/
-BOOL isFittingInCell( char * string, int cellWidth, int cellHeight )
-{
-  int rect[4] ;
-  int pos[2] = {0,0} ;
-
-  /* get the size of the string */
-  getStringBbox( string, pos, rect ) ;
-
-  if ( rect[2] < cellWidth && rect[3] < cellHeight )
-  {
-    return TRUE ;
-  }
-  return FALSE ;
-}
-/*-------------------------------------------------------------------------------*/
-void getStringPositionTranslation( BOOL centeredPos, int textSize[2], int bbox[4][2], int trans[2] )
-{
-  if ( centeredPos )
-  {
-    trans[0] = ( textSize[0] + bbox[0][0] - bbox[2][0] ) / 2 ;
-    trans[1] = ( -textSize[1] + bbox[0][1] - bbox[2][1] ) / 2 ;
-  }
-  else
-  {
-    trans[0] = 0 ;
-    trans[1] = 0 ;
-  }
-}
-/*-------------------------------------------------------------------------------*/
-int computeSuitableFont( StringMatrix  * strMat, Vect2iMatrix  * stringPosition )
-{
-  int nbRow = getMatNbRow( strMat ) ;
-  int nbCol = getMatNbCol( strMat ) ;
-  int largestFont = 0 ;
-  int smallestFont = 1 ;
-  int i ;
-  int j ; 
-  //integer curFont[2] = {0,0} ;
-
-  /* C2F(dr)("xget","font",&verbose,curFont,&v,PI0,PI0,PI0,PD0,PD0,PD0,PD0,5L,5L) ; */
-
-  /* the largest font is the minimum of all largest font which can be used for each cells */
-  /* initializeit with the largest font the driver can display */
-  /* C2F(dr)( "xfontmxs","", &smallestFont, &largestFont, PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L ) ; */
-
-  /* set the largest font */
-  /* C2F(dr)("xset","font",&(curFont[0]),&largestFont,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); */
-
-  for ( i = 0 ; i < nbRow ; i++ )
-  {
-    for ( j = 0 ; j < nbCol ; j++ )
-    {
-      int  * blCorner = getVect2iMatElement( stringPosition, i    , j     ) ;
-      int  * urCorner = getVect2iMatElement( stringPosition, i + 1, j + 1 ) ;
-      char * string   = getStrMatElement( strMat, i, j ) ;
-      int width  = urCorner[0] - blCorner[0] ;
-      int height = urCorner[1] - blCorner[1] ;
-      while ( !isFittingInCell( string, width, height ) )
-      {
-        largestFont-- ;
-        if ( largestFont == smallestFont )
-        {
-          /* we reach the minimum size, no need to continue */
-          /* C2F(dr)("xset","font",&curFont[0],&curFont[1],PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ; */
-          return smallestFont ;
-        }
-        /* set the new font */
-        /* C2F(dr)("xset","font",&(curFont[0]),&largestFont,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); */
-      }
-    }
-  }
-
-  /* return to the previous font */
-  /* C2F(dr)("xset","font",&curFont[0],&curFont[1],PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  */
-  return largestFont ;
-
-}
-/*-------------------------------------------------------------------------------*/
index 1deb97a..331bad6 100644 (file)
 #define _STRING_BOX_H_
 
 #include "machine.h"
-#include "StringMatrix.h"
-#include "Vect2Matrix.h"
 #include "ObjectStructure.h"
 
 /*----------------------------------------------------------------------------------*/
 /**
- * return the bounding rectangle of a string.
- * @param string bounded string
- * @param center Position where the string ought to be displayed.
- * @param rect   vector containing the upper left point and the width and height of the
- *               bounding box : [x,y,w,h].
- */
-void getStringBbox( char * string, int center[2], int rect[4] ) ;
-
-/**
- * This is a wrapping of the function C2F(dr)("xstringl",... It should be prefered to xstringl
- * because it is working even in drawlater mode. The parent Subwindow of the text must be the
- * current axes.
- */
-void callXstringL( char * string, int posX, int posY, int boundingRect[4] ) ;
-/*----------------------------------------------------------------------------------*/
-/**
- * compute the four corners of a text
- * works only in 2D
- */
-void getStringBox( char   ** text         ,
-                   double    textPos[2]   ,
-                   int       textDim[2]   ,
-                   BOOL      autoSize     ,
-                   double    userSize[2]  ,
-                   double    angle        ,
-                   int       fontId       ,
-                   int       fontSize     ,
-                   double    corners[4][2] ) ;
-
-/**
- * Compute an array of cells in which a set of strings can be displayed. The size of the
- * array is automatically computed using the current font.
- * This routine does not compute any rotation.
- * @param strMat Set of strings.
- * @param textPos Position of the upper left point of the string array.
- * @param stringPosition matrix containing the corners of the cells. Element (i,j) of this
- *                       matrix correspond to the upper-left point of the string (i,j).
- *                       It size must be equal to the size of strMat plus one in each
- *                       dimension. If NULL, not computed.
- * @param boundingBox position of the four corners of the bounding box surrounding the
- *                    array of cells.
- */
-void getStringsRect( StringMatrix  * strMat            ,
-                     int             textPos[2]        ,
-                     Vect2iMatrix  * stringPosition    ,
-                     int             boundingBox[4][2]  ) ;
-
-/**
- * Compute an array of cells in which a set of strings can be displayed when the size
- * (width and height) of the array are specified by user. This routine does not compute
- * any rotation.
- * @param strMat Set of strings.
- * @param textPos Position of the upper left point of the string array.
- * @param stringPosition matrix containing the corners of the cells. Element (i,j) of this
- *                       matrix correspond to the upper-left point of the string (i,j).
- *                       It size must be equal to the size of strMat plus one in each
- *                       dimension. If NULL, not computed.
- * @param boundingBox position of the four corners of the bounding box surrounding the
- *                    array of cells.
- * @param userSize width and height of the array of cells.
- * @param newFontSize font size which would fit the array best using the strings in strMat.
- */
-void getStringsRectSized( StringMatrix  * strMat           ,
-                          int             textPos[2]       ,
-                          Vect2iMatrix  * stringPosition   ,
-                          int             boundingBox[4][2],
-                          int             userSize[2]      ,
-                          int           * newFontSize       ) ;
-
-/**
- * Compute an array of cells in which each string will fit. The bounding box of the
- * finally displayed string is also computed. The generated array of cells can the be used
- * for the display with the drawStringsInPosition routine.
- * @param strMat    Set of string.
- * @param fontId    specify the fontId of the strings.
- * @param fontSize  if autoSize is on then specify the size of the strings. Otherwise,
- *                  this returns the size which should be used to display the strings in
- *                  the cell array.
- * @param textPos   Position of the upper left point of the string array and center
- *                  of rotation.
- * @param autoSize  If TRUE, the size of the text is displayed usign the specified font.
- *                  If flase the width and height of the text are specified by the user.
- * @param textSize  if autoSize is false, specify the size of the rectangle in which the
- *                  text must fit.
- * @param angle     Angle for the rotation of the strings.
- * @param centerPos Specify where is the rotation center of the string. If TRUE in the middle
- *                  of the array, otherwise in the bottom-left.
- * @param stringPosition matrix containing the corners of the cells. Element (i,j) of this
- *                       matrix correspond to the upper-left point of the string (i,j).
- *                       It size must be equal to the size of strMat plus one in each
- *                       dimension. If NULL, not computed.
- * @param boundingBox position of the four corners of the bounding box surrounding the
- *                    array of cells. The points are given clockwise.
- */
-void getStringsPositions( StringMatrix  * strMat        ,
-                          int           * fontId        ,
-                          int           * fontSize      ,
-                          int             textPos[2]    ,
-                          BOOL            autoSize      ,
-                          int             textSize[2]   ,
-                          BOOL            centerPos     ,
-                          double          angle         ,
-                          Vect2iMatrix  * stringPosition,
-                          int             boundingBox[4][2] ) ;
-/*----------------------------------------------------------------------------------*/
-/**
- * Compute the bounding box of a text object.
- * @param pText   Pointer on the object to surround.
- * @param cornPix Bounding box in pixel coordinates. If NULL, not computed.
- * @param corners Bounding box in user coordinates. If NULL, not computed.
- */
-void getTextBoundingBox( sciPointObj * pText        ,
-                         int           cornPix[4][2],
-                         double        corners[4][2] ) ;
-
-/**
- * Compute the axis aligned bounding box of a text object.
- * @param pText   Pointer on the object to surround.
- * @param rectPix Bounding box (x,y,w,h) in pixel coordinates. If NULL, not computed.
- *                (x,y) is the coordinates of the bottom left vertice.
- * @param conrPix The four corners of the real bounding box. If NULL, not computed.
- */
-void getTextAabb( sciPointObj * pText        ,
-                  int           rectPix[4]   ,
-                  int           cornPix[4][2] ) ;
-/*----------------------------------------------------------------------------------*/
-/**
- * Rotate four points around the first one.
- * @param boundingBox the four 2D points.
- * @param angle rotation angle in radian.
- */
-void rotateBoundingBox( int boundingBox[4][2], int center[2], double angle ) ;
-
-/**
- * Translae four points around the first one.
- * @param boundingBox the four 2D points.
- * @param angle rotation angle in radian.
- */
-void translateBoundingBox( int boundingBox[4][2], int trans[2] ) ;
-/*----------------------------------------------------------------------------------*/
- /**
- * returns the minimal space between too consecutive strings horizontally.
- */
-int getStringHorizontalSpace( void ) ;
-
-/**
- * returns the minimal space between too consecutive strings vertically.
- */
-int getStringVerticalSpace( void ) ;
-
-/*----------------------------------------------------------------------------------*/
-/**
- * Check if a string can be displayed in a cell with a certain width and height.
- */
-BOOL isFittingInCell( char * string, int cellWidth, int cellHeight ) ;
-
-/**
- * Get the translation which should be applied to the text depending on the meaning of
- * its position.
- * @param centeredPos specify the meaning of the position of the text. If FALSE, the
- *                    position corresponds to the position of the lower left point. So
- *                    nothing needs to be changed. If TRUE, the center is the position
- *                    corresponds to the center of the text bounding box and then a
- *                    translation must be performed.
- * @param textSize width and height wanted for the text.
- * @param bbox The four corners of the computed boundign box of the text. The first corner
- *             should correspond to the position of the text.
- * @param trans Translation to apply to the text.
- */
-void getStringPositionTranslation( BOOL centeredPos, int textSize[2], int bbox[4][2], int trans[2] ) ;
-
-/**
-* get the largest font which can be used to fit the strings in the array.
-* @param strMat Set of strings which try to fit in stringPosition.
-* @param position of the cells in which the strings need to fit.
-*/
-int computeSuitableFont( StringMatrix  * strMat, Vect2iMatrix  * stringPosition ) ;
+ * Compute the position of the 4 corners of a text in 2d view coordinates
+ * @param text matrix of text of size nbRow x nbCol.
+ * @param xPos X coordinate of the string
+ * @param yPos Y coordinate of the string
+ * @param angle font angle in degree, clockwise
+ * @param corners result containing the postions of the 4 corners of the text box
+ */
+void getTextBoundingBox(char ** text, int nbRow, int nbCol,
+                        double xPos, double yPos,
+                        double angle, int fontId, double fontSize,
+                        double corners[4][2]);
 /*----------------------------------------------------------------------------------*/
 #endif /* _STRING_BOX_H_ */
index 32e6f9f..64f6618 100644 (file)
@@ -19,18 +19,23 @@ function ge_draw_graph(GraphList)
   gindex=ge_axes_handle.user_data
   
   hnodes=[];
+  tic();
   for k=1:size(GraphList.nodes.graphics.x,'*'), 
     hnodes(k)=ge_draw_node(k); 
-    if modulo(k,40)==0 then drawnow();show_pixmap();drawlater(),end
+    //if modulo(k,40)==0 then drawnow();show_pixmap();drawlater(),end
   end
+  disp(toc())
+  tic();
   hedges=[];
   for k=1:size(GraphList.edges.tail,'*'), 
     hedges(k)=ge_draw_edge(k),
-    if modulo(k,40)==0 then drawnow();show_pixmap();drawlater(),end
+    //if modulo(k,40)==0 then drawnow();show_pixmap();drawlater(),end
   end
+  disp(toc());
   
   gindex.node=hnodes;gindex.edge=hedges;
   ge_axes_handle.user_data=gindex;
   
-  drawnow();show_pixmap()
+  drawnow();
+show_pixmap()
 endfunction
index d2e3f93..0d35c09 100644 (file)
@@ -165,3 +165,4 @@ isFigureModel
 sciGetSubwinIndex
 sciGetNbTypedObjects
 sciGetAutoSubticks
+sciisTextEmpty
index 424e1be..0f938f9 100644 (file)
@@ -66,9 +66,13 @@ void sciGetJava2dViewCoordinates(sciPointObj * pSubwin, const double userCoords3
 void sciGetJava2dViewCoordFromPixel(sciPointObj * pSubwin, const int pixCoords[2], double userCoords2D[2]);
 
 /**
+ * Get the bounding box of a text object.
+ */
+void sciGetJavaBoundingBox(sciPointObj * pText, double corner1[3], double corner2[3],
+                           double corner3[3], double corner4[3]);
+
+/**
  * Get the bounding box in pixels of a text object.
- * Warning: the pixel size is in OpenGL frame, not in Scilab
- * (Y axis inverted)
  */
 void sciGetJavaPixelBoundingBox(sciPointObj * pText, int corner1[2], int corner2[2],
                                 int corner3[2], int corner4[2]);
index 9d82879..8619641 100644 (file)
@@ -40,5 +40,6 @@ sciGetJava2dViewPixelCoordinates
 sciGetJava2dViewCoordinates
 javaRubberBox
 sciGetJavaIsAbleToCreateWindow
+sciGetJavaBoundingBox
 ; --------------------------------------- 
 
index 6373921..f37453f 100644 (file)
@@ -64,6 +64,12 @@ void sciGetJava2dViewCoordFromPixel(sciPointObj * pSubwin, const int pixCoords[2
   getSubwinDrawer(pSubwin)->getCamera()->get2dViewCoordinates(pixCoords, userCoords2D);
 }
 /*---------------------------------------------------------------------------------*/
+void sciGetJavaBoundingBox(sciPointObj * pText, double corner1[3], double corner2[3],
+                           double corner3[3], double corner4[3])
+{
+  getTextDrawer(pText)->getBoundingRectangle(corner1, corner2, corner3, corner4);
+}
+/*---------------------------------------------------------------------------------*/
 void sciGetJavaPixelBoundingBox(sciPointObj * pText, int corner1[2], int corner2[2],
                                 int corner3[2], int corner4[2])
 {
index f837b2c..3ab0ad7 100644 (file)
@@ -408,6 +408,11 @@ void Camera::getViewingArea(int * xPos, int * yPos, int * width, int * height)
   getCameraImp()->getViewingArea(xPos, yPos, width, height);
 }
 /*--------------------------------------------------------------------------*/
+void Camera::getViewport(int viewport[4])
+{
+  getCameraImp()->getViewport(viewport);
+}
+/*--------------------------------------------------------------------------*/
 void Camera::computeZoomAreaLines(const double areaPixCorners[4][2], double areaLines[4][2][3])
 {
   for (int i = 0; i < 4; i++)
index c2eb7e2..4d98a9c 100644 (file)
@@ -117,6 +117,11 @@ public:
    */
   void getViewingArea(int * xPos, int * yPos, int * width, int * height);
 
+  /**
+   * Get viewport of the canvas
+   */
+  void getViewport(int viewport[4]);
+
 protected:
 
   /**
index 33b281f..58ab9a8 100644 (file)
@@ -127,6 +127,11 @@ public:
   virtual void getViewingArea(int * xPos, int * yPos, int * width, int * height) = 0;
 
   /**
+   * Get viewport of the canvas
+   */
+  virtual void getViewport(int viewport[4]) = 0;
+
+  /**
    * Add an axes reverse strategy.
    */
   void setAxesReverse(bool axisReverseX, bool axisReverseY, bool axisReverseZ);
index 3c495ec..f5f3398 100644 (file)
@@ -229,4 +229,12 @@ void CameraJoGL::getViewingArea(int * xPos, int * yPos, int * width, int * heigh
   *yPos = (int) (m_aViewPort[1]  + m_aViewPort[3] * (1.0 - m_aViewingTranslation[1])) - *height;
 }
 /*--------------------------------------------------------------------------*/
+void CameraJoGL::getViewport(int viewport[4])
+{
+  for (int i = 0; i < 4; i++)
+  {
+    viewport[i] = m_aViewPort[i];
+  }
+}
+/*--------------------------------------------------------------------------*/
 }
index 14ccbb3..a2012ac 100644 (file)
@@ -104,6 +104,11 @@ public:
    */
   virtual void getViewingArea(int * xPos, int * yPos, int * width, int * height);
 
+  /**
+   * Get viewport of the canvas
+   */
+  virtual void getViewport(int viewport[4]);
+
 protected:
 
   /*----------------------------------------------------------------*/
index c3c5309..4f77c8b 100644 (file)
@@ -68,6 +68,11 @@ void CenteredTextDrawerJavaMapper::setTextParameters(int textAlignment, int colo
   m_pJavaObject->setTextParameters(textAlignment, color, fontStyle, fontSize, rotationAngle, useFractionalMetrics);
 }
 /*---------------------------------------------------------------------------------*/
+void CenteredTextDrawerJavaMapper::updateParentFigure(int parentFigureIndex)
+{
+  m_pJavaObject->updateParentFigure(parentFigureIndex);
+}
+/*---------------------------------------------------------------------------------*/
 void CenteredTextDrawerJavaMapper::setTextContent(char ** text, int nbRow, int nbCol)
 {
   m_pJavaObject->setTextContent(text, nbRow * nbCol, nbRow, nbCol);
@@ -83,14 +88,11 @@ double * CenteredTextDrawerJavaMapper::drawTextContent(void)
   return m_pJavaObject->drawTextContent();
 }
 /*---------------------------------------------------------------------------------*/
-double * CenteredTextDrawerJavaMapper::getBoundingRectangle(void)
-{
-  return m_pJavaObject->getBoundingRectangle();
-}
-/*---------------------------------------------------------------------------------*/
-long * CenteredTextDrawerJavaMapper::getScreenBoundingBox(void)
+double * CenteredTextDrawerJavaMapper::getScreenBoundingBox(double centerPixX,
+                                                            double centerPixY,
+                                                            double centerPixZ)
 {
-  return m_pJavaObject->getScreenBoundingBox();
+  return m_pJavaObject->getScreenBoundingBox(centerPixX, centerPixY, centerPixZ);
 }
 /*---------------------------------------------------------------------------------*/
 void CenteredTextDrawerJavaMapper::setFilledBoxSize(double boxWidth, double boxHeight)
index 568cd5a..bd82f66 100644 (file)
@@ -47,12 +47,14 @@ public:
   virtual void setCenterPosition(double centerX, double centerY, double centerZ);
   virtual double * drawTextContent(void);
 
-  virtual double * getBoundingRectangle(void);
-
-  virtual long * getScreenBoundingBox(void);
+  virtual double * getScreenBoundingBox(double centerPixX,
+                                        double centerPixY,
+                                        double centerPixZ);
 
   virtual void setTextParameters(int textAlignment, int color, int fontStyle,
                                  double fontSize, double rotationAngle, bool useFractionalMetrics);
+
+  virtual void updateParentFigure(int parentFigureIndex);
   /*----------------------------------------------------------------------*/
   // specific for centered text drawer
   virtual void setFilledBoxSize(double boxWidth, double boxHeight);
index c104140..d9fb2a0 100644 (file)
@@ -51,10 +51,6 @@ void CenteredTextDrawerJoGL::setDrawerParameters(void)
   double boxHeight;
   getUserSizePix(boxWidth, boxHeight);
   getCenteredTextDrawerJavaMapper()->setFilledBoxSize(boxWidth, boxHeight);
-
-  double textPos[3];
-  getTextDisplayPos(textPos);
-  getCenteredTextDrawerJavaMapper()->setCenterPosition(textPos[0], textPos[1], textPos[2]);
 }
 /*---------------------------------------------------------------------------------*/
 void CenteredTextDrawerJoGL::redrawTextContent(double corner1[3], double corner2[3], double corner3[3], double corner4[3])
index 718d8f8..bc75370 100644 (file)
@@ -141,18 +141,10 @@ void ConcreteDrawableText::updateTextBox(void)
     return;
   }
   // just update, no need to draw
-  requestBoundsUpdate();
-  BOOL visibility = sciGetVisibility(m_pDrawed);
-  sciSetVisibility(m_pDrawed, FALSE);
-  sciDrawSingleObj(m_pDrawed);
-  sciSetVisibility(m_pDrawed, visibility);
-}
-/*---------------------------------------------------------------------------------*/
-void ConcreteDrawableText::updateTextBoxFromContext(void)
-{
   sciText * ppText = pTEXT_FEATURE(m_pDrawed);
   getBoundingRectangle(ppText->corners[0], ppText->corners[1],
                        ppText->corners[2], ppText->corners[3]);
+  
 }
 /*---------------------------------------------------------------------------------*/
 }
index 5f7869e..b208c54 100644 (file)
@@ -69,11 +69,6 @@ public:
    */
   virtual void updateTextBox(void);
 
-  /**
-   * Update the text box a text object from OpenGL context.
-   */
-  virtual void updateTextBoxFromContext(void);
-
 protected:
 
   /*---------------------------------------------------------------------------------*/
index 34dcd5e..4686f35 100644 (file)
@@ -28,7 +28,6 @@ namespace sciGraphics
 DrawableText::DrawableText( sciPointObj * pObj ) : DrawableClippedObject( pObj )
 {
   m_dDefaultFontSize = DEFAULT_FONT_SIZE;
-   m_bBoundsUpdateRequested = false;
 }
 /*---------------------------------------------------------------------------------*/
 DrawableText::~DrawableText( void )
@@ -36,25 +35,11 @@ DrawableText::~DrawableText( void )
 
 }
 /*---------------------------------------------------------------------------------*/
-void DrawableText::updateTextBoxIfRequested(void)
-{
-  if(needBoundsUpdate()){
-    updateTextBoxFromContext();
-    m_bBoundsUpdateRequested = false;
-  }
-}
-/*---------------------------------------------------------------------------------*/
-void DrawableText::requestBoundsUpdate(void)
-{
-  m_bBoundsUpdateRequested = true;
-}
-/*---------------------------------------------------------------------------------*/
 DrawableObject::EDisplayStatus DrawableText::draw( void )
 { 
   // update might be needed
   if (!checkVisibility() || isTextEmpty() )
   {
-    updateTextBoxIfRequested();
     return UNCHANGED;
   }
 
@@ -93,7 +78,6 @@ DrawableObject::EDisplayStatus DrawableText::redraw(void)
   // update might be needed
   if (!checkVisibility() || isTextEmpty() )
   {
-    updateTextBoxIfRequested();
     return UNCHANGED;
   }
   initializeDrawing();
@@ -108,11 +92,6 @@ DrawableObject::EDisplayStatus DrawableText::redraw(void)
   return SUCCESS;
 }
 /*---------------------------------------------------------------------------------*/
-bool DrawableText::needBoundsUpdate(void)
-{
-  return m_bBoundsUpdateRequested;
-}
-/*---------------------------------------------------------------------------------*/
 #undef DEFAULT_FONT_SIZE
 
 }
index 50cdbb1..024825b 100644 (file)
@@ -52,16 +52,6 @@ public:
   virtual void updateTextBox(void) = 0;
 
   /**
-   * Update the text box a text object from OpenGL context.
-   */
-  virtual void updateTextBoxFromContext(void) = 0;
-
-  /**
-   * Update the text bounding box if needed
-   */
-  void updateTextBoxIfRequested(void);
-
-  /**
    * Keep the default font size used by FilledTextDrawers
    */
   double getDefaultFontSize(void) {return m_dDefaultFontSize;}
@@ -121,22 +111,12 @@ protected:
    */
   virtual void showTextContent(void) = 0;
 
-  /**
-   * Check wether bounds of the text needs to be updated
-   */
-  bool needBoundsUpdate(void);
-
   /*----------------------------------------------*/
   /**
    * Previous font size used by filled text drawer in Scilab Scale.
    * Might be negative for small text.
    */
   double m_dDefaultFontSize;
-
-  /**
-   * If true, next redraw of the text must compute its bounding box.
-   */
-  bool m_bBoundsUpdateRequested;
   /*----------------------------------------------*/
 
 } ;
index b54b21d..1632c15 100644 (file)
@@ -69,6 +69,11 @@ void FilledTextDrawerJavaMapper::setTextParameters(int textAlignment, int color,
                                    rotationAngle, useFractionalMetrics);
 }
 /*---------------------------------------------------------------------------------*/
+void FilledTextDrawerJavaMapper::updateParentFigure(int parentFigureIndex)
+{
+  m_pJavaObject->updateParentFigure(parentFigureIndex);
+}
+/*---------------------------------------------------------------------------------*/
 void FilledTextDrawerJavaMapper::setTextContent(char ** text, int nbRow, int nbCol)
 {
   m_pJavaObject->setTextContent(text, nbRow * nbCol, nbRow, nbCol);
@@ -84,14 +89,11 @@ double * FilledTextDrawerJavaMapper::drawTextContent(void)
   return m_pJavaObject->drawTextContent();
 }
 /*---------------------------------------------------------------------------------*/
-double * FilledTextDrawerJavaMapper::getBoundingRectangle(void)
-{
-  return m_pJavaObject->getBoundingRectangle();
-}
-/*---------------------------------------------------------------------------------*/
-long * FilledTextDrawerJavaMapper::getScreenBoundingBox(void)
+double * FilledTextDrawerJavaMapper::getScreenBoundingBox(double centerPixX,
+                                                          double centerPixY,
+                                                          double centerPixZ)
 {
-  return m_pJavaObject->getScreenBoundingBox();
+  return m_pJavaObject->getScreenBoundingBox(centerPixX, centerPixY, centerPixZ);
 }
 /*---------------------------------------------------------------------------------*/
 double FilledTextDrawerJavaMapper::getFontSize(void)
index 3d1eb17..e420e8b 100644 (file)
@@ -47,12 +47,14 @@ public:
   virtual void setCenterPosition(double centerX, double centerY, double centerZ);
   virtual double * drawTextContent(void);
 
-  virtual double * getBoundingRectangle(void);
-
-  virtual long * getScreenBoundingBox(void);
+  virtual double * getScreenBoundingBox(double centerPixX,
+                                        double centerPixY,
+                                        double centerPixZ);
 
   virtual void setTextParameters(int textAlignment, int color, int fontStyle,
                                  double defaultFontSize, double rotationAngle, bool useFractionalMetrics);
+
+  virtual void updateParentFigure(int parentFigureIndex);
   /*----------------------------------------------------------------------*/
   // specific for filled text drawer
 
index 75f48c9..3333cd4 100644 (file)
@@ -57,10 +57,6 @@ void FilledTextDrawerJoGL::setDrawerParameters(void)
   double boxHeight;
   getUserSizePix(boxWidth, boxHeight);
   getFilledTextDrawerJavaMapper()->setFilledBoxSize(boxWidth, boxHeight);
-
-  double textPos[3];
-  getTextDisplayPos(textPos);
-  getFilledTextDrawerJavaMapper()->setCenterPosition(textPos[0], textPos[1], textPos[2]);
 }
 /*---------------------------------------------------------------------------------*/
 void FilledTextDrawerJoGL::drawTextContent(double corner1[3], double corner2[3], double corner3[3], double corner4[3])
index 96e955d..8002c0e 100644 (file)
@@ -69,6 +69,11 @@ void StandardTextDrawerJavaMapper::setTextParameters(int textAlignment, int colo
   m_pJavaObject->setTextParameters(textAlignment, color, fontStyle, fontSize, rotationAngle, useFractionalMetrics);
 }
 /*---------------------------------------------------------------------------------*/
+void StandardTextDrawerJavaMapper::updateParentFigure(int parentFigureIndex)
+{
+  m_pJavaObject->updateParentFigure(parentFigureIndex);
+}
+/*---------------------------------------------------------------------------------*/
 void StandardTextDrawerJavaMapper::setTextContent(char ** text, int nbRow, int nbCol)
 {
   m_pJavaObject->setTextContent(text, nbRow * nbCol, nbRow, nbCol);
@@ -84,14 +89,11 @@ double * StandardTextDrawerJavaMapper::drawTextContent(void)
   return m_pJavaObject->drawTextContent();
 }
 /*---------------------------------------------------------------------------------*/
-double * StandardTextDrawerJavaMapper::getBoundingRectangle(void)
-{
-  return m_pJavaObject->getBoundingRectangle();
-}
-/*---------------------------------------------------------------------------------*/
-long * StandardTextDrawerJavaMapper::getScreenBoundingBox(void)
+double * StandardTextDrawerJavaMapper::getScreenBoundingBox(double centerPixX,
+                                                            double centerPixY,
+                                                            double centerPixZ)
 {
-  return m_pJavaObject->getScreenBoundingBox();
+  return m_pJavaObject->getScreenBoundingBox(centerPixX, centerPixY, centerPixZ);
 }
 /*---------------------------------------------------------------------------------*/
 }
index 1c2b641..6a827bc 100644 (file)
@@ -47,9 +47,11 @@ public:
   virtual void setCenterPosition(double centerX, double centerY, double centerZ);
   virtual double * drawTextContent(void);
 
-  virtual double * getBoundingRectangle(void);
+  virtual double * getScreenBoundingBox(double centerPixX,
+                                        double centerPixY,
+                                        double centerPixZ);
 
-  virtual long * getScreenBoundingBox(void);
+  virtual void updateParentFigure(int parentFigureIndex);
   /*----------------------------------------------------------------------*/
   // specific for standard text drawer
   virtual void setTextParameters(int textAlignment, int color, int fontStyle,
index 60dad96..8cd7c6e 100644 (file)
@@ -44,11 +44,6 @@ void StandardTextDrawerJoGL::setDrawerParameters(void)
 
   StringMatrix * textMatrix = sciGetText(pObj);
   getStandardTextDrawerJavaMapper()->setTextContent(getStrMatData(textMatrix), getMatNbRow(textMatrix), getMatNbCol(textMatrix));
-
-  // get text position.
-  double textPos[3];
-  getTextDisplayPos(textPos);
-  getStandardTextDrawerJavaMapper()->setCenterPosition(textPos[0], textPos[1], textPos[2]);
 }
 /*---------------------------------------------------------------------------------*/
 StandardTextDrawerJavaMapper * StandardTextDrawerJoGL::getStandardTextDrawerJavaMapper(void)
index 9183199..43ddf34 100644 (file)
@@ -31,13 +31,14 @@ public:
   virtual void setCenterPosition(double centerX, double centerY, double centerZ) = 0;
   virtual double * drawTextContent(void) = 0;
 
-  virtual double * getBoundingRectangle(void) = 0;
-
-  virtual long * getScreenBoundingBox(void) = 0;
-
+  virtual double * getScreenBoundingBox(double centerPixX,
+                                        double centerPixY,
+                                        double centerPixZ) = 0;
   virtual void setTextParameters(int textAlignment, int color, int fontStyle,
                                  double fontSize, double rotationAngle, bool useFractionalMetrics) = 0;
 
+  virtual void updateParentFigure(int parentFigureIndex) = 0;
+
 };
 
 }
index 34ca0e0..1af3e03 100644 (file)
@@ -39,41 +39,32 @@ TextContentDrawerJoGL::TextContentDrawerJoGL(DrawableText * drawer)
 /*---------------------------------------------------------------------------------*/
 void TextContentDrawerJoGL::getBoundingRectangle(double corner1[3], double corner2[3], double corner3[3], double corner4[3])
 {
-  initializeDrawing();
-  setDrawerParameters();
-
-  // we got an array of size 12
-  double * rect = getTextContentDrawerJavaMapper()->getBoundingRectangle();
-
-  convertCornersArray(rect, corner1, corner2, corner3, corner4);
-
-  delete[] rect;
-
-  endDrawing();
+  // get pixel bounding in 3D
+  double corners[4][3];
+  getPixelBoundingBox(corners[0], corners[1], corners[2], corners[3]);
+
+  // convert it to 2D
+  Camera * cam = getSubwinDrawer(sciGetParentSubwin(m_pDrawed->getDrawedObject()))->getCamera();
+  cam->getSceneCoordinates(corners[0], corner1);
+  cam->getSceneCoordinates(corners[1], corner2);
+  cam->getSceneCoordinates(corners[2], corner3);
+  cam->getSceneCoordinates(corners[3], corner4);
 }
 /*---------------------------------------------------------------------------------*/
 void TextContentDrawerJoGL::getScreenBoundingBox(int corner1[2], int corner2[2], int corner3[2], int corner4[2])
 {
-  initializeDrawing();
-  setDrawerParameters();
-
-  // we got an array of size 8
-  long * rect = getTextContentDrawerJavaMapper()->getScreenBoundingBox();
-
-  corner1[0] = rect[0];
-  corner1[1] = rect[1];
-
-  corner2[0] = rect[2];
-  corner2[1] = rect[3];
-
-  corner3[0] = rect[4];
-  corner3[1] = rect[5];
-
-  corner4[0] = rect[6];
-  corner4[1] = rect[7];
-
-  delete[] rect;
-  endDrawing();
+  // get pixel bounding in 3D
+  double corners[4][3];
+  getPixelBoundingBox(corners[0], corners[1], corners[2], corners[3]);
+
+  // keep only the first 2 values
+  for (int i = 0; i < 2; i++)
+  {
+    corner1[i] = (int) corners[0][i];
+    corner2[i] = (int) corners[1][i];
+    corner3[i] = (int) corners[2][i];
+    corner4[i] = (int) corners[3][i];
+  }
 }
 /*---------------------------------------------------------------------------------*/
 void TextContentDrawerJoGL::drawTextContent(double corner1[3], double corner2[3], double corner3[3], double corner4[3])
@@ -81,6 +72,11 @@ void TextContentDrawerJoGL::drawTextContent(double corner1[3], double corner2[3]
   initializeDrawing();
   setDrawerParameters();
 
+  // set text center
+  double textPos[3];
+  getTextDisplayPos(textPos);
+  getTextContentDrawerJavaMapper()->setCenterPosition(textPos[0], textPos[1], textPos[2]);
+
   double * rect = getTextContentDrawerJavaMapper()->drawTextContent();
 
   convertCornersArray(rect, corner1, corner2, corner3, corner4);
@@ -214,6 +210,47 @@ void TextContentDrawerJoGL::getUserSizePix(double & boxWidthPix, double & boxHei
   getPixelLength(sciGetParentSubwin(pObj), textPos, boxWidth, boxHeight, boxWidthPix, boxHeightPix);
 }
 /*---------------------------------------------------------------------------------*/
+void TextContentDrawerJoGL::getPixelBoundingBox(double corner1[3], double corner2[3], double corner3[3], double corner4[3])
+{
+  // just update parent figure to avoid problems with OpenGL
+  getTextContentDrawerJavaMapper()->setFigureIndex(sciGetNum(sciGetParentFigure(m_pDrawed->getDrawedObject())));
+  setDrawerParameters();
+
+  // get text center
+  double textCenterPix[3];
+  getTextDisplayPos(textCenterPix);
+
+  // convert it to pixels
+  Camera * cam = getSubwinDrawer(sciGetParentSubwin(m_pDrawed->getDrawedObject()))->getCamera();
+  cam->getPixelCoordinatesRaw(textCenterPix, textCenterPix);
+
+  // we need to convert form OpenGL coordinates to Java ones
+  int viewport[4];
+  cam->getViewport(viewport);
+  textCenterPix[1] = viewport[1] - textCenterPix[1];
+
+  // we got an array of size 12
+  double * rect = getTextContentDrawerJavaMapper()->getScreenBoundingBox(textCenterPix[0], textCenterPix[1], textCenterPix[2]);
+
+  corner1[0] = rect[0];
+  corner1[1] = viewport[1] - rect[1]; // we need to convert form OpenGL coordinates to Java ones
+  corner1[2] = rect[2];
+
+  corner2[0] = rect[3];
+  corner2[1] = viewport[1] - rect[4]; // we need to convert form OpenGL coordinates to Java ones
+  corner1[2] = rect[5];
+
+  corner3[0] = rect[6];
+  corner3[1] = viewport[1] - rect[7]; // we need to convert form OpenGL coordinates to Java ones
+  corner1[2] = rect[8];
+
+  corner4[0] = rect[9];
+  corner4[1] = viewport[1] - rect[10]; // we need to convert form OpenGL coordinates to Java ones
+  corner1[2] = rect[11];
+
+  delete[] rect;
+}
+/*---------------------------------------------------------------------------------*/
 TextContentDrawerJavaMapper * TextContentDrawerJoGL::getTextContentDrawerJavaMapper(void)
 {
   return dynamic_cast<TextContentDrawerJavaMapper *>(getJavaMapper());
index f98a56e..bfc0249 100644 (file)
@@ -93,6 +93,11 @@ protected:
   void getUserSizePix(double & boxWidthPix, double & boxHeightPix);
 
   /**
+   * Compute bounding box the text in pixels coordinates
+   */
+  void getPixelBoundingBox(double corner1[3], double corner2[3], double corner3[3], double corner4[3]);
+
+  /**
    * Get the object performing mapping with Java class.
    */
   TextContentDrawerJavaMapper * getTextContentDrawerJavaMapper(void);
index a1a7334..0a89a30 100644 (file)
@@ -74,12 +74,20 @@ public abstract class ObjectGL {
         *                          Needed to get the GL context to draw in.
         */
        public void initializeDrawing(int parentFigureIndex) {
-               parentFigureGL = FigureMapper.getCorrespondingFigure(parentFigureIndex);
+               updateParentFigure(parentFigureIndex);
                updateGLContext();
                updateColorMap();
        }
        
        /**
+        * Set the parent figure for this objects
+        * @param parentFigureIndex index of the parent figure.
+        */
+       public void updateParentFigure(int parentFigureIndex) {
+               parentFigureGL = FigureMapper.getCorrespondingFigure(parentFigureIndex);
+       }
+       
+       /**
         * Function called at the end of the OpenGL use.
         */
        public void endDrawing() { }
index 66c65e3..b0f4b7f 100644 (file)
@@ -911,7 +911,9 @@ public class TicksDrawerGL extends DrawableObjectGL {
         */
        private SciTextRenderer getTextRenderer() {
                double[] color = getColorMap().getColor(labelColor);
-               return getParentFigureGL().getTextRendererCreator().createTextRenderer(labelFont, color, useFractionalMetrics); 
+               SciTextRenderer res = getParentFigureGL().getTextRendererCreator().createTextRenderer(labelFont, useFractionalMetrics); 
+               res.setColor(color);
+               return res;
        }
        
        /**
@@ -921,7 +923,9 @@ public class TicksDrawerGL extends DrawableObjectGL {
                if (isDisplayingExponents()) {
                        double[] color = getColorMap().getColor(labelColor);
                        Font exponentFont = labelFont.deriveFont(labelFont.getSize2D() * EXPONENT_SIZE);
-                       return getParentFigureGL().getTextRendererCreator().createTextRenderer(exponentFont, color, useFractionalMetrics);
+                       SciTextRenderer res = getParentFigureGL().getTextRendererCreator().createTextRenderer(exponentFont, useFractionalMetrics);
+                       res.setColor(color);
+                       return res;
                } else {
                        // no need for exponent renderer
                        return null;
index 4c0a2a7..9c4089a 100644 (file)
@@ -89,7 +89,7 @@ public abstract class FixedFontTextDrawerGL extends TextContentDrawerGL {
         */
        public Vector3D[] getBoundingRectanglePix() {
                // assume we are in pixels coordinates
-               SciTextRenderer renderer = getTextRenderer();
+               SciTextRenderer renderer = getTextRendererNoColor();
                
                setTextMatrix(computeStringSizes(renderer, getTextMatrix()));
                Vector3D[] bbox = getBoundingBox(getTextMatrix());
index 4632771..db1bd7d 100644 (file)
@@ -193,10 +193,22 @@ public abstract class TextContentDrawerGL extends DrawableObjectGL implements Te
        /**
         * Get the text renderer used to draw the text object.
         * Create one if none has already been created.
+        * Also set the right color for the renderer.
         * @return instance of SciTextRenderer
         */
        public SciTextRenderer getTextRenderer() {
-               return getParentFigureGL().getTextRendererCreator().createTextRenderer(getFont(), getFontColor(), useFractionalMetrics);
+               SciTextRenderer res = getTextRendererNoColor();
+               res.setColor(getFontColor());
+               return res;
+       }
+       
+       /**
+        * Get the text renderer used to draw the text object.
+        * Create one if none has already been created.
+        * @return instance of SciTextRenderer
+        */
+       protected SciTextRenderer getTextRendererNoColor() {
+               return getParentFigureGL().getTextRendererCreator().createTextRenderer(getFont(), useFractionalMetrics);
        }
        
        /**
@@ -304,16 +316,6 @@ public abstract class TextContentDrawerGL extends DrawableObjectGL implements Te
        }
        
        /**
-        * Compute the 4 corners of the bounding rectangle of the text.
-        * @return array of size 12 which is the concatenation of the 4 corners
-        *         where a corner is the array {cornerX, cornerY, cornerZ}.
-        */
-       public double[] getBoundingRectangle() {
-               double[] res = convertToArray(getBoundingRectangle3D());
-               return res;
-       }
-       
-       /**
         * Concatenate the coordinates of each points into an array of double
         * @param vects vectors to concatenate
         * @return array of size nbVects * 3, containing the nummber of vectors
@@ -332,33 +334,19 @@ public abstract class TextContentDrawerGL extends DrawableObjectGL implements Te
        
        /**
         * Get the bounding box of the text in pixels on the screen.
-        * @return array of size 8 which is the concatenation of the 4 corners
-        *         where a corner is the array {cornerX, cornerY}.
-        */
-       public int[] getScreenBoundingBox() {
-               Vector3D[] resVect = getBoundingRectangle2D();
-               int nbCorner = resVect.length;
-               int nbDim = 2;
-               int[] res = new int[nbCorner * nbDim];
-               for (int i = 0; i < nbCorner; i++) {
-                       res[nbDim * i] = (int) resVect[i].getX();
-                       res[nbDim * i + 1] = (int) resVect[i].getY();
-               }
-               return res;
-       }
-       
-       /**
-        * Get the 4 corners of the text bounding box in user coordinate system.
-        * @return array of size 4 containing the corners of the bounding rectangle.
+        * This function unlike other graphic functions operate only with Java2D
+        * and thus does not require an OpenGL to be current.
+        * @param centerPixX X coordinate of text center in pixel
+        * @param centerPixY Y coordinate of text center in pixel
+        * @param centerPixZ Z coordinate of text center in pixel
+        * @return array of size 12 which is the concatenation of the 4 corners
+        *         where a corner is the array {cornerX, cornerY, cornerZ}.
         */
-       protected Vector3D[] getBoundingRectangle3D() {
-               GL gl = getGL();                
-               Vector3D[] res = getBoundingRectangle2D();
-               CoordinateTransformation transform = getCoordinateTransformation();
-               for (int i = 0; i < res.length; i++) {
-                       res[i] = transform.retrieveSceneCoordinates(gl, res[i]);
-               }
-               return res;
+       public double[] getScreenBoundingBox(double centerPixX, double centerPixY, double centerPixZ) {
+               this.textCenterPix = new Vector3D(centerPixX, centerPixY, centerPixZ);
+               // computing text size in pixel does not need the OpenGL context to be current.
+               Vector3D[] resVect = getBoundingRectanglePix();
+               return convertToArray(resVect);
        }
        
        /**
index 24d46bc..c93a885 100644 (file)
@@ -180,13 +180,11 @@ public class TextRendererManager extends HashMap<String, TextRenderer[]> {
        /**
         * Create a new instance of SciTextRenderer displaying the font font.
         * @param font that will be used in the created SciTextRenderer
-        * @param color color of the text to display
         * @param useFractionalMetrics if true the generated renderer will be able to use fractional metrics
         * @return new instance of SciTextRenderer
         */
-       public SciTextRenderer createTextRenderer(Font font, double[] color, boolean useFractionalMetrics) {
+       public SciTextRenderer createTextRenderer(Font font, boolean useFractionalMetrics) {
                SciTextRenderer res = factory.createTextRenderer(getTextRenderer(font, useFractionalMetrics), font);
-               res.setColor(color);
                res.setUseFractionalMetrics(useFractionalMetrics);
                return res;
        }
index 0ffac91..94b0af7 100644 (file)
@@ -1,5 +1,5 @@
 #include "CenteredTextDrawerGL.hxx"
-/* Generated by GIWS (version 0.9.9.1) */
+/* Generated by GIWS (version 0.9.9.2) */
 /*
 
 Copyright 2007-2008 INRIA
@@ -113,9 +113,9 @@ stringArrayClass = (jclass) curEnv->NewGlobalRef(localStringArrayClass);
 curEnv->DeleteLocalRef(localStringArrayClass);
 voidsetCenterPositionjdoublejdoublejdoubleID=NULL; 
 jdoubleArraydrawTextContentID=NULL; 
-jdoubleArraygetBoundingRectangleID=NULL; 
-jintArraygetScreenBoundingBoxID=NULL; 
 voidsetFilledBoxSizejdoublejdoubleID=NULL; 
+jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID=NULL; 
+jdoubleArrayupdateParentFigurejintID=NULL; 
 
 
 }
@@ -152,9 +152,9 @@ stringArrayClass = (jclass) curEnv->NewGlobalRef(localStringArrayClass);
 curEnv->DeleteLocalRef(localStringArrayClass);
 voidsetCenterPositionjdoublejdoublejdoubleID=NULL; 
 jdoubleArraydrawTextContentID=NULL; 
-jdoubleArraygetBoundingRectangleID=NULL; 
-jintArraygetScreenBoundingBoxID=NULL; 
 voidsetFilledBoxSizejdoublejdoubleID=NULL; 
+jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID=NULL; 
+jdoubleArrayupdateParentFigurejintID=NULL; 
 
 
 }
@@ -371,16 +371,31 @@ return myArray;
 
 }
 
-double * CenteredTextDrawerGL::getBoundingRectangle (){
+void CenteredTextDrawerGL::setFilledBoxSize (double boxWidth, double boxHeight){
 
 JNIEnv * curEnv = getCurrentEnv();
 
-if (jdoubleArraygetBoundingRectangleID==NULL) { /* Use the cache Luke */ jdoubleArraygetBoundingRectangleID = curEnv->GetMethodID(this->instanceClass, "getBoundingRectangle", "()[D" ) ;
-if (jdoubleArraygetBoundingRectangleID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getBoundingRectangle");
+if (voidsetFilledBoxSizejdoublejdoubleID==NULL) { /* Use the cache Luke */ voidsetFilledBoxSizejdoublejdoubleID = curEnv->GetMethodID(this->instanceClass, "setFilledBoxSize", "(DD)V" ) ;
+if (voidsetFilledBoxSizejdoublejdoubleID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "setFilledBoxSize");
+}
+}
+                         curEnv->CallVoidMethod( this->instance, voidsetFilledBoxSizejdoublejdoubleID ,boxWidth, boxHeight);
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 }
-                        jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArraygetBoundingRectangleID );
+
+double * CenteredTextDrawerGL::getScreenBoundingBox (double centerPixX, double centerPixY, double centerPixZ){
+
+JNIEnv * curEnv = getCurrentEnv();
+
+if (jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID==NULL) { /* Use the cache Luke */ jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID = curEnv->GetMethodID(this->instanceClass, "getScreenBoundingBox", "(DDD)[D" ) ;
+if (jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenBoundingBox");
+}
+}
+                        jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID ,centerPixX, centerPixY, centerPixZ);
                         
 jsize len = curEnv->GetArrayLength(res);
 jboolean isCopy = JNI_FALSE;
@@ -402,23 +417,23 @@ return myArray;
 
 }
 
-long * CenteredTextDrawerGL::getScreenBoundingBox (){
+double * CenteredTextDrawerGL::updateParentFigure (long parentFigureIndex){
 
 JNIEnv * curEnv = getCurrentEnv();
 
-if (jintArraygetScreenBoundingBoxID==NULL) { /* Use the cache Luke */ jintArraygetScreenBoundingBoxID = curEnv->GetMethodID(this->instanceClass, "getScreenBoundingBox", "()[I" ) ;
-if (jintArraygetScreenBoundingBoxID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenBoundingBox");
+if (jdoubleArrayupdateParentFigurejintID==NULL) { /* Use the cache Luke */ jdoubleArrayupdateParentFigurejintID = curEnv->GetMethodID(this->instanceClass, "updateParentFigure", "(I)[D" ) ;
+if (jdoubleArrayupdateParentFigurejintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "updateParentFigure");
 }
 }
-                        jintArray res =  (jintArray) curEnv->CallObjectMethod( this->instance, jintArraygetScreenBoundingBoxID );
+                        jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArrayupdateParentFigurejintID ,parentFigureIndex);
                         
 jsize len = curEnv->GetArrayLength(res);
 jboolean isCopy = JNI_FALSE;
 
 /* faster than getXXXArrayElements */
-jint *resultsArray = (jint *) curEnv->GetPrimitiveArrayCritical(res, &isCopy);
-long * myArray= new long[len];
+jdouble *resultsArray = (jdouble *) curEnv->GetPrimitiveArrayCritical(res, &isCopy);
+double * myArray= new double[len];
 
 for (jsize i = 0; i < len; i++){
 myArray[i]=resultsArray[i];
@@ -433,19 +448,4 @@ return myArray;
 
 }
 
-void CenteredTextDrawerGL::setFilledBoxSize (double boxWidth, double boxHeight){
-
-JNIEnv * curEnv = getCurrentEnv();
-
-if (voidsetFilledBoxSizejdoublejdoubleID==NULL) { /* Use the cache Luke */ voidsetFilledBoxSizejdoublejdoubleID = curEnv->GetMethodID(this->instanceClass, "setFilledBoxSize", "(DD)V" ) ;
-if (voidsetFilledBoxSizejdoublejdoubleID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "setFilledBoxSize");
-}
-}
-                         curEnv->CallVoidMethod( this->instance, voidsetFilledBoxSizejdoublejdoubleID ,boxWidth, boxHeight);
-                        if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
-
 }
index c67f964..63a5bde 100644 (file)
     </method>
     <method name="drawTextContent" returnType="double[]">
     </method>
-    <method name="getBoundingRectangle" returnType="double[]">
-    </method>
-    <method name="getScreenBoundingBox" returnType="int[]">
-    </method>
     <method name="setFilledBoxSize" returnType="void">
       <param type="double" name="boxWidth" />
       <param type="double" name="boxHeight" />
     </method>
+    <method name="getScreenBoundingBox" returnType="double[]">
+      <param type="double" name="centerPixX" />
+      <param type="double" name="centerPixY" />
+      <param type="double" name="centerPixZ" />
+    </method>
+    <method name="updateParentFigure" returnType="double[]">
+      <param type="int" name="parentFigureIndex" />
+    </method>
   </object>
 </package>
index 3b9513c..93534ef 100644 (file)
@@ -1,4 +1,4 @@
-/* Generated by GIWS (version 0.9.9.1) */
+/* Generated by GIWS (version 0.9.9.2) */
 /*
 
 Copyright 2007-2008 INRIA
@@ -65,9 +65,9 @@ jmethodID voidsetTextContentjobjectArrayjintjintID; // cache method id
 jclass stringArrayClass;
 jmethodID voidsetCenterPositionjdoublejdoublejdoubleID; // cache method id
 jmethodID jdoubleArraydrawTextContentID; // cache method id
-jmethodID jdoubleArraygetBoundingRectangleID; // cache method id
-jmethodID jintArraygetScreenBoundingBoxID; // cache method id
 jmethodID voidsetFilledBoxSizejdoublejdoubleID; // cache method id
+jmethodID jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID; // cache method id
+jmethodID jdoubleArrayupdateParentFigurejintID; // cache method id
 
 
 /**
@@ -129,11 +129,11 @@ void setCenterPosition(double centerX, double centerY, double centerZ);
 
 double * drawTextContent();
 
-double * getBoundingRectangle();
+void setFilledBoxSize(double boxWidth, double boxHeight);
 
-long * getScreenBoundingBox();
+double * getScreenBoundingBox(double centerPixX, double centerPixY, double centerPixZ);
 
-void setFilledBoxSize(double boxWidth, double boxHeight);
+double * updateParentFigure(long parentFigureIndex);
 
 
                         /**
index 9d7c287..807a7b7 100644 (file)
@@ -1,5 +1,5 @@
 #include "FilledTextDrawerGL.hxx"
-/* Generated by GIWS (version 0.9.9.1) */
+/* Generated by GIWS (version 0.9.9.2) */
 /*
 
 Copyright 2007-2008 INRIA
@@ -113,10 +113,10 @@ stringArrayClass = (jclass) curEnv->NewGlobalRef(localStringArrayClass);
 curEnv->DeleteLocalRef(localStringArrayClass);
 voidsetCenterPositionjdoublejdoublejdoubleID=NULL; 
 jdoubleArraydrawTextContentID=NULL; 
-jdoubleArraygetBoundingRectangleID=NULL; 
-jintArraygetScreenBoundingBoxID=NULL; 
+jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID=NULL; 
 jdoublegetScilabFontSizeID=NULL; 
 voidsetFilledBoxSizejdoublejdoubleID=NULL; 
+jdoubleArrayupdateParentFigurejintID=NULL; 
 
 
 }
@@ -153,10 +153,10 @@ stringArrayClass = (jclass) curEnv->NewGlobalRef(localStringArrayClass);
 curEnv->DeleteLocalRef(localStringArrayClass);
 voidsetCenterPositionjdoublejdoublejdoubleID=NULL; 
 jdoubleArraydrawTextContentID=NULL; 
-jdoubleArraygetBoundingRectangleID=NULL; 
-jintArraygetScreenBoundingBoxID=NULL; 
+jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID=NULL; 
 jdoublegetScilabFontSizeID=NULL; 
 voidsetFilledBoxSizejdoublejdoubleID=NULL; 
+jdoubleArrayupdateParentFigurejintID=NULL; 
 
 
 }
@@ -373,16 +373,16 @@ return myArray;
 
 }
 
-double * FilledTextDrawerGL::getBoundingRectangle (){
+double * FilledTextDrawerGL::getScreenBoundingBox (double centerPixX, double centerPixY, double centerPixZ){
 
 JNIEnv * curEnv = getCurrentEnv();
 
-if (jdoubleArraygetBoundingRectangleID==NULL) { /* Use the cache Luke */ jdoubleArraygetBoundingRectangleID = curEnv->GetMethodID(this->instanceClass, "getBoundingRectangle", "()[D" ) ;
-if (jdoubleArraygetBoundingRectangleID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getBoundingRectangle");
+if (jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID==NULL) { /* Use the cache Luke */ jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID = curEnv->GetMethodID(this->instanceClass, "getScreenBoundingBox", "(DDD)[D" ) ;
+if (jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenBoundingBox");
 }
 }
-                        jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArraygetBoundingRectangleID );
+                        jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID ,centerPixX, centerPixY, centerPixZ);
                         
 jsize len = curEnv->GetArrayLength(res);
 jboolean isCopy = JNI_FALSE;
@@ -404,37 +404,6 @@ return myArray;
 
 }
 
-long * FilledTextDrawerGL::getScreenBoundingBox (){
-
-JNIEnv * curEnv = getCurrentEnv();
-
-if (jintArraygetScreenBoundingBoxID==NULL) { /* Use the cache Luke */ jintArraygetScreenBoundingBoxID = curEnv->GetMethodID(this->instanceClass, "getScreenBoundingBox", "()[I" ) ;
-if (jintArraygetScreenBoundingBoxID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenBoundingBox");
-}
-}
-                        jintArray res =  (jintArray) curEnv->CallObjectMethod( this->instance, jintArraygetScreenBoundingBoxID );
-                        
-jsize len = curEnv->GetArrayLength(res);
-jboolean isCopy = JNI_FALSE;
-
-/* faster than getXXXArrayElements */
-jint *resultsArray = (jint *) curEnv->GetPrimitiveArrayCritical(res, &isCopy);
-long * myArray= new long[len];
-
-for (jsize i = 0; i < len; i++){
-myArray[i]=resultsArray[i];
-}
-curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
-
-                        curEnv->DeleteLocalRef(res);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-return myArray;
-
-}
-
 double FilledTextDrawerGL::getScilabFontSize (){
 
 JNIEnv * curEnv = getCurrentEnv();
@@ -467,4 +436,35 @@ throw GiwsException::JniCallMethodException(curEnv);
 }
 }
 
+double * FilledTextDrawerGL::updateParentFigure (long parentFigureIndex){
+
+JNIEnv * curEnv = getCurrentEnv();
+
+if (jdoubleArrayupdateParentFigurejintID==NULL) { /* Use the cache Luke */ jdoubleArrayupdateParentFigurejintID = curEnv->GetMethodID(this->instanceClass, "updateParentFigure", "(I)[D" ) ;
+if (jdoubleArrayupdateParentFigurejintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "updateParentFigure");
+}
+}
+                        jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArrayupdateParentFigurejintID ,parentFigureIndex);
+                        
+jsize len = curEnv->GetArrayLength(res);
+jboolean isCopy = JNI_FALSE;
+
+/* faster than getXXXArrayElements */
+jdouble *resultsArray = (jdouble *) curEnv->GetPrimitiveArrayCritical(res, &isCopy);
+double * myArray= new double[len];
+
+for (jsize i = 0; i < len; i++){
+myArray[i]=resultsArray[i];
+}
+curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
+
+                        curEnv->DeleteLocalRef(res);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return myArray;
+
+}
+
 }
index d716c92..110371b 100644 (file)
     </method>
     <method name="drawTextContent" returnType="double[]">
     </method>
-    <method name="getBoundingRectangle" returnType="double[]">
-    </method>
-    <method name="getScreenBoundingBox" returnType="int[]">
+    <method name="getScreenBoundingBox" returnType="double[]">
+      <param type="double" name="centerPixX" />
+      <param type="double" name="centerPixY" />
+      <param type="double" name="centerPixZ" />
     </method>
     <method name="getScilabFontSize" returnType="double">
     </method>
@@ -46,5 +47,8 @@
       <param type="double" name="boxWidth" />
       <param type="double" name="boxHeight" />
     </method>
+    <method name="updateParentFigure" returnType="double[]">
+      <param type="int" name="parentFigureIndex" />
+    </method>
   </object>
 </package>
index 82c83f3..b909461 100644 (file)
@@ -1,4 +1,4 @@
-/* Generated by GIWS (version 0.9.9.1) */
+/* Generated by GIWS (version 0.9.9.2) */
 /*
 
 Copyright 2007-2008 INRIA
@@ -65,10 +65,10 @@ jmethodID voidsetTextContentjobjectArrayjintjintID; // cache method id
 jclass stringArrayClass;
 jmethodID voidsetCenterPositionjdoublejdoublejdoubleID; // cache method id
 jmethodID jdoubleArraydrawTextContentID; // cache method id
-jmethodID jdoubleArraygetBoundingRectangleID; // cache method id
-jmethodID jintArraygetScreenBoundingBoxID; // cache method id
+jmethodID jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID; // cache method id
 jmethodID jdoublegetScilabFontSizeID; // cache method id
 jmethodID voidsetFilledBoxSizejdoublejdoubleID; // cache method id
+jmethodID jdoubleArrayupdateParentFigurejintID; // cache method id
 
 
 /**
@@ -130,14 +130,14 @@ void setCenterPosition(double centerX, double centerY, double centerZ);
 
 double * drawTextContent();
 
-double * getBoundingRectangle();
-
-long * getScreenBoundingBox();
+double * getScreenBoundingBox(double centerPixX, double centerPixY, double centerPixZ);
 
 double getScilabFontSize();
 
 void setFilledBoxSize(double boxWidth, double boxHeight);
 
+double * updateParentFigure(long parentFigureIndex);
+
 
                         /**
                         * Get class name to use for static methods
index 19f02ea..c9e429d 100644 (file)
@@ -1,5 +1,5 @@
 #include "StandardTextDrawerGL.hxx"
-/* Generated by GIWS (version 0.9.9.1) */
+/* Generated by GIWS (version 0.9.9.2) */
 /*
 
 Copyright 2007-2008 INRIA
@@ -113,8 +113,8 @@ stringArrayClass = (jclass) curEnv->NewGlobalRef(localStringArrayClass);
 curEnv->DeleteLocalRef(localStringArrayClass);
 voidsetCenterPositionjdoublejdoublejdoubleID=NULL; 
 jdoubleArraydrawTextContentID=NULL; 
-jdoubleArraygetBoundingRectangleID=NULL; 
-jintArraygetScreenBoundingBoxID=NULL; 
+jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID=NULL; 
+jdoubleArrayupdateParentFigurejintID=NULL; 
 
 
 }
@@ -151,8 +151,8 @@ stringArrayClass = (jclass) curEnv->NewGlobalRef(localStringArrayClass);
 curEnv->DeleteLocalRef(localStringArrayClass);
 voidsetCenterPositionjdoublejdoublejdoubleID=NULL; 
 jdoubleArraydrawTextContentID=NULL; 
-jdoubleArraygetBoundingRectangleID=NULL; 
-jintArraygetScreenBoundingBoxID=NULL; 
+jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID=NULL; 
+jdoubleArrayupdateParentFigurejintID=NULL; 
 
 
 }
@@ -369,16 +369,16 @@ return myArray;
 
 }
 
-double * StandardTextDrawerGL::getBoundingRectangle (){
+double * StandardTextDrawerGL::getScreenBoundingBox (double centerPixX, double centerPixY, double centerPixZ){
 
 JNIEnv * curEnv = getCurrentEnv();
 
-if (jdoubleArraygetBoundingRectangleID==NULL) { /* Use the cache Luke */ jdoubleArraygetBoundingRectangleID = curEnv->GetMethodID(this->instanceClass, "getBoundingRectangle", "()[D" ) ;
-if (jdoubleArraygetBoundingRectangleID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getBoundingRectangle");
+if (jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID==NULL) { /* Use the cache Luke */ jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID = curEnv->GetMethodID(this->instanceClass, "getScreenBoundingBox", "(DDD)[D" ) ;
+if (jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenBoundingBox");
 }
 }
-                        jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArraygetBoundingRectangleID );
+                        jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID ,centerPixX, centerPixY, centerPixZ);
                         
 jsize len = curEnv->GetArrayLength(res);
 jboolean isCopy = JNI_FALSE;
@@ -400,23 +400,23 @@ return myArray;
 
 }
 
-long * StandardTextDrawerGL::getScreenBoundingBox (){
+double * StandardTextDrawerGL::updateParentFigure (long parentFigureIndex){
 
 JNIEnv * curEnv = getCurrentEnv();
 
-if (jintArraygetScreenBoundingBoxID==NULL) { /* Use the cache Luke */ jintArraygetScreenBoundingBoxID = curEnv->GetMethodID(this->instanceClass, "getScreenBoundingBox", "()[I" ) ;
-if (jintArraygetScreenBoundingBoxID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenBoundingBox");
+if (jdoubleArrayupdateParentFigurejintID==NULL) { /* Use the cache Luke */ jdoubleArrayupdateParentFigurejintID = curEnv->GetMethodID(this->instanceClass, "updateParentFigure", "(I)[D" ) ;
+if (jdoubleArrayupdateParentFigurejintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "updateParentFigure");
 }
 }
-                        jintArray res =  (jintArray) curEnv->CallObjectMethod( this->instance, jintArraygetScreenBoundingBoxID );
+                        jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArrayupdateParentFigurejintID ,parentFigureIndex);
                         
 jsize len = curEnv->GetArrayLength(res);
 jboolean isCopy = JNI_FALSE;
 
 /* faster than getXXXArrayElements */
-jint *resultsArray = (jint *) curEnv->GetPrimitiveArrayCritical(res, &isCopy);
-long * myArray= new long[len];
+jdouble *resultsArray = (jdouble *) curEnv->GetPrimitiveArrayCritical(res, &isCopy);
+double * myArray= new double[len];
 
 for (jsize i = 0; i < len; i++){
 myArray[i]=resultsArray[i];
index 772e65d..c5a4c6a 100644 (file)
     </method>
     <method name="drawTextContent" returnType="double[]">
     </method>
-    <method name="getBoundingRectangle" returnType="double[]">
+    <method name="getScreenBoundingBox" returnType="double[]">
+      <param type="double" name="centerPixX" />
+      <param type="double" name="centerPixY" />
+      <param type="double" name="centerPixZ" />
     </method>
-    <method name="getScreenBoundingBox" returnType="int[]">
+    <method name="updateParentFigure" returnType="double[]">
+      <param type="int" name="parentFigureIndex" />
     </method>
   </object>
 </package>
index 5aa56d8..5df1cbc 100644 (file)
@@ -1,4 +1,4 @@
-/* Generated by GIWS (version 0.9.9.1) */
+/* Generated by GIWS (version 0.9.9.2) */
 /*
 
 Copyright 2007-2008 INRIA
@@ -65,8 +65,8 @@ jmethodID voidsetTextContentjobjectArrayjintjintID; // cache method id
 jclass stringArrayClass;
 jmethodID voidsetCenterPositionjdoublejdoublejdoubleID; // cache method id
 jmethodID jdoubleArraydrawTextContentID; // cache method id
-jmethodID jdoubleArraygetBoundingRectangleID; // cache method id
-jmethodID jintArraygetScreenBoundingBoxID; // cache method id
+jmethodID jdoubleArraygetScreenBoundingBoxjdoublejdoublejdoubleID; // cache method id
+jmethodID jdoubleArrayupdateParentFigurejintID; // cache method id
 
 
 /**
@@ -128,9 +128,9 @@ void setCenterPosition(double centerX, double centerY, double centerZ);
 
 double * drawTextContent();
 
-double * getBoundingRectangle();
+double * getScreenBoundingBox(double centerPixX, double centerPixY, double centerPixZ);
 
-long * getScreenBoundingBox();
+double * updateParentFigure(long parentFigureIndex);
 
 
                         /**