plotters_pslike.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

 
#pragma once
 
#include "plotter.h"
#include <memory>
#include <optional>
#include <plotters/pdf_stroke_font.h>
#include <plotters/pdf_outline_font.h>
#include <math/vector3.h>
 
namespace MARKUP { struct NODE; }

class PSLIKE_PLOTTER : public PLOTTER
{
public:
    PSLIKE_PLOTTER( const PROJECT* aProject = nullptr) :
            PLOTTER( aProject ),
            plotScaleAdjX( 1 ),
            plotScaleAdjY( 1 ),
            m_textMode( PLOT_TEXT_MODE::PHANTOM )
    {
    }

    virtual void SetTextMode( PLOT_TEXT_MODE mode ) override
    {
        if( mode != PLOT_TEXT_MODE::DEFAULT )
            m_textMode = mode;
    }

    void SetScaleAdjust( double scaleX, double scaleY )
    {
        plotScaleAdjX = scaleX;
        plotScaleAdjY = scaleY;
    }
 
    // Pad routines are handled with lower level primitives
    virtual void FlashPadCircle( const VECTOR2I& aPadPos, int aDiameter, void* aData ) override;
    virtual void FlashPadOval( const VECTOR2I& aPadPos, const VECTOR2I& aSize,
                               const EDA_ANGLE& aPadOrient, void* aData ) override;
    virtual void FlashPadRect( const VECTOR2I& aPadPos, const VECTOR2I& aSize,
                               const EDA_ANGLE& aPadOrient, void* aData ) override;
    virtual void FlashPadRoundRect( const VECTOR2I& aPadPos, const VECTOR2I& aSize,
                                    int aCornerRadius, const EDA_ANGLE& aOrient,
                                    void* aData ) override;
    virtual void FlashPadCustom( const VECTOR2I& aPadPos, const VECTOR2I& aSize,
                                 const EDA_ANGLE& aOrient, SHAPE_POLY_SET* aPolygons,
                                 void* aData ) override;
    virtual void FlashPadTrapez( const VECTOR2I& aPadPos, const VECTOR2I* aCorners,
                                 const EDA_ANGLE& aPadOrient, void* aData ) override;
    virtual void FlashRegularPolygon( const VECTOR2I& aShapePos, int aDiameter, int aCornerCount,
                                      const EDA_ANGLE& aOrient, void* aData ) override;

    virtual void SetColor( const COLOR4D& color ) override;
 
protected:
    void computeTextParameters( const VECTOR2I&          aPos,
                                const wxString&          aText,
                                const EDA_ANGLE&         aOrient,
                                const VECTOR2I&          aSize,
                                bool                     aMirror,
                                enum GR_TEXT_H_ALIGN_T   aH_justify,
                                enum GR_TEXT_V_ALIGN_T   aV_justify,
                                int                      aWidth,
                                bool                     aItalic,
                                bool                     aBold,
                                double                   *wideningFactor,
                                double                   *ctm_a,
                                double                   *ctm_b,
                                double                   *ctm_c,
                                double                   *ctm_d,
                                double                   *ctm_e,
                                double                   *ctm_f,
                                double                   *heightFactor );

    virtual std::string encodeStringForPlotter( const wxString& aUnicode );

    virtual void emitSetRGBColor( double r, double g, double b, double a ) = 0;

    static const double postscriptTextAscent; // = 0.718;

    int returnPostscriptTextWidth( const wxString& aText, int aXSize, bool aItalic, bool aBold );

    double plotScaleAdjX, plotScaleAdjY;

    PLOT_TEXT_MODE m_textMode;
};
 
 
class PS_PLOTTER : public PSLIKE_PLOTTER
{
public:
    PS_PLOTTER( const PROJECT* aProject = nullptr ) :
        PSLIKE_PLOTTER( aProject )
    {
        // The phantom plot in postscript is an hack and reportedly
        // crashes Adobe's own postscript interpreter!
        m_textMode = PLOT_TEXT_MODE::STROKE;
    }
 
    static wxString GetDefaultFileExtension()
    {
        return wxString( wxT( "ps" ) );
    }
 
    virtual PLOT_FORMAT GetPlotterType() const override
    {
        return PLOT_FORMAT::POST;
    }

    virtual bool StartPlot( const wxString& aPageNumber ) override;
    virtual bool EndPlot() override;

    virtual void SetCurrentLineWidth( int width, void* aData = nullptr ) override;

    virtual void SetDash( int aLineWidth, LINE_STYLE aLineStyle ) override;
 
    virtual void SetViewport( const VECTOR2I& aOffset, double aIusPerDecimil,
                              double aScale, bool aMirror ) override;
    virtual void Rect( const VECTOR2I& p1, const VECTOR2I& p2, FILL_T fill, int width,
                       int aCornerRadius = 0 ) override;
    virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill, int width ) override;
    virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
                      const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth ) override;
 
    virtual void PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill,
                           int aWidth, void* aData = nullptr ) override;

    virtual void PlotImage( const wxImage& aImage, const VECTOR2I& aPos,
                            double aScaleFactor ) override;
 
    virtual void PenTo( const VECTOR2I& pos, char plume ) override;
    virtual void 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 = nullptr ) override;
 
    virtual void PlotText( const VECTOR2I&        aPos,
                           const COLOR4D&         aColor,
                           const wxString&        aText,
                           const TEXT_ATTRIBUTES& aAttributes,
                           KIFONT::FONT*          aFont,
                           const KIFONT::METRICS& aFontMetrics,
                           void*                  aData = nullptr ) override;
 
    virtual void PlotPoly( const SHAPE_LINE_CHAIN& aCornerList, FILL_T aFill,
                           int aWidth, void* aData = nullptr ) override;
 
 
protected:
    virtual void emitSetRGBColor( double r, double g, double b, double a ) override;
};
 
 
struct PDF_3D_VIEW
{
    std::string m_name;
    std::vector<float> m_cameraMatrix;
    float       m_cameraCenter;
    float       m_fov;
};
 
 
class PDF_PLOTTER : public PSLIKE_PLOTTER
{
public:
    PDF_PLOTTER( const PROJECT* aProject = nullptr ) :
            PSLIKE_PLOTTER( aProject ),
            m_pageTreeHandle( 0 ),
            m_fontResDictHandle( 0 ),
            m_imgResDictHandle( 0 ),
            m_extGStateResDictHandle( 0 ),
            m_jsNamesHandle( 0 ),
            m_pageStreamHandle( -1 ),
            m_streamLengthHandle( 0 ),
            m_workFile( nullptr ),
            m_totalOutlineNodes( 0 ),
            m_3dModelHandle( -1 ),
            m_3dExportMode( false ),
            m_usedBase14Fonts( false ),
            m_currentAlpha( 1.0 ),
            m_strokeFontManager( nullptr ),
            m_outlineFontManager( nullptr )
    {
    }
 
    virtual ~PDF_PLOTTER();
 
    virtual PLOT_FORMAT GetPlotterType() const override
    {
        return PLOT_FORMAT::PDF;
    }
 
    static wxString GetDefaultFileExtension()
    {
        return wxString( wxT( "pdf" ) );
    }

    virtual bool OpenFile( const wxString& aFullFilename ) override;

    virtual bool StartPlot( const wxString& aPageNumber ) override;
 
    virtual bool StartPlot( const wxString& aPageNumber,
                            const wxString& aPageName = wxEmptyString );
 
    virtual bool EndPlot() override;

    virtual void StartPage( const wxString& aPageNumber,
                            const wxString& aPageName = wxEmptyString,
                            const wxString& aParentPageNumber = wxEmptyString,
                            const wxString& aParentPageName = wxEmptyString );

    virtual void ClosePage();

    virtual void SetCurrentLineWidth( int width, void* aData = nullptr ) override;

    virtual void SetDash( int aLineWidth, LINE_STYLE aLineStyle ) override;

    virtual void SetViewport( const VECTOR2I& aOffset, double aIusPerDecimil, double aScale,
                              bool aMirror ) override;

    virtual void Rect( const VECTOR2I& p1, const VECTOR2I& p2, FILL_T fill, int width,
                       int aCornerRadius = 0 ) override;

    virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill, int width ) override;

    virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle,
                      double aRadius, FILL_T aFill, int aWidth ) override;

    virtual void PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill,
                           int aWidth = USE_DEFAULT_LINE_WIDTH, void* aData = nullptr ) override;
 
    virtual void PlotPoly( const SHAPE_LINE_CHAIN& aLineChain, FILL_T aFill,
                           int aWidth = USE_DEFAULT_LINE_WIDTH, void* aData = nullptr ) override;
 
    virtual void PenTo( const VECTOR2I& pos, char plume ) override;
 
    virtual void 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 = nullptr ) override;
 
private:
    // Structure to hold overbar drawing information
    struct OVERBAR_INFO
    {
        VECTOR2I          startPos;    // Start position of overbar text
        VECTOR2I          endPos;      // End position of overbar text
        VECTOR2I          fontSize;    // Font size for proper overbar positioning
        bool              isOutline;   // True if the overbar applies to an outline font run
        GR_TEXT_V_ALIGN_T vAlign;      // Original vertical alignment of the parent text
    };

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

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

    void drawOverbars( const std::vector<OVERBAR_INFO>& aOverbars, const EDA_ANGLE& aOrient,
                       const KIFONT::METRICS& aFontMetrics );
 
    std::vector<VECTOR2D> arcPath( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
                                   const EDA_ANGLE& aAngle, double aRadius );
 
public:
    virtual void PlotText( const VECTOR2I&        aPos,
                           const COLOR4D&         aColor,
                           const wxString&        aText,
                           const TEXT_ATTRIBUTES& aAttributes,
                           KIFONT::FONT*          aFont,
                           const KIFONT::METRICS& aFontMetrics,
                           void*                  aData = nullptr ) override;
 
    void HyperlinkBox( const BOX2I& aBox, const wxString& aDestinationURL ) override;
 
    void HyperlinkMenu( const BOX2I& aBox, const std::vector<wxString>& aDestURLs ) override;
 
    void Bookmark( const BOX2I& aBox, const wxString& aName,
                   const wxString& aGroupName = wxEmptyString ) override;
 
    void Plot3DModel( const wxString& aSourcePath, const std::vector<PDF_3D_VIEW>& a3DViews );
 
    void Set3DExport( bool aYes ) { m_3dExportMode = aYes; }

    void PlotImage( const wxImage& aImage, const VECTOR2I& aPos, double aScaleFactor ) override;

    static std::vector<float> CreateC2WMatrixFromAngles( const VECTOR3D& aTargetPosition,
                                                         float aCameraDistance,
                                                         float aYawDegrees,
                                                         float aPitchDegrees,
                                                         float aRollDegrees );
 
protected:
    struct OUTLINE_NODE
    {
        int      actionHandle;  
        wxString title;         
        int      entryHandle;   
 
        std::vector<OUTLINE_NODE*> children;    
 
        ~OUTLINE_NODE()
        {
            std::for_each( children.begin(), children.end(),
                           []( OUTLINE_NODE* node )
                           {
                               delete node;
                           } );
        }
 
        OUTLINE_NODE* AddChild( int aActionHandle, const wxString& aTitle, int aEntryHandle )
        {
            OUTLINE_NODE* child = new OUTLINE_NODE
            {
                aActionHandle, aTitle, aEntryHandle, {}
            };
 
            children.push_back( child );
 
            return child;
        }
    };

    OUTLINE_NODE* addOutlineNode( OUTLINE_NODE* aParent, int aActionHandle,
                                  const wxString& aTitle );

    std::string encodeStringForPlotter( const wxString& aUnicode ) override;

    std::string encodeDoubleForPlotter( double aValue ) const;

    virtual void emitSetRGBColor( double r, double g, double b, double a ) override;

    int allocPdfObject();

    int getExtGStateHandleForAlpha( double aAlpha );

    int startPdfObject( int aHandle = -1 );

    void closePdfObject();

    int startPdfStream( int aHandle = -1 );

    void closePdfStream();

    int emitOutline();

    void emitOutlineNode( OUTLINE_NODE* aNode, int aParentHandle, int aNextNode, int aPrevNode );

    int emitGoToAction( int aPageHandle, const VECTOR2I& aBottomLeft, const VECTOR2I& aTopRight );
    int emitGoToAction( int aPageHandle );
 
 
    void endPlotEmitResources();
 
    void emitStrokeFonts();
    void emitOutlineFonts();
 
    std::string encodeByteString( const std::string& aBytes );
 
protected:
    class XREF_TABLE
    {
    public:
        void Reset()
        {
            m_offsets.assign( 1, 0 );
        }

        int Allocate()
        {
            m_offsets.push_back( 0 );
            return static_cast<int>( m_offsets.size() ) - 1;
        }

        bool IsValid( int aHandle ) const
        {
            return aHandle > 0 && aHandle < static_cast<int>( m_offsets.size() );
        }

        void SetOffset( int aHandle, long aOffset )
        {
            wxASSERT_MSG( IsValid( aHandle ), "PDF object handle is not valid" );
            wxASSERT_MSG( aOffset >= 0, "PDF object offset must be non-negative" );
 
            if( IsValid( aHandle ) )
                m_offsets[aHandle] = aOffset;
        }
 
        const std::vector<long>& Entries() const
        {
            return m_offsets;
        }
 
    private:
        std::vector<long> m_offsets = { 0 };
    };
 
    int               m_pageTreeHandle;           
    int               m_fontResDictHandle;        
    int               m_imgResDictHandle;         
    int               m_extGStateResDictHandle;   
    int               m_jsNamesHandle;            
    std::vector<int>  m_pageHandles;              
    int               m_pageStreamHandle;         
    int               m_streamLengthHandle;       
 
    wxString          m_workFilename;
    wxString          m_pageName;
    wxString          m_parentPageName;
 
    FILE*             m_workFile;                 

    XREF_TABLE m_xrefTable;

    std::vector<wxString>                                       m_pageNumbers;

    std::vector<std::pair<BOX2I, wxString>>                     m_hyperlinksInPage;
    std::vector<std::pair<BOX2I, std::vector<wxString>>>        m_hyperlinkMenusInPage;

    std::map<int, std::pair<BOX2D, wxString>>                   m_hyperlinkHandles;
    std::map<int, std::pair<BOX2D, std::vector<wxString>>>      m_hyperlinkMenuHandles;
 
    std::map<wxString, std::vector<std::pair<BOX2I, wxString>>> m_bookmarksInPage;
 
    std::map<int, wxImage>                                      m_imageHandles;
 
    std::unique_ptr<OUTLINE_NODE> m_outlineRoot;        
    int                           m_totalOutlineNodes;  
 
    int                           m_3dModelHandle;
    bool                          m_3dExportMode;

    bool                          m_usedBase14Fonts;

    double m_currentAlpha = 1.0;

    std::map<double, int> m_alphaToExtGStateHandles;
 
    std::unique_ptr<PDF_STROKE_FONT_MANAGER>  m_strokeFontManager;
    std::unique_ptr<PDF_OUTLINE_FONT_MANAGER> m_outlineFontManager;
};
 
 
class SVG_PLOTTER : public PSLIKE_PLOTTER
{
public:
    SVG_PLOTTER( const PROJECT* aProject = nullptr );
 
    static wxString GetDefaultFileExtension()
    {
        return wxString( wxT( "svg" ) );
    }
 
    virtual PLOT_FORMAT GetPlotterType() const override
    {
        return PLOT_FORMAT::SVG;
    }

    virtual bool StartPlot( const wxString& aPageNumber ) override;
    virtual bool EndPlot() override;

    virtual void SetCurrentLineWidth( int width, void* aData = nullptr ) override;

    virtual void SetDash( int aLineWidth, LINE_STYLE aLineStyle ) override;
 
    virtual void SetViewport( const VECTOR2I& aOffset, double aIusPerDecimil, double aScale,
                              bool aMirror ) override;
    virtual void Rect( const VECTOR2I& p1, const VECTOR2I& p2, FILL_T fill, int width,
                       int aCornerRadius = 0 ) override;
    virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill, int width ) override;
    virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
                      const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill,
                      int aWidth ) override;
 
    virtual void BezierCurve( const VECTOR2I& aStart, const VECTOR2I& aControl1,
                              const VECTOR2I& aControl2, const VECTOR2I& aEnd,
                              int aTolerance, int aLineThickness ) override;
 
    virtual void PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill,
                           int aWidth, void * aData ) override;

    virtual void PlotImage( const wxImage& aImage, const VECTOR2I& aPos,
                            double aScaleFactor ) override;
 
    virtual void PenTo( const VECTOR2I& pos, char plume ) override;

    virtual void SetSvgCoordinatesFormat( unsigned aPrecision ) override;

    virtual void SetPlotBBox( const BOX2I& aBBoxIU ) override;

    virtual void StartBlock( void* aData ) override;

    virtual void EndBlock( void* aData ) override;
 
    virtual void 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 = nullptr ) override;
 
 
    virtual void PlotText( const VECTOR2I&        aPos,
                           const COLOR4D&         aColor,
                           const wxString&        aText,
                           const TEXT_ATTRIBUTES& aAttributes,
                           KIFONT::FONT*          aFont,
                           const KIFONT::METRICS& aFontMetrics,
                           void*                  aData = nullptr ) override;
 
protected:
    virtual VECTOR2D userToDeviceCoordinates( const VECTOR2I& aCoordinate ) override;

    virtual void emitSetRGBColor( double r, double g, double b, double a ) override;

    void setSVGPlotStyle( int aLineWidth, bool aIsGroup = true,
                          const std::string& aExtraStyle = {} );

    void setFillMode( FILL_T fill );
 
    FILL_T     m_fillMode;          // true if the current contour rect, arc, circle, polygon must
                                    // be filled
    uint32_t   m_pen_rgb_color;     // current rgb color value: each color has a value 0 ... 255,
                                    //   and the 3 colors are grouped in a 3x8 bits value (written
                                    //   in hex to svg files)
    uint32_t   m_brush_rgb_color;   // same as m_pen_rgb_color, used to fill some contours.
    double     m_brush_alpha;
    bool       m_graphics_changed;  // true if a pen/brush parameter is modified color, pen size,
                                    //   fill mode ... the new SVG stype must be output on file
    LINE_STYLE m_dashed;            // plot line style
    unsigned   m_precision;         // How fine the step size is
                                    // Use 3-6 (3 means um precision, 6 nm precision) in PcbNew
                                    // 3-4 in other modules (avoid values >4 to avoid overflow)
                                    // see also comment for m_useInch.
 
    std::optional<BOX2I> m_plotBBoxIU; // Explicit plot content bounding box (IUs), when set.
};