PDF_plotter.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 1992-2012 Lorenzo Marcantonio, [email protected]
 * 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, 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
 */
 
#include <algorithm>
#include <iterator>
#include <cstdio> // snprintf
#include <stack>
#include <ranges>
 
#include <wx/filename.h>
#include <wx/mstream.h>
#include <wx/zstream.h>
#include <wx/wfstream.h>
#include <wx/datstrm.h>
#include <wx/tokenzr.h>
 
#include <advanced_config.h>
#include <common.h>               // ResolveUriByEnvVars
#include <eda_text.h>             // for IsGotoPageHref
#include <font/font.h>
#include <core/ignore.h>
#include <macros.h>
#include <trace_helpers.h>
#include <trigo.h>
#include <string_utils.h>
#include <core/utf8.h>
#include <markup_parser.h>
#include <fmt/format.h>
#include <fmt/chrono.h>
#include <fmt/ranges.h>
 
#include <plotters/pdf_stroke_font.h>
#include <plotters/pdf_outline_font.h>
#include <plotters/plotters_pslike.h>
#include <geometry/shape_rect.h>
#include <text_eval/text_eval_wrapper.h>
 
 
PDF_PLOTTER::~PDF_PLOTTER() = default;
 
#define GLM_ENABLE_EXPERIMENTAL //for older glm to enable euler angles
#include <glm/glm.hpp>
#include <glm/gtx/euler_angles.hpp>
 
std::string PDF_PLOTTER::encodeStringForPlotter( const wxString& aText )
{
    // returns a string compatible with PDF string convention from a unicode string.
    // if the initial text is only ASCII7, return the text between ( and ) for a good readability
    // if the initial text is no ASCII7, return the text between < and >
    // and encoded using 16 bits hexa (4 digits) by wide char (unicode 16)
    std::string result;
 
    // Is aText only ASCII7 ?
    bool is_ascii7 = true;
 
    for( size_t ii = 0; ii < aText.Len(); ii++ )
    {
        if( aText[ii] >= 0x7F )
        {
            is_ascii7 = false;
            break;
        }
    }
 
    if( is_ascii7 )
    {
        result = '(';
 
        for( unsigned ii = 0; ii < aText.Len(); ii++ )
        {
            unsigned int code = aText[ii];
 
            // These characters must be escaped
            switch( code )
            {
            case '(':
            case ')':
            case '\\':
                result += '\\';
                KI_FALLTHROUGH;
 
            default:
                result += code;
                break;
            }
        }
 
        result += ')';
    }
    else
    {
        result = "<FEFF";
 
        for( size_t ii = 0; ii < aText.Len(); ii++ )
        {
            unsigned int code = aText[ii];
            result += fmt::format("{:04X}", code);
        }
 
        result += '>';
    }
 
    return result;
}
 
 
std::string PDF_PLOTTER::encodeDoubleForPlotter( double aValue ) const
{
    std::string buf = fmt::format( "{:g}", aValue );
 
    // PDF syntax does not allow exponent notation (PostScript does). fmt's {:g} can emit it and
    // can't be configured to force non-exponent output, so fall back to fixed when needed.
    if( buf.find( 'e' ) != std::string::npos || buf.find( 'E' ) != std::string::npos )
        buf = fmt::format( "{:.10f}", aValue );
 
    if( buf.find( '.' ) != std::string::npos )
    {
        // Trim trailing zeros from fixed output while keeping at least one digit.
        while( buf.size() > 1 && buf.back() == '0' )
            buf.pop_back();
 
        // Remove a dangling decimal point if we stripped all fractional digits.
        if( !buf.empty() && buf.back() == '.' )
            buf.pop_back();
    }
 
    // Avoid emitting "-0" for tiny negative values that round to zero.
    if( buf == "-0" )
        buf = "0";
 
    return buf;
}
 
 
std::string PDF_PLOTTER::encodeByteString( const std::string& aBytes )
{
    std::string result;
    result.reserve( aBytes.size() * 4 + 2 );
    result.push_back( '(' );
 
    for( unsigned char byte : aBytes )
    {
        if( byte == '(' || byte == ')' || byte == '\\' )
        {
            result.push_back( '\\' );
            result.push_back( static_cast<char>( byte ) );
        }
        else if( byte < 32 || byte > 126 )
        {
            fmt::format_to( std::back_inserter( result ), "\\{:03o}", byte );
        }
        else
        {
            result.push_back( static_cast<char>( byte ) );
        }
    }
 
    result.push_back( ')' );
    return result;
}
 
 
bool PDF_PLOTTER::OpenFile( const wxString& aFullFilename )
{
    m_filename = aFullFilename;
 
    wxASSERT( !m_outputFile );
 
    // Open the PDF file in binary mode
    m_outputFile = wxFopen( m_filename, wxT( "wb" ) );
 
    if( m_outputFile == nullptr )
        return false ;
 
    return true;
}
 
 
void PDF_PLOTTER::SetViewport( const VECTOR2I& aOffset, double aIusPerDecimil,
                               double aScale, bool aMirror )
{
    m_plotMirror    = aMirror;
    m_plotOffset    = aOffset;
    m_plotScale     = aScale;
    m_IUsPerDecimil = aIusPerDecimil;
 
    // The CTM is set to 1 user unit per decimal
    m_iuPerDeviceUnit = 1.0 / aIusPerDecimil;
 
    /* The paper size in this engine is handled page by page
       Look in the StartPage function */
}
 
 
void PDF_PLOTTER::SetCurrentLineWidth( int aWidth, void* aData )
{
    wxASSERT( m_workFile );
 
    if( aWidth == DO_NOT_SET_LINE_WIDTH )
        return;
    else if( aWidth == USE_DEFAULT_LINE_WIDTH )
        aWidth = m_renderSettings->GetDefaultPenWidth();
 
    if( aWidth == 0 )
        aWidth = 1;
 
    wxASSERT_MSG( aWidth > 0, "Plotter called to set negative pen width" );
 
    if( aWidth != m_currentPenWidth )
        fmt::println( m_workFile, "{} w", encodeDoubleForPlotter( userToDeviceSize( aWidth ) ) );
 
    m_currentPenWidth = aWidth;
}
 
 
void PDF_PLOTTER::emitSetRGBColor( double r, double g, double b, double a )
{
    wxASSERT( m_workFile );
 
    // PDF treats all colors as opaque, so the best we can do with alpha is generate an
    // appropriate blended color assuming white paper.
    if( a < 1.0 )
    {
        r = ( r * a ) + ( 1 - a );
        g = ( g * a ) + ( 1 - a );
        b = ( b * a ) + ( 1 - a );
    }
 
    fmt::println( m_workFile, "{} {} {} rg {} {} {} RG",
                  encodeDoubleForPlotter( r ), encodeDoubleForPlotter( g ), encodeDoubleForPlotter( b ),
                  encodeDoubleForPlotter( r ), encodeDoubleForPlotter( g ), encodeDoubleForPlotter( b ) );
}
 
 
void PDF_PLOTTER::SetDash( int aLineWidth, LINE_STYLE aLineStyle )
{
    wxASSERT( m_workFile );
 
    switch( aLineStyle )
    {
    case LINE_STYLE::DASH:
        fmt::println( m_workFile, "[{} {}] 0 d",
                      (int) GetDashMarkLenIU( aLineWidth ),
                      (int) GetDashGapLenIU( aLineWidth ) );
        break;
 
    case LINE_STYLE::DOT:
        fmt::println( m_workFile, "[{} {}] 0 d",
                      (int) GetDotMarkLenIU( aLineWidth ),
                      (int) GetDashGapLenIU( aLineWidth ) );
        break;
 
    case LINE_STYLE::DASHDOT:
        fmt::println( m_workFile, "[{} {} {} {}] 0 d",
                      (int) GetDashMarkLenIU( aLineWidth ),
                      (int) GetDashGapLenIU( aLineWidth ),
                      (int) GetDotMarkLenIU( aLineWidth ),
                      (int) GetDashGapLenIU( aLineWidth ) );
        break;
 
    case LINE_STYLE::DASHDOTDOT:
        fmt::println( m_workFile, "[{} {} {} {} {} {}] 0 d",
                      (int) GetDashMarkLenIU( aLineWidth ),
                      (int) GetDashGapLenIU( aLineWidth ),
                      (int) GetDotMarkLenIU( aLineWidth ),
                      (int) GetDashGapLenIU( aLineWidth ),
                      (int) GetDotMarkLenIU( aLineWidth ),
                      (int) GetDashGapLenIU( aLineWidth ) );
        break;
 
    default:
        fmt::println( m_workFile, "[] 0 d\n" );
    }
}
 
 
void PDF_PLOTTER::Rect( const VECTOR2I& p1, const VECTOR2I& p2, FILL_T fill, int width,
                        int aCornerRadius )
{
    wxASSERT( m_workFile );
 
    if( fill == FILL_T::NO_FILL && width == 0 )
        return;
 
    SetCurrentLineWidth( width );
 
    if( aCornerRadius > 0 )
    {
        BOX2I box( p1, VECTOR2I( p2.x - p1.x, p2.y - p1.y ) );
        box.Normalize();
        SHAPE_RECT rect( box );
        rect.SetRadius( aCornerRadius );
        PlotPoly( rect.Outline(), fill, width, nullptr );
        return;
    }
 
    VECTOR2I size = p2 - p1;
 
    if( size.x == 0 && size.y == 0 )
    {
        // Can't draw zero-sized rectangles
        MoveTo( VECTOR2I( p1.x, p1.y ) );
        FinishTo( VECTOR2I( p1.x, p1.y ) );
 
        return;
    }
 
    if( std::min( std::abs( size.x ), std::abs( size.y ) ) < width )
    {
        // Too thick stroked rectangles are buggy, draw as polygon
        std::vector<VECTOR2I> cornerList;
 
        cornerList.emplace_back( p1.x, p1.y );
        cornerList.emplace_back( p2.x, p1.y );
        cornerList.emplace_back( p2.x, p2.y );
        cornerList.emplace_back( p1.x, p2.y );
        cornerList.emplace_back( p1.x, p1.y );
 
        PlotPoly( cornerList, fill, width, nullptr );
 
        return;
    }
 
    VECTOR2D p1_dev = userToDeviceCoordinates( p1 );
    VECTOR2D p2_dev = userToDeviceCoordinates( p2 );
 
    char paintOp;
 
    if( fill == FILL_T::NO_FILL )
        paintOp = 'S';
    else
        paintOp = width > 0 ? 'B' : 'f';
 
    fmt::println( m_workFile, "{} {} {} {} re {}",
                  encodeDoubleForPlotter( p1_dev.x ),
                  encodeDoubleForPlotter( p1_dev.y ),
                  encodeDoubleForPlotter( p2_dev.x - p1_dev.x ),
                  encodeDoubleForPlotter( p2_dev.y - p1_dev.y ),
                  paintOp );
}
 
 
void PDF_PLOTTER::Circle( const VECTOR2I& pos, int diametre, FILL_T aFill, int width )
{
    wxASSERT( m_workFile );
 
    if( aFill == FILL_T::NO_FILL && width == 0 )
        return;
 
    SetCurrentLineWidth( width );
 
    VECTOR2D pos_dev = userToDeviceCoordinates( pos );
    double   radius = userToDeviceSize( diametre / 2.0 );
 
    // If diameter is less than width, switch to filled mode
    if( aFill == FILL_T::NO_FILL && diametre < GetCurrentLineWidth() )
    {
        aFill = FILL_T::FILLED_SHAPE;
        radius = userToDeviceSize( ( diametre / 2.0 ) + ( width / 2.0 ) );
    }
 
    /* OK. Here's a trick. PDF doesn't support circles or circular angles, that's
       a fact. You'll have to do with cubic beziers. These *can't* represent
       circular arcs (NURBS can, beziers don't). But there is a widely known
       approximation which is really good
    */
 
    double magic = radius * 0.551784; // You don't want to know where this come from
 
    // This is the convex hull for the bezier approximated circle
    fmt::println( m_workFile,
                  "{} {} m "
                  "{} {} {} {} {} {} c "
                  "{} {} {} {} {} {} c "
                  "{} {} {} {} {} {} c "
                  "{} {} {} {} {} {} c {}",
                  encodeDoubleForPlotter( pos_dev.x - radius ), encodeDoubleForPlotter( pos_dev.y ),
 
                  encodeDoubleForPlotter( pos_dev.x - radius ), encodeDoubleForPlotter( pos_dev.y + magic ),
                  encodeDoubleForPlotter( pos_dev.x - magic ), encodeDoubleForPlotter( pos_dev.y + radius ),
                  encodeDoubleForPlotter( pos_dev.x ), encodeDoubleForPlotter( pos_dev.y + radius ),
 
                  encodeDoubleForPlotter( pos_dev.x + magic ), encodeDoubleForPlotter( pos_dev.y + radius ),
                  encodeDoubleForPlotter( pos_dev.x + radius ), encodeDoubleForPlotter( pos_dev.y + magic ),
                  encodeDoubleForPlotter( pos_dev.x + radius ), encodeDoubleForPlotter( pos_dev.y ),
 
                  encodeDoubleForPlotter( pos_dev.x + radius ), encodeDoubleForPlotter( pos_dev.y - magic ),
                  encodeDoubleForPlotter( pos_dev.x + magic ), encodeDoubleForPlotter( pos_dev.y - radius ),
                  encodeDoubleForPlotter( pos_dev.x ), encodeDoubleForPlotter( pos_dev.y - radius ),
 
                  encodeDoubleForPlotter( pos_dev.x - magic ), encodeDoubleForPlotter( pos_dev.y - radius ),
                  encodeDoubleForPlotter( pos_dev.x - radius ), encodeDoubleForPlotter( pos_dev.y - magic ),
                  encodeDoubleForPlotter( pos_dev.x - radius ), encodeDoubleForPlotter( pos_dev.y ),
 
                  aFill == FILL_T::NO_FILL ? 's' : 'b' );
}
 
 
std::vector<VECTOR2D> PDF_PLOTTER::arcPath( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
                                            const EDA_ANGLE& aAngle, double aRadius )
{
    std::vector<VECTOR2D> path;
 
    /*
     * Arcs are not so easily approximated by beziers (in the general case), so we approximate
     * them in the old way
     */
    EDA_ANGLE       startAngle = -aStartAngle;
    EDA_ANGLE       endAngle = startAngle - aAngle;
    VECTOR2I        start;
    VECTOR2I        end;
    const EDA_ANGLE delta( 5, DEGREES_T );   // increment to draw circles
 
    if( startAngle > endAngle )
        std::swap( startAngle, endAngle );
 
    // Usual trig arc plotting routine...
    start.x = KiROUND( aCenter.x + aRadius * ( -startAngle ).Cos() );
    start.y = KiROUND( aCenter.y + aRadius * ( -startAngle ).Sin() );
    path.emplace_back( userToDeviceCoordinates( start ) );
 
    for( EDA_ANGLE ii = startAngle + delta; ii < endAngle; ii += delta )
    {
        end.x = KiROUND( aCenter.x + aRadius * ( -ii ).Cos() );
        end.y = KiROUND( aCenter.y + aRadius * ( -ii ).Sin() );
        path.emplace_back( userToDeviceCoordinates( end ) );
    }
 
    end.x = KiROUND( aCenter.x + aRadius * ( -endAngle ).Cos() );
    end.y = KiROUND( aCenter.y + aRadius * ( -endAngle ).Sin() );
    path.emplace_back( userToDeviceCoordinates( end ) );
 
    return path;
}
 
 
void PDF_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
                       const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth )
{
    wxASSERT( m_workFile );
 
    SetCurrentLineWidth( aWidth );
 
    if( aRadius <= 0 )
    {
        Circle( aCenter, GetCurrentLineWidth(), FILL_T::FILLED_SHAPE, 0 );
        return;
    }
 
    std::vector<VECTOR2D> path = arcPath( aCenter, aStartAngle, aAngle, aRadius );
 
    if( path.size() >= 2 )
    {
        fmt::print( m_workFile, "{} {} m ",
                    encodeDoubleForPlotter( path[0].x ), encodeDoubleForPlotter( path[0].y ) );
 
        for( int ii = 1; ii < (int) path.size(); ++ii )
            fmt::print( m_workFile, "{} {} l ",
                        encodeDoubleForPlotter( path[ii].x ), encodeDoubleForPlotter( path[ii].y ) );
    }
 
    // The arc is drawn... if not filled we stroke it, otherwise we finish
    // closing the pie at the center
    if( aFill == FILL_T::NO_FILL )
    {
        fmt::println( m_workFile, "S" );
    }
    else
    {
        VECTOR2D pos_dev = userToDeviceCoordinates( aCenter );
        fmt::println( m_workFile, "{} {} l b",
                      encodeDoubleForPlotter( pos_dev.x ), encodeDoubleForPlotter( pos_dev.y ) );
    }
}
 
 
void PDF_PLOTTER::PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill, int aWidth,
                            void* aData )
{
    wxASSERT( m_workFile );
 
    if( aCornerList.size() <= 1 )
        return;
 
    if( aFill == FILL_T::NO_FILL && aWidth == 0 )
        return;
 
    SetCurrentLineWidth( aWidth );
 
    VECTOR2D pos = userToDeviceCoordinates( aCornerList[0] );
    fmt::print( m_workFile, "{:f} {:f} m ", pos.x, pos.y );
 
    for( unsigned ii = 1; ii < aCornerList.size(); ii++ )
    {
        pos = userToDeviceCoordinates( aCornerList[ii] );
        fmt::print( m_workFile, "{:f} {:f} l ", pos.x, pos.y );
    }
 
    // Close path and stroke and/or fill
    if( aFill == FILL_T::NO_FILL )
        fmt::println( m_workFile, "S" );
    else if( aWidth == 0 )
        fmt::println( m_workFile, "h f" );
    else
        fmt::println( m_workFile, "b" );
}
 
 
void PDF_PLOTTER::PlotPoly( const SHAPE_LINE_CHAIN& aLineChain, FILL_T aFill, int aWidth, void* aData )
{
    SetCurrentLineWidth( aWidth );
 
    std::set<size_t>      handledArcs;
    std::vector<VECTOR2D> path;
 
    for( int ii = 0; ii < aLineChain.SegmentCount(); ++ii )
    {
        if( aLineChain.IsArcSegment( ii ) )
        {
            size_t arcIndex = aLineChain.ArcIndex( ii );
 
            if( !handledArcs.contains( arcIndex ) )
            {
                handledArcs.insert( arcIndex );
                const SHAPE_ARC& arc( aLineChain.Arc( arcIndex ) );
                std::vector<VECTOR2D> arc_path = arcPath( arc.GetCenter(), arc.GetStartAngle(),
                                                          arc.GetCentralAngle(), arc.GetRadius() );
 
                for( const VECTOR2D& pt : std::ranges::reverse_view( arc_path ) )
                    path.emplace_back( pt );
            }
        }
        else
        {
            const SEG& seg( aLineChain.Segment( ii ) );
            path.emplace_back( userToDeviceCoordinates( seg.A ) );
            path.emplace_back( userToDeviceCoordinates( seg.B ) );
        }
    }
 
    if( path.size() <= 1 )
        return;
 
    fmt::print( m_workFile, "{} {} m ",
                encodeDoubleForPlotter( path[0].x ), encodeDoubleForPlotter( path[0].y ) );
 
    for( int ii = 1; ii < (int) path.size(); ++ii )
        fmt::print( m_workFile, "{} {} l ",
                    encodeDoubleForPlotter( path[ii].x ), encodeDoubleForPlotter( path[ii].y ) );
 
    // Close path and stroke and/or fill
    if( aFill == FILL_T::NO_FILL )
        fmt::println( m_workFile, "S" );
    else if( aWidth == 0 )
        fmt::println( m_workFile, "h f" );
    else
        fmt::println( m_workFile, "b" );
}
 
 
void PDF_PLOTTER::PenTo( const VECTOR2I& pos, char plume )
{
    wxASSERT( m_workFile );
 
    if( plume == 'Z' )
    {
        if( m_penState != 'Z' )
        {
            fmt::println( m_workFile, "S" );
            m_penState     = 'Z';
            m_penLastpos.x = -1;
            m_penLastpos.y = -1;
        }
 
        return;
    }
 
    if( m_penState != plume || pos != m_penLastpos )
    {
        VECTOR2D pos_dev = userToDeviceCoordinates( pos );
        fmt::println( m_workFile, "{:f} {:f} {}",
                      pos_dev.x,
                      pos_dev.y,
                      plume == 'D' ? 'l' : 'm' );
    }
 
    m_penState   = plume;
    m_penLastpos = pos;
}
 
 
void PDF_PLOTTER::PlotImage( const wxImage& aImage, const VECTOR2I& aPos, double aScaleFactor )
{
    wxASSERT( m_workFile );
    VECTOR2I pix_size( aImage.GetWidth(), aImage.GetHeight() );
 
    // Requested size (in IUs)
    VECTOR2D drawsize( aScaleFactor * pix_size.x, aScaleFactor * pix_size.y );
 
    // calculate the bitmap start position
    VECTOR2I start( aPos.x - drawsize.x / 2, aPos.y + drawsize.y / 2 );
    VECTOR2D dev_start = userToDeviceCoordinates( start );
 
    // Deduplicate images
    auto findHandleForImage =
            [&]( const wxImage& aCurrImage ) -> int
            {
                for( const auto& [imgHandle, image] : m_imageHandles )
                {
                    if( image.IsSameAs( aCurrImage ) )
                        return imgHandle;
 
                    if( image.GetWidth() != aCurrImage.GetWidth() )
                        continue;
 
                    if( image.GetHeight() != aCurrImage.GetHeight() )
                        continue;
 
                    if( image.GetType() != aCurrImage.GetType() )
                        continue;
 
                    if( image.HasAlpha() != aCurrImage.HasAlpha() )
                        continue;
 
                    if( image.HasMask() != aCurrImage.HasMask()
                      || image.GetMaskRed() != aCurrImage.GetMaskRed()
                      || image.GetMaskGreen() != aCurrImage.GetMaskGreen()
                      || image.GetMaskBlue() != aCurrImage.GetMaskBlue() )
                        continue;
 
                    int pixCount = image.GetWidth() * image.GetHeight();
 
                    if( memcmp( image.GetData(), aCurrImage.GetData(), pixCount * 3 ) != 0 )
                        continue;
 
                    if( image.HasAlpha() && memcmp( image.GetAlpha(), aCurrImage.GetAlpha(), pixCount ) != 0 )
                        continue;
 
                    return imgHandle;
                }
 
                return -1;
            };
 
    int imgHandle = findHandleForImage( aImage );
 
    if( imgHandle == -1 )
    {
        imgHandle = allocPdfObject();
        m_imageHandles.emplace( imgHandle, aImage );
    }
 
    /* PDF has an uhm... simplified coordinate system handling. There is
       *one* operator to do everything (the PS concat equivalent). At least
       they kept the matrix stack to save restore environments. Also images
       are always emitted at the origin with a size of 1x1 user units.
       What we need to do is:
       1) save the CTM end establish the new one
       2) plot the image
       3) restore the CTM
       4) profit
     */
    fmt::println( m_workFile, "q {} 0 0 {} {} {} cm", // Step 1
                  encodeDoubleForPlotter( userToDeviceSize( drawsize.x ) ),
                  encodeDoubleForPlotter( userToDeviceSize( drawsize.y ) ),
                  encodeDoubleForPlotter( dev_start.x ),
                  encodeDoubleForPlotter( dev_start.y ) );
 
    fmt::println( m_workFile, "/Im{} Do", imgHandle );
    fmt::println( m_workFile, "Q" );
}
 
 
int PDF_PLOTTER::allocPdfObject()
{
    m_xrefTable.push_back( 0 );
    return m_xrefTable.size() - 1;
}
 
 
int PDF_PLOTTER::startPdfObject( int aHandle )
{
    wxASSERT( m_outputFile );
    wxASSERT( !m_workFile );
 
    if( aHandle < 0 )
        aHandle = allocPdfObject();
 
    m_xrefTable[aHandle] = ftell( m_outputFile );
    fmt::println( m_outputFile, "{} 0 obj", aHandle );
    return aHandle;
}
 
 
void PDF_PLOTTER::closePdfObject()
{
    wxASSERT( m_outputFile );
    wxASSERT( !m_workFile );
    fmt::println( m_outputFile, "endobj" );
}
 
 
int PDF_PLOTTER::startPdfStream( int aHandle )
{
    wxASSERT( m_outputFile );
    wxASSERT( !m_workFile );
    int handle = startPdfObject( aHandle );
 
    // This is guaranteed to be handle+1 but needs to be allocated since
    // you could allocate more object during stream preparation
    m_streamLengthHandle = allocPdfObject();
 
    if( ADVANCED_CFG::GetCfg().m_DebugPDFWriter )
    {
        fmt::print( m_outputFile,
                     "<< /Length {} 0 R >>\nstream\n",
                     m_streamLengthHandle );
    }
    else
    {
        fmt::print( m_outputFile,
                     "<< /Length {} 0 R /Filter /FlateDecode >>\nstream\n",
                     m_streamLengthHandle );
    }
 
    // Open a temporary file to accumulate the stream
    m_workFilename = wxFileName::CreateTempFileName( "" );
    m_workFile = wxFopen( m_workFilename, wxT( "w+b" ) );
    wxASSERT( m_workFile );
    return handle;
}
 
 
void PDF_PLOTTER::closePdfStream()
{
    wxASSERT( m_workFile );
 
    long stream_len = ftell( m_workFile );
 
    if( stream_len < 0 )
    {
        wxASSERT( false );
        return;
    }
 
    // Rewind the file, read in the page stream and DEFLATE it
    fseek( m_workFile, 0, SEEK_SET );
    unsigned char *inbuf = new unsigned char[stream_len];
 
    int rc = fread( inbuf, 1, stream_len, m_workFile );
    wxASSERT( rc == stream_len );
    ignore_unused( rc );
 
    // We are done with the temporary file, junk it
    fclose( m_workFile );
    m_workFile = nullptr;
    ::wxRemoveFile( m_workFilename );
 
    unsigned out_count;
 
    if( ADVANCED_CFG::GetCfg().m_DebugPDFWriter )
    {
        out_count = stream_len;
        fwrite( inbuf, out_count, 1, m_outputFile );
    }
    else
    {
        // NULL means memos owns the memory, but provide a hint on optimum size needed.
        wxMemoryOutputStream    memos( nullptr, std::max( 2000l, stream_len ) ) ;
 
        {
            /* Somewhat standard parameters to compress in DEFLATE. The PDF spec is
             * misleading, it says it wants a DEFLATE stream but it really want a ZLIB
             * stream! (a DEFLATE stream would be generated with -15 instead of 15)
             * rc = deflateInit2( &zstrm, Z_BEST_COMPRESSION, Z_DEFLATED, 15,
             *                    8, Z_DEFAULT_STRATEGY );
             */
 
            wxZlibOutputStream      zos( memos, wxZ_BEST_COMPRESSION, wxZLIB_ZLIB );
 
            zos.Write( inbuf, stream_len );
        }   // flush the zip stream using zos destructor
 
        wxStreamBuffer* sb = memos.GetOutputStreamBuffer();
 
        out_count = sb->Tell();
        fwrite( sb->GetBufferStart(), 1, out_count, m_outputFile );
    }
 
    delete[] inbuf;
    fmt::print( m_outputFile, "\nendstream\n" );
    closePdfObject();
 
    // Writing the deferred length as an indirect object
    startPdfObject( m_streamLengthHandle );
    fmt::println( m_outputFile, "{}", out_count );
    closePdfObject();
}
 
 
void PDF_PLOTTER::StartPage( const wxString& aPageNumber, const wxString& aPageName,
                             const wxString& aParentPageNumber, const wxString& aParentPageName )
{
    wxASSERT( m_outputFile );
    wxASSERT( !m_workFile );
 
    m_pageNumbers.push_back( aPageNumber );
    m_pageName = aPageName.IsEmpty() ? wxString::Format( _( "Page %s" ),
                                                         aPageNumber )
                                     : wxString::Format( _( "%s (Page %s)" ),
                                                         aPageName,
                                                         aPageNumber );
    m_parentPageName = aParentPageName.IsEmpty() ? wxString::Format( _( "Page %s" ),
                                                                     aParentPageNumber )
                                                 : wxString::Format( _( "%s (Page %s)" ),
                                                                     aParentPageName,
                                                                     aParentPageNumber );
 
    // Compute the paper size in IUs
    m_paperSize = m_pageInfo.GetSizeMils();
    m_paperSize.x *= 10.0 / m_iuPerDeviceUnit;
    m_paperSize.y *= 10.0 / m_iuPerDeviceUnit;
 
    // Set m_currentPenWidth to a unused value to ensure the pen width
    // will be initialized to a the right value in pdf file by the first item to plot
    m_currentPenWidth = 0;
 
    if( !m_3dExportMode )
    {
        // Open the content stream; the page object will go later
        m_pageStreamHandle = startPdfStream();
 
        /* Now, until ClosePage *everything* must be wrote in workFile, to be
           compressed later in closePdfStream */
 
        // Default graphic settings (coordinate system, default color and line style)
        fmt::println( m_workFile,
                      "{} 0 0 {} 0 0 cm 1 J 1 j 0 0 0 rg 0 0 0 RG {} w",
                      encodeDoubleForPlotter( 0.0072 * plotScaleAdjX ),
                      encodeDoubleForPlotter( 0.0072 * plotScaleAdjY ),
                      encodeDoubleForPlotter( userToDeviceSize( m_renderSettings->GetDefaultPenWidth() ) ) );
    }
}
 
 
void WriteImageStream( const wxImage& aImage, wxDataOutputStream& aOut, wxColor bg, bool colorMode )
{
    int w = aImage.GetWidth();
    int h = aImage.GetHeight();
 
    for( int y = 0; y < h; y++ )
    {
        for( int x = 0; x < w; x++ )
        {
            unsigned char r = aImage.GetRed( x, y ) & 0xFF;
            unsigned char g = aImage.GetGreen( x, y ) & 0xFF;
            unsigned char b = aImage.GetBlue( x, y ) & 0xFF;
 
            if( aImage.HasMask() )
            {
                if( r == aImage.GetMaskRed() && g == aImage.GetMaskGreen()
                    && b == aImage.GetMaskBlue() )
                {
                    r = bg.Red();
                    g = bg.Green();
                    b = bg.Blue();
                }
            }
 
            if( colorMode )
            {
                aOut.Write8( r );
                aOut.Write8( g );
                aOut.Write8( b );
            }
            else
            {
                // Greyscale conversion (CIE 1931)
                unsigned char grey = KiROUND( r * 0.2126 + g * 0.7152 + b * 0.0722 );
 
                aOut.Write8( grey );
            }
        }
    }
}
 
 
void WriteImageSMaskStream( const wxImage& aImage, wxDataOutputStream& aOut )
{
    int w = aImage.GetWidth();
    int h = aImage.GetHeight();
 
    if( aImage.HasMask() )
    {
        for( int y = 0; y < h; y++ )
        {
            for( int x = 0; x < w; x++ )
            {
                unsigned char a = 255;
                unsigned char r = aImage.GetRed( x, y );
                unsigned char g = aImage.GetGreen( x, y );
                unsigned char b = aImage.GetBlue( x, y );
 
                if( r == aImage.GetMaskRed() && g == aImage.GetMaskGreen()
                    && b == aImage.GetMaskBlue() )
                {
                    a = 0;
                }
 
                aOut.Write8( a );
            }
        }
    }
    else if( aImage.HasAlpha() )
    {
        int size = w * h;
        aOut.Write8( aImage.GetAlpha(), size );
    }
}
 
 
void PDF_PLOTTER::ClosePage()
{
    // non 3d exports need this
    if( m_pageStreamHandle != -1 )
    {
        wxASSERT( m_workFile );
 
        // Close the page stream (and compress it)
        closePdfStream();
    }
 
    // Page size is in 1/72 of inch (default user space units).  Works like the bbox in postscript
    // but there is no need for swapping the sizes, since PDF doesn't require a portrait page.
    // We use the MediaBox but PDF has lots of other less-used boxes that could be used.
    const double PTsPERMIL = 0.072;
    VECTOR2D     psPaperSize = VECTOR2D( m_pageInfo.GetSizeMils() ) * PTsPERMIL;
 
    auto iuToPdfUserSpace =
            [&]( const VECTOR2I& aCoord ) -> VECTOR2D
            {
                VECTOR2D pos = VECTOR2D( aCoord ) * PTsPERMIL / ( m_IUsPerDecimil * 10 );
 
                // PDF y=0 is at bottom of page, invert coordinate
                VECTOR2D retval( pos.x, psPaperSize.y - pos.y );
 
                // The pdf plot can be mirrored (from left to right). So mirror the
                // x coordinate if m_plotMirror is set
                if( m_plotMirror )
                {
                    if( m_mirrorIsHorizontal )
                        retval.x = ( psPaperSize.x - pos.x );
                    else
                        retval.y = pos.y;
                }
 
                return retval;
            };
 
    // Handle annotations (at the moment only "link" type objects)
    std::vector<int> annotHandles;
 
    // Allocate all hyperlink objects for the page and calculate their position in user space
    // coordinates
    for( const std::pair<BOX2I, wxString>& linkPair : m_hyperlinksInPage )
    {
        const BOX2I&    box = linkPair.first;
        const wxString& url = linkPair.second;
 
        VECTOR2D bottomLeft = iuToPdfUserSpace( box.GetPosition() );
        VECTOR2D topRight = iuToPdfUserSpace( box.GetEnd() );
 
        BOX2D userSpaceBox;
        userSpaceBox.SetOrigin( bottomLeft );
        userSpaceBox.SetEnd( topRight );
 
        annotHandles.push_back( allocPdfObject() );
 
        m_hyperlinkHandles.insert( { annotHandles.back(), { userSpaceBox, url } } );
    }
 
    for( const std::pair<BOX2I, std::vector<wxString>>& menuPair : m_hyperlinkMenusInPage )
    {
        const BOX2I&                 box = menuPair.first;
        const std::vector<wxString>& urls = menuPair.second;
 
        VECTOR2D bottomLeft = iuToPdfUserSpace( box.GetPosition() );
        VECTOR2D topRight = iuToPdfUserSpace( box.GetEnd() );
 
        BOX2D userSpaceBox;
        userSpaceBox.SetOrigin( bottomLeft );
        userSpaceBox.SetEnd( topRight );
 
        annotHandles.push_back( allocPdfObject() );
 
        m_hyperlinkMenuHandles.insert( { annotHandles.back(), { userSpaceBox, urls } } );
    }
 
    int annot3DHandle = -1;
 
    if( m_3dExportMode )
    {
        annot3DHandle = allocPdfObject();
        annotHandles.push_back( annot3DHandle );
    }
 
 
    int annotArrayHandle = -1;
 
    // If we have added any annotation links, create an array containing all the objects
    if( annotHandles.size() > 0 )
    {
        annotArrayHandle = startPdfObject();
        bool isFirst = true;
 
        fmt::print( m_outputFile, "[" );
 
        for( int handle : annotHandles )
        {
            if( isFirst )
                isFirst = false;
            else
                fmt::print( m_outputFile, " " );
 
            fmt::print( m_outputFile, "{} 0 R", handle );
        }
 
        fmt::println( m_outputFile, "]" );
        closePdfObject();
    }
 
    // Emit the page object and put it in the page list for later
    int pageHandle = startPdfObject();
    m_pageHandles.push_back( pageHandle );
 
    fmt::print( m_outputFile,
                "<<\n"
                "/Type /Page\n"
                "/Parent {} 0 R\n"
                "/Resources <<\n"
                "    /ProcSet [/PDF /Text /ImageC /ImageB]\n"
                "    /Font {} 0 R\n"
                "    /XObject {} 0 R >>\n"
                "/MediaBox [0 0 {} {}]\n",
                m_pageTreeHandle,
                m_fontResDictHandle,
                m_imgResDictHandle,
                encodeDoubleForPlotter( psPaperSize.x ),
                encodeDoubleForPlotter( psPaperSize.y ) );
 
    if( m_pageStreamHandle != -1 )
        fmt::print( m_outputFile, "/Contents {} 0 R\n", m_pageStreamHandle );
 
    if( annotHandles.size() > 0 )
        fmt::print( m_outputFile, "/Annots {} 0 R", annotArrayHandle );
 
    fmt::print( m_outputFile, ">>\n" );
 
    closePdfObject();
 
    if( m_3dExportMode )
    {
        startPdfObject( annot3DHandle );
        fmt::print( m_outputFile,
                    "<<\n"
                    "/Type /Annot\n"
                    "/Subtype /3D\n"
                    "/Rect [0 0 {} {}]\n"
                    "/NM (3D Annotation)\n"
                    "/3DD {} 0 R\n"
                    "/3DV 0\n"
                    "/3DA<</A/PO/D/PC/TB true/NP true>>\n"
                    "/3DI true\n"
                    "/P {} 0 R\n"
                    ">>\n",
                    encodeDoubleForPlotter( psPaperSize.x ), encodeDoubleForPlotter( psPaperSize.y ),
                    m_3dModelHandle, pageHandle );
 
        closePdfObject();
    }
 
    // Mark the page stream as idle
    m_pageStreamHandle = -1;
 
    int                        actionHandle = emitGoToAction( pageHandle );
    PDF_PLOTTER::OUTLINE_NODE* parent_node = m_outlineRoot.get();
 
    if( !m_parentPageName.IsEmpty() )
    {
        // Search for the parent node iteratively through the entire tree
        std::stack<OUTLINE_NODE*> nodes;
        nodes.push( m_outlineRoot.get() );
 
        while( !nodes.empty() )
        {
            OUTLINE_NODE* node = nodes.top();
            nodes.pop();
 
            // Check if this node matches
            if( node->title == m_parentPageName )
            {
                parent_node = node;
                break;
            }
 
            // Add all children to the stack
            for( OUTLINE_NODE* child : node->children )
                nodes.push( child );
        }
    }
 
    OUTLINE_NODE* pageOutlineNode = addOutlineNode( parent_node, actionHandle, m_pageName );
 
    // let's reorg the symbol bookmarks under a page handle
    // let's reorg the symbol bookmarks under a page handle
    for( const auto& [groupName, groupVector] : m_bookmarksInPage )
    {
        OUTLINE_NODE* groupOutlineNode = addOutlineNode( pageOutlineNode, actionHandle, groupName );
 
        for( const std::pair<BOX2I, wxString>& bookmarkPair : groupVector )
        {
            const BOX2I&    box = bookmarkPair.first;
            const wxString& ref = bookmarkPair.second;
 
            VECTOR2I bottomLeft = iuToPdfUserSpace( box.GetPosition() );
            VECTOR2I topRight = iuToPdfUserSpace( box.GetEnd() );
 
            actionHandle = emitGoToAction( pageHandle, bottomLeft, topRight );
 
            addOutlineNode( groupOutlineNode, actionHandle, ref );
        }
 
        std::sort( groupOutlineNode->children.begin(), groupOutlineNode->children.end(),
                   []( const OUTLINE_NODE* a, const OUTLINE_NODE* b ) -> bool
                   {
                       return a->title < b->title;
                   } );
    }
 
    // Clean up
    m_hyperlinksInPage.clear();
    m_hyperlinkMenusInPage.clear();
    m_bookmarksInPage.clear();
}
 
 
bool PDF_PLOTTER::StartPlot( const wxString& aPageNumber )
{
    return StartPlot( aPageNumber, wxEmptyString );
}
 
 
bool PDF_PLOTTER::StartPlot( const wxString& aPageNumber, const wxString& aPageName )
{
    wxASSERT( m_outputFile );
 
    // First things first: the customary null object
    m_xrefTable.clear();
    m_xrefTable.push_back( 0 );
    m_hyperlinksInPage.clear();
    m_hyperlinkMenusInPage.clear();
    m_hyperlinkHandles.clear();
    m_hyperlinkMenuHandles.clear();
    m_bookmarksInPage.clear();
    m_totalOutlineNodes = 0;
 
    m_outlineRoot = std::make_unique<OUTLINE_NODE>();
 
    if( !m_strokeFontManager )
        m_strokeFontManager = std::make_unique<PDF_STROKE_FONT_MANAGER>();
    else
        m_strokeFontManager->Reset();
 
    if( !m_outlineFontManager )
        m_outlineFontManager = std::make_unique<PDF_OUTLINE_FONT_MANAGER>();
    else
        m_outlineFontManager->Reset();
 
    /* The header (that's easy!). The second line is binary junk required
       to make the file binary from the beginning (the important thing is
       that they must have the bit 7 set) */
    fmt::print( m_outputFile, "%PDF-1.5\n%\200\201\202\203\n" );
 
    /* Allocate an entry for the page tree root, it will go in every page parent entry */
    m_pageTreeHandle = allocPdfObject();
 
    /* In the same way, the font resource dictionary is used by every page
       (it *could* be inherited via the Pages tree */
    m_fontResDictHandle = allocPdfObject();
 
    m_imgResDictHandle = allocPdfObject();
 
    m_jsNamesHandle = allocPdfObject();
 
    /* Now, the PDF is read from the end, (more or less)... so we start
       with the page stream for page 1. Other more important stuff is written
       at the end */
    StartPage( aPageNumber, aPageName );
    return true;
}
 
 
int PDF_PLOTTER::emitGoToAction( int aPageHandle, const VECTOR2I& aBottomLeft,
                                 const VECTOR2I& aTopRight )
{
    int actionHandle = allocPdfObject();
    startPdfObject( actionHandle );
 
    fmt::print( m_outputFile,
                "<</S /GoTo /D [{} 0 R /FitR {} {} {} {}]\n"
                ">>\n",
                aPageHandle,
                aBottomLeft.x,
                aBottomLeft.y,
                aTopRight.x,
                aTopRight.y );
 
    closePdfObject();
 
    return actionHandle;
}
 
 
int PDF_PLOTTER::emitGoToAction( int aPageHandle )
{
    int actionHandle = allocPdfObject();
    startPdfObject( actionHandle );
 
    fmt::println( m_outputFile,
                  "<</S /GoTo /D [{} 0 R /Fit]\n"
                  ">>",
                  aPageHandle );
 
    closePdfObject();
 
    return actionHandle;
}
 
 
void PDF_PLOTTER::emitOutlineNode( OUTLINE_NODE* node, int parentHandle, int nextNode,
                                   int prevNode )
{
    int nodeHandle = node->entryHandle;
    int prevHandle = -1;
    int nextHandle = -1;
 
    for( std::vector<OUTLINE_NODE*>::iterator it = node->children.begin();
         it != node->children.end(); it++ )
    {
        if( it >= node->children.end() - 1 )
        {
            nextHandle = -1;
        }
        else
        {
            nextHandle = ( *( it + 1 ) )->entryHandle;
        }
 
        emitOutlineNode( *it, nodeHandle, nextHandle, prevHandle );
 
        prevHandle = ( *it )->entryHandle;
    }
 
    // -1 for parentHandle is the outline root itself which is handed elsewhere.
    if( parentHandle != -1 )
    {
        startPdfObject( nodeHandle );
 
        fmt::print( m_outputFile,
                    "<<\n"
                    "/Title {}\n"
                    "/Parent {} 0 R\n",
                    encodeStringForPlotter(node->title ),
                    parentHandle);
 
        if( nextNode > 0 )
        {
            fmt::println( m_outputFile, "/Next {} 0 R", nextNode );
        }
 
        if( prevNode > 0 )
        {
            fmt::println( m_outputFile, "/Prev {} 0 R", prevNode );
        }
 
        if( node->children.size() > 0 )
        {
            int32_t count = -1 * static_cast<int32_t>( node->children.size() );
            fmt::println( m_outputFile, "/Count {}", count );
            fmt::println( m_outputFile, "/First {} 0 R", node->children.front()->entryHandle );
            fmt::println( m_outputFile, "/Last {} 0 R", node->children.back()->entryHandle );
        }
 
        if( node->actionHandle != -1 )
        {
            fmt::println( m_outputFile, "/A {} 0 R", node->actionHandle );
        }
 
        fmt::println( m_outputFile, ">>" );
        closePdfObject();
    }
}
 
 
PDF_PLOTTER::OUTLINE_NODE* PDF_PLOTTER::addOutlineNode( OUTLINE_NODE* aParent, int aActionHandle,
                                                        const wxString& aTitle )
{
    OUTLINE_NODE *node = aParent->AddChild( aActionHandle, aTitle, allocPdfObject() );
    m_totalOutlineNodes++;
 
    return node;
}
 
 
int PDF_PLOTTER::emitOutline()
{
    if( m_outlineRoot->children.size() > 0 )
    {
        // declare the outline object
        m_outlineRoot->entryHandle = allocPdfObject();
 
        emitOutlineNode( m_outlineRoot.get(), -1, -1, -1 );
 
        startPdfObject( m_outlineRoot->entryHandle );
 
        fmt::print( m_outputFile,
                    "<< /Type /Outlines\n"
                    "   /Count {}\n"
                    "   /First {} 0 R\n"
                    "   /Last {} 0 R\n"
                    ">>\n",
                    m_totalOutlineNodes,
                    m_outlineRoot->children.front()->entryHandle,
                    m_outlineRoot->children.back()->entryHandle
            );
 
        closePdfObject();
 
        return m_outlineRoot->entryHandle;
    }
 
    return -1;
}
 
void PDF_PLOTTER::emitStrokeFonts()
{
    if( !m_strokeFontManager )
        return;
 
    for( PDF_STROKE_FONT_SUBSET* subsetPtr : m_strokeFontManager->AllSubsets() )
    {
        PDF_STROKE_FONT_SUBSET& subset = *subsetPtr;
 
        if( subset.GlyphCount() <= 1 )
        {
            subset.SetCharProcsHandle( -1 );
            subset.SetFontHandle( -1 );
            subset.SetToUnicodeHandle( -1 );
            continue;
        }
 
        for( PDF_STROKE_FONT_SUBSET::GLYPH& glyph : subset.Glyphs() )
        {
            int charProcHandle = startPdfStream();
 
            if( !glyph.m_stream.empty() )
                fmt::print( m_workFile, "{}\n", glyph.m_stream );
 
            closePdfStream();
            glyph.m_charProcHandle = charProcHandle;
        }
 
        int charProcDictHandle = startPdfObject();
        fmt::println( m_outputFile, "<<" );
 
        for( const PDF_STROKE_FONT_SUBSET::GLYPH& glyph : subset.Glyphs() )
            fmt::println( m_outputFile, "    /{} {} 0 R", glyph.m_name, glyph.m_charProcHandle );
 
        fmt::println( m_outputFile, ">>" );
        closePdfObject();
        subset.SetCharProcsHandle( charProcDictHandle );
 
        int toUnicodeHandle = startPdfStream();
        std::string cmap = subset.BuildToUnicodeCMap();
 
        if( !cmap.empty() )
            fmt::print( m_workFile, "{}", cmap );
 
        closePdfStream();
        subset.SetToUnicodeHandle( toUnicodeHandle );
 
        double fontMatrixScale = 1.0 / subset.UnitsPerEm();
        double minX = subset.FontBBoxMinX();
        double minY = subset.FontBBoxMinY();
        double maxX = subset.FontBBoxMaxX();
        double maxY = subset.FontBBoxMaxY();
 
        int fontHandle = startPdfObject();
        fmt::print( m_outputFile,
                    "<<\n/Type /Font\n/Subtype /Type3\n/Name {}\n/FontBBox [ {} {} {} {} ]\n",
                    subset.ResourceName(),
                    encodeDoubleForPlotter( minX ),
                    encodeDoubleForPlotter( minY ),
                    encodeDoubleForPlotter( maxX ),
                    encodeDoubleForPlotter( maxY ) );
        fmt::print( m_outputFile,
                    "/FontMatrix [ {} 0 0 {} 0 0 ]\n/CharProcs {} 0 R\n",
                    encodeDoubleForPlotter( fontMatrixScale ),
                    encodeDoubleForPlotter( fontMatrixScale ),
                    subset.CharProcsHandle() );
        fmt::print( m_outputFile,
                    "/Encoding << /Type /Encoding /Differences {} >>\n",
                    subset.BuildDifferencesArray() );
        fmt::print( m_outputFile,
                    "/FirstChar {}\n/LastChar {}\n/Widths {}\n",
                    subset.FirstChar(),
                    subset.LastChar(),
                    subset.BuildWidthsArray() );
        fmt::print( m_outputFile,
                    "/ToUnicode {} 0 R\n/Resources << /ProcSet [/PDF /Text] >>\n>>\n",
                    subset.ToUnicodeHandle() );
        closePdfObject();
        subset.SetFontHandle( fontHandle );
    }
}
 
 
void PDF_PLOTTER::emitOutlineFonts()
{
    if( !m_outlineFontManager )
        return;
 
    for( PDF_OUTLINE_FONT_SUBSET* subsetPtr : m_outlineFontManager->AllSubsets() )
    {
        if( !subsetPtr || !subsetPtr->HasGlyphs() )
            continue;
 
        const std::vector<uint8_t>& fontData = subsetPtr->FontFileData();
 
        if( fontData.empty() )
            continue;
 
        int fontFileHandle = startPdfStream();
        subsetPtr->SetFontFileHandle( fontFileHandle );
 
        if( !fontData.empty() )
            fwrite( fontData.data(), fontData.size(), 1, m_workFile );
 
        closePdfStream();
 
        std::string cidMap = subsetPtr->BuildCIDToGIDStream();
        int cidMapHandle = startPdfStream();
        subsetPtr->SetCIDMapHandle( cidMapHandle );
 
        if( !cidMap.empty() )
            fwrite( cidMap.data(), cidMap.size(), 1, m_workFile );
 
        closePdfStream();
 
        std::string toUnicode = subsetPtr->BuildToUnicodeCMap();
        int toUnicodeHandle = startPdfStream();
        subsetPtr->SetToUnicodeHandle( toUnicodeHandle );
 
        if( !toUnicode.empty() )
            fmt::print( m_workFile, "{}", toUnicode );
 
        closePdfStream();
 
        int descriptorHandle = startPdfObject();
        subsetPtr->SetFontDescriptorHandle( descriptorHandle );
 
        fmt::print( m_outputFile,
                    "<<\n/Type /FontDescriptor\n/FontName /{}\n/Flags {}\n/ItalicAngle {}\n/Ascent {}\n/Descent {}\n"
                    "/CapHeight {}\n/StemV {}\n/FontBBox [ {} {} {} {} ]\n/FontFile2 {} 0 R\n>>\n",
                    subsetPtr->BaseFontName(),
                    subsetPtr->Flags(),
                    encodeDoubleForPlotter( subsetPtr->ItalicAngle() ),
                    encodeDoubleForPlotter( subsetPtr->Ascent() ),
                    encodeDoubleForPlotter( subsetPtr->Descent() ),
                    encodeDoubleForPlotter( subsetPtr->CapHeight() ),
                    encodeDoubleForPlotter( subsetPtr->StemV() ),
                    encodeDoubleForPlotter( subsetPtr->BBoxMinX() ),
                    encodeDoubleForPlotter( subsetPtr->BBoxMinY() ),
                    encodeDoubleForPlotter( subsetPtr->BBoxMaxX() ),
                    encodeDoubleForPlotter( subsetPtr->BBoxMaxY() ),
                    subsetPtr->FontFileHandle() );
        closePdfObject();
 
        int cidFontHandle = startPdfObject();
        subsetPtr->SetCIDFontHandle( cidFontHandle );
 
        std::string widths = subsetPtr->BuildWidthsArray();
 
        fmt::print( m_outputFile,
                    "<<\n/Type /Font\n/Subtype /CIDFontType2\n/BaseFont /{}\n"
                    "/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >>\n"
                    "/FontDescriptor {} 0 R\n/W {}\n/CIDToGIDMap {} 0 R\n>>\n",
                    subsetPtr->BaseFontName(),
                    subsetPtr->FontDescriptorHandle(),
                    widths,
                    subsetPtr->CIDMapHandle() );
        closePdfObject();
 
        int fontHandle = startPdfObject();
        subsetPtr->SetFontHandle( fontHandle );
 
        fmt::print( m_outputFile,
                    "<<\n/Type /Font\n/Subtype /Type0\n/BaseFont /{}\n/Encoding /Identity-H\n"
                    "/DescendantFonts [ {} 0 R ]\n/ToUnicode {} 0 R\n>>\n",
                    subsetPtr->BaseFontName(),
                    subsetPtr->CIDFontHandle(),
                    subsetPtr->ToUnicodeHandle() );
        closePdfObject();
    }
}
 
 
void PDF_PLOTTER::endPlotEmitResources()
{
    emitOutlineFonts();
    emitStrokeFonts();
 
    startPdfObject( m_fontResDictHandle );
    fmt::println( m_outputFile, "<<" );
 
    if( m_outlineFontManager )
    {
        for( PDF_OUTLINE_FONT_SUBSET* subsetPtr : m_outlineFontManager->AllSubsets() )
        {
            if( subsetPtr && subsetPtr->FontHandle() >= 0 )
                fmt::println( m_outputFile, "    {} {} 0 R", subsetPtr->ResourceName(), subsetPtr->FontHandle() );
        }
    }
 
    if( m_strokeFontManager )
    {
        for( PDF_STROKE_FONT_SUBSET* subsetPtr : m_strokeFontManager->AllSubsets() )
        {
            const PDF_STROKE_FONT_SUBSET& subset = *subsetPtr;
            if( subset.FontHandle() >= 0 )
                fmt::println( m_outputFile, "    {} {} 0 R", subset.ResourceName(), subset.FontHandle() );
        }
    }
 
    fmt::println( m_outputFile, ">>" );
    closePdfObject();
 
    // Named image dictionary (was allocated, now we emit it)
    startPdfObject( m_imgResDictHandle );
    fmt::println( m_outputFile, "<<\n" );
 
    for( const auto& [imgHandle, image] : m_imageHandles )
    {
        fmt::print( m_outputFile, "    /Im{} {} 0 R\n", imgHandle, imgHandle );
    }
 
    fmt::println( m_outputFile, ">>" );
    closePdfObject();
 
    // Emit images with optional SMask for transparency
    for( const auto& [imgHandle, image] : m_imageHandles )
    {
        // Init wxFFile so wxFFileOutputStream won't close file in dtor.
        wxFFile outputFFile( m_outputFile );
 
        // Image
        startPdfObject( imgHandle );
        int imgLenHandle = allocPdfObject();
        int smaskHandle = ( image.HasAlpha() || image.HasMask() ) ? allocPdfObject() : -1;
 
        fmt::print( m_outputFile,
                    "<<\n"
                    "/Type /XObject\n"
                    "/Subtype /Image\n"
                    "/BitsPerComponent 8\n"
                    "/ColorSpace {}\n"
                    "/Width {}\n"
                    "/Height {}\n"
                    "/Filter /FlateDecode\n"
                    "/Length {} 0 R\n", // Length is deferred
                    m_colorMode ? "/DeviceRGB" : "/DeviceGray",
                    image.GetWidth(),
                    image.GetHeight(),
                    imgLenHandle );
 
        if( smaskHandle != -1 )
            fmt::println( m_outputFile, "/SMask {} 0 R", smaskHandle );
 
        fmt::println( m_outputFile, ">>" );
        fmt::println( m_outputFile, "stream" );
 
        long imgStreamStart = ftell( m_outputFile );
 
        {
            wxFFileOutputStream ffos( outputFFile );
            wxZlibOutputStream  zos( ffos, wxZ_BEST_COMPRESSION, wxZLIB_ZLIB );
            wxDataOutputStream  dos( zos );
 
            WriteImageStream( image, dos, m_renderSettings->GetBackgroundColor().ToColour(),
                              m_colorMode );
        }
 
        long imgStreamSize = ftell( m_outputFile ) - imgStreamStart;
 
        fmt::print( m_outputFile, "\nendstream\n" );
        closePdfObject();
 
        startPdfObject( imgLenHandle );
        fmt::println( m_outputFile, "{}", imgStreamSize );
        closePdfObject();
 
        if( smaskHandle != -1 )
        {
            // SMask
            startPdfObject( smaskHandle );
            int smaskLenHandle = allocPdfObject();
 
            fmt::print( m_outputFile,
                        "<<\n"
                        "/Type /XObject\n"
                        "/Subtype /Image\n"
                        "/BitsPerComponent 8\n"
                        "/ColorSpace /DeviceGray\n"
                        "/Width {}\n"
                        "/Height {}\n"
                        "/Length {} 0 R\n"
                        "/Filter /FlateDecode\n"
                        ">>\n", // Length is deferred
                        image.GetWidth(),
                        image.GetHeight(),
                        smaskLenHandle );
 
            fmt::println( m_outputFile, "stream" );
 
            long smaskStreamStart = ftell( m_outputFile );
 
            {
                wxFFileOutputStream ffos( outputFFile );
                wxZlibOutputStream  zos( ffos, wxZ_BEST_COMPRESSION, wxZLIB_ZLIB );
                wxDataOutputStream  dos( zos );
 
                WriteImageSMaskStream( image, dos );
            }
 
            long smaskStreamSize = ftell( m_outputFile ) - smaskStreamStart;
 
            fmt::print( m_outputFile, "\nendstream\n" );
            closePdfObject();
 
            startPdfObject( smaskLenHandle );
            fmt::println( m_outputFile, "{}", (unsigned) smaskStreamSize );
            closePdfObject();
        }
 
        outputFFile.Detach(); // Don't close it
    }
 
    for( const auto& [ linkHandle, linkPair ] : m_hyperlinkHandles )
    {
        BOX2D    box = linkPair.first;
        wxString url = linkPair.second;
 
        startPdfObject( linkHandle );
 
        fmt::print( m_outputFile,
                    "<<\n"
                    "/Type /Annot\n"
                    "/Subtype /Link\n"
                    "/Rect [{} {} {} {}]\n"
                    "/Border [16 16 0]\n",
                    encodeDoubleForPlotter( box.GetLeft() ),
                    encodeDoubleForPlotter( box.GetBottom() ),
                    encodeDoubleForPlotter( box.GetRight() ),
                    encodeDoubleForPlotter( box.GetTop() ) );
 
        wxString pageNumber;
        bool     pageFound = false;
 
        if( EDA_TEXT::IsGotoPageHref( url, &pageNumber ) )
        {
            for( size_t ii = 0; ii < m_pageNumbers.size(); ++ii )
            {
                if( m_pageNumbers[ii] == pageNumber )
                {
                    fmt::print( m_outputFile,
                                "/Dest [{} 0 R /FitB]\n"
                                ">>\n",
                                m_pageHandles[ii] );
 
                    pageFound = true;
                    break;
                }
            }
 
            if( !pageFound )
            {
                // destination page is not being plotted, assign the NOP action to the link
                fmt::print( m_outputFile, "/A << /Type /Action /S /NOP >>\n"
                                          ">>\n" );
            }
        }
        else
        {
            if( m_project )
                url = ResolveUriByEnvVars( url, m_project );
 
            fmt::print( m_outputFile,
                        "/A << /Type /Action /S /URI /URI {} >>\n"
                        ">>\n",
                        encodeStringForPlotter( url ) );
        }
 
        closePdfObject();
    }
 
    for( const auto& [ menuHandle, menuPair ] : m_hyperlinkMenuHandles )
    {
        const BOX2D&                 box = menuPair.first;
        const std::vector<wxString>& urls = menuPair.second;
        wxString                     js = wxT( "ShM([\n" );
 
        for( const wxString& url : urls )
        {
            if( url.StartsWith( "!" ) )
            {
                wxString property = url.AfterFirst( '!' );
 
                if( property.Find( "http:" ) >= 0 )
                {
                    wxString href = property.substr( property.Find( "http:" ) );
 
                    if( m_project )
                        href = ResolveUriByEnvVars( href, m_project );
 
                    js += wxString::Format( wxT( "[\"%s\", \"%s\"],\n" ),
                                            EscapeString( href, CTX_JS_STR ),
                                            EscapeString( href, CTX_JS_STR ) );
                }
                else if( property.Find( "https:" ) >= 0 )
                {
                    wxString href = property.substr( property.Find( "https:" ) );
 
                    if( m_project )
                        href = ResolveUriByEnvVars( href, m_project );
 
                    js += wxString::Format( wxT( "[\"%s\", \"%s\"],\n" ),
                                            EscapeString( href, CTX_JS_STR ),
                                            EscapeString( href, CTX_JS_STR ) );
                }
                else if( property.Find( "file:" ) >= 0 )
                {
                    wxString href = property.substr( property.Find( "file:" ) );
 
                    if( m_project )
                        href = ResolveUriByEnvVars( href, m_project );
 
                    href = NormalizeFileUri( href );
 
                    js += wxString::Format( wxT( "[\"%s\", \"%s\"],\n" ),
                                            EscapeString( href, CTX_JS_STR ),
                                            EscapeString( href, CTX_JS_STR ) );
                }
                else
                {
                    js += wxString::Format( wxT( "[\"%s\"],\n" ),
                                            EscapeString( property, CTX_JS_STR ) );
                }
            }
            else if( url.StartsWith( "#" ) )
            {
                wxString pageNumber = url.AfterFirst( '#' );
 
                for( size_t ii = 0; ii < m_pageNumbers.size(); ++ii )
                {
                    if( m_pageNumbers[ii] == pageNumber )
                    {
                        wxString menuText = wxString::Format( _( "Show Page %s" ), pageNumber );
 
                        js += wxString::Format( wxT( "[\"%s\", \"#%d\"],\n" ),
                                                EscapeString( menuText, CTX_JS_STR ),
                                                static_cast<int>( ii ) );
                        break;
                    }
                }
            }
            else if( url.StartsWith( "http:" ) || url.StartsWith( "https:" )
                   || url.StartsWith( "file:" ) )
            {
                wxString href = url;
 
                if( m_project )
                    href = ResolveUriByEnvVars( url, m_project );
 
                if( url.StartsWith( "file:" ) )
                    href = NormalizeFileUri( href );
 
                wxString menuText = wxString::Format( _( "Open %s" ), href );
 
                js += wxString::Format( wxT( "[\"%s\", \"%s\"],\n" ),
                                        EscapeString( href, CTX_JS_STR ),
                                        EscapeString( href, CTX_JS_STR ) );
            }
        }
 
        js += wxT( "]);" );
 
        startPdfObject( menuHandle );
 
        fmt::print( m_outputFile,
                    "<<\n"
                    "/Type /Annot\n"
                    "/Subtype /Link\n"
                    "/Rect [{} {} {} {}]\n"
                    "/Border [16 16 0]\n",
                    encodeDoubleForPlotter( box.GetLeft() ),
                    encodeDoubleForPlotter( box.GetBottom() ),
                    encodeDoubleForPlotter( box.GetRight() ),
                    encodeDoubleForPlotter( box.GetTop() ) );
 
        fmt::print( m_outputFile,
                 "/A << /Type /Action /S /JavaScript /JS {} >>\n"
                 ">>\n",
                 encodeStringForPlotter( js ) );
 
        closePdfObject();
    }
 
    {
        startPdfObject( m_jsNamesHandle );
 
        wxString js = R"JS(
function ShM(aEntries) {
    var aParams = [];
    for (var i in aEntries) {
        aParams.push({
            cName: aEntries[i][0],
            cReturn: aEntries[i][1]
        })
    }
 
    var cChoice = app.popUpMenuEx.apply(app, aParams);
    if (cChoice != null && cChoice.substring(0, 1) == '#') this.pageNum = parseInt(cChoice.slice(1));
    else if (cChoice != null && cChoice.substring(0, 4) == 'http') app.launchURL(cChoice);
    else if (cChoice != null && cChoice.substring(0, 4) == 'file') app.openDoc(cChoice.substring(7));
}
)JS";
 
        fmt::print( m_outputFile,
                    "<< /JavaScript\n"
                    " << /Names\n"
                    "    [ (JSInit) << /Type /Action /S /JavaScript /JS {} >> ]\n"
                    " >>\n"
                    ">>\n",
                    encodeStringForPlotter( js ) );
 
        closePdfObject();
    }
}
 
bool PDF_PLOTTER::EndPlot()
{
    // We can end up here if there was nothing to plot
    if( !m_outputFile )
        return false;
 
    // Close the current page (often the only one)
    ClosePage();
 
    if( !m_3dExportMode )
    {
        endPlotEmitResources();
    }
 
    /* The page tree: it's a B-tree but luckily we only have few pages!
       So we use just an array... The handle was allocated at the beginning,
       now we instantiate the corresponding object */
    startPdfObject( m_pageTreeHandle );
    fmt::print( m_outputFile,
                "<<\n"
                "/Type /Pages\n"
                "/Kids [\n" );
 
    for( unsigned i = 0; i < m_pageHandles.size(); i++ )
        fmt::println( m_outputFile, "{} 0 R", m_pageHandles[i] );
 
    fmt::print( m_outputFile,
                "]\n"
                "/Count {}\n"
                ">>\n", m_pageHandles.size() );
    closePdfObject();
 
    int         infoDictHandle = startPdfObject();
 
    std::time_t time = std::time( nullptr );
    std::tm tm{};
    #if defined( _WIN32 ) || defined( _MSC_VER )
    localtime_s( &tm, &time );
    #else
    localtime_r( &time, &tm );
    #endif
    std::string dt = fmt::format( "D:{:%Y:%m:%d:%H:%M:%S}", tm );
 
    if( m_title.IsEmpty() )
    {
        // Windows uses '\' and other platforms use '/' as separator
        m_title = m_filename.AfterLast( '\\' );
        m_title = m_title.AfterLast( '/' );
    }
 
    fmt::print( m_outputFile,
                "<<\n"
                "/Producer (KiCad PDF)\n"
                "/CreationDate ({})\n"
                "/Creator {}\n"
                "/Title {}\n"
                "/Author {}\n"
                "/Subject {}\n",
                dt,
                encodeStringForPlotter( m_creator ),
                encodeStringForPlotter( m_title ),
                encodeStringForPlotter( m_author ),
                encodeStringForPlotter( m_subject ) );
 
    fmt::println( m_outputFile, ">>" );
    closePdfObject();
 
    // Let's dump in the outline
    int outlineHandle = -1;
    if( !m_3dExportMode )
    {
        outlineHandle = emitOutline();
    }
 
    // The catalog, at last
    int catalogHandle = startPdfObject();
 
    if( outlineHandle > 0 )
    {
        fmt::println( m_outputFile,
                      "<<\n"
                      "/Type /Catalog\n"
                      "/Pages {} 0 R\n"
                      "/Version /1.5\n"
                      "/PageMode /UseOutlines\n"
                      "/Outlines {} 0 R\n"
                      "/Names {} 0 R\n"
                      "/PageLayout /SinglePage\n"
                      ">>",
                      m_pageTreeHandle,
                      outlineHandle,
                      m_jsNamesHandle );
    }
    else
    {
        fmt::println( m_outputFile,
                      "<<\n"
                      "/Type /Catalog\n"
                      "/Pages {} 0 R\n"
                      "/Version /1.5\n"
                      "/PageMode /UseNone\n"
                      "/PageLayout /SinglePage\n"
                      ">>",
                      m_pageTreeHandle );
    }
 
    closePdfObject();
 
    /* Emit the xref table (format is crucial to the byte, each entry must
       be 20 bytes long, and object zero must be done in that way). Also
       the offset must be kept along for the trailer */
    long xref_start = ftell( m_outputFile );
    fmt::print( m_outputFile,
                "xref\n"
                "0 {}\n"
                "0000000000 65535 f \n",
                m_xrefTable.size() );
 
    for( unsigned i = 1; i < m_xrefTable.size(); i++ )
    {
        fmt::print( m_outputFile, "{:010d} 00000 n \n", m_xrefTable[i] );
    }
 
    // Done the xref, go for the trailer
    fmt::print( m_outputFile,
                "trailer\n"
                "<< /Size {} /Root {} 0 R /Info {} 0 R >>\n"
                "startxref\n"
                "{}\n" // The offset we saved before
                "%%EOF\n",
                m_xrefTable.size(),
                catalogHandle,
                infoDictHandle,
                xref_start );
 
    fclose( m_outputFile );
    m_outputFile = nullptr;
 
    return true;
}
 
 
void PDF_PLOTTER::Text( const VECTOR2I&        aPos,
                        const COLOR4D&         aColor,
                        const wxString&        aText,
                        const EDA_ANGLE&       aOrient,
                        const VECTOR2I&        aSize,
                        enum GR_TEXT_H_ALIGN_T aH_justify,
                        enum GR_TEXT_V_ALIGN_T aV_justify,
                        int                    aWidth,
                        bool                   aItalic,
                        bool                   aBold,
                        bool                   aMultilineAllowed,
                        KIFONT::FONT*          aFont,
                        const KIFONT::METRICS& aFontMetrics,
                        void*                  aData )
{
    // PDF files do not like 0 sized texts which create broken files.
    if( aSize.x == 0 || aSize.y == 0 )
        return;
 
    wxString text( aText );
 
    if( text.Contains( wxS( "@{" ) ) )
    {
        EXPRESSION_EVALUATOR evaluator;
        text = evaluator.Evaluate( text );
    }
 
    SetColor( aColor );
    SetCurrentLineWidth( aWidth, aData );
 
    if( !aFont )
        aFont = KIFONT::FONT::GetFont( m_renderSettings->GetDefaultFont() );
 
    VECTOR2I t_size( std::abs( aSize.x ), std::abs( aSize.y ) );
    bool     textMirrored = aSize.x < 0;
 
    // Parse the text for markup
    // IMPORTANT: Use explicit UTF-8 encoding. wxString::ToStdString() is locale-dependent
    // and under C/POSIX locale can drop or mangle non-ASCII, leading to missing CMaps.
    // The markup parser expects UTF-8 bytes.
    UTF8 utf8Text( text );
    MARKUP::MARKUP_PARSER markupParser( utf8Text.substr() );
    std::unique_ptr<MARKUP::NODE> markupTree( markupParser.Parse() );
 
    if( !markupTree )
    {
        wxLogTrace( tracePdfPlotter, "PDF_PLOTTER::Text: Markup parsing failed, falling back to plain text." );
        // Fallback to simple text rendering if parsing fails
        wxStringTokenizer str_tok( text, " ", wxTOKEN_RET_DELIMS );
        VECTOR2I pos = aPos;
 
        while( str_tok.HasMoreTokens() )
        {
            wxString word = str_tok.GetNextToken();
            pos = renderWord( word, pos, t_size, aOrient, textMirrored, aWidth, aBold, aItalic, aFont,
                              aFontMetrics, aV_justify, 0 );
        }
        return;
    }
 
    // Calculate the full text bounding box for alignment
    VECTOR2I full_box( aFont->StringBoundaryLimits( text, t_size, aWidth, aBold, aItalic, aFontMetrics ) );
 
    if( textMirrored )
        full_box.x *= -1;
 
    VECTOR2I box_x( full_box.x, 0 );
    VECTOR2I box_y( 0, full_box.y );
 
    RotatePoint( box_x, aOrient );
    RotatePoint( box_y, aOrient );
 
    VECTOR2I pos( aPos );
    if( aH_justify == GR_TEXT_H_ALIGN_CENTER )
        pos -= box_x / 2;
    else if( aH_justify == GR_TEXT_H_ALIGN_RIGHT )
        pos -= box_x;
 
    if( aV_justify == GR_TEXT_V_ALIGN_CENTER )
        pos += box_y / 2;
    else if( aV_justify == GR_TEXT_V_ALIGN_TOP )
        pos += box_y;
 
    // Render markup tree
    std::vector<OVERBAR_INFO> overbars;
    renderMarkupNode( markupTree.get(), pos, t_size, aOrient, textMirrored, aWidth,
                      aBold, aItalic, aFont, aFontMetrics, aV_justify, 0, overbars );
 
    // Draw any overbars that were accumulated
    drawOverbars( overbars, aOrient, aFontMetrics );
}
 
 
VECTOR2I PDF_PLOTTER::renderWord( const wxString& aWord, const VECTOR2I& aPosition,
                                  const VECTOR2I& aSize, const EDA_ANGLE& aOrient,
                                  bool aTextMirrored, int aWidth, bool aBold, bool aItalic,
                                  KIFONT::FONT* aFont, const KIFONT::METRICS& aFontMetrics,
                                  enum GR_TEXT_V_ALIGN_T aV_justify, TEXT_STYLE_FLAGS aTextStyle )
{
    if( wxGetEnv( "KICAD_DEBUG_SYN_STYLE", nullptr ) )
    {
        int styleFlags = 0;
        if( aFont->IsOutline() )
            styleFlags = static_cast<KIFONT::OUTLINE_FONT*>( aFont )->GetFace() ? static_cast<KIFONT::OUTLINE_FONT*>( aFont )->GetFace()->style_flags : 0;
        wxLogTrace( tracePdfPlotter, "renderWord enter word='%s' bold=%d italic=%d textStyle=%u styleFlags=%d", TO_UTF8( aWord ), (int) aBold, (int) aItalic, (unsigned) aTextStyle, styleFlags );
    }
 
    // Don't try to output a blank string, but handle space characters for word separation
    if( aWord.empty() )
        return aPosition;
 
    // If the word is just a space character, advance position by space width and continue
    if( aWord == wxT( " " ) )
    {
        // Calculate space width and advance position
        VECTOR2I spaceBox( aFont->StringBoundaryLimits( "n", aSize, aWidth, aBold, aItalic,
                                                        aFontMetrics ).x / 2, 0 );
 
        if( aTextMirrored )
            spaceBox.x *= -1;
 
        VECTOR2I rotatedSpaceBox = spaceBox;
        RotatePoint( rotatedSpaceBox, aOrient );
        return aPosition + rotatedSpaceBox;
    }
 
    // If the word contains tab characters, we need to handle them specially.
    // Split by tabs and render each segment, advancing to the next tab stop for each tab.
    if( aWord.Contains( wxT( '\t' ) ) )
    {
        constexpr double TAB_WIDTH = 4 * 0.6;
 
        VECTOR2I pos = aPosition;
        wxString segment;
 
        for( wxUniChar c : aWord )
        {
            if( c == '\t' )
            {
                if( !segment.IsEmpty() )
                {
                    pos = renderWord( segment, pos, aSize, aOrient, aTextMirrored, aWidth, aBold,
                                      aItalic, aFont, aFontMetrics, aV_justify, aTextStyle );
                    segment.clear();
                }
 
                int tabWidth = KiROUND( aSize.x * TAB_WIDTH );
                int currentIntrusion = ( pos.x - aPosition.x ) % tabWidth;
                VECTOR2I tabAdvance( tabWidth - currentIntrusion, 0 );
 
                if( aTextMirrored )
                    tabAdvance.x *= -1;
 
                RotatePoint( tabAdvance, aOrient );
                pos += tabAdvance;
            }
            else
            {
                segment += c;
            }
        }
 
        if( !segment.IsEmpty() )
        {
            pos = renderWord( segment, pos, aSize, aOrient, aTextMirrored, aWidth, aBold, aItalic,
                              aFont, aFontMetrics, aV_justify, aTextStyle );
        }
 
        return pos;
    }
 
    // Compute transformation parameters for this word
    double ctm_a, ctm_b, ctm_c, ctm_d, ctm_e, ctm_f;
    double wideningFactor, heightFactor;
 
    computeTextParameters( aPosition, aWord, aOrient, aSize, aTextMirrored, GR_TEXT_H_ALIGN_LEFT,
                           GR_TEXT_V_ALIGN_BOTTOM, aWidth, aItalic, aBold, &wideningFactor,
                           &ctm_a, &ctm_b, &ctm_c, &ctm_d, &ctm_e, &ctm_f, &heightFactor );
 
    // Calculate next position for word spacing
    VECTOR2I bbox( aFont->StringBoundaryLimits( aWord, aSize, aWidth, aBold, aItalic, aFontMetrics ).x, 0 );
 
    if( aTextMirrored )
        bbox.x *= -1;
 
    RotatePoint( bbox, aOrient );
    VECTOR2I nextPos = aPosition + bbox;
 
    // Apply vertical offset for subscript/superscript
    // Stroke font positioning (baseline) already correct per user feedback.
    // Outline fonts need: superscript +1 full font height higher; subscript +1 full font height higher
    if( aTextStyle & TEXT_STYLE::SUPERSCRIPT )
    {
        double factor = aFont->IsOutline() ? 0.050 : 0.030; // stroke original ~0.40, outline needs +1.0
        VECTOR2I offset( 0, static_cast<int>( std::lround( aSize.y * factor ) ) );
        RotatePoint( offset, aOrient );
        ctm_e -= offset.x;
        ctm_f += offset.y; // Note: PDF Y increases upward
    }
    else if( aTextStyle & TEXT_STYLE::SUBSCRIPT )
    {
        // For outline fonts raise by one font height versus stroke (which shifts downward slightly)
        VECTOR2I offset( 0, 0 );
 
        if( aFont->IsStroke() )
            offset.y = static_cast<int>( std::lround( aSize.y * 0.01 ) );
 
        RotatePoint( offset, aOrient );
        ctm_e += offset.x;
        ctm_f -= offset.y; // Note: PDF Y increases upward
    }
 
    // Render the word using existing outline font logic
    if( aFont->IsOutline() )
    {
        std::vector<PDF_OUTLINE_FONT_RUN> outlineRuns;
 
        if( m_outlineFontManager )
        {
            m_outlineFontManager->EncodeString( aWord, static_cast<KIFONT::OUTLINE_FONT*>( aFont ),
                                                ( aItalic || ( aTextStyle & TEXT_STYLE::ITALIC ) ),
                                                ( aBold || ( aTextStyle & TEXT_STYLE::BOLD ) ),
                                                &outlineRuns );
        }
 
        if( !outlineRuns.empty() )
        {
            // Apply baseline adjustment (keeping existing logic)
            double baseline_factor = 0.17;
            double alignment_multiplier = 1.0;
 
            if( aV_justify == GR_TEXT_V_ALIGN_CENTER )
                alignment_multiplier = 2.0;
            else if( aV_justify == GR_TEXT_V_ALIGN_TOP )
                alignment_multiplier = 4.0;
 
            VECTOR2D font_size_dev = userToDeviceSize( aSize );
            double baseline_adjustment = font_size_dev.y * baseline_factor * alignment_multiplier;
 
            double adjusted_ctm_e = ctm_e;
            double adjusted_ctm_f = ctm_f;
 
            double angle_rad = aOrient.AsRadians();
            double cos_angle = cos( angle_rad );
            double sin_angle = sin( angle_rad );
 
            adjusted_ctm_e = ctm_e - baseline_adjustment * sin_angle;
            adjusted_ctm_f = ctm_f + baseline_adjustment * cos_angle;
 
            double adj_c = ctm_c;
            double adj_d = ctm_d;
 
            // Synthetic italic (shear) for outline font if requested but font not intrinsically italic
            bool syntheticItalicApplied = false;
            double appliedTilt = 0.0;
            double syn_c = adj_c;
            double syn_d = adj_d;
            double syn_a = ctm_a;
            double syn_b = ctm_b;
            bool wantItalic = ( aItalic || ( aTextStyle & TEXT_STYLE::ITALIC ) );
 
            if( std::getenv( "KICAD_FORCE_SYN_ITALIC" ) )
                wantItalic = true; // debug: ensure path triggers when forcing synthetic italic
 
            bool wantBold   = ( aBold || ( aTextStyle & TEXT_STYLE::BOLD ) );
            bool fontIsItalic = aFont->IsItalic();
            bool fontIsBold   = aFont->IsBold();
            bool fontIsFakeItalic = static_cast<KIFONT::OUTLINE_FONT*>( aFont )->IsFakeItalic();
            bool fontIsFakeBold   = static_cast<KIFONT::OUTLINE_FONT*>( aFont )->IsFakeBold();
 
            // Environment overrides for testing synthetic italics:
            //   KICAD_FORCE_SYN_ITALIC=1 forces synthetic shear even if font has italic face
            //   KICAD_SYN_ITALIC_TILT=<float degrees or tangent?>: if value contains 'deg' treat as degrees,
            //   otherwise treat as raw tilt factor (x += tilt*y)
            bool forceSynItalic = false;
            double overrideTilt = 0.0;
 
            if( const char* envForce = std::getenv( "KICAD_FORCE_SYN_ITALIC" ) )
            {
                if( *envForce != '\0' && *envForce != '0' )
                    forceSynItalic = true;
            }
 
            if( const char* envTilt = std::getenv( "KICAD_SYN_ITALIC_TILT" ) )
            {
                std::string tiltStr( envTilt );
 
                try
                {
                    if( tiltStr.find( "deg" ) != std::string::npos )
                    {
                        double deg = std::stod( tiltStr );
                        overrideTilt = tan( deg * M_PI / 180.0 );
                    }
                    else
                    {
                        overrideTilt = std::stod( tiltStr );
                    }
                }
                catch( ... )
                {
                    overrideTilt = 0.0; // ignore malformed
                }
            }
 
            // Trace after we know style flags
            wxLogTrace( tracePdfPlotter,
                        "Outline path word='%s' runs=%zu wantItalic=%d fontIsItalic=%d fontIsFakeItalic=%d wantBold=%d fontIsBold=%d fontIsFakeBold=%d forceSyn=%d",
                        TO_UTF8( aWord ), outlineRuns.size(), (int) wantItalic, (int) fontIsItalic,
                        (int) fontIsFakeItalic, (int) wantBold, (int) fontIsBold, (int) fontIsFakeBold,
                        (int) forceSynItalic );
 
            // Apply synthetic italic if:
            //  - Italic requested AND outline font
            //  - And either forceSynItalic env var set OR there is no REAL italic face.
            //    (A fake italic flag from fontconfig substitution should NOT block synthetic shear.)
            bool realItalicFace = fontIsItalic && !fontIsFakeItalic;
 
            if( wantItalic && ( forceSynItalic || !realItalicFace ) )
            {
                // We want to apply a horizontal shear so that x' = x + tilt * y in the glyph's
                // local coordinate system BEFORE rotation.  The existing text matrix columns are:
                //   first column  = (a, b)^T  -> x-axis direction & scale
                //   second column = (c, d)^T  -> y-axis direction & scale
                // Prepending a shear matrix S = [[1 tilt][0 1]] (i.e. T' = T * S is WRONG here).
                // We need to LEFT-multiply: T' = R * S where R is the original rotation/scale.
                // Left multiplication keeps first column unchanged and adds (tilt * firstColumn)
                // to the second column: (c', d') = (c + tilt * a, d + tilt * b).
                // This produces a right-leaning italic for positive tilt.
                double tilt = ( overrideTilt != 0.0 ) ? overrideTilt : ITALIC_TILT;
 
                if( wideningFactor < 0 )       // mirrored text should mirror the shear
                    tilt = -tilt;
 
                syn_c = adj_c + tilt * syn_a;
                syn_d = adj_d + tilt * syn_b;
                appliedTilt = tilt;
                syntheticItalicApplied = true;
 
                wxLogTrace( tracePdfPlotter, "Synthetic italic shear applied: tilt=%f a=%f b=%f c->%f d->%f",
                            tilt, syn_a, syn_b, syn_c, syn_d );
            }
 
            if( wantBold && !fontIsBold )
            {
                // Slight horizontal widening to simulate bold (~3%)
                syn_a *= 1.03;
                syn_b *= 1.03;
            }
 
            if( syntheticItalicApplied )
            {
                // PDF comment to allow manual inspection in the output stream
                fmt::print( m_workFile, "% syn-italic tilt={} a={} b={} c={} d={}\n",
                            appliedTilt, syn_a, syn_b, syn_c, syn_d );
            }
 
            fmt::print( m_workFile, "q {:f} {:f} {:f} {:f} {:f} {:f} cm BT {} Tr {} Tz ",
                        syn_a, syn_b, syn_c, syn_d, adjusted_ctm_e, adjusted_ctm_f,
                        0, // render_mode
                        encodeDoubleForPlotter( wideningFactor * 100 ) );
 
            for( const PDF_OUTLINE_FONT_RUN& run : outlineRuns )
            {
                fmt::print( m_workFile, "{} {} Tf <",
                            run.m_subset->ResourceName(), encodeDoubleForPlotter( heightFactor ) );
 
                for( const PDF_OUTLINE_FONT_GLYPH& glyph : run.m_glyphs )
                {
                    fmt::print( m_workFile, "{:02X}{:02X}",
                                static_cast<unsigned char>( ( glyph.cid >> 8 ) & 0xFF ),
                                static_cast<unsigned char>( glyph.cid & 0xFF ) );
                }
 
                fmt::print( m_workFile, "> Tj " );
            }
 
            fmt::println( m_workFile, "ET" );
            fmt::println( m_workFile, "Q" );
        }
    }
    else
    {
        // Handle stroke fonts
        if( !m_strokeFontManager )
            return nextPos;
 
        wxLogTrace( tracePdfPlotter, "Stroke path word='%s' wantItalic=%d aItalic=%d aBold=%d",
                    TO_UTF8( aWord ), (int) ( aItalic || ( aTextStyle & TEXT_STYLE::ITALIC ) ), (int) aItalic, (int) aBold );
 
        std::vector<PDF_STROKE_FONT_RUN> runs;
        m_strokeFontManager->EncodeString( aWord, &runs, aBold, aItalic );
 
        if( !runs.empty() )
        {
            VECTOR2D dev_size = userToDeviceSize( aSize );
            double fontSize = dev_size.y;
 
            double adj_c = ctm_c;
            double adj_d = ctm_d;
 
            if( aItalic )
            {
                double tilt = -ITALIC_TILT;
 
                if( wideningFactor < 0 )
                    tilt = -tilt;
 
                adj_c -= ctm_a * tilt;
                adj_d -= ctm_b * tilt;
            }
 
            fmt::print( m_workFile, "q {:f} {:f} {:f} {:f} {:f} {:f} cm BT {} Tr {} Tz ",
                        ctm_a, ctm_b, adj_c, adj_d, ctm_e, ctm_f,
                        0, // render_mode
                        encodeDoubleForPlotter( wideningFactor * 100 ) );
 
            for( const PDF_STROKE_FONT_RUN& run : runs )
            {
                fmt::print( m_workFile, "{} {} Tf {} Tj ",
                            run.m_subset->ResourceName(),
                            encodeDoubleForPlotter( fontSize ),
                            encodeByteString( run.m_bytes ) );
            }
 
            fmt::println( m_workFile, "ET" );
            fmt::println( m_workFile, "Q" );
        }
    }
 
    return nextPos;
}
 
 
VECTOR2I PDF_PLOTTER::renderMarkupNode( const MARKUP::NODE* aNode, const VECTOR2I& aPosition,
                                         const VECTOR2I& aBaseSize, const EDA_ANGLE& aOrient,
                                         bool aTextMirrored, int aWidth, bool aBaseBold, bool aBaseItalic,
                                         KIFONT::FONT* aFont, const KIFONT::METRICS& aFontMetrics,
                                         enum GR_TEXT_V_ALIGN_T aV_justify, TEXT_STYLE_FLAGS aTextStyle,
                                         std::vector<OVERBAR_INFO>& aOverbars )
{
    VECTOR2I nextPosition = aPosition;
 
    if( !aNode )
        return nextPosition;
 
    TEXT_STYLE_FLAGS currentStyle = aTextStyle;
    VECTOR2I currentSize = aBaseSize;
    bool drawOverbar = false;
 
    // Handle markup node types
    if( !aNode->is_root() )
    {
        if( aNode->isSubscript() )
        {
            currentStyle |= TEXT_STYLE::SUBSCRIPT;
            // Subscript: smaller size and lower position
            currentSize = VECTOR2I( aBaseSize.x * 0.5, aBaseSize.y * 0.6 );
        }
        else if( aNode->isSuperscript() )
        {
            currentStyle |= TEXT_STYLE::SUPERSCRIPT;
            // Superscript: smaller size and higher position
            currentSize = VECTOR2I( aBaseSize.x * 0.5, aBaseSize.y * 0.6 );
        }
 
        if( aNode->isOverbar() )
        {
            drawOverbar = true;
            // Overbar doesn't change font size, just adds decoration
        }
 
        // Render content of this node if it has text
        if( aNode->has_content() )
        {
            wxString nodeText = aNode->asWxString();
 
            // Process text content (simplified version of the main text processing)
            wxStringTokenizer str_tok( nodeText, " ", wxTOKEN_RET_DELIMS );
 
            while( str_tok.HasMoreTokens() )
            {
                wxString word = str_tok.GetNextToken();
                nextPosition = renderWord( word, nextPosition, currentSize, aOrient, aTextMirrored,
                                           aWidth, aBaseBold || (currentStyle & TEXT_STYLE::BOLD),
                                           aBaseItalic || (currentStyle & TEXT_STYLE::ITALIC),
                                           aFont, aFontMetrics, aV_justify, currentStyle );
            }
        }
    }
 
    // Process child nodes recursively
    for( const std::unique_ptr<MARKUP::NODE>& child : aNode->children )
    {
        VECTOR2I startPos = nextPosition;
 
        nextPosition = renderMarkupNode( child.get(), nextPosition, currentSize, aOrient,
                                         aTextMirrored, aWidth, aBaseBold, aBaseItalic,
                                         aFont, aFontMetrics, aV_justify, currentStyle, aOverbars );
 
        // Store overbar info for later rendering
        if( drawOverbar )
        {
            VECTOR2I endPos = nextPosition;
            aOverbars.push_back( { startPos, endPos, currentSize, aFont->IsOutline(), aV_justify } );
        }
    }
 
    return nextPosition;
}
 
 
void PDF_PLOTTER::drawOverbars( const std::vector<OVERBAR_INFO>& aOverbars, const EDA_ANGLE& aOrient,
                                const KIFONT::METRICS& aFontMetrics )
{
    for( const OVERBAR_INFO& overbar : aOverbars )
    {
        // Baseline direction (vector from start to end). If zero length, derive from orientation.
        VECTOR2D dir( overbar.endPos.x - overbar.startPos.x, overbar.endPos.y - overbar.startPos.y );
 
        double len = hypot( dir.x, dir.y );
        if( len <= 1e-6 )
        {
            // Fallback: derive direction from orientation angle
            double ang = aOrient.AsRadians();
            dir.x = cos( ang );
            dir.y = sin( ang );
            len = 1.0;
        }
 
        dir.x /= len;
        dir.y /= len;
 
        // Perpendicular (rotate dir 90° CCW). Upward in text space so overbar sits above baseline.
        VECTOR2D nrm( -dir.y, dir.x );
 
        // Base vertical offset distance in device units (baseline -> default overbar position)
        double barOffset = aFontMetrics.GetOverbarVerticalPosition( overbar.fontSize.y );
 
        // Adjust further to match screen drawing.  This is somewhat disturbing, but I can't figure
        // out why it's needed.
        if( overbar.isOutline )
            barOffset += overbar.fontSize.y * 0.16;
        else
            barOffset += overbar.fontSize.y * 0.32;
 
        // Mirror the text vertical alignment adjustments used for baseline shifting.
        // Earlier logic scales baseline adjustment: CENTER ~2x, TOP ~4x. We apply proportional
        // extra raise so that overbars track visually with perceived baseline shift.
        double alignMult = 1.0;
 
        switch( overbar.vAlign )
        {
        case GR_TEXT_V_ALIGN_CENTER: alignMult = overbar.isOutline ? 2.0 : 1.0; break;
        case GR_TEXT_V_ALIGN_TOP:    alignMult = overbar.isOutline ? 4.0 : 1.0; break;
        default:                     alignMult = 1.0; break; // bottom
        }
 
        if( alignMult > 1.0 )
        {
            // Scale only the baseline component (approx 17% of height, matching earlier baseline_factor)
            double baseline_factor = 0.17;
            barOffset += ( alignMult - 1.0 ) * ( baseline_factor * overbar.fontSize.y );
        }
 
        // Trim to avoid rounded cap extension (assumes stroke caps); proportion of font width.
        double barTrim = overbar.fontSize.x * 0.1;
 
        // Apply trim along baseline direction and offset along normal
        VECTOR2D startPt( overbar.startPos.x, overbar.startPos.y );
        VECTOR2D endPt( overbar.endPos.x, overbar.endPos.y );
 
        // Both endpoints should share identical vertical (normal) offset above baseline.
        // Use a single offset vector offVec = -barOffset * nrm (negative because nrm points 'up').
        VECTOR2D offVec( -barOffset * nrm.x, -barOffset * nrm.y );
 
        startPt.x += dir.x * barTrim + offVec.x;
        startPt.y += dir.y * barTrim + offVec.y;
        endPt.x -= dir.x * barTrim - offVec.x; // subtract trim, then apply same vertical offset
        endPt.y -= dir.y * barTrim - offVec.y;
 
        VECTOR2I iStart = KiROUND( startPt.x, startPt.y );
        VECTOR2I iEnd = KiROUND( endPt.x, endPt.y );
 
        MoveTo( iStart );
        LineTo( iEnd );
        PenFinish();
    }
}
 
 
void PDF_PLOTTER::PlotText( const VECTOR2I&        aPos,
                            const COLOR4D&         aColor,
                            const wxString&        aText,
                            const TEXT_ATTRIBUTES& aAttributes,
                            KIFONT::FONT*          aFont,
                            const KIFONT::METRICS& aFontMetrics,
                            void*                  aData )
{
    VECTOR2I size = aAttributes.m_Size;
 
    // PDF files do not like 0 sized texts which create broken files.
    if( size.x == 0 || size.y == 0 )
        return;
 
    if( aAttributes.m_Mirrored )
        size.x = -size.x;
 
    PDF_PLOTTER::Text( aPos, aColor, aText, aAttributes.m_Angle, size, aAttributes.m_Halign,
                       aAttributes.m_Valign, aAttributes.m_StrokeWidth, aAttributes.m_Italic,
                       aAttributes.m_Bold, aAttributes.m_Multiline, aFont, aFontMetrics, aData );
}
 
 
void PDF_PLOTTER::HyperlinkBox( const BOX2I& aBox, const wxString& aDestinationURL )
{
    m_hyperlinksInPage.push_back( std::make_pair( aBox, aDestinationURL ) );
}
 
 
void PDF_PLOTTER::HyperlinkMenu( const BOX2I& aBox, const std::vector<wxString>& aDestURLs )
{
    m_hyperlinkMenusInPage.push_back( std::make_pair( aBox, aDestURLs ) );
}
 
 
void PDF_PLOTTER::Bookmark( const BOX2I& aLocation, const wxString& aSymbolReference,
                            const wxString &aGroupName )
{
 
    m_bookmarksInPage[aGroupName].push_back( std::make_pair( aLocation, aSymbolReference ) );
}
 
 
void PDF_PLOTTER::Plot3DModel( const wxString&                 aSourcePath,
                               const std::vector<PDF_3D_VIEW>& a3DViews )
{
    std::map<float, int> m_fovMap;
    std::vector<int>     m_viewHandles;
 
    for( const PDF_3D_VIEW& view : a3DViews )
    {
        // this is a strict need
        wxASSERT( view.m_cameraMatrix.size() == 12 );
 
        int fovHandle = -1;
        if( !m_fovMap.contains( view.m_fov ) )
        {
            fovHandle = allocPdfObject();
            m_fovMap[view.m_fov] = fovHandle;
 
            startPdfObject( fovHandle );
            fmt::print( m_outputFile,
                        "<<\n"
                        "/FOV {}\n"
                        "/PS /Min\n"
                        "/Subtype /P\n"
                        ">>\n",
                        encodeDoubleForPlotter( view.m_fov ) );
            closePdfObject();
        }
        else
        {
            fovHandle = m_fovMap[view.m_fov];
        }
 
        int viewHandle = allocPdfObject();
        startPdfObject( viewHandle );
 
        fmt::print( m_outputFile,
                    "<<\n"
                    "/Type /3DView\n"
                    "/XN ({})\n"
                    "/IN ({})\n"
                    "/MS /M\n"
                    "/C2W [{:f} {:f} {:f} {:f} {:f} {:f} {:f} {:f} {:f} {:f} {:f} {:f}]\n"
                    "/CO {:f}\n"
                    "/NR false\n"
                    "/BG<<\n"
                    "/Type /3DBG\n"
                    "/Subtype /SC\n"
                    "/CS /DeviceRGB\n"
                    "/C [1.000000 1.000000 1.000000]>>\n"
                    "/P {} 0 R\n"
                    "/LS<<\n"
                    "/Type /3DLightingScheme\n"
                    "/Subtype /CAD>>\n"
                    ">>\n",
                    view.m_name, view.m_name, view.m_cameraMatrix[0],
                    view.m_cameraMatrix[1],
                    view.m_cameraMatrix[2], view.m_cameraMatrix[3], view.m_cameraMatrix[4],
                    view.m_cameraMatrix[5], view.m_cameraMatrix[6], view.m_cameraMatrix[7],
                    view.m_cameraMatrix[8], view.m_cameraMatrix[9], view.m_cameraMatrix[10],
                    view.m_cameraMatrix[11],
                    view.m_cameraCenter,
                    fovHandle );
 
        closePdfObject();
 
        m_viewHandles.push_back( viewHandle );
    }
 
    m_3dModelHandle = startPdfObject();
 
    // so we can get remotely stuff the length afterwards
    int modelLenHandle = allocPdfObject();
 
    fmt::print( m_outputFile,
                "<<\n"
                "/Type /3D\n"
                "/Subtype /U3D\n"
                "/DV 0\n" );
 
    fmt::print( m_outputFile, "/VA [" );
    for( int viewHandle : m_viewHandles )
    {
        fmt::print( m_outputFile, "{} 0 R ", viewHandle );
    }
    fmt::print( m_outputFile, "]\n" );
 
    fmt::print( m_outputFile,
                "/Length {} 0 R\n"
                "/Filter /FlateDecode\n"
                ">>\n", // Length is deferred
                modelLenHandle );
 
    fmt::println( m_outputFile, "stream" );
 
    wxFFile outputFFile( m_outputFile );
 
    fflush( m_outputFile );
    long imgStreamStart = ftell( m_outputFile );
 
    size_t model_stored_size = 0;
    {
        wxFFileOutputStream ffos( outputFFile );
        wxZlibOutputStream  zos( ffos, wxZ_BEST_COMPRESSION, wxZLIB_ZLIB );
 
        wxFFileInputStream fileStream( aSourcePath );
        if( !fileStream.IsOk() )
        {
            wxLogError( _( "Failed to open 3D model file: %s" ), aSourcePath );
        }
 
        zos.Write( fileStream );
    }
    fflush( m_outputFile );
    model_stored_size = ftell( m_outputFile );
    model_stored_size -= imgStreamStart; // Get the size of the compressed stream
 
    fmt::print( m_outputFile, "\nendstream\n" );
    closePdfObject();
 
    startPdfObject( modelLenHandle );
    fmt::println( m_outputFile, "{}", (unsigned) model_stored_size );
    closePdfObject();
 
    outputFFile.Detach(); // Don't close it
}
 
 
std::vector<float> PDF_PLOTTER::CreateC2WMatrixFromAngles( const VECTOR3D& aTargetPosition,
                                                            float aCameraDistance,
                                                            float aYawDegrees,
                                                            float aPitchDegrees,
                                                            float aRollDegrees )
{
    float yRadians = glm::radians( aYawDegrees );
    float xRadians = glm::radians( aPitchDegrees );
    float zRadians = glm::radians( aRollDegrees );
 
    // Create rotation matrix from Euler angles
    glm::mat4 rotationMatrix = glm::eulerAngleYXZ( yRadians, xRadians, zRadians );
 
    // Calculate camera position based on target, distance, and rotation
    // Start with a vector pointing backward along the z-axis
    glm::vec4 cameraOffset = glm::vec4( 0.0f, 0.0f, aCameraDistance, 1.0f );
 
    // Apply rotation to this offset
    cameraOffset = rotationMatrix * cameraOffset;
 
    // Camera position is target position minus the rotated offset
    glm::vec3 cameraPosition = glm::vec3(aTargetPosition.x, aTargetPosition.y, aTargetPosition.z)
        - glm::vec3( cameraOffset );
 
    std::vector<float> result( 12 );
 
    // Handle rotation part in column-major order (first 9 elements)
    int index = 0;
    for( int col = 0; col < 3; ++col )
    {
        for( int row = 0; row < 3; ++row )
        {
            result[index++] = static_cast<float>( rotationMatrix[col][row] );
        }
    }
 
    // Handle translation part (last 3 elements)
    result[9] = static_cast<float>( cameraPosition.x );
    result[10] = static_cast<float>( cameraPosition.y );
    result[11] = static_cast<float>( cameraPosition.z );
 
    return result;
}