pdf_stroke_font.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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, see <https://www.gnu.org/licenses/>.
 */
 
#include <plotters/pdf_stroke_font.h>
 
#include <algorithm>
#include <cstdint>
#include <limits>
 
#include <fmt/format.h>
 
#include <font/glyph.h>
#include <advanced_config.h>
 
namespace
{
static constexpr int MAX_SIMPLE_FONT_CODES = 256;
 
// Build the stroked path for a glyph.
// KiCad's internal stroke font glyph coordinates use an inverted Y axis relative to the
// PDF coordinate system we are targeting here.  We therefore optionally flip Y so text
// renders upright.  A slightly thicker default stroke width (4% of EM) is used to improve
// legibility at typical plot zoom levels.
static std::string buildGlyphStream( const KIFONT::STROKE_GLYPH* aGlyph, double aUnitsPerEm,
                                     bool aInvertY, bool aBold )
{
    if( !aGlyph )
        return std::string();
 
    fmt::memory_buffer buffer;
    double factor = ADVANCED_CFG::GetCfg().m_PDFStrokeFontWidthFactor;
 
    if( aBold )
    {
        double boldMul = ADVANCED_CFG::GetCfg().m_PDFStrokeFontBoldMultiplier;
        if( boldMul < 1.0 ) boldMul = 1.0;
        factor *= boldMul;
    }
 
    if( factor <= 0.0 )
        factor = 0.04; // fallback safety
 
    double lw = aUnitsPerEm * factor;
    fmt::format_to( std::back_inserter( buffer ), "{:.3f} w 1 J 1 j ", lw );
    auto& cfg = ADVANCED_CFG::GetCfg();
 
    for( const std::vector<VECTOR2D>& stroke : *aGlyph )
    {
        bool firstPoint = true;
 
        for( const VECTOR2D& point : stroke )
        {
            double x = ( point.x + cfg.m_PDFStrokeFontXOffset ) * aUnitsPerEm;
            double y = point.y * aUnitsPerEm;
 
            if( aInvertY )
            {
                y = -y; // Mirror vertically about baseline (y=0)
                y += cfg.m_PDFStrokeFontYOffset * aUnitsPerEm;
            }
 
            if( firstPoint )
            {
                fmt::format_to( std::back_inserter( buffer ), "{:.3f} {:.3f} m ", x, y );
                firstPoint = false;
            }
            else
            {
                fmt::format_to( std::back_inserter( buffer ), "{:.3f} {:.3f} l ", x, y );
            }
        }
 
        if( !stroke.empty() )
            fmt::format_to( std::back_inserter( buffer ), "S " );
    }
 
    return std::string( buffer.data(), buffer.size() );
}
 
static std::string formatUnicodeHex( uint32_t aCodepoint )
{
    if( aCodepoint <= 0xFFFF )
        return fmt::format( "{:04X}", aCodepoint );
 
    if( aCodepoint <= 0x10FFFF )
    {
        uint32_t value = aCodepoint - 0x10000;
        uint16_t high = 0xD800 + ( value >> 10 );
        uint16_t low = 0xDC00 + ( value & 0x3FF );
        return fmt::format( "{:04X}{:04X}", high, low );
    }
 
    return std::string( "003F" );
}
} // anonymous namespace
 
 
PDF_STROKE_FONT_SUBSET::PDF_STROKE_FONT_SUBSET( const KIFONT::STROKE_FONT* aFont, double aUnitsPerEm,
                                                unsigned aSubsetIndex, bool aBold, bool aItalic ) :
        m_font( aFont ),
        m_unitsPerEm( aUnitsPerEm ),
        m_resourceName( fmt::format( "/KiCadStroke{}", aSubsetIndex ) ),
        m_cmapName( fmt::format( "KiCadStrokeCMap{}", aSubsetIndex ) ),
        m_widths( MAX_SIMPLE_FONT_CODES, 0.0 ),
        m_nextCode( 1 ),
        m_lastCode( 0 ),
        m_bboxMinX( std::numeric_limits<double>::max() ),
        m_bboxMinY( std::numeric_limits<double>::max() ),
        m_bboxMaxX( std::numeric_limits<double>::lowest() ),
        m_bboxMaxY( std::numeric_limits<double>::lowest() ),
        m_charProcsHandle( -1 ),
        m_fontHandle( -1 ),
        m_toUnicodeHandle( -1 ),
        m_isBold( aBold ),
        m_isItalic( aItalic )
{
    GLYPH notdef;
    notdef.m_unicode = 0;
    notdef.m_code = 0;
    notdef.m_glyphIndex = -1;
    notdef.m_name = ".notdef";
    notdef.m_stream.clear();
    notdef.m_width = 0.0;
    notdef.m_minX = 0.0;
    notdef.m_minY = 0.0;
    notdef.m_maxX = 0.0;
    notdef.m_maxY = 0.0;
    notdef.m_charProcHandle = -1;
 
    m_glyphs.push_back( notdef );
    m_bboxMinX = 0.0;
    m_bboxMinY = 0.0;
    m_bboxMaxX = 0.0;
    m_bboxMaxY = 0.0;
}
 
 
bool PDF_STROKE_FONT_SUBSET::Contains( wxUniChar aCode ) const
{
    return m_unicodeToCode.find( aCode ) != m_unicodeToCode.end();
}
 
 
int PDF_STROKE_FONT_SUBSET::EnsureGlyph( wxUniChar aCode )
{
    auto it = m_unicodeToCode.find( aCode );
 
    if( it != m_unicodeToCode.end() )
        return it->second;
 
    if( IsFull() )
        return -1;
 
    int glyphIndex = glyphIndexForUnicode( aCode );
 
    int code = m_nextCode++;
    m_lastCode = std::max( m_lastCode, code );
 
    GLYPH data;
    data.m_unicode = aCode;
    data.m_code = code;
    data.m_glyphIndex = glyphIndex;
    data.m_name = makeGlyphName( code );
    data.m_charProcHandle = -1;
 
    const KIFONT::STROKE_GLYPH* glyph = nullptr;
    BOX2D bbox;
 
    if( m_font )
    {
        glyph = m_font->GetGlyph( glyphIndex );
        bbox = m_font->GetGlyphBoundingBox( glyphIndex );
    }
 
    VECTOR2D origin = bbox.GetOrigin();
    VECTOR2D size = bbox.GetSize();
 
    data.m_width = size.x * m_unitsPerEm;
    data.m_minX = origin.x * m_unitsPerEm;
    data.m_minY = origin.y * m_unitsPerEm;
    data.m_maxX = ( origin.x + size.x ) * m_unitsPerEm;
    data.m_maxY = ( origin.y + size.y ) * m_unitsPerEm;
 
    // Invert Y so glyphs render upright in PDF coordinate space.
    bool invertY = true;
 
    if( invertY )
    {
        // Mirror bounding box vertically about baseline.
        double newMinY = -data.m_maxY;
        double newMaxY = -data.m_minY;
        data.m_minY = newMinY;
        data.m_maxY = newMaxY;
 
        // Apply Y offset to bounding box to match the offset applied to stroke coordinates
        double yOffset = ADVANCED_CFG::GetCfg().m_PDFStrokeFontYOffset * m_unitsPerEm;
        data.m_minY += yOffset;
        data.m_maxY += yOffset;
    }
 
    // Apply X offset to bounding box to match the offset applied to stroke coordinates
    double xOffset = ADVANCED_CFG::GetCfg().m_PDFStrokeFontXOffset * m_unitsPerEm;
    data.m_minX += xOffset;
    data.m_maxX += xOffset;
 
    // Expand bbox by half the stroke width so the d1 clipping rect covers the full painted
    // area, not just the stroke center lines.
    double widthFactor = ADVANCED_CFG::GetCfg().m_PDFStrokeFontWidthFactor;
 
    if( m_isBold )
    {
        double boldMul = ADVANCED_CFG::GetCfg().m_PDFStrokeFontBoldMultiplier;
 
        if( boldMul < 1.0 )
            boldMul = 1.0;
 
        widthFactor *= boldMul;
    }
 
    if( widthFactor <= 0.0 )
        widthFactor = 0.04;
 
    double halfStroke = m_unitsPerEm * widthFactor / 2.0;
    data.m_minX -= halfStroke;
    data.m_minY -= halfStroke;
    data.m_maxX += halfStroke;
    data.m_maxY += halfStroke;
 
    // Build charproc stream: first specify width and bbox (d1 operator) then stroke path.
    double kerningFactor = ADVANCED_CFG::GetCfg().m_PDFStrokeFontKerningFactor;
 
    if( kerningFactor <= 0.0 )
        kerningFactor = 1.0;
 
    std::string strokes = buildGlyphStream( glyph, m_unitsPerEm, invertY, m_isBold );
    data.m_width = size.x * m_unitsPerEm * kerningFactor;
    data.m_stream = fmt::format( "{:.3f} 0 {:.3f} {:.3f} {:.3f} {:.3f} d1 {}",
                                 data.m_width,
                                 data.m_minX, data.m_minY, data.m_maxX, data.m_maxY,
                                 strokes );
 
    m_widths[code] = data.m_width;
 
    m_bboxMinX = std::min( m_bboxMinX, data.m_minX );
    m_bboxMinY = std::min( m_bboxMinY, data.m_minY );
    m_bboxMaxX = std::max( m_bboxMaxX, data.m_maxX );
    m_bboxMaxY = std::max( m_bboxMaxY, data.m_maxY );
 
    m_glyphs.push_back( std::move( data ) );
    m_unicodeToCode.emplace( aCode, code );
 
    return code;
}
 
 
int PDF_STROKE_FONT_SUBSET::CodeForGlyph( wxUniChar aCode ) const
{
    auto it = m_unicodeToCode.find( aCode );
 
    if( it != m_unicodeToCode.end() )
        return it->second;
 
    return -1;
}
 
 
bool PDF_STROKE_FONT_SUBSET::IsFull() const
{
    return m_nextCode >= MAX_SIMPLE_FONT_CODES;
}
 
 
int PDF_STROKE_FONT_SUBSET::GlyphCount() const
{
    return static_cast<int>( m_glyphs.size() );
}
 
 
int PDF_STROKE_FONT_SUBSET::FirstChar() const
{
    return 0;
}
 
 
int PDF_STROKE_FONT_SUBSET::LastChar() const
{
    return std::max( 0, m_lastCode );
}
 
 
std::string PDF_STROKE_FONT_SUBSET::BuildDifferencesArray() const
{
    int first = FirstChar();
    int last = LastChar();
 
    fmt::memory_buffer buffer;
    fmt::format_to( std::back_inserter( buffer ), "[ {} ", first );
 
    for( int code = first; code <= last; ++code )
    {
        const GLYPH* glyph = glyphForCode( code );
 
        if( glyph )
        fmt::format_to( std::back_inserter( buffer ), "/{} ", glyph->m_name );
        else
        fmt::format_to( std::back_inserter( buffer ), "/.notdef " );
    }
 
    fmt::format_to( std::back_inserter( buffer ), "]" );
    return std::string( buffer.data(), buffer.size() );
}
 
 
std::string PDF_STROKE_FONT_SUBSET::BuildWidthsArray() const
{
    int first = FirstChar();
    int last = LastChar();
 
    fmt::memory_buffer buffer;
    fmt::format_to( std::back_inserter( buffer ), "[" );
 
    for( int code = first; code <= last; ++code )
        fmt::format_to( std::back_inserter( buffer ), " {:g}", m_widths[code] );
 
    fmt::format_to( std::back_inserter( buffer ), " ]" );
    return std::string( buffer.data(), buffer.size() );
}
 
 
std::string PDF_STROKE_FONT_SUBSET::BuildToUnicodeCMap() const
{
    size_t mappingCount = 0;
 
    for( const GLYPH& glyph : m_glyphs )
    {
        if( glyph.m_code == 0 )
            continue;
 
        ++mappingCount;
    }
 
    fmt::memory_buffer buffer;
 
    fmt::format_to( std::back_inserter( buffer ), "/CIDInit /ProcSet findresource begin\n" );
    fmt::format_to( std::back_inserter( buffer ), "12 dict begin\n" );
    fmt::format_to( std::back_inserter( buffer ), "begincmap\n" );
    fmt::format_to( std::back_inserter( buffer ), "/CIDSystemInfo << /Registry (KiCad) /Ordering (StrokeFont) /Supplement 0 >> def\n" );
    fmt::format_to( std::back_inserter( buffer ), "/CMapName /{} def\n", m_cmapName );
    fmt::format_to( std::back_inserter( buffer ), "/CMapType 2 def\n" );
    fmt::format_to( std::back_inserter( buffer ), "1 begincodespacerange\n" );
    fmt::format_to( std::back_inserter( buffer ), "<00> <FF>\n" );
    fmt::format_to( std::back_inserter( buffer ), "endcodespacerange\n" );
 
    fmt::format_to( std::back_inserter( buffer ), "{} beginbfchar\n", mappingCount );
 
    for( const GLYPH& glyph : m_glyphs )
    {
        if( glyph.m_code == 0 )
            continue;
 
        fmt::format_to( std::back_inserter( buffer ), "<{:02X}> <{}>\n", glyph.m_code,
                        formatUnicodeHex( static_cast<uint32_t>( glyph.m_unicode ) ) );
    }
 
    fmt::format_to( std::back_inserter( buffer ), "endbfchar\n" );
    fmt::format_to( std::back_inserter( buffer ), "endcmap\n" );
    fmt::format_to( std::back_inserter( buffer ), "CMapName currentdict /CMap defineresource pop\n" );
    fmt::format_to( std::back_inserter( buffer ), "end\n" );
    fmt::format_to( std::back_inserter( buffer ), "end\n" );
 
    return std::string( buffer.data(), buffer.size() );
}
 
 
int PDF_STROKE_FONT_SUBSET::glyphIndexForUnicode( wxUniChar aCode ) const
{
    int value = static_cast<int>( aCode );
 
    if( value < ' ' )
        return static_cast<int>( '?' ) - ' ';
 
    int index = value - ' ';
    int count = static_cast<int>( m_font ? m_font->GetGlyphCount() : 0 );
 
    if( index < 0 || index >= count )
        return static_cast<int>( '?' ) - ' ';
 
    return index;
}
 
 
std::string PDF_STROKE_FONT_SUBSET::makeGlyphName( int aCode ) const
{
    return fmt::format( "g{:02X}", aCode );
}
 
 
const PDF_STROKE_FONT_SUBSET::GLYPH* PDF_STROKE_FONT_SUBSET::glyphForCode( int aCode ) const
{
    for( const GLYPH& glyph : m_glyphs )
    {
        if( glyph.m_code == aCode )
            return &glyph;
    }
 
    return nullptr;
}
 
 
PDF_STROKE_FONT_MANAGER::PDF_STROKE_FONT_MANAGER() :
        m_font( KIFONT::STROKE_FONT::LoadFont( wxEmptyString ) ),
        m_unitsPerEm( 1000.0 ),
        m_nextSubsetIndex( 0 )
{
    Reset();
}
 
 
void PDF_STROKE_FONT_MANAGER::Reset()
{
    m_styleGroups.clear();
    m_nextSubsetIndex = 0;
 
    if( !m_font )
        m_font.reset( KIFONT::STROKE_FONT::LoadFont( wxEmptyString ) );
}
 
 
PDF_STROKE_FONT_MANAGER::STYLE_GROUP& PDF_STROKE_FONT_MANAGER::groupFor( bool aBold, bool aItalic )
{
    unsigned key = styleKey( aBold, aItalic );
    return m_styleGroups[key];
}
 
void PDF_STROKE_FONT_MANAGER::EncodeString( const wxString& aText,
                                            std::vector<PDF_STROKE_FONT_RUN>* aRuns,
                                            bool aBold, bool aItalic )
{
    if( !aRuns )
        return;
 
    aRuns->clear();
 
    if( aText.empty() )
        return;
 
    PDF_STROKE_FONT_SUBSET* currentSubset = nullptr;
    std::string currentBytes;
 
    for( wxUniChar ch : aText )
    {
        PDF_STROKE_FONT_SUBSET* subset = ensureSubsetForGlyph( ch, aBold, aItalic );
 
        if( !subset )
            continue;
 
        int code = subset->EnsureGlyph( ch );
 
        if( code < 0 )
            continue;
 
        if( subset != currentSubset )
        {
            if( !currentBytes.empty() && currentSubset )
                aRuns->push_back( { currentSubset, currentBytes, aBold, aItalic } );
 
            currentSubset = subset;
            currentBytes.clear();
        }
 
        currentBytes.push_back( static_cast<char>( code ) );
    }
 
    if( !currentBytes.empty() && currentSubset )
        aRuns->push_back( { currentSubset, std::move( currentBytes ), aBold, aItalic } );
}
 
PDF_STROKE_FONT_SUBSET* PDF_STROKE_FONT_MANAGER::ensureSubsetForGlyph( wxUniChar aCode, bool aBold, bool aItalic )
{
    STYLE_GROUP& group = groupFor( aBold, aItalic );
 
    for( const std::unique_ptr<PDF_STROKE_FONT_SUBSET>& subset : group.subsets )
    {
        if( subset->Contains( aCode ) )
            return subset.get();
    }
 
    for( const std::unique_ptr<PDF_STROKE_FONT_SUBSET>& subset : group.subsets )
    {
        if( subset->IsFull() )
            continue;
 
        if( subset->EnsureGlyph( aCode ) >= 0 )
            return subset.get();
    }
 
    unsigned subsetIndex = m_nextSubsetIndex++;
    auto newSubset = std::make_unique<PDF_STROKE_FONT_SUBSET>( m_font.get(), m_unitsPerEm, subsetIndex, aBold, aItalic );
    PDF_STROKE_FONT_SUBSET* subsetPtr = newSubset.get();
    subsetPtr->EnsureGlyph( aCode );
    group.subsets.emplace_back( std::move( newSubset ) );
    return subsetPtr;
}
 
std::vector<PDF_STROKE_FONT_SUBSET*> PDF_STROKE_FONT_MANAGER::AllSubsets() const
{
    std::vector<PDF_STROKE_FONT_SUBSET*> out;
 
    for( const auto& [key, group] : m_styleGroups )
    {
        (void) key;
        for( const auto& up : group.subsets )
            out.push_back( up.get() );
    }
    return out;
}