VRS - The Virtual Rendering System

version 3.3

fontdefinition.h

Go to the documentation of this file.

 /**********************************************************************
 VRS - The Virtual Rendering System
 Copyright (C) 2001 Computer Graphics Systems Group at the 
 Hasso-Plattner-Institute, Potsdam, Germany.
 This library is free software; you can redistribute it and/or 
 modify it under the terms of the GNU Lesser General Public 
 License as published by the Free Software Foundation; either 
 version 2.1 of the License, or (at your option) any later version.
 This library is distributed in the hope that it will be useful, but 
 WITHOUT ANY WARRANTY; without even the implied warranty of 
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
 See the GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser+ General Public
 License along with this library; if not, write to the FreeSoftware 
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA, 02111-1307, USA.
 **********************************************************************/



#ifndef __FONTDEFINITION_H__
#define __FONTDEFINITION_H__

#include <vrs/image/imagemanipulator.h>
#include <vrs/container/array.h>
#include <vrs/sharedobj.h>

#include <vrs/text/vrs_textprerequisites.h>
#include <vrs/text/fontglyph.h>
#include <vrs/text/fonttexture.h>
#include <vrs/text/fontsize.h>

#include <vector>
#include <map>
#include <string>

struct FT_FaceRec_;
typedef struct FT_FaceRec_*  FT_Face;
struct FT_Bitmap_;
typedef struct FT_Bitmap_ FT_Bitmap;
struct FT_Stroker_;
typedef struct FT_StrokerRec_* FT_Stroker;


namespace VRS
{    
namespace TEXT
{
    typedef std::vector< SO<FontTexture> > FontTextureVector;
    typedef std::map<unsigned int, SO<FontGlyph> > FontGlyphMap;
    typedef std::map<GlyphCharcode, SO<FontGlyph> > FontGlyphCharMap;

    class VRS_CORE_API FontDefinition : public SharedObj
    {
    public:
        FontDefinition( const std::string& name, const std::string& fontfile, 
            const std::string& style, SO<FontSize> size, unsigned int typeFlags );
        virtual ~FontDefinition();

        inline const std::string& getName() const
            { return m_Name; };
        inline const std::string& getFont() const
            { return m_Font; };
        inline const std::string& getStyle() const
            { return m_Style; };
        inline const SO<FontSize> getSize() const
            { return m_Size; };
        inline float getLineHeight() const
        { if( m_UseMetrics != 0 ) return m_UseMetrics->getLineHeight(); else return m_LineHeight; };
        inline bool hasVerticalMetrics() const
            { return m_HasVerticalMetrics; };
        inline bool hasHorizontalMetrics() const
            { return m_HasHorizontalMetrics; };

        inline float getAscender() const
            { if( m_UseMetrics != 0 ) return m_UseMetrics->getAscender(); else return m_Ascender; };
        inline float getDescender() const
            { if( m_UseMetrics != 0 ) return m_UseMetrics->getDescender(); else return m_Descender; };
        inline unsigned int getTextureSize() const
            { return m_TextureSize; };

        // The Pixel per Font Unit
        inline unsigned int getPixelPerEmY() const
            { return m_PixelPerEmY; };
        // The Pixel per Font Unit
        inline unsigned int getPixelPerEmX() const
            { return m_PixelPerEmX; };

        std::string toString() const;

        void loadFontFace();    

        SO<FontDefinition> getFallBackFont() const;
        void setFallBackFont( SO<FontDefinition> fontdef );

        SO<FontTexture> getFontTexture(unsigned int id) const;


        void addGlyphs( GlyphCharcode* charArray, unsigned int count );
#ifdef VRS_HAS_WSTRING     // Has Unicode support
        void addGlyphs( const std::wstring& str );
#endif
        void addGlyphs( const std::string& str );
#ifdef VRS_HAS_WSTRING     // Has Unicode support
        void addGlyphs( const wchar_t* str, int count );
#endif
        void addGlyphs( const char* str, int count );

        void addGlyphs( std::vector<GlyphCharcode> charVec );
        void addGlyphs( SO<Array<GlyphCharcode> > charArr );
        void addDefaultGlyphs( );

        bool hasGlyphForChar( GlyphCharcode cha ) const;

        bool isGlyphForCharLoaded( GlyphCharcode cha ) const;
        SO<FontGlyph> getGlyphForCharcode( GlyphCharcode cha );
        
        void injectFontGlyph( GlyphCharcode cha, SO<FontGlyph> fg );
        SO<FontGlyph> getInjectedFontGlyph( GlyphCharcode cha );
        void removeInjectedFontGlyph( GlyphCharcode cha );
        void clearInjectedFontGlyphs( );

        SO<FontGlyph> addGlyphForChar( GlyphCharcode cha );

        SO<FontGlyph> addGlyph( unsigned int glyph_index, GlyphCharcode cha = 0 );

        void setOutline( float bordersize, SO<FontDefinition> useMetrics = NULL );

        SO<FontDefinition> getUseMetrics( ) const;

        void applyImageManipulation( SO<ImageManipulator> imageman, unsigned int times = 1 );

        inline unsigned int getGlpyhSpacing() const
            { return m_GlyphSpacing; };
        void setGlpyhSpacing( unsigned int spacing );
        void setExtraGlpyhBorder( unsigned int border );

        unsigned int getGlyphRepresentationTypes() const;

#ifdef PROTOTYPE
        void writeTexturesToPng() const;
#endif

        VRS_TYPEINFO(FontDefinition, SharedObj);
                VRS_SERIALIZABLE(FontDefinition);
    private:
        SO<FontGlyph> doAddGlyph( unsigned int glyph_index, GlyphCharcode cha = 0 );

        SO<FontTexture> renderBitmap( const FT_Bitmap& bitmap, unsigned int* uv );
            
                FontDefinition();

        std::string m_Name;
        std::string m_Font;
        std::string m_Style;
        SO<FontSize> m_Size;

        float m_LineHeight;
        float m_Ascender; 
        float m_Descender;
        float m_PixelPerEmY;
        float m_PixelPerEmX;

        unsigned int m_TextureSize;
        FT_Face m_Face;
        FT_Stroker m_Stroker;
        float m_StrokerBorder;

        SO<ImageManipulator> m_ImageManipulator;
        unsigned int m_ManipulateTimes;

        FontTextureVector m_Textures;
        FontGlyphMap m_Glyphs;
        bool m_isLoaded;

        bool m_HasVerticalMetrics;
        bool m_HasHorizontalMetrics;

        SO<FontDefinition> m_FallbackFont;
        SO<FontDefinition> m_UseMetrics;

        FontGlyphCharMap m_InjectedGlyphs;

        unsigned int m_GlyphSpacing;
        unsigned int m_ExtraGlyphBorder;

                unsigned int m_GlyphRepresentationTypes;
    };

}
}

#endif

---

Generated on Wed May 23 06:00:12 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact