KIGFX::STROKE_FONT Class Reference

Class STROKE_FONT implements stroke font drawing. More...

#include <stroke_font.h>

Public Member Functions
	STROKE_FONT (GAL *aGal)
	Constructor. More...
bool	LoadNewStrokeFont (const char *const aNewStrokeFont[], int aNewStrokeFontSize)
	Load the new stroke font. More...
void	Draw (const UTF8 &aText, const VECTOR2D &aPosition, double aRotationAngle)
	Draw a string. More...
void	SetGAL (GAL *aGal)
	Function SetGAL Changes Graphics Abstraction Layer used for drawing items for a new one. More...
VECTOR2D	ComputeStringBoundaryLimits (const UTF8 &aText, const VECTOR2D &aGlyphSize, double aGlyphThickness) const
	Compute the boundary limits of aText (the bounding box of all shapes). More...
double	ComputeOverbarVerticalPosition (double aGlyphHeight, double aGlyphThickness) const
	Compute the vertical position of an overbar, sometimes used in texts. More...

Static Public Member Functions
static double	GetInterline (double aGlyphHeight, double aGlyphThickness)
	Compute the distance (interline) between 2 lines of text (for multiline texts). More...

Private Member Functions
VECTOR2D	computeTextLineSize (const UTF8 &aText) const
	Compute the X and Y size of a given text. More...
double	computeOverbarVerticalPosition () const
	Compute the vertical position of an overbar, sometimes used in texts. More...
int	getInterline () const
	Returns a single line height using current settings. More...
BOX2D	computeBoundingBox (const GLYPH &aGlyph, const VECTOR2D &aGlyphBoundingX) const
	Compute the bounding box of a given glyph. More...
void	drawSingleLineText (const UTF8 &aText)
	Draws a single line of text. More...
unsigned	linesCount (const UTF8 &aText) const
	Returns number of lines for a given text. More...

Private Attributes
GAL *	m_gal
	Pointer to the GAL. More...
GLYPH_LIST	m_glyphs
	Glyph list. More...
std::vector< BOX2D >	m_glyphBoundingBoxes
	Bounding boxes of the glyphs. More...

Static Private Attributes
static const double	OVERBAR_POSITION_FACTOR = 1.22
	Factor that determines relative vertical position of the overbar. More...
static const double	BOLD_FACTOR = 1.3
	Factor that determines relative line width for bold text. More...
static const double	STROKE_FONT_SCALE = 1.0 / 21.0
	Scale factor for a glyph More...
static const double	ITALIC_TILT = 1.0 / 8
	Tilt factor for italic style (the is is the scaling factor on dY relative coordinates to give a tilst shape More...
static const double	INTERLINE_PITCH_RATIO = 1.5
	Factor that determines the pitch between 2 lines. More...

Friends
class	GAL

Detailed Description

Class STROKE_FONT implements stroke font drawing.

A stroke font is composed of lines.

Definition at line 53 of file stroke_font.h.

Constructor & Destructor Documentation

STROKE_FONT::STROKE_FONT

(

GAL *

aGal

)

Constructor.

Definition at line 43 of file stroke_font.cpp.

                                    :
    m_gal( aGal )
{
}

Member Function Documentation

BOX2D STROKE_FONT::computeBoundingBox ( const GLYPH &  aGlyph, const VECTOR2D &  aGlyphBoundingX  ) const

private

Compute the bounding box of a given glyph.

Parameters

aGlyph	is the glyph.
aGlyphBoundingX	is the x-component of the bounding box size.

Returns

is the complete bounding box size.

Definition at line 139 of file stroke_font.cpp.

References boundingBox(), BOX2< Vec >::Compute(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by LoadNewStrokeFont().

{
    BOX2D boundingBox;

    std::deque<VECTOR2D> boundingPoints;

    boundingPoints.emplace_back( VECTOR2D( aGLYPHBoundingX.x, 0 ) );
    boundingPoints.emplace_back( VECTOR2D( aGLYPHBoundingX.y, 0 ) );

    for( GLYPH::const_iterator pointListIt = aGLYPH.begin(); pointListIt != aGLYPH.end(); ++pointListIt )
    {
        for( std::deque<VECTOR2D>::const_iterator pointIt = pointListIt->begin();
                pointIt != pointListIt->end(); ++pointIt )
        {
            boundingPoints.emplace_back( VECTOR2D( aGLYPHBoundingX.x, pointIt->y ) );
        }
    }

    boundingBox.Compute( boundingPoints );

    return boundingBox;
}

double STROKE_FONT::ComputeOverbarVerticalPosition	(	double	aGlyphHeight,
		double	aGlyphThickness
	)		const

Compute the vertical position of an overbar, sometimes used in texts.

This is the distance between the text base line and the overbar.

Parameters

aGlyphHeight	is the height (vertical size) of the text.
aGlyphThickness	is the thickness of the lines used to draw the text.

Returns

the relative position of the overbar axis.

Definition at line 378 of file stroke_font.cpp.

References OVERBAR_POSITION_FACTOR.

Referenced by computeOverbarVerticalPosition(), EDA_TEXT::GetTextBox(), and SetGAL().

{
    // Static method.
    // Compute the Y position of the overbar. This is the distance between
    // the text base line and the overbar axis.
    return aGlyphHeight * OVERBAR_POSITION_FACTOR + aGlyphThickness;
}

double STROKE_FONT::computeOverbarVerticalPosition ( ) const

private

Compute the vertical position of an overbar, sometimes used in texts.

This is the distance between the text base line and the overbar.

Returns

the relative position of the overbar axis.

Definition at line 387 of file stroke_font.cpp.

References ComputeOverbarVerticalPosition(), KIGFX::GAL::GetGlyphSize(), KIGFX::GAL::GetLineWidth(), m_gal, and VECTOR2< T >::y.

Referenced by drawSingleLineText(), and KIGFX::GAL::GetOverbarVerticalPosition().

{
    // Compute the Y position of the overbar. This is the distance between
    // the text base line and the overbar axis.
    return ComputeOverbarVerticalPosition( m_gal->GetGlyphSize().y, m_gal->GetLineWidth() );
}

VECTOR2D STROKE_FONT::ComputeStringBoundaryLimits	(	const UTF8 &	aText,
		const VECTOR2D &	aGlyphSize,
		double	aGlyphThickness
	)		const

Compute the boundary limits of aText (the bounding box of all shapes).

The overbar and alignment are not taken in account, '~' characters are skipped.

Returns

a VECTOR2D giving the width and height of text.

Definition at line 401 of file stroke_font.cpp.

References BOX2< Vec >::GetEnd(), GetInterline(), KIGFX::GAL::IsFontItalic(), ITALIC_TILT, m_gal, m_glyphBoundingBoxes, max, UTF8::ubegin(), UTF8::uend(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by computeTextLineSize(), EDA_TEXT::GetTextBox(), and SetGAL().

{
    VECTOR2D string_bbox;
    int line_count = 1;
    double maxX = 0.0, curX = 0.0;

    for( UTF8::uni_iter it = aText.ubegin(), end = aText.uend(); it < end; ++it )
    {
        if( *it == '\n' )
        {
            curX = 0.0;
            maxX = std::max( maxX, curX );
            ++line_count;
            continue;
        }

        // If it is double tilda, then it is displayed as a single tilda
        // If it is single tilda, then it is toggling overbar, so we need to skip it
        if( *it == '~' )
        {
            if( ++it >= end )
                break;
        }

        // Index in the bounding boxes table
        int dd = *it - ' ';

        if( dd >= (int) m_glyphBoundingBoxes.size() || dd < 0 )
            dd = '?' - ' ';

        const BOX2D& box = m_glyphBoundingBoxes[dd];
        curX += box.GetEnd().x;
    }

    string_bbox.x = std::max( maxX, curX );
    string_bbox.x *= aGlyphSize.x;
    string_bbox.x += aGlyphThickness;
    string_bbox.y = line_count * GetInterline( aGlyphSize.y, aGlyphThickness );

    // For italic correction, take in account italic tilt
    if( m_gal->IsFontItalic() )
        string_bbox.x += string_bbox.y * STROKE_FONT::ITALIC_TILT;

    return string_bbox;
}

VECTOR2D STROKE_FONT::computeTextLineSize ( const UTF8 &  aText ) const

private

Compute the X and Y size of a given text.

The text is expected to be a only one line text.

Parameters

aText

is the text string (one line).

Returns

the text size.

Definition at line 395 of file stroke_font.cpp.

References ComputeStringBoundaryLimits(), KIGFX::GAL::GetGlyphSize(), KIGFX::GAL::GetLineWidth(), and m_gal.

Referenced by drawSingleLineText(), and KIGFX::GAL::GetTextLineSize().

{
    return ComputeStringBoundaryLimits( aText, m_gal->GetGlyphSize(), m_gal->GetLineWidth() );
}

void STROKE_FONT::Draw	(	const UTF8 &	aText,
		const VECTOR2D &	aPosition,
		double	aRotationAngle
	)

Draw a string.

Parameters

aText	is the text to be drawn.
aPosition	is the text position in world coordinates.
aRotationAngle	is the text rotation angle in radians.

Definition at line 163 of file stroke_font.cpp.

References BOLD_FACTOR, drawSingleLineText(), UTF8::empty(), UTF8::find(), KIGFX::GAL::GetGlyphSize(), getInterline(), KIGFX::GAL::GetLineWidth(), KIGFX::GAL::GetVerticalJustify(), GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, KIGFX::GAL::IsFontBold(), linesCount(), m_gal, UTF8::npos, KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), KIGFX::GAL::Save(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), UTF8::substr(), KIGFX::GAL::Translate(), and VECTOR2< T >::y.

Referenced by KIGFX::GAL::StrokeText().

{
    if( aText.empty() )
        return;

    // Context needs to be saved before any transformations
    m_gal->Save();

    m_gal->Translate( aPosition );
    m_gal->Rotate( -aRotationAngle );

    // Single line height
    int lineHeight = getInterline( );
    int lineCount = linesCount( aText );
    const VECTOR2D& glyphSize = m_gal->GetGlyphSize();

    // align the 1st line of text
    switch( m_gal->GetVerticalJustify() )
    {
    case GR_TEXT_VJUSTIFY_TOP:
        m_gal->Translate( VECTOR2D( 0, glyphSize.y ) );
        break;

    case GR_TEXT_VJUSTIFY_CENTER:
        m_gal->Translate( VECTOR2D( 0, glyphSize.y / 2.0 ) );
        break;

    case GR_TEXT_VJUSTIFY_BOTTOM:
        break;

    default:
        break;
    }

    if( lineCount > 1 )
    {
        switch( m_gal->GetVerticalJustify() )
        {
        case GR_TEXT_VJUSTIFY_TOP:
            break;

        case GR_TEXT_VJUSTIFY_CENTER:
            m_gal->Translate( VECTOR2D(0, -( lineCount - 1 ) * lineHeight / 2) );
            break;

        case GR_TEXT_VJUSTIFY_BOTTOM:
            m_gal->Translate( VECTOR2D(0, -( lineCount - 1 ) * lineHeight ) );
            break;
        }
    }

    m_gal->SetIsStroke( true );
    //m_gal->SetIsFill( false );

    if( m_gal->IsFontBold() )
        m_gal->SetLineWidth( m_gal->GetLineWidth() * BOLD_FACTOR );

    // Split multiline strings into separate ones and draw them line by line
    size_t  begin = 0;
    size_t  newlinePos = aText.find( '\n' );

    while( newlinePos != aText.npos )
    {
        size_t length = newlinePos - begin;

        drawSingleLineText( aText.substr( begin, length ) );
        m_gal->Translate( VECTOR2D( 0.0, lineHeight ) );

        begin = newlinePos + 1;
        newlinePos = aText.find( '\n', begin );
    }

    // Draw the last (or the only one) line
    if( !aText.empty() )
        drawSingleLineText( aText.substr( begin ) );

    m_gal->Restore();
}

void STROKE_FONT::drawSingleLineText ( const UTF8 &  aText )

private

Draws a single line of text.

Multiline texts should be split before using the function.

Parameters

aText

is the text to be drawn.

Definition at line 243 of file stroke_font.cpp.

References computeOverbarVerticalPosition(), computeTextLineSize(), KIGFX::GAL::DrawLine(), KIGFX::GAL::DrawPolyline(), BOX2< Vec >::GetEnd(), KIGFX::GAL::GetGlyphSize(), KIGFX::GAL::GetHorizontalJustify(), KIGFX::GAL::GetLineWidth(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, i, KIGFX::GAL::IsFontItalic(), KIGFX::GAL::IsTextMirrored(), ITALIC_TILT, m_gal, m_glyphBoundingBoxes, m_glyphs, ProcessOverbars(), KIGFX::GAL::Restore(), KIGFX::GAL::Save(), KIGFX::GAL::Translate(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Draw().

{
    double      xOffset;
    VECTOR2D    glyphSize( m_gal->GetGlyphSize() );
    double      overbar_italic_comp = computeOverbarVerticalPosition() * ITALIC_TILT;

    if( m_gal->IsTextMirrored() )
        overbar_italic_comp = -overbar_italic_comp;

    // Compute the text size
    VECTOR2D textSize = computeTextLineSize( aText );
    double half_thickness = m_gal->GetLineWidth()/2;

    // Context needs to be saved before any transformations
    m_gal->Save();

    // First adjust: the text X position is corrected by half_thickness
    // because when the text with thickness is draw, its full size is textSize,
    // but the position of lines is half_thickness to textSize - half_thickness
    // so we must translate the coordinates by half_thickness on the X axis
    // to place the text inside the 0 to textSize X area.
    m_gal->Translate( VECTOR2D( half_thickness, 0 ) );

    // Adjust the text position to the given horizontal justification
    switch( m_gal->GetHorizontalJustify() )
    {
    case GR_TEXT_HJUSTIFY_CENTER:
        m_gal->Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
        break;

    case GR_TEXT_HJUSTIFY_RIGHT:
        if( !m_gal->IsTextMirrored() )
            m_gal->Translate( VECTOR2D( -textSize.x, 0 ) );
        break;

    case GR_TEXT_HJUSTIFY_LEFT:
        if( m_gal->IsTextMirrored() )
            m_gal->Translate( VECTOR2D( -textSize.x, 0 ) );
        break;

    default:
        break;
    }

    if( m_gal->IsTextMirrored() )
    {
        // In case of mirrored text invert the X scale of points and their X direction
        // (m_glyphSize.x) and start drawing from the position where text normally should end
        // (textSize.x)
        xOffset = textSize.x - m_gal->GetLineWidth();
        glyphSize.x = -glyphSize.x;
    }
    else
    {
        xOffset = 0.0;
    }

    // The overbar is indented inward at the beginning of an italicized section, but
    // must not be indented on subsequent letters to ensure that the bar segments
    // overlap.
    bool last_had_overbar = false;
    auto processedText = ProcessOverbars( aText );
    const auto& text = processedText.first;
    const auto& overbars = processedText.second;
    int i = 0;

    for( UTF8::uni_iter chIt = text.ubegin(), end = text.uend(); chIt < end; ++chIt )
    {
        int dd = *chIt - ' ';

        if( dd >= (int) m_glyphBoundingBoxes.size() || dd < 0 )
            dd = '?' - ' ';

        GLYPH& glyph = m_glyphs[dd];
        BOX2D& bbox  = m_glyphBoundingBoxes[dd];

        if( overbars[i] )
        {
            double overbar_start_x = xOffset;
            double overbar_start_y = - computeOverbarVerticalPosition();
            double overbar_end_x = xOffset + glyphSize.x * bbox.GetEnd().x;
            double overbar_end_y = overbar_start_y;

            if( !last_had_overbar )
            {
                if( m_gal->IsFontItalic() )
                    overbar_start_x += overbar_italic_comp;

                last_had_overbar = true;
            }

            VECTOR2D startOverbar( overbar_start_x, overbar_start_y );
            VECTOR2D endOverbar( overbar_end_x, overbar_end_y );

            m_gal->DrawLine( startOverbar, endOverbar );
        }
        else
        {
            last_had_overbar = false;
        }

        for( GLYPH::iterator pointListIt = glyph.begin(); pointListIt != glyph.end();
             ++pointListIt )
        {
            std::deque<VECTOR2D> pointListScaled;

            for( std::deque<VECTOR2D>::iterator pointIt = pointListIt->begin();
                 pointIt != pointListIt->end(); ++pointIt )
            {
                VECTOR2D pointPos( pointIt->x * glyphSize.x + xOffset, pointIt->y * glyphSize.y );

                if( m_gal->IsFontItalic() )
                {
                    // FIXME should be done other way - referring to the lowest Y value of point
                    // because now italic fonts are translated a bit
                    if( m_gal->IsTextMirrored() )
                        pointPos.x += pointPos.y * STROKE_FONT::ITALIC_TILT;
                    else
                        pointPos.x -= pointPos.y * STROKE_FONT::ITALIC_TILT;
                }

                pointListScaled.push_back( pointPos );
            }

            m_gal->DrawPolyline( pointListScaled );
        }

        xOffset += glyphSize.x * bbox.GetEnd().x;
        ++i;
    }

    m_gal->Restore();
}

double STROKE_FONT::GetInterline ( double  aGlyphHeight, double  aGlyphThickness  )

static

Compute the distance (interline) between 2 lines of text (for multiline texts).

Parameters

aGlyphHeight	is the height (vertical size) of the text.
aGlyphThickness	is the thickness of the lines used to draw the text.

Returns

the interline.

Definition at line 127 of file stroke_font.cpp.

References INTERLINE_PITCH_RATIO.

Referenced by ComputeStringBoundaryLimits(), SCH_GLOBALLABEL::CreateGraphicShape(), getInterline(), EDA_TEXT::GetInterline(), and SetGAL().

{
    return ( aGlyphHeight * INTERLINE_PITCH_RATIO ) + aGlyphThickness;
}

int STROKE_FONT::getInterline ( ) const

private

Returns a single line height using current settings.

Returns

The line height.

Definition at line 133 of file stroke_font.cpp.

References KIGFX::GAL::GetGlyphSize(), GetInterline(), KIGFX::GAL::GetLineWidth(), KiROUND(), m_gal, and VECTOR2< T >::y.

Referenced by Draw().

{
    return KiROUND( GetInterline( m_gal->GetGlyphSize().y, m_gal->GetLineWidth() ) );
}

unsigned KIGFX::STROKE_FONT::linesCount ( const UTF8 &  aText ) const

inlineprivate

Returns number of lines for a given text.

Parameters

aText

is the text to be checked.

Returns

unsigned - The number of lines in aText.

Definition at line 169 of file stroke_font.h.

References UTF8::begin(), UTF8::empty(), and UTF8::end().

Referenced by Draw().

    {
        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;
    }

bool STROKE_FONT::LoadNewStrokeFont	(	const char *const	aNewStrokeFont[],
		int	aNewStrokeFontSize
	)

Load the new stroke font.

Parameters

aNewStrokeFont	is the pointer to the font data.
aNewStrokeFontSize	is the size of the font data.

Returns

True, if the font was successfully loaded, else false.

Definition at line 49 of file stroke_font.cpp.

References computeBoundingBox(), FONT_OFFSET, i, m_glyphBoundingBoxes, m_glyphs, STROKE_FONT_SCALE, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by KIGFX::GAL::GAL().

{
    m_glyphs.clear();
    m_glyphBoundingBoxes.clear();
    m_glyphs.resize( aNewStrokeFontSize );
    m_glyphBoundingBoxes.resize( aNewStrokeFontSize );

    for( int j = 0; j < aNewStrokeFontSize; j++ )
    {
        GLYPH&   glyph = m_glyphs[j];
        double   glyphStartX = 0.0;
        double   glyphEndX = 0.0;
        VECTOR2D glyphBoundingX;

        std::deque<VECTOR2D>* pointList = nullptr;

        int i = 0;

        while( aNewStrokeFont[j][i] )
        {
            VECTOR2D    point( 0.0, 0.0 );
            char        coordinate[2] = { 0, };

            for( int k = 0; k < 2; k++ )
            {
                coordinate[k] = aNewStrokeFont[j][i + k];
            }

            if( i < 2 )
            {
                // The first two values contain the width of the char
                glyphStartX     = ( coordinate[0] - 'R' ) * STROKE_FONT_SCALE;
                glyphEndX       = ( coordinate[1] - 'R' ) * STROKE_FONT_SCALE;
                glyphBoundingX  = VECTOR2D( 0, glyphEndX - glyphStartX );
            }
            else if( ( coordinate[0] == ' ' ) && ( coordinate[1] == 'R' ) )
            {
                // Raise pen
                pointList = nullptr;
            }
            else
            {
                // In stroke font, coordinates values are coded as <value> + 'R',
                // <value> is an ASCII char.
                // therefore every coordinate description of the Hershey format has an offset,
                // it has to be subtracted
                // Note:
                //  * the stroke coordinates are stored in reduced form (-1.0 to +1.0),
                //    and the actual size is stroke coordinate * glyph size
                //  * a few shapes have a height slightly bigger than 1.0 ( like '{' '[' )
                point.x = (double) ( coordinate[0] - 'R' ) * STROKE_FONT_SCALE - glyphStartX;
                #define FONT_OFFSET -10
                // FONT_OFFSET is here for historical reasons, due to the way the stroke font
                // was built. It allows shapes coordinates like W M ... to be >= 0
                // Only shapes like j y have coordinates < 0
                point.y = (double) ( coordinate[1] - 'R' + FONT_OFFSET ) * STROKE_FONT_SCALE;

                if( !pointList )
                {
                    glyph.emplace_back( std::deque<VECTOR2D>() );
                    pointList = &glyph.back();
                }

                pointList->push_back( point );
            }

            i += 2;
        }

        // Compute the bounding box of the glyph
        m_glyphBoundingBoxes[j] = computeBoundingBox( glyph, glyphBoundingX );
    }

    return true;
}

void KIGFX::STROKE_FONT::SetGAL ( GAL *  aGal )

inline

Function SetGAL Changes Graphics Abstraction Layer used for drawing items for a new one.

Parameters

aGal	is the new GAL instance.

Definition at line 84 of file stroke_font.h.

References ComputeOverbarVerticalPosition(), ComputeStringBoundaryLimits(), GetInterline(), and m_gal.

    {
        m_gal = aGal;
    }

Friends And Related Function Documentation

friend class GAL

friend

Definition at line 55 of file stroke_font.h.

Member Data Documentation

const double STROKE_FONT::BOLD_FACTOR = 1.3

staticprivate

Factor that determines relative line width for bold text.

Definition at line 182 of file stroke_font.h.

Referenced by Draw().

const double STROKE_FONT::INTERLINE_PITCH_RATIO = 1.5

staticprivate

Factor that determines the pitch between 2 lines.

Definition at line 192 of file stroke_font.h.

Referenced by GetInterline().

const double STROKE_FONT::ITALIC_TILT = 1.0 / 8

staticprivate

Tilt factor for italic style (the is is the scaling factor on dY relative coordinates to give a tilst shape

Definition at line 189 of file stroke_font.h.

Referenced by ComputeStringBoundaryLimits(), and drawSingleLineText().

GAL* KIGFX::STROKE_FONT::m_gal

private

Pointer to the GAL.

Definition at line 119 of file stroke_font.h.

Referenced by computeOverbarVerticalPosition(), ComputeStringBoundaryLimits(), computeTextLineSize(), Draw(), drawSingleLineText(), getInterline(), and SetGAL().

std::vector<BOX2D> KIGFX::STROKE_FONT::m_glyphBoundingBoxes

private

Bounding boxes of the glyphs.

Definition at line 121 of file stroke_font.h.

Referenced by ComputeStringBoundaryLimits(), drawSingleLineText(), and LoadNewStrokeFont().

GLYPH_LIST KIGFX::STROKE_FONT::m_glyphs

private

Glyph list.

Definition at line 120 of file stroke_font.h.

Referenced by drawSingleLineText(), and LoadNewStrokeFont().

const double STROKE_FONT::OVERBAR_POSITION_FACTOR = 1.22

staticprivate

Factor that determines relative vertical position of the overbar.

Definition at line 179 of file stroke_font.h.

Referenced by ComputeOverbarVerticalPosition().

const double STROKE_FONT::STROKE_FONT_SCALE = 1.0 / 21.0

staticprivate

Scale factor for a glyph

Definition at line 185 of file stroke_font.h.

Referenced by LoadNewStrokeFont().

---

The documentation for this class was generated from the following files:

• stroke_font.h
• stroke_font.cpp