Font.h

Go to the documentation of this file.

// Font.h -- Font class, for Gnash
//
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

// Based on the public domain work of Thatcher Ulrich <tu@tulrich.com> 2003


#ifndef GNASH_FONT_H
#define GNASH_FONT_H

#include <string>
#include <memory>
#include <cstdint>
#include <memory>
#include <vector>
#include <map>

#include "ref_counted.h"

namespace gnash {
    class FreetypeGlyphsProvider;
    namespace SWF {
        class ShapeRecord;
        class DefineFontTag;
    }
}

namespace gnash {



// @@ replace this with a flat hash, or else a sorted array
//    (binary search)
class kerning_pair
{
public:
    std::uint16_t m_char0;
    std::uint16_t m_char1;

    bool operator==(const kerning_pair& k) const
    {
        return m_char0 == k.m_char0 && m_char1 == k.m_char1;
    }
};

// for use in standard algorithms
inline bool
operator< (const kerning_pair& p1, const kerning_pair& p2)
{
    if (p1.m_char0 < p2.m_char0) return true;
    if (p1.m_char0 == p2.m_char0) {
        if (p1.m_char1 < p2.m_char1) return true;
    }
    
    return false;
}


//
//
//
class Font : public ref_counted
{
public:

    // This table maps from Unicode DisplayObject number to glyph index.
    typedef std::map<std::uint16_t, int> CodeTable;

    Font(std::unique_ptr<SWF::DefineFontTag> ft);

    //
    Font(std::string name, bool bold = false, bool italic = false);

    ~Font();

    std::uint16_t codeTableLookup(int glyph, bool embedded) const;

    //
    bool matches(const std::string& name, bool bold, bool italic) const;

    //
    SWF::ShapeRecord* get_glyph(int glyph_index, bool embedded) const;

    const std::string& name() const { return _name; }

    //
    int get_glyph_index(std::uint16_t code, bool embedded) const;

    //
    //
    float get_advance(int glyph_index, bool embedded) const;

    //
    float get_kerning_adjustment(int last_code, int this_code) const;

    //
    size_t unitsPerEM(bool embedded) const;

    //
    float ascent(bool embedded) const;
        
    //
    float descent(bool embedded) const;

    //
    float leading() const;

    bool isBold() const {
        return _bold;
    }
    
    bool isItalic() const {
        return _italic;
    }

    //
    struct FontNameInfo
    {
        std::string displayName;
        std::string copyrightName;
    };

    struct GlyphInfo
    {
        // no glyph, default textured glyph, 0 advance
        GlyphInfo();

        //
        GlyphInfo(std::unique_ptr<SWF::ShapeRecord> glyph, float advance);

        std::unique_ptr<SWF::ShapeRecord> glyph;

        float advance;
    };

    typedef std::vector<GlyphInfo> GlyphInfoRecords;

    //
    void addFontNameInfo(const FontNameInfo& fontName);

    //
    void setName(const std::string& name);

    //
    void setFlags(std::uint8_t flags);

    //
    void setCodeTable(std::unique_ptr<CodeTable> table);

    GlyphInfoRecords::size_type glyphCount() const;

    //
    FreetypeGlyphsProvider* ftProvider() const;

private:

    //
    int add_os_glyph(std::uint16_t code);

    std::unique_ptr<SWF::DefineFontTag> _fontTag;

    // Device glyphs
    GlyphInfoRecords _deviceGlyphTable;

    std::string    _name;
    std::string _displayName;
    std::string _copyrightName;

    bool _unicodeChars;
    bool _shiftJISChars;
    bool _ansiChars;
    bool _italic;
    bool _bold;

    //
    std::shared_ptr<const CodeTable> _embeddedCodeTable;

    CodeTable _deviceCodeTable; 

    typedef std::map<kerning_pair, float> kernings_table;
    kernings_table m_kerning_pairs;

    mutable std::unique_ptr<FreetypeGlyphsProvider> _ftProvider;

};


}    // end namespace gnash



#endif // GNASH_FONT_H

// Local Variables:
// mode: C++
// c-basic-offset: 8 
// tab-width: 8
// indent-tabs-mode: t
// End: