StringBox.c File Reference

#include "StringBox.h"
#include "Xcall1.h"
#include "GetProperty.h"
#include "Axes.h"
#include "math_graphics.h"
#include "PloEch.h"
#include "MALLOC.h"
#include "CurrentObjectsManagement.h"
#include "ObjectSelection.h"

Include dependency graph for StringBox.c:

Go to the source code of this file.

Functions
void	getStringBbox (char *string, int center[2], int rect[4])
void	callXstringL (char *string, int posX, int posY, int boundingRect[4])
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])
void	getStringsRect (StringMatrix *strMat, int textPos[2], Vect2iMatrix *stringPosition, int boundingBox[4][2])
void	getStringsRectSized (StringMatrix *strMat, int textPos[2], Vect2iMatrix *stringPosition, int boundingBox[4][2], int userSize[2], int *newFontSize)
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])
void	getTextBoundingBox (sciPointObj *pText, int cornPix[4][2], double corners[4][2])
void	getTextAabb (sciPointObj *pText, int rectPix[4], int cornPix[4][2])
void	rotateBoundingBox (int boundingBox[4][2], int center[2], double angle)
void	translateBoundingBox (int boundingBox[4][2], int trans[2])
int	getStringVerticalSpace (void)
int	getStringHorizontalSpace (void)
BOOL	isFittingInCell (char *string, int cellWidth, int cellHeight)
void	getStringPositionTranslation (BOOL centeredPos, int textSize[2], int bbox[4][2], int trans[2])
int	computeSuitableFont (StringMatrix *strMat, Vect2iMatrix *stringPosition)

---

Function Documentation

void callXstringL	(	char *	string,
		int	posX,
		int	posY,
		int	boundingRect[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.

Definition at line 25 of file StringBox.c.

References C2F, dr(), L, PD0, PI0, SCI_SUBWIN, sciGetCurrentFigure(), sciGetFirstTypedSelectedSon(), and updateScaleIfRequired().

{
  sciPointObj * parentSubWin = sciGetFirstTypedSelectedSon( sciGetCurrentFigure(), SCI_SUBWIN ) ;

  updateScaleIfRequired( parentSubWin ) ;

  /* now we can call xstringl */
  C2F(dr)("xstringl",string,&posX,&posY,boundingRect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

}

Here is the call graph for this function:

int computeSuitableFont	(	StringMatrix *	strMat,
		Vect2iMatrix *	stringPosition
	)

get the largest font which can be used to fit the strings in the array.

Parameters:

	strMat	Set of strings which try to fit in stringPosition.
	position	of the cells in which the strings need to fit.

Definition at line 485 of file StringBox.c.

References C2F, dr(), getMatNbCol(), getMatNbRow(), getStrMatElement(), getVect2iMatElement(), height, isFittingInCell(), L, PD0, PI0, string, v, and width.

Referenced by getStringsRectSized().

{
  int nbRow = getMatNbRow( strMat ) ;
  int nbCol = getMatNbCol( strMat ) ;
  int largestFont  ;
  int smallestFont ;
  int i ;
  int j ; 
  integer curFont[2]  ;
  integer verbose = 0 ;
  integer v ;

  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 ;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void getStringBbox	(	char *	string,
		int	center[2],
		int	rect[4]
	)

return the bounding rectangle of a string.

Parameters:

	string	bounded string
	center	Position where the string ought to be displayed.
	rect	vector containing the upper left point and the width and height of the bounding box : [x,y,w,h].

Definition at line 20 of file StringBox.c.

References bsiz, C2F, dr(), L, PD0, and PI0.

Referenced by drawStringInCell(), getStringHorizontalSpace(), getStringsRect(), getStringVerticalSpace(), and isFittingInCell().

{
  C2F(dr)("xstringl",string,&(center[0]),&(center[1]),rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,9L,bsiz);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 the four corners of a text works only in 2D

Definition at line 36 of file StringBox.c.

References desallocateMatrix(), FALSE, getStringsPositions(), HDouble2Pixel, newCompleteMatrix(), NULL, pos, WDouble2Pixel, XDouble2Pixel, XDPixel2Double, YDouble2Pixel, and YDPixel2Double.

{
  int pos[2] ;
  int textSize[2] = {0,0} ;
  int corn[4][2] ;
  StringMatrix * strings = newCompleteMatrix( (void **) text, textDim[0], textDim[1] ) ;

  /* take coordinates in pixels */
  pos[0] = XDouble2Pixel( textPos[0] ) ;
  pos[1] = YDouble2Pixel( textPos[1] ) ;

  if ( !autoSize )
  {
    textSize[0] = WDouble2Pixel( textPos[0], userSize[0] ) ;
    textSize[1] = HDouble2Pixel( textPos[1], userSize[1] ) ;
  }

  /* NULL because we don't need the position of each string */
  getStringsPositions( strings, &fontId, &fontSize, pos, autoSize, textSize, FALSE, angle, NULL, corn ) ;

  /* 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] ) ;

  /* we don't need the matrix anymore, but the text is needed */
  desallocateMatrix( strings ) ;

}

Here is the call graph for this function:

int getStringHorizontalSpace

(

void

)

returns the minimal space between too consecutive strings horizontally.

Definition at line 447 of file StringBox.c.

References getStringBbox(), and pos.

Referenced by getStringsRect().

{
  int rect[4] ;
  int pos[2] = {0,0} ;
  /* return the width of a space */
  getStringBbox( " ", pos, rect ) ;
  return rect[2] ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void getStringPositionTranslation	(	BOOL	centeredPos,
		int	textSize[2],
		int	bbox[4][2],
		int	trans[2]
	)

Get the translation which should be applied to the text depending on the meaning of its position.

Parameters:

	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.
	textSize	width and height wanted for the text.
	bbox	The four corners of the computed boundign box of the text. The first corner should correspond to the position of the text.
	trans	Translation to apply to the text.

Definition at line 471 of file StringBox.c.

Referenced by getStringsPositions().

{
  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 ;
  }
}

Here is the caller graph for this function:

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 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.

Parameters:

	strMat	Set of string.
	fontId	specify the fontId of the strings.
	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.
	textPos	Position of the upper left point of the string array and center of rotation.
	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.
	textSize	if autoSize is false, specify the size of the rectangle in which the text must fit.
	angle	Angle for the rotation of the strings.
	centerPos	Specify where is the rotation center of the string. If TRUE in the middle of the array, otherwise in the bottom-left.
	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.
	boundingBox	position of the four corners of the bounding box surrounding the array of cells. The points are given clockwise.

Definition at line 218 of file StringBox.c.

References Abs, C2F, dr(), EPSILON, getStringPositionTranslation(), getStringsRect(), getStringsRectSized(), L, NULL, PD0, PI0, rotateBoundingBox(), rotateVect2iMatrix(), translateBoundingBox(), translateVect2iMatrix(), and v.

Referenced by drawTextEntity(), getStringBox(), and getTextBoundingBox().

{
  integer curFont[2]  ;
  integer verbose = 0 ;
  integer v           ;
  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 ) ;
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

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. The size of the array is automatically computed using the current font. This routine does not compute any rotation.

Parameters:

	strMat	Set of strings.
	textPos	Position of the upper left point of the string array.
	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.
	boundingBox	position of the four corners of the bounding box surrounding the array of cells.

Definition at line 83 of file StringBox.c.

References copyVect2iMatElement(), FREE, getMatNbCol(), getMatNbRow(), getStringBbox(), getStringHorizontalSpace(), getStringVerticalSpace(), getStrMatElement(), i, j, MALLOC, Max, and NULL.

Referenced by getStringsPositions(), and getStringsRectSized().

{
  /* 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  ) ;

}

Here is the call graph for this function:

Here is the caller graph for this function:

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 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.

Parameters:

	strMat	Set of strings.
	textPos	Position of the upper left point of the string array.
	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.
	boundingBox	position of the four corners of the bounding box surrounding the array of cells.
	userSize	width and height of the array of cells.
	newFontSize	font size which would fit the array best using the strings in strMat.

Definition at line 172 of file StringBox.c.

References C2F, computeSuitableFont(), dr(), getStringsRect(), homothVect2iMatrix(), iHomothety2D(), L, NULL, PD0, PI0, and v.

Referenced by getStringsPositions().

{
  integer curFont[2]  ;
  integer verbose = 0 ;
  integer v           ;
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int getStringVerticalSpace

(

void

)

returns the minimal space between too consecutive strings vertically.

Definition at line 439 of file StringBox.c.

References getStringBbox(), and pos.

Referenced by getStringsRect().

{
  int rect[4] ;
  int pos[2] = {0,0} ;
  getStringBbox( " ", pos, rect ) ;
  return rect[3] ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void getTextAabb	(	sciPointObj *	pText,
		int	rectPix[4],
		int	cornPix[4][2]
	)

Compute the axis aligned bounding box of a text object.

Parameters:

	pText	Pointer on the object to surround.
	rectPix	Bounding box (x,y,w,h) in pixel coordinates. If NULL, not computed. (x,y) is the coordinates of the bottom left vertice.
	conrPix	The four corners of the real bounding box. If NULL, not computed.

Definition at line 382 of file StringBox.c.

References abs, getTextBoundingBox(), Max, Min, and NULL.

{
  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] ) ) ;
    }
  }

}

Here is the call graph for this function:

void getTextBoundingBox	(	sciPointObj *	pText,
		int	cornPix[4][2],
		double	corners[4][2]
	)

Compute the bounding box of a text object.

Parameters:

	pText	Pointer on the object to surround.
	cornPix	Bounding box in pixel coordinates. If NULL, not computed.
	corners	Bounding box in user coordinates. If NULL, not computed.

Definition at line 277 of file StringBox.c.

References DEG2RAD, getPixelCoordinates(), getStringsPositions(), NULL, PixelHeight2d(), PixelWidth2d(), pTEXT_FEATURE, sciGetAutoSize(), sciGetCenterPos(), sciGetFontDeciWidth(), sciGetFontOrientation(), sciGetFontStyle(), sciGetIs3d(), sciGetParentSubwin(), sciGetText(), sciGetUserSize(), updateScaleIfRequired(), sciText::x, XDouble2Pixel, XDPixel2Double, sciText::y, YDouble2Pixel, YDPixel2Double, and sciText::z.

Referenced by computeLabelAutoPos(), getTextAabb(), and sci_StringBox().

{
  int           fontId   = sciGetFontStyle( pText ) ;
  int           fontSize = sciGetFontDeciWidth( pText ) / 100 ;
  double        angle    = DEG2RAD( sciGetFontOrientation (pText) / 10 ) ; 
  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 ;

  updateScaleIfRequired( parentSW ) ;

  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] ) ;
    }
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

BOOL isFittingInCell	(	char *	string,
		int	cellWidth,
		int	cellHeight
	)

Check if a string can be displayed in a cell with a certain width and height.

Definition at line 456 of file StringBox.c.

References FALSE, getStringBbox(), pos, and TRUE.

Referenced by computeSuitableFont().

{
  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 ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rotateBoundingBox	(	int	boundingBox[4][2],
		int	center[2],
		double	angle
	)

Rotate four points around the first one.

Parameters:

	boundingBox	the four 2D points.
	angle	rotation angle in radian.

Definition at line 417 of file StringBox.c.

References Abs, EPSILON, and iRotate2Dim().

Referenced by drawTextEntity(), and getStringsPositions().

{
  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] ) ;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void translateBoundingBox	(	int	boundingBox[4][2],
		int	trans[2]
	)

Translae four points around the first one.

Parameters:

	boundingBox	the four 2D points.
	angle	rotation angle in radian.

Definition at line 430 of file StringBox.c.

References iTranslate2D().

Referenced by getStringsPositions().

{
  iTranslate2D( boundingBox[0], trans, boundingBox[0] ) ;
  iTranslate2D( boundingBox[1], trans, boundingBox[1] ) ;
  iTranslate2D( boundingBox[2], trans, boundingBox[2] ) ;
  iTranslate2D( boundingBox[3], trans, boundingBox[3] ) ;

}

Here is the call graph for this function:

Here is the caller graph for this function:

---