pcb_io_eagle.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <[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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef PCB_IO_EAGLE_H_
#define PCB_IO_EAGLE_H_
 
#include <io/eagle/eagle_parser.h>
#include <pcb_io/pcb_io.h>
#include <pcb_io/pcb_io_mgr.h>
#include <pcb_io/common/plugin_common_layer_mapping.h>
 
#include <eda_units.h>
#include <layer_ids.h>
#include <lset.h>
#include <netclass.h>
 
#include <map>
#include <tuple>
#include <wx/xml/xml.h>
 
class PAD;
class PCB_TEXT;
class ZONE;
 
typedef std::map<wxString, FOOTPRINT*> FOOTPRINT_MAP;
typedef std::vector<ZONE*>             ZONES;
typedef std::map<wxString, ENET>        NET_MAP;
typedef NET_MAP::const_iterator         NET_MAP_CITER;
 

struct ERULES
{
    ERULES() :
        psElongationLong    ( 100 ),
        psElongationOffset  ( 0 ),
 
        mvStopFrame         ( 1.0 ),
        mvCreamFrame        ( 0.0 ),
        mlMinStopFrame      ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  4.0 ) ),
        mlMaxStopFrame      ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  4.0 ) ),
        mlMinCreamFrame     ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  0.0 ) ),
        mlMaxCreamFrame     ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  0.0 ) ),
 
        psTop               ( EPAD::UNDEF ),
        psBottom            ( EPAD::UNDEF ),
        psFirst             ( EPAD::UNDEF ),
 
        srRoundness         ( 0.0 ),
        srMinRoundness      ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  0.0 ) ),
        srMaxRoundness      ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  0.0 ) ),
 
        rvPadTop            ( 0.25 ),
        // rvPadBottom      ( 0.25 ),
        rlMinPadTop         ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  10 ) ),
        rlMaxPadTop         ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  20 ) ),
        rlMinPadInner       ( 0.0 ),
        rlMaxPadInner       ( 0.0 ),
        rlMinPadBottom      ( 0.0 ),
        rlMaxPadBottom      ( 0.0 ),
 
        rvViaOuter          ( 0.25 ),
        rlMinViaOuter       ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  10 ) ),
        rlMaxViaOuter       ( EDA_UNIT_UTILS::Mils2IU( pcbIUScale,  20 ) ),
        mdWireWire          ( 0 )
    {}
 
    void parse( wxXmlNode* aRules, std::function<void()> aCheckpoint );

    int    psElongationLong;
 
    int    psElongationOffset;  

    double mvStopFrame;

    double mvCreamFrame;
    int    mlMinStopFrame;      
    int    mlMaxStopFrame;      
    int    mlMinCreamFrame;     
    int    mlMaxCreamFrame;     
 
    int    psTop;               
    int    psBottom;            
    int    psFirst;             
 
    double srRoundness;         

    int    srMinRoundness;

    int    srMaxRoundness;
 
    double rvPadTop;            
    // double   rvPadBottom;    ///< bottom pad size as percent of drill size
 
    double rlMinPadTop;         
    double rlMaxPadTop;         
    double rlMinPadInner;       
    double rlMaxPadInner;       
    double rlMinPadBottom;      
    double rlMaxPadBottom;      
 
    double rvViaOuter;          
    double rlMinViaOuter;       
    double rlMaxViaOuter;       
    double mdWireWire;          
};
 

class PCB_IO_EAGLE : public PCB_IO, public LAYER_MAPPABLE_PLUGIN
{
public:
    const IO_BASE::IO_FILE_DESC GetBoardFileDesc() const override
    {
        return IO_BASE::IO_FILE_DESC( _HKI( "Eagle PCB files (6.x XML and pre-v6 binary)" ),
                                      { "brd" } );
    }
 
    const IO_BASE::IO_FILE_DESC GetLibraryDesc() const override
    {
        return IO_BASE::IO_FILE_DESC( _HKI( "Eagle ver. 6.x XML library files" ), { "lbr" } );
    }
 
    bool CanReadBoard( const wxString& aFileName ) const override;
    bool CanReadLibrary( const wxString& aFileName ) const override;
    bool CanReadFootprint( const wxString& aFileName ) const override;
 
    std::vector<FOOTPRINT*> GetImportedCachedLibraryFootprints() override;
 
    void FootprintEnumerate( wxArrayString& aFootprintNames, const wxString& aLibraryPath,
                             bool aBestEfforts, const std::map<std::string, UTF8>* aProperties = nullptr) override;
 
    std::unique_ptr<FOOTPRINT> FootprintLoad( const wxString& aLibraryPath, const wxString& aFootprintName,
                                              bool                               aKeepUUID = false,
                                              const std::map<std::string, UTF8>* aProperties = nullptr ) override;
 
    long long GetLibraryTimestamp( const wxString& aLibraryPath ) const override;
 
    bool IsLibraryWritable( const wxString& aLibraryPath ) override
    {
        return false;   // until someone writes others like FootprintSave(), etc.
    }
 
    typedef int BIU;
 
    PCB_IO_EAGLE();
    ~PCB_IO_EAGLE();
 
protected:
    void loadBoard( const wxString& aFileName, BOARD& aBoard, bool aIsNewLoad,
                    const std::map<std::string, UTF8>* aProperties = nullptr, PROJECT* aProject = nullptr ) override;

    std::map<wxString, PCB_LAYER_ID> DefaultLayerMappingCallback(
            const std::vector<INPUT_LAYER_DESC>& aInputLayerDescriptionVector );
 
private:
    void init( const std::map<std::string, UTF8>* aProperties );
 
    bool checkHeader( const wxString& aFileName ) const;
 
    void checkpoint();
 
    void clear_cu_map();

    int kicad_y( const ECOORD& y ) const { return -y.ToPcbUnits(); }
    int kicad_x( const ECOORD& x ) const { return x.ToPcbUnits(); }

    VECTOR2I kicad_fontsize( const ECOORD& d, int aTextThickness ) const;

    void mapEagleLayersToKicad( bool aIsLibraryCache = false );

    PCB_LAYER_ID kicad_layer( int aLayer ) const;

    std::tuple<PCB_LAYER_ID, LSET, bool> defaultKicadLayer( int aEagleLayer,
                                                            bool aIsLibraryCache = false ) const;

    const wxString& eagle_layer_name( int aLayer ) const;

    int eagle_layer_id( const wxString& aLayerName ) const;
 
    void setKeepoutSettingsToZone( ZONE* aZone, int aLayer ) const;

    void cacheLib( const wxString& aLibraryPath );

    static wxDateTime getModificationTime( const wxString& aPath );

    int getMinimumCopperLayerCount() const;
 
    // all these loadXXX() throw IO_ERROR or ptree_error exceptions:
 
    void loadAllSections( wxXmlNode* aDocument );
    void loadDesignRules( wxXmlNode* aDesignRules );
    void loadLayerDefs( wxXmlNode* aLayers );
    void loadPlain( wxXmlNode* aPlain );
    void loadClasses( wxXmlNode* aClasses );
    void loadSignals( wxXmlNode* aSignals );

    void loadLibrary( wxXmlNode* aLib, const wxString* aLibName );
 
    void loadLibraries( wxXmlNode* aLibs );
    void loadElements( wxXmlNode* aElements );

    ZONE* loadPolygon( wxXmlNode* aPolyNode );
 
    void orientFootprintAndText( FOOTPRINT* aFootprint, const EELEMENT& e, const EATTR* aNameAttr,
                                 const EATTR* aValueAttr );
 
    void orientFPText( FOOTPRINT* aFootprint, const EELEMENT& e, PCB_TEXT* aFPText, const EATTR* aAttr,
                       double aTextDefAngle = 0.0, bool aTextDefMirror = false, bool aTextDefSpin = false );
 

    void adjustFootprintForDesignRules( FOOTPRINT* aFootprint );

    void centerBoard();

    FOOTPRINT* makeFootprint( wxXmlNode* aPackage, const wxString& aPkgName );
 
    void packageWire( FOOTPRINT* aFootprint, wxXmlNode* aTree ) const;
    void packagePad( FOOTPRINT* aFootprint, wxXmlNode* aTree );
    void packageText( FOOTPRINT* aFootprint, wxXmlNode* aTree ) const;
    void packageRectangle( FOOTPRINT* aFootprint, wxXmlNode* aTree ) const;
    void packagePolygon( FOOTPRINT* aFootprint, wxXmlNode* aTree ) const;
    void packageCircle( FOOTPRINT* aFootprint, wxXmlNode* aTree ) const;

    void packageHole( FOOTPRINT* aFootprint, wxXmlNode* aTree, bool aCenter ) const;
    void packageSMD( FOOTPRINT* aFootprint, wxXmlNode* aTree ) const;

    void transferPad( const EPAD_COMMON& aEaglePad, PAD* aPad ) const;

    void deleteTemplates();
 
    typedef std::vector<ELAYER>     ELAYERS;
    typedef ELAYERS::const_iterator EITER;
 
    int                              m_cu_map[17];     
    std::map<int, ELAYER>            m_eagleLayers;    
    std::map<wxString, int>          m_eagleLayersIds; 
    std::map<wxString, PCB_LAYER_ID> m_layer_map;      

    std::map<wxString, std::shared_ptr<NETCLASS>>  m_classMap;
 
    wxString                         m_customRules;
 
    ERULES*       m_rules;          
    XPATH*        m_xpath;          
 
    int           m_hole_count;     
 
    NET_MAP       m_pads_to_nets;   
 
    std::map<wxString, FOOTPRINT*> m_templates;  
 
    PROGRESS_REPORTER*  m_progressReporter;  
    unsigned            m_doneCount;
    unsigned            m_lastProgressCount;
    unsigned            m_totalCount;         
 
    int                 m_min_trace;        
    int                 m_min_hole;         
    int                 m_min_via;          
    int                 m_min_annulus;      
 
    wxString            m_lib_path;
    long long           m_timestamp;
};
 
#endif  // PCB_IO_EAGLE_H_