plotter.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2016 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * 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
 */
 
#ifndef PLOT_COMMON_H_
#define PLOT_COMMON_H_
 
#include <eda_shape.h>
#include <vector>
#include <math/box2.h>
#include <gr_text.h>
#include <page_info.h>
#include <gal/color4d.h>
#include <stroke_params.h>
#include <render_settings.h>
#include <font/font.h>
 
 
class COLOR_SETTINGS;
class SHAPE_ARC;
class SHAPE_POLY_SET;
class SHAPE_LINE_CHAIN;
class GBR_NETLIST_METADATA;
class PROJECT;
 
using KIGFX::RENDER_SETTINGS;
 
 
// Must be in the same order as the drop-down list in the plot dialog inside pcbnew
// Units (inch/mm for DXF plotter
enum class DXF_UNITS
{
    INCH = 0,   // Do not use MM: it conficts with a Windows header
    MM = 1
};
 

enum class PLOT_FORMAT
{
    UNDEFINED    = -1,
    FIRST_FORMAT = 0,
    HPGL         = FIRST_FORMAT,
    GERBER,
    POST,
    DXF,
    PDF,
    SVG,
    LAST_FORMAT = SVG
};

enum DXF_OUTLINE_MODE
{
    SKETCH = 0,     // sketch mode: draw segments outlines only
    FILLED = 1      // normal mode: solid segments
};

enum class PLOT_TEXT_MODE
{
    STROKE,
    NATIVE,
    PHANTOM,
    DEFAULT
};
 
class PLOT_PARAMS
{
public:
    virtual DXF_OUTLINE_MODE GetDXFPlotMode() const { wxFAIL; return DXF_OUTLINE_MODE::FILLED; }
    virtual PLOT_TEXT_MODE GetTextMode() const { return PLOT_TEXT_MODE::DEFAULT; }
};
 

enum class DXF_LAYER_OUTPUT_MODE
{
    Layer_Name,
    Layer_Color_Name,
    Current_Layer_Name,
    Current_Layer_Color_Name
};

class PLOTTER
{
public:
    // These values are used as flag for pen or aperture selection
    static const int DO_NOT_SET_LINE_WIDTH = -2;    // Skip selection
    static const int USE_DEFAULT_LINE_WIDTH = -1;   // use the default pen
 
    PLOTTER( const PROJECT* aProject = nullptr );
 
    virtual ~PLOTTER();

    virtual PLOT_FORMAT GetPlotterType() const = 0;
 
    virtual bool StartPlot( const wxString& aPageNumber ) = 0;
    virtual bool EndPlot() = 0;
 
    virtual void SetNegative( bool aNegative ) { m_negativeMode = aNegative; }

    virtual void SetColorMode( bool aColorMode ) { m_colorMode = aColorMode; }
    bool GetColorMode() const { return m_colorMode; }
 
    void SetRenderSettings( RENDER_SETTINGS* aSettings ) { m_renderSettings = aSettings; }
    RENDER_SETTINGS* RenderSettings() { return m_renderSettings; }
 
    virtual void SetPageSettings( const PAGE_INFO& aPageSettings ) { m_pageInfo = aPageSettings; }
    PAGE_INFO& PageSettings() { return m_pageInfo; }
 
    void SetPlotMirrored( bool aMirror ) { m_plotMirror = aMirror; };
    bool GetPlotMirrored() const { return m_plotMirror; }

    virtual void SetCurrentLineWidth( int width, void* aData = nullptr ) = 0;
    virtual int GetCurrentLineWidth() const  { return m_currentPenWidth; }
 
    virtual void SetColor( const COLOR4D& color ) = 0;
 
    virtual void SetDash( int aLineWidth, LINE_STYLE aLineStyle ) = 0;
 
    virtual void SetCreator( const wxString& aCreator ) { m_creator = aCreator; }
    virtual void SetTitle( const wxString& aTitle ) { m_title = aTitle; }
    virtual void SetAuthor( const wxString& aAuthor ) { m_author = aAuthor; }
    virtual void SetSubject( const wxString& aSubject ) { m_subject = aSubject; }

    void AddLineToHeader( const wxString& aExtraString )
    {
        m_headerExtraLines.Add( aExtraString );
    }

    void ClearHeaderLinesList()
    {
        m_headerExtraLines.Clear();
    }

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

    void SetLayersToExport( const std::vector<std::pair<PCB_LAYER_ID, wxString>>& aLayersToExport ) { m_layersToExport = aLayersToExport; }

    PCB_LAYER_ID GetLayer() const { return m_layer; }

    void SetLayer( PCB_LAYER_ID aLayer ) { m_layer = aLayer; }

    virtual bool OpenFile( const wxString& aFullFilename );

    double GetIUsPerDecimil() const { return m_IUsPerDecimil; }
 
    int GetPlotterArcLowDef() const { return m_IUsPerDecimil * 8; }
    int GetPlotterArcHighDef() const { return m_IUsPerDecimil * 2; }
 
    // Low level primitives
    virtual void Rect( const VECTOR2I& p1, const VECTOR2I& p2, FILL_T fill, int width,
                       int aCornerRadius = 0 ) = 0;
    virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill, int width ) = 0;
 
    virtual void Arc( const VECTOR2D& aStart, const VECTOR2D& aMid, const VECTOR2D& aEnd,
                      FILL_T aFill, int aWidth );
 
    virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
                      const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill,
                      int aWidth );

    virtual void BezierCurve( const VECTOR2I& aStart, const VECTOR2I& aControl1,
                              const VECTOR2I& aControl2, const VECTOR2I& aEnd,
                              int aTolerance, int aLineThickness );

    virtual void PenTo( const VECTOR2I& pos, char plume ) = 0;
 
    // Convenience functions for PenTo
    void MoveTo( const VECTOR2I& pos )
    {
        PenTo( pos, 'U' );
    }
 
    void LineTo( const VECTOR2I& pos )
    {
        PenTo( pos, 'D' );
    }
 
    void FinishTo( const VECTOR2I& pos )
    {
        PenTo( pos, 'D' );
        PenTo( pos, 'Z' );
    }
 
    void PenFinish()
    {
        // The point is not important with Z motion
        PenTo( VECTOR2I( 0, 0 ), 'Z' );
    }

    virtual void PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill, int aWidth,
                           void* aData ) = 0;

    virtual void PlotPoly( const SHAPE_LINE_CHAIN& aLineChain, FILL_T aFill, int aWidth, void* aData );

    virtual void PlotImage( const wxImage& aImage, const VECTOR2I& aPos, double aScaleFactor );
 
    // Higher level primitives -- can be drawn as line, sketch or 'filled'
    virtual void ThickSegment( const VECTOR2I& start, const VECTOR2I& end, int width, void* aData );
 
    virtual void ThickArc( const EDA_SHAPE& aArcShape, void* aData, int aWidth );
 
    virtual void ThickArc( const VECTOR2D& aCentre, const EDA_ANGLE& aStAngle,
                           const EDA_ANGLE& aAngle, double aRadius, int aWidth, void* aData );
 
    virtual void ThickRect( const VECTOR2I& p1, const VECTOR2I& p2, int width, void* aData );
 
    virtual void ThickCircle( const VECTOR2I& pos, int diametre, int width, void* aData );
 
    virtual void FilledCircle( const VECTOR2I& pos, int diametre, void* aData );
 
    virtual void ThickOval( const VECTOR2I& aPos, const VECTOR2I& aSize, const EDA_ANGLE& aOrient,
                            int aWidth, void* aData );
 
    virtual void ThickPoly( const SHAPE_POLY_SET& aPoly, int aWidth, void* aData );
 
    // Flash primitives

    virtual void FlashPadCircle( const VECTOR2I& aPadPos, int aDiameter, void* aData ) = 0;

    virtual void FlashPadOval( const VECTOR2I& aPadPos, const VECTOR2I& aSize,
                               const EDA_ANGLE& aPadOrient, void* aData ) = 0;

    virtual void FlashPadRect( const VECTOR2I& aPadPos, const VECTOR2I& aSize,
                               const EDA_ANGLE& aPadOrient, void* aData ) = 0;

    virtual void FlashPadRoundRect( const VECTOR2I& aPadPos, const VECTOR2I& aSize,
                                    int aCornerRadius, const EDA_ANGLE& aOrient,
                                    void* aData ) = 0;

    virtual void FlashPadCustom( const VECTOR2I& aPadPos, const VECTOR2I& aSize,
                                 const EDA_ANGLE& aPadOrient, SHAPE_POLY_SET* aPolygons,
                                 void* aData ) = 0;

    virtual void FlashPadTrapez( const VECTOR2I& aPadPos, const VECTOR2I* aCorners,
                                 const EDA_ANGLE& aPadOrient, void* aData ) = 0;

    virtual void FlashRegularPolygon( const VECTOR2I& aShapePos, int aDiameter, int aCornerCount,
                                      const EDA_ANGLE& aOrient, void* aData ) = 0;

    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                    aPenWidth,
                       bool                   aItalic,
                       bool                   aBold,
                       bool                   aMultilineAllowed,
                       KIFONT::FONT*          aFont,
                       const KIFONT::METRICS& aFontMetrics,
                       void*                  aData = nullptr );
 
    virtual void PlotText( const VECTOR2I&        aPos,
                           const COLOR4D&         aColor,
                           const wxString&        aText,
                           const TEXT_ATTRIBUTES& aAttributes,
                           KIFONT::FONT*          aFont = nullptr,
                           const KIFONT::METRICS& aFontMetrics = KIFONT::METRICS::Default(),
                           void*                  aData = nullptr );
    virtual void HyperlinkBox( const BOX2I& aBox, const wxString& aDestinationURL )
    {
        // NOP for most plotters.
    }

    virtual void HyperlinkMenu( const BOX2I& aBox, const std::vector<wxString>& aDestURLs )
    {
        // NOP for most plotters.
    }

    virtual void Bookmark( const BOX2I& aBox, const wxString& aName,
                           const wxString& aGroupName = wxEmptyString )
    {
        // NOP for most plotters.
    }

    static const unsigned MARKER_COUNT = 58;

    void Marker( const VECTOR2I& position, int diametre, unsigned aShapeId );

    virtual void SetLayerPolarity( bool aPositive )
    {
        // NOP for most plotters
    }

    virtual void SetTextMode( PLOT_TEXT_MODE mode )
    {
        // NOP for most plotters.
    }
 
    virtual void SetGerberCoordinatesFormat( int aResolution, bool aUseInches = false )
    {
        // NOP for most plotters. Only for Gerber plotter
    }

    virtual void SetSvgCoordinatesFormat( unsigned aPrecision )
    {
        // NOP for most plotters. Only for SVG plotter
    }

    virtual void StartBlock( void* aData ) {}

    virtual void EndBlock( void* aData ) {}

    VECTOR2I GetPlotOffsetUserUnits() {return m_plotOffset; }
 
 
protected:
    virtual void polyArc( const VECTOR2D& aCentre, const EDA_ANGLE& aStartAngle,
                          const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth );
 
    // These are marker subcomponents
    void markerCircle( const VECTOR2I& pos, int radius );

    void markerHBar( const VECTOR2I& pos, int radius );

    void markerSlash( const VECTOR2I& pos, int radius );

    void markerBackSlash( const VECTOR2I& pos, int radius );

    void markerVBar( const VECTOR2I& pos, int radius );

    void markerSquare( const VECTOR2I& position, int radius );

    void markerLozenge( const VECTOR2I& position, int radius );
 
    // Helper function for sketched filler segment
 
 
    // Coordinate and scaling conversion functions

    virtual VECTOR2D userToDeviceCoordinates( const VECTOR2I& aCoordinate );

    virtual VECTOR2D userToDeviceSize( const VECTOR2I& size );

    virtual double userToDeviceSize( double size ) const;
 
    double GetDotMarkLenIU( int aLineWidth ) const;
 
    double GetDashMarkLenIU( int aLineWidth ) const;
 
    double GetDashGapLenIU( int aLineWidth ) const;
 
 
protected:      // variables used in most of plotters:

    double           m_plotScale;
 
    /* Caller scale (how many IUs in a decimil - always); it's a double
     * because in Eeschema there are 0.1 IUs in a decimil (Eeschema
     * always works in mils internally) while PcbNew can work in decimil
     * or nanometers, so this value would be >= 1 */
     double           m_IUsPerDecimil;
 
    double           m_iuPerDeviceUnit;     // Device scale (from IUs to plotter device units;
                                            // usually decimils)
    VECTOR2I         m_plotOffset;          // Plot offset (in IUs)
    bool             m_plotMirror;          // X axis orientation (SVG)
                                            // and plot mirrored (only for PS, PDF and SVG)
    bool             m_mirrorIsHorizontal;  // true to mirror horizontally (else vertically)
    bool             m_yaxisReversed;       // true if the Y axis is top to bottom (SVG)

    FILE*            m_outputFile;
 
    // Pen handling
    bool             m_colorMode;           // true to plot in color, otherwise black & white
    bool             m_negativeMode;        // true to generate a negative image (PS mode mainly)
    int              m_currentPenWidth;
    char             m_penState;            // current pen state: 'U', 'D' or 'Z' (see PenTo)
    VECTOR2I         m_penLastpos;          // last pen position; -1,-1 when pen is at rest
 
    wxString         m_creator;
    wxString         m_filename;
    wxString         m_title;
    wxString         m_author;
    wxString         m_subject;
    PAGE_INFO        m_pageInfo;
    VECTOR2I         m_paperSize;           // Paper size in IU - not in mils
 
    wxArrayString    m_headerExtraLines;    // a set of string to print in header file
 
    RENDER_SETTINGS* m_renderSettings;
 
    const PROJECT*   m_project;
    std::vector<std::pair<PCB_LAYER_ID, wxString>> m_layersToExport;
 
    PCB_LAYER_ID m_layer;
};
 
 
class TITLE_BLOCK;
 
void PlotDrawingSheet( PLOTTER* plotter, const PROJECT* aProject, const TITLE_BLOCK& aTitleBlock,
                       const PAGE_INFO& aPageInfo, const std::map<wxString, wxString>*aProperties,
                       const wxString& aSheetNumber, int aSheetCount, const wxString& aSheetName,
                       const wxString& aSheetPath, const wxString& aFilename,
                       COLOR4D aColor = COLOR4D::UNSPECIFIED, bool aIsFirstPage = true );

wxString GetDefaultPlotExtension( PLOT_FORMAT aFormat );
 
 
#endif  // PLOT_COMMON_H_