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)
	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...
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.61
	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::STROKE_FONT

(

GAL *

aGal

)

Constructor.

Definition at line 43 of file stroke_font.cpp.

                                    :
    m_gal( aGal )
{
}

Member Function Documentation

computeBoundingBox()

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 135 of file stroke_font.cpp.

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

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

Referenced by LoadNewStrokeFont().

ComputeOverbarVerticalPosition()

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 388 of file stroke_font.cpp.

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

References OVERBAR_POSITION_FACTOR.

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

computeOverbarVerticalPosition()

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 397 of file stroke_font.cpp.

{
    // 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() );
}

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

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

ComputeStringBoundaryLimits()

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 411 of file stroke_font.cpp.

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

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

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(), and EDA_TEXT::GetTextBox().

computeTextLineSize()

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 405 of file stroke_font.cpp.

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

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

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

Draw()

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 159 of file stroke_font.cpp.

{
    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 = KiROUND( GetInterline( m_gal->GetGlyphSize().y ) );
    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();
}

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(), KiROUND(), 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().

drawSingleLineText()

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 239 of file stroke_font.cpp.

{
    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         overbar_index = 0;

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

        // Handle tabs as locked to the nearest 4th column (counting in spaces)
        // The choice of spaces is somewhat arbitrary but sufficient for aligning text
        if( *chIt == '\t' )
        {
            double fourSpaces = 4.0 * glyphSize.x * m_glyphBoundingBoxes[0].GetEnd().x;
            double addlSpace = fourSpaces - std::fmod( xOffset, fourSpaces );

            // Add the remaining space (between 0 and 3 spaces)
            xOffset += addlSpace;

            // Set the character to ' ' instead of the '?' for tab
            dd = 0;
        }

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

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

        if( overbars[overbar_index] )
        {
            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;
        ++overbar_index;
    }

    m_gal->Restore();
}

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, 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().

GetInterline()

double STROKE_FONT::GetInterline ( double  aGlyphHeight )

static

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

Parameters

aGlyphHeight

is the height (vertical size) of the text.

Returns

the interline.

Definition at line 127 of file stroke_font.cpp.

{
    // Do not add the glyph thickness to the interline.  This makes bold text line-spacing
    // different from normal text, which is poor typography.
    return ( aGlyphHeight * INTERLINE_PITCH_RATIO );
}

References INTERLINE_PITCH_RATIO.

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

linesCount()

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 161 of file stroke_font.h.

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

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

Referenced by Draw().

LoadNewStrokeFont()

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.

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

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

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

SetGAL()

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.

    {
        m_gal = aGal;
    }

References m_gal.

Friends And Related Function Documentation

GAL

friend class GAL

friend

Definition at line 55 of file stroke_font.h.

Member Data Documentation

BOLD_FACTOR

const double STROKE_FONT::BOLD_FACTOR = 1.3

staticprivate

Factor that determines relative line width for bold text.

Definition at line 174 of file stroke_font.h.

Referenced by Draw().

INTERLINE_PITCH_RATIO

const double STROKE_FONT::INTERLINE_PITCH_RATIO = 1.61

staticprivate

Factor that determines the pitch between 2 lines.

Definition at line 184 of file stroke_font.h.

Referenced by GetInterline().

ITALIC_TILT

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 181 of file stroke_font.h.

Referenced by ComputeStringBoundaryLimits(), and drawSingleLineText().

m_gal

GAL* KIGFX::STROKE_FONT::m_gal

private

Pointer to the GAL.

Definition at line 118 of file stroke_font.h.

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

m_glyphBoundingBoxes

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

private

Bounding boxes of the glyphs.

Definition at line 120 of file stroke_font.h.

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

m_glyphs

GLYPH_LIST KIGFX::STROKE_FONT::m_glyphs

private

Glyph list.

Definition at line 119 of file stroke_font.h.

Referenced by drawSingleLineText(), and LoadNewStrokeFont().

OVERBAR_POSITION_FACTOR

const double STROKE_FONT::OVERBAR_POSITION_FACTOR = 1.22

staticprivate

Factor that determines relative vertical position of the overbar.

Definition at line 171 of file stroke_font.h.

Referenced by ComputeOverbarVerticalPosition().

STROKE_FONT_SCALE

const double STROKE_FONT::STROKE_FONT_SCALE = 1.0 / 21.0

staticprivate

Scale factor for a glyph

Definition at line 177 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