RE/RE_Font.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        RE_Font.h (RE Library, C++)
 *
 * COMMENTS:
 */

#ifndef __RE_Font__
#define __RE_Font__

#include "RE_API.h"
#include <UT/UT_String.h>

#define DEFAULT_FONTNAME        "Proportional"
#define DEFAULT_FONTSIZE        12.0

class RE_Render;
class UT_WorkBuffer;

#define LOADFONT()              { if (!myFontLoaded) loadFont(); }
#define POINTS_PER_INCH         72.0

class RE_API RE_Font
{
/*
 *  This is the generic base class for font access. Sub-classes of RE_Font
 *  must implement the pure virtual methods defined below. Font objects
 *  are instantiated by calling RE_Render::getFont which relies on
 *  its device dependent sub-class to create a RE_Font sub-class suitable
 *  for use on that device.
 */
public:
    /// Construct an RE_Font. name is the name of the font face you want to
    /// use, and size is the size in points you want to use.
             RE_Font(const char *name, float size = DEFAULT_FONTSIZE);
    virtual ~RE_Font();

    /// Set the current font to name and size. Invalidates the current font.
    void                 setFont(const char *name, float size);

    /// Note that returning a UT_String usually isn't safe, but myFontName has
    /// been constructed with UT_String::ALWAYS_DEEP, so it won't cause any
    /// problems.
    UT_String            getName() const
                         { return myFontName; }

    /// Get the size, in points, of this font.
    float                getSize() const
                         { return myFontSize; }

    /// Render string s using the position defined by the renderer r's
    /// raster X, Y, and Z, set with the RE_Render::textMove* functions.
    /// Implicitly updates the raster position to point at the end of the
    /// rendered text.
    virtual void         render(RE_Render *r, const char *s) = 0;

    /// The descender is the distance, in pixels,  from the baseline to the
    /// bottommost pixel of all glyphs in the font.
    int                  getDescender()
                         { LOADFONT(); return myDescender; }

    /// The height is the designed height, in pixels, of the font. Often
    /// thought to be ascender + descender, but this isn't necessarily the
    /// case.
    int                  getHeight()
                         { LOADFONT(); return myFontHeight; }

    /// Get the width, in pixels, of a particular character.
    /// Most often, this will just be the horizontal advance of the glyph.
    /// NOTE: This ignores kerning! If you want to get the width of a whole
    /// string, use getStringWidth instead.
    int                  getCharWidth(char c)
                         { LOADFONT(); return getCharWidth(c, '\0'); }

    /// Get the width, in pixels, of a particular character as laid out on the
    /// screen, including kerning.
    /// This is better thought of as answering the question "how far
    /// horizontally will the font renderer travel if it renders c after prev?"
    virtual int          getCharWidth(char c, char prev) = 0;

    /// Get the width of a string, including all kerning adjustments.
    virtual int          getStringWidth(const char *s) = 0;

    /// Get the number of glyphs this font. Note that it's dangerous
    /// to assume that the glyphs this font contains correspond to the
    /// numbers betwen 0 and getNumGlyphs - 1: they might not even be
    /// contiguous!
    int                  getNumGlyphs()
                         { LOADFONT(); return myNumGlyphs; }

    /// This method wraps the string src to fit into a box of width w and 
    /// height h.  It takes into account the character height and width of
    /// this font.  The string dest contains the wrapped text (\n are
    /// inserted where necessary).  If h is -1, then no limit is placed on
    /// height, otherwise your dest string may contain only the portion of
    /// the src string that fits in h.
    void                 wrapString(const char *src, UT_WorkBuffer &dest, 
                                    int w, int h = -1);
protected: // functions

    /// A helper function to set up myFontName correctly depending on whether
    /// name is non-NULL (set it to name) or NULL (set it to the default).
    void                 setFontName(const char *name);

    /// Override this to load your font and set myFontLoaded to true.
    virtual void         loadFont() = 0;

protected: // variables

    /// The name of this font face.
    UT_String            myFontName;

    /// The size, in points, of this font.
    float                myFontSize;

    /// Whether this font has been loaded yet. Set this in sub-classes on load.
    /// All variables below this one are not valid if myFontLoaded is false.
    bool                 myFontLoaded;

    /// The text height of this font, in pixels. Can be thought of as the
    /// maximum height of the bounding box of all glyphs in this font.
    int                  myFontHeight;

    /// The distance from the baseline to the bottom of the lowest font glyph.
    /// Set this in sub-classes on load.
    int                  myDescender;

    /// The number of glyphs available in this font. Note that this doesn't
    /// mean that you can then render the characters between 0 and
    /// myNumGlyphs - 1: number of glyphs is unrelated to the characters
    /// they represent!
    int                  myNumGlyphs;
};
#endif

---