font.h

Go to the documentation of this file.

/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright (C) 2021 Ola Rinta-Koski
 * Copyright (C) 2021-2023 Kicad Developers, see AUTHORS.txt for contributors.
 *
 * Font abstract base class
 *
 * 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 2
 * 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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef FONT_H_
#define FONT_H_
 
#include <gal/gal.h>
#include <iostream>
#include <map>
#include <algorithm>
#include <wx/string.h>
#include <font/glyph.h>
#include <font/text_attributes.h>
 
namespace KIGFX
{
class GAL;
}
 
 
enum TEXT_STYLE
{
 BOLD = 1,
 ITALIC = 1 << 1,
 SUBSCRIPT = 1 << 2,
 SUPERSCRIPT = 1 << 3,
 OVERBAR = 1 << 4,
 UNDERLINE = 1 << 5
};
 
 
static constexpr double ITALIC_TILT = 1.0 / 8;
 
 
using TEXT_STYLE_FLAGS = unsigned int;
 
 
inline bool IsBold( TEXT_STYLE_FLAGS aFlags )
{
 return aFlags & TEXT_STYLE::BOLD;
}
 
 
inline bool IsItalic( TEXT_STYLE_FLAGS aFlags )
{
 return aFlags & TEXT_STYLE::ITALIC;
}
 
 
inline bool IsSuperscript( TEXT_STYLE_FLAGS aFlags )
{
 return aFlags & TEXT_STYLE::SUPERSCRIPT;
}
 
 
inline bool IsSubscript( TEXT_STYLE_FLAGS aFlags )
{
 return aFlags & TEXT_STYLE::SUBSCRIPT;
}
 
 
namespace KIFONT
{
class GAL_API METRICS
{
public:
 double GetOverbarVerticalPosition( double aGlyphHeight ) const
 {
 return aGlyphHeight * m_OverbarHeight;
 }
 
 double GetUnderlineVerticalPosition( double aGlyphHeight ) const
 {
 return aGlyphHeight * m_UnderlineOffset;
 }
 
 double GetInterline( double aFontHeight ) const
 {
 return aFontHeight * m_InterlinePitch;
 }
 
 static const METRICS& Default();
 
public:
 double m_InterlinePitch = 1.68;
 double m_OverbarHeight = 1.23;
 double m_UnderlineOffset = -0.16;
};
 
class GAL_API FONT
{
public:
 explicit FONT();
 
 virtual ~FONT()
 { }
 
 virtual bool IsStroke() const { return false; }
 virtual bool IsOutline() const { return false; }
 virtual bool IsBold() const { return false; }
 virtual bool IsItalic() const { return false; }
 
 static FONT* GetFont( const wxString& aFontName = wxEmptyString, bool aBold = false,
 bool aItalic = false );
 static bool IsStroke( const wxString& aFontName );
 
 const wxString& GetName() const { return m_fontName; };
 inline const char* NameAsToken() const { return GetName().utf8_str().data(); }
 
 void Draw( KIGFX::GAL* aGal, const wxString& aText, const VECTOR2I& aPosition,
 const VECTOR2I& aCursor, const TEXT_ATTRIBUTES& aAttributes,
 const METRICS& aFontMetrics ) const;
 
 void Draw( KIGFX::GAL* aGal, const wxString& aText, const VECTOR2I& aPosition,
 const TEXT_ATTRIBUTES& aAttributes, const METRICS& aFontMetrics ) const
 {
 Draw( aGal, aText, aPosition, VECTOR2I( 0, 0 ), aAttributes, aFontMetrics );
 }
 
 VECTOR2I StringBoundaryLimits( const wxString& aText, const VECTOR2I& aSize, int aThickness,
 bool aBold, bool aItalic, const METRICS& aFontMetrics ) const;
 
 void LinebreakText( wxString& aText, int aColumnWidth, const VECTOR2I& aGlyphSize,
 int aThickness, bool aBold, bool aItalic ) const;
 
 virtual double GetInterline( double aGlyphHeight, const METRICS& aFontMetrics ) const = 0;
 
 virtual VECTOR2I GetTextAsGlyphs( BOX2I* aBBox, std::vector<std::unique_ptr<GLYPH>>* aGlyphs,
 const wxString& aText, const VECTOR2I& aSize,
 const VECTOR2I& aPosition, const EDA_ANGLE& aAngle,
 bool aMirror, const VECTOR2I& aOrigin,
 TEXT_STYLE_FLAGS aTextStyle ) const = 0;
 
protected:
 inline unsigned linesCount( const wxString& aText ) const
 {
 if( aText.empty() )
 return 0; // std::count does not work well with empty strings
 else
 // aText.end() - 1 is to skip a newline character that is potentially at the end
 return std::count( aText.begin(), aText.end() - 1, '\n' ) + 1;
 }
 
 void drawSingleLineText( KIGFX::GAL* aGal, BOX2I* aBoundingBox, const wxString& aText,
 const VECTOR2I& aPosition, const VECTOR2I& aSize,
 const EDA_ANGLE& aAngle, bool aMirror, const VECTOR2I& aOrigin,
 bool aItalic, bool aUnderline, const METRICS& aFontMetrics ) const;
 
 VECTOR2I boundingBoxSingleLine( BOX2I* aBBox, const wxString& aText, const VECTOR2I& aPosition,
 const VECTOR2I& aSize, bool aItalic, const METRICS& aFontMetrics ) const;
 
 void getLinePositions( const wxString& aText, const VECTOR2I& aPosition,
 wxArrayString& aTextLines, std::vector<VECTOR2I>& aPositions,
 std::vector<VECTOR2I>& aExtents, const TEXT_ATTRIBUTES& aAttrs,
 const METRICS& aFontMetrics ) const;
 
 VECTOR2I drawMarkup( BOX2I* aBoundingBox, std::vector<std::unique_ptr<GLYPH>>* aGlyphs,
 const wxString& aText, const VECTOR2I& aPosition,
 const VECTOR2I& aSize, const EDA_ANGLE& aAngle, bool aMirror,
 const VECTOR2I& aOrigin, TEXT_STYLE_FLAGS aTextStyle,
 const METRICS& aFontMetrics ) const;
 
 void wordbreakMarkup( std::vector<std::pair<wxString, int>>* aWords, const wxString& aText,
 const VECTOR2I& aSize, TEXT_STYLE_FLAGS aTextStyle ) const;
 
private:
 static FONT* getDefaultFont();
 
protected:
 wxString m_fontName; 
 wxString m_fontFileName; 
 
private:
 static FONT* s_defaultFont;
 
 static std::map< std::tuple<wxString, bool, bool>, FONT* > s_fontMap;
};
 
} //namespace KIFONT
 
 
inline std::ostream& operator<<(std::ostream& os, const KIFONT::FONT& aFont)
{
 os << "[Font \"" << aFont.GetName() << "\"" << ( aFont.IsStroke() ? " stroke" : "" )
 << ( aFont.IsOutline() ? " outline" : "" ) << ( aFont.IsBold() ? " bold" : "" )
 << ( aFont.IsItalic() ? " italic" : "" ) << "]";
 return os;
}
 
 
inline std::ostream& operator<<(std::ostream& os, const KIFONT::FONT* aFont)
{
 os << *aFont;
 return os;
}
 
#endif // FONT_H_