vtkFreeTypeUtilities.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkFreeTypeUtilities.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 vtkFreeTypeUtilities_h
#define vtkFreeTypeUtilities_h
 
#define VTK_FTFC_CACHE_CAPACITY 150
 
#include "vtkRenderingFreeTypeModule.h" // For export macro
#include "vtkObject.h"
 
class vtkImageData;
class vtkTextProperty;
class vtkTextActor;
class vtkViewport;
 
// FreeType
 
#include <FTGL.h>
 
#include "vtk_freetype.h"  //since ft2build.h could be in the path
#include FT_FREETYPE_H
#include FT_GLYPH_H
 
#if (FREETYPE_MAJOR >2 ||(FREETYPE_MAJOR == 2 && ( FREETYPE_MINOR > 1 || (FREETYPE_MINOR == 1 && FREETYPE_PATCH >= 9))))
# include FT_CACHE_H
// This flag will be used to check if Caching support is to be compiled.
# define VTK_FREETYPE_CACHING_SUPPORTED
#endif
 
#ifdef FTGL_USE_NAMESPACE
namespace ftgl
{
#endif
class FTFont;
#ifdef FTGL_USE_NAMESPACE
}
#endif
 
//----------------------------------------------------------------------------
// Singleton cleanup
 
class VTKRENDERINGFREETYPE_EXPORT vtkFreeTypeUtilitiesCleanup
{
public:
  vtkFreeTypeUtilitiesCleanup();
  ~vtkFreeTypeUtilitiesCleanup();
};
 
//----------------------------------------------------------------------------
// Singleton font cache
 
class VTKRENDERINGFREETYPE_EXPORT vtkFreeTypeUtilities : public vtkObject
{
public:
  vtkTypeMacro(vtkFreeTypeUtilities, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  static vtkFreeTypeUtilities *New();
 
  static vtkFreeTypeUtilities* GetInstance();
 
  static void SetInstance(vtkFreeTypeUtilities *instance);
 
  FT_Library* GetLibrary();
 
 
  vtkSetClampMacro(MaximumNumberOfFaces,unsigned int,1,VTK_UNSIGNED_INT_MAX);
  vtkGetMacro(MaximumNumberOfFaces, unsigned int);
  vtkSetClampMacro(MaximumNumberOfSizes,unsigned int,1,VTK_UNSIGNED_INT_MAX);
  vtkGetMacro(MaximumNumberOfSizes, unsigned int);
  vtkSetClampMacro(MaximumNumberOfBytes,unsigned long,1,VTK_UNSIGNED_LONG_MAX);
  vtkGetMacro(MaximumNumberOfBytes, unsigned long);
 
  int GetSize(vtkTextProperty *tprop, FT_Size *size);
 
  int GetFace(vtkTextProperty *tprop, FT_Face *face);
 
  int GetGlyphIndex(vtkTextProperty *tprop, FT_UInt32 c, FT_UInt *gindex);
 
  //BTX
 
  enum
  {
    GLYPH_REQUEST_DEFAULT = 0,
    GLYPH_REQUEST_BITMAP  = 1,
    GLYPH_REQUEST_OUTLINE = 2
  };
  //ETX
  int GetGlyph(vtkTextProperty *tprop,
               FT_UInt32 c,
               FT_Glyph *glyph,
               int request = GLYPH_REQUEST_DEFAULT);
 
 
  int GetBoundingBox(vtkTextProperty *tprop, const char *str, int bbox[4]);
  int IsBoundingBoxValid(int bbox[4]);
 
 
  int RenderString(vtkTextProperty *tprop,
                   const char *str,
                   vtkImageData *data);
 
 
  void MapTextPropertyToId(vtkTextProperty *tprop, unsigned long *tprop_cache_id);
  void MapIdToTextProperty(unsigned long tprop_cache_id, vtkTextProperty *tprop);
 
 
  int GetSize(unsigned long tprop_cache_id, int font_size, FT_Size *size);
  int GetFace(unsigned long tprop_cache_id, FT_Face *face);
  int GetGlyphIndex(unsigned long tprop_cache_id, FT_UInt32 c,
                    FT_UInt *gindex);
  int GetGlyph(unsigned long tprop_cache_id,
               int font_size,
               FT_UInt gindex,
               FT_Glyph *glyph,
               int request = GLYPH_REQUEST_DEFAULT);
 
 
  void GetWidthHeightDescender(const char *str,
                               vtkTextProperty *tprop,
                               int *width,
                               int *height,
                               float *descender);
 
 
  void PrepareImageData(vtkImageData *data,
                        vtkTextProperty *tprop,
                        const char *str,
                        int *x, int *y);
 
 
  int GetConstrainedFontSize(const char *str, vtkTextProperty *tprop,
                             double orientation, int targetWidth,
                             int targetHeight);
 
 
  void JustifyLine(const char *str, vtkTextProperty *tprop,
                   int totalWidth, int *x, int *y);
 
  // Old Code
  // Cache entry
 
  struct Entry
  {
    vtkTextProperty *TextProperty;
#ifdef FTGL_USE_NAMESPACE
    ftgl::FTFont *Font;
#else
    FTFont *Font;
#endif
    float LargestAscender;
    float LargestDescender;
  };
 
  vtkFreeTypeUtilities::Entry* GetFont(vtkTextProperty *tprop,
                                       double override_color[3] = NULL);
 
protected:
  //Internal helper method called by RenderString
  int PopulateImageData(vtkTextProperty *tprop, const char *str,
                        int x, int y, vtkImageData *data, int use_shadow_color);
  vtkFreeTypeUtilities();
  virtual ~vtkFreeTypeUtilities();
 
private:
  vtkFreeTypeUtilities(const vtkFreeTypeUtilities&);  // Not implemented.
  void operator=(const vtkFreeTypeUtilities&);  // Not implemented.
 
  // The singleton instance and the singleton cleanup instance
 
  static vtkFreeTypeUtilities* Instance;
  static vtkFreeTypeUtilitiesCleanup Cleanup;
 
  // The cache manager, image cache and charmap cache
 
#ifdef VTK_FREETYPE_CACHING_SUPPORTED
  FTC_Manager *CacheManager;
  FTC_ImageCache *ImageCache;
  FTC_CMapCache  *CMapCache;
 
 
  FTC_Manager* GetCacheManager();
  FTC_ImageCache* GetImageCache();
  FTC_CMapCache* GetCMapCache();
#endif
 
 
  unsigned int MaximumNumberOfFaces;
  unsigned int MaximumNumberOfSizes;
  unsigned long MaximumNumberOfBytes;
 
  void InitializeCacheManager();
  void ReleaseCacheManager();
 
  // Old Code
 
  void PrintEntry(int i, char *msg = 0);
  void ReleaseEntry(int i);
 
  void InitializeCache();
  void ReleaseCache();
 
  Entry *Entries[VTK_FTFC_CACHE_CAPACITY];
  int NumberOfEntries;
};
 
#endif
// VTK-HeaderTest-Exclude: vtkFreeTypeUtilities.h