vtkTextProperty.h

Go to the documentation of this file.

/*=========================================================================

  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.

=========================================================================*/
#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) override;

  static vtkTextProperty *New();


  vtkSetVector3Macro(Color,double);
  vtkGetVector3Macro(Color,double);


  vtkSetClampMacro(Opacity, double, 0., 1.);
  vtkGetMacro(Opacity,double);


  vtkSetVector3Macro(BackgroundColor, double);
  vtkGetVector3Macro(BackgroundColor, double);


  vtkSetClampMacro(BackgroundOpacity, double, 0., 1.);
  vtkGetMacro(BackgroundOpacity, double);


  vtkSetVector3Macro(FrameColor, double);
  vtkGetVector3Macro(FrameColor, double);


  vtkSetMacro(Frame, vtkTypeBool);
  vtkGetMacro(Frame, vtkTypeBool);
  vtkBooleanMacro(Frame, vtkTypeBool);


  vtkSetClampMacro(FrameWidth, int, 0, VTK_INT_MAX);
  vtkGetMacro(FrameWidth, int);


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


  vtkGetStringMacro(FontFile)
  vtkSetStringMacro(FontFile)


  vtkSetClampMacro(FontSize,int,0,VTK_INT_MAX);
  vtkGetMacro(FontSize, int);


  vtkSetMacro(Bold, vtkTypeBool);
  vtkGetMacro(Bold, vtkTypeBool);
  vtkBooleanMacro(Bold, vtkTypeBool);


  vtkSetMacro(Italic, vtkTypeBool);
  vtkGetMacro(Italic, vtkTypeBool);
  vtkBooleanMacro(Italic, vtkTypeBool);


  vtkSetMacro(Shadow, vtkTypeBool);
  vtkGetMacro(Shadow, vtkTypeBool);
  vtkBooleanMacro(Shadow, vtkTypeBool);


  vtkSetVector2Macro(ShadowOffset,int);
  vtkGetVectorMacro(ShadowOffset,int,2);

  void GetShadowColor(double color[3]);


  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();


  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();


  vtkSetMacro(UseTightBoundingBox, vtkTypeBool);
  vtkGetMacro(UseTightBoundingBox, vtkTypeBool);
  vtkBooleanMacro(UseTightBoundingBox, vtkTypeBool);


  vtkSetMacro(Orientation,double);
  vtkGetMacro(Orientation,double);


  vtkSetMacro(LineSpacing, double);
  vtkGetMacro(LineSpacing, double);


  vtkSetMacro(LineOffset, double);
  vtkGetMacro(LineOffset, double);

  void ShallowCopy(vtkTextProperty *tprop);

protected:
  vtkTextProperty();
  ~vtkTextProperty() override;

  double Color[3];
  double Opacity;
  double BackgroundColor[3];
  double BackgroundOpacity;
  vtkTypeBool    Frame;
  double FrameColor[3];
  int    FrameWidth;
  char* FontFamilyAsString;
  char* FontFile;
  int   FontSize;
  vtkTypeBool   Bold;
  vtkTypeBool   Italic;
  vtkTypeBool   Shadow;
  int   ShadowOffset[2];
  int   Justification;
  int   VerticalJustification;
  vtkTypeBool   UseTightBoundingBox;
  double Orientation;
  double LineOffset;
  double LineSpacing;

private:
  vtkTextProperty(const vtkTextProperty&) = delete;
  void operator=(const vtkTextProperty&) = delete;
};

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