You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
389 lines
9.0 KiB
C++
389 lines
9.0 KiB
C++
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkTextProperty.h
|
|
|
|
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
|
|
All rights reserved.
|
|
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notice for more information.
|
|
|
|
=========================================================================*/
|
|
/**
|
|
* @class vtkTextProperty
|
|
* @brief represent text properties.
|
|
*
|
|
* vtkTextProperty is an object that represents text properties.
|
|
* The primary properties that can be set are color, opacity, font size,
|
|
* font family horizontal and vertical justification, bold/italic/shadow
|
|
* styles.
|
|
* @sa
|
|
* vtkTextMapper vtkTextActor vtkLegendBoxActor vtkCaptionActor2D
|
|
*/
|
|
|
|
#ifndef vtkTextProperty_h
|
|
#define vtkTextProperty_h
|
|
|
|
#include "vtkRenderingCoreModule.h" // For export macro
|
|
#include "vtkObject.h"
|
|
|
|
class VTKRENDERINGCORE_EXPORT vtkTextProperty : public vtkObject
|
|
{
|
|
public:
|
|
vtkTypeMacro(vtkTextProperty,vtkObject);
|
|
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
|
|
|
|
/**
|
|
* Creates a new text property with font size 12, bold off, italic off,
|
|
* and Arial font.
|
|
*/
|
|
static vtkTextProperty *New();
|
|
|
|
//@{
|
|
/**
|
|
* Set the color of the text.
|
|
*/
|
|
vtkSetVector3Macro(Color,double);
|
|
vtkGetVector3Macro(Color,double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the text's opacity. 1.0 is totally opaque and 0.0 is completely
|
|
* transparent.
|
|
*/
|
|
vtkSetClampMacro(Opacity, double, 0., 1.);
|
|
vtkGetMacro(Opacity,double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* The background color.
|
|
*/
|
|
vtkSetVector3Macro(BackgroundColor, double);
|
|
vtkGetVector3Macro(BackgroundColor, double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* The background opacity. 1.0 is totally opaque and 0.0 is completely
|
|
* transparent.
|
|
*/
|
|
vtkSetClampMacro(BackgroundOpacity, double, 0., 1.);
|
|
vtkGetMacro(BackgroundOpacity, double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* The frame color.
|
|
*/
|
|
vtkSetVector3Macro(FrameColor, double);
|
|
vtkGetVector3Macro(FrameColor, double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Enable/disable text frame.
|
|
*/
|
|
vtkSetMacro(Frame, int);
|
|
vtkGetMacro(Frame, int);
|
|
vtkBooleanMacro(Frame, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the width of the frame. The width is expressed in pixels.
|
|
* The default is 1 pixel.
|
|
*/
|
|
vtkSetClampMacro(FrameWidth, int, 0, VTK_INT_MAX);
|
|
vtkGetMacro(FrameWidth, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the font family. Supports legacy three font family system.
|
|
* If the symbolic constant VTK_FONT_FILE is returned by GetFontFamily(), the
|
|
* string returned by GetFontFile() must be an absolute filepath
|
|
* to a local FreeType compatible font.
|
|
*/
|
|
vtkGetStringMacro(FontFamilyAsString);
|
|
vtkSetStringMacro(FontFamilyAsString);
|
|
void SetFontFamily(int t);
|
|
int GetFontFamily();
|
|
int GetFontFamilyMinValue() { return VTK_ARIAL; };
|
|
void SetFontFamilyToArial();
|
|
void SetFontFamilyToCourier();
|
|
void SetFontFamilyToTimes();
|
|
static int GetFontFamilyFromString( const char *f );
|
|
static const char *GetFontFamilyAsString( int f );
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* The absolute filepath to a local file containing a freetype-readable font
|
|
* if GetFontFamily() return VTK_FONT_FILE. The result is undefined for other
|
|
* values of GetFontFamily().
|
|
*/
|
|
vtkGetStringMacro(FontFile)
|
|
vtkSetStringMacro(FontFile)
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the font size (in points).
|
|
*/
|
|
vtkSetClampMacro(FontSize,int,0,VTK_INT_MAX);
|
|
vtkGetMacro(FontSize, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Enable/disable text bolding.
|
|
*/
|
|
vtkSetMacro(Bold, int);
|
|
vtkGetMacro(Bold, int);
|
|
vtkBooleanMacro(Bold, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Enable/disable text italic.
|
|
*/
|
|
vtkSetMacro(Italic, int);
|
|
vtkGetMacro(Italic, int);
|
|
vtkBooleanMacro(Italic, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Enable/disable text shadow.
|
|
*/
|
|
vtkSetMacro(Shadow, int);
|
|
vtkGetMacro(Shadow, int);
|
|
vtkBooleanMacro(Shadow, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the shadow offset, i.e. the distance from the text to
|
|
* its shadow, in the same unit as FontSize.
|
|
*/
|
|
vtkSetVector2Macro(ShadowOffset,int);
|
|
vtkGetVectorMacro(ShadowOffset,int,2);
|
|
//@}
|
|
|
|
/**
|
|
* Get the shadow color. It is computed from the Color ivar
|
|
*/
|
|
void GetShadowColor(double color[3]);
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the horizontal justification to left (default), centered,
|
|
* or right.
|
|
*/
|
|
vtkSetClampMacro(Justification,int,VTK_TEXT_LEFT,VTK_TEXT_RIGHT);
|
|
vtkGetMacro(Justification,int);
|
|
void SetJustificationToLeft()
|
|
{ this->SetJustification(VTK_TEXT_LEFT);};
|
|
void SetJustificationToCentered()
|
|
{ this->SetJustification(VTK_TEXT_CENTERED);};
|
|
void SetJustificationToRight()
|
|
{ this->SetJustification(VTK_TEXT_RIGHT);};
|
|
const char *GetJustificationAsString();
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the vertical justification to bottom (default), middle,
|
|
* or top.
|
|
*/
|
|
vtkSetClampMacro(VerticalJustification,int,VTK_TEXT_BOTTOM,VTK_TEXT_TOP);
|
|
vtkGetMacro(VerticalJustification,int);
|
|
void SetVerticalJustificationToBottom()
|
|
{this->SetVerticalJustification(VTK_TEXT_BOTTOM);};
|
|
void SetVerticalJustificationToCentered()
|
|
{this->SetVerticalJustification(VTK_TEXT_CENTERED);};
|
|
void SetVerticalJustificationToTop()
|
|
{this->SetVerticalJustification(VTK_TEXT_TOP);};
|
|
const char *GetVerticalJustificationAsString();
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* If this property is on, text is alligned to drawn pixels not to font metrix.
|
|
* If the text does not include descents, the bounding box will not extend below
|
|
* the baseline. This option can be used to get centered labels. It does not
|
|
* work well if the string changes as the string position will move around.
|
|
*/
|
|
vtkSetMacro(UseTightBoundingBox, int);
|
|
vtkGetMacro(UseTightBoundingBox, int);
|
|
vtkBooleanMacro(UseTightBoundingBox, int);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the text's orientation (in degrees).
|
|
*/
|
|
vtkSetMacro(Orientation,double);
|
|
vtkGetMacro(Orientation,double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the (extra) spacing between lines,
|
|
* expressed as a text height multiplication factor.
|
|
*/
|
|
vtkSetMacro(LineSpacing, double);
|
|
vtkGetMacro(LineSpacing, double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the vertical offset (measured in pixels).
|
|
*/
|
|
vtkSetMacro(LineOffset, double);
|
|
vtkGetMacro(LineOffset, double);
|
|
//@}
|
|
|
|
/**
|
|
* Shallow copy of a text property.
|
|
*/
|
|
void ShallowCopy(vtkTextProperty *tprop);
|
|
|
|
protected:
|
|
vtkTextProperty();
|
|
~vtkTextProperty();
|
|
|
|
double Color[3];
|
|
double Opacity;
|
|
double BackgroundColor[3];
|
|
double BackgroundOpacity;
|
|
int Frame;
|
|
double FrameColor[3];
|
|
int FrameWidth;
|
|
char* FontFamilyAsString;
|
|
char* FontFile;
|
|
int FontSize;
|
|
int Bold;
|
|
int Italic;
|
|
int Shadow;
|
|
int ShadowOffset[2];
|
|
int Justification;
|
|
int VerticalJustification;
|
|
int UseTightBoundingBox;
|
|
double Orientation;
|
|
double LineOffset;
|
|
double LineSpacing;
|
|
|
|
private:
|
|
vtkTextProperty(const vtkTextProperty&) VTK_DELETE_FUNCTION;
|
|
void operator=(const vtkTextProperty&) VTK_DELETE_FUNCTION;
|
|
};
|
|
|
|
inline const char *vtkTextProperty::GetFontFamilyAsString( int f )
|
|
{
|
|
if ( f == VTK_ARIAL )
|
|
{
|
|
return "Arial";
|
|
}
|
|
else if ( f == VTK_COURIER )
|
|
{
|
|
return "Courier";
|
|
}
|
|
else if ( f == VTK_TIMES )
|
|
{
|
|
return "Times";
|
|
}
|
|
else if ( f == VTK_FONT_FILE )
|
|
{
|
|
return "File";
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
inline void vtkTextProperty::SetFontFamily( int t )
|
|
{
|
|
this->SetFontFamilyAsString( this->GetFontFamilyAsString( t ) );
|
|
}
|
|
|
|
inline void vtkTextProperty::SetFontFamilyToArial()
|
|
{
|
|
this->SetFontFamily(VTK_ARIAL);
|
|
}
|
|
|
|
inline void vtkTextProperty::SetFontFamilyToCourier()
|
|
{
|
|
this->SetFontFamily(VTK_COURIER);
|
|
}
|
|
|
|
inline void vtkTextProperty::SetFontFamilyToTimes()
|
|
{
|
|
this->SetFontFamily(VTK_TIMES);
|
|
}
|
|
|
|
inline int vtkTextProperty::GetFontFamilyFromString( const char *f )
|
|
{
|
|
if ( strcmp( f, GetFontFamilyAsString( VTK_ARIAL ) ) == 0 )
|
|
{
|
|
return VTK_ARIAL;
|
|
}
|
|
else if ( strcmp( f, GetFontFamilyAsString( VTK_COURIER ) ) == 0 )
|
|
{
|
|
return VTK_COURIER;
|
|
}
|
|
else if ( strcmp( f, GetFontFamilyAsString( VTK_TIMES ) ) == 0 )
|
|
{
|
|
return VTK_TIMES;
|
|
}
|
|
else if ( strcmp( f, GetFontFamilyAsString( VTK_FONT_FILE) ) == 0 )
|
|
{
|
|
return VTK_FONT_FILE;
|
|
}
|
|
return VTK_UNKNOWN_FONT;
|
|
}
|
|
|
|
inline int vtkTextProperty::GetFontFamily()
|
|
{
|
|
return GetFontFamilyFromString( this->FontFamilyAsString );
|
|
}
|
|
|
|
inline const char *vtkTextProperty::GetJustificationAsString(void)
|
|
{
|
|
if (this->Justification == VTK_TEXT_LEFT)
|
|
{
|
|
return "Left";
|
|
}
|
|
else if (this->Justification == VTK_TEXT_CENTERED)
|
|
{
|
|
return "Centered";
|
|
}
|
|
else if (this->Justification == VTK_TEXT_RIGHT)
|
|
{
|
|
return "Right";
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char *vtkTextProperty::GetVerticalJustificationAsString(void)
|
|
{
|
|
if (this->VerticalJustification == VTK_TEXT_BOTTOM)
|
|
{
|
|
return "Bottom";
|
|
}
|
|
else if (this->VerticalJustification == VTK_TEXT_CENTERED)
|
|
{
|
|
return "Centered";
|
|
}
|
|
else if (this->VerticalJustification == VTK_TEXT_TOP)
|
|
{
|
|
return "Top";
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
#endif
|