252 lines
7.9 KiB
C++
252 lines
7.9 KiB
C++
#ifndef EAGLE_PLUGIN_H_
|
|
#define EAGLE_PLUGIN_H_
|
|
|
|
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
|
|
* Copyright (C) 2012 KiCad Developers, see change_log.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 <io_mgr.h>
|
|
|
|
|
|
// forward declaration on ptree template so we can confine use of big boost
|
|
// headers to only the implementation *.cpp file.
|
|
|
|
#include <boost/property_tree/ptree_fwd.hpp>
|
|
#include <boost/ptr_container/ptr_map.hpp>
|
|
#include <map>
|
|
|
|
|
|
class MODULE;
|
|
typedef boost::ptr_map< std::string, MODULE > MODULE_MAP;
|
|
|
|
|
|
struct ENET
|
|
{
|
|
int netcode;
|
|
std::string netname;
|
|
|
|
ENET( int aNetCode, const std::string& aNetName ) :
|
|
netcode( aNetCode ),
|
|
netname( aNetName )
|
|
{}
|
|
|
|
ENET() :
|
|
netcode( 0 )
|
|
{}
|
|
};
|
|
|
|
typedef std::map< std::string, ENET > NET_MAP;
|
|
typedef NET_MAP::const_iterator NET_MAP_CITER;
|
|
|
|
/*
|
|
#include
|
|
namespace boost {
|
|
namespace property_tree
|
|
{
|
|
template < class Key, class Data, class KeyCompare = std::less<Key> >
|
|
class basic_ptree;
|
|
|
|
typedef basic_ptree< std::string, std::string > ptree;
|
|
}
|
|
}
|
|
*/
|
|
|
|
typedef boost::property_tree::ptree PTREE;
|
|
typedef const PTREE CPTREE;
|
|
|
|
struct EWIRE;
|
|
struct EVIA;
|
|
struct EROT;
|
|
struct EATTR;
|
|
struct ECIRCLE;
|
|
struct ETEXT;
|
|
struct ERECT;
|
|
struct EPAD;
|
|
struct ESMD;
|
|
struct EVERTEX;
|
|
struct EPOLYGON;
|
|
|
|
/**
|
|
* Class EAGLE_PLUGIN
|
|
* works with Eagle 6.x XML board files and footprints.
|
|
*/
|
|
class EAGLE_PLUGIN : public PLUGIN
|
|
{
|
|
public:
|
|
|
|
//-----<PUBLIC PLUGIN API>--------------------------------------------------
|
|
const wxString& PluginName() const;
|
|
|
|
BOARD* Load( const wxString& aFileName, BOARD* aAppendToMe, PROPERTIES* aProperties = NULL );
|
|
|
|
const wxString& GetFileExtension() const;
|
|
|
|
/*
|
|
void Save( const wxString& aFileName, BOARD* aBoard, PROPERTIES* aProperties = NULL );
|
|
|
|
wxArrayString FootprintEnumerate( const wxString& aLibraryPath, PROPERTIES* aProperties = NULL);
|
|
|
|
MODULE* FootprintLoad( const wxString& aLibraryPath, const wxString& aFootprintName, PROPERTIES* aProperties = NULL );
|
|
|
|
void FootprintSave( const wxString& aLibraryPath, const MODULE* aFootprint, PROPERTIES* aProperties = NULL );
|
|
|
|
void FootprintDelete( const wxString& aLibraryPath, const wxString& aFootprintName );
|
|
|
|
void FootprintLibCreate( const wxString& aLibraryPath, PROPERTIES* aProperties = NULL );
|
|
|
|
void FootprintLibDelete( const wxString& aLibraryPath, PROPERTIES* aProperties = NULL );
|
|
|
|
bool IsFootprintLibWritable( const wxString& aLibraryPath );
|
|
*/
|
|
|
|
//-----</PUBLIC PLUGIN API>-------------------------------------------------
|
|
|
|
typedef int BIU;
|
|
|
|
EAGLE_PLUGIN();
|
|
~EAGLE_PLUGIN();
|
|
|
|
private:
|
|
|
|
NET_MAP m_pads_to_nets;
|
|
|
|
MODULE_MAP m_templates; ///< is part of a MODULE factory that operates
|
|
///< using copy construction.
|
|
///< lookup key is libname.packagename
|
|
|
|
PROPERTIES* m_props; ///< passed via Save() or Load(), no ownership, may be NULL.
|
|
|
|
BOARD* m_board; ///< which BOARD, no ownership here
|
|
double mm_per_biu; ///< how many mm in each BIU
|
|
double biu_per_mm; ///< how many bius in a mm
|
|
|
|
/// initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
|
|
void init( PROPERTIES* aProperties );
|
|
|
|
int kicad( double d ) const;
|
|
int kicad_y( double y ) const { return -kicad( y ); }
|
|
int kicad_x( double x ) const { return kicad( x ); }
|
|
wxSize kicad_fontz( double d ) const;
|
|
|
|
|
|
static int kicad_layer( int aLayer );
|
|
|
|
double eagle( BIU d ) const { return mm_per_biu * d; }
|
|
double eagle_x( BIU x ) const { return eagle( x ); }
|
|
double eagle_y( BIU y ) const { return eagle( y ); }
|
|
|
|
|
|
#if 0
|
|
/// encapsulate the BIU formatting tricks in one place.
|
|
int biuSprintf( char* buf, BIU aValue ) const;
|
|
|
|
/**
|
|
* Function fmtBIU
|
|
* converts a BIU to engineering units by scaling and formatting to ASCII.
|
|
* This function is the complement of biuParse(). One has to know what the
|
|
* other is doing.
|
|
*/
|
|
std::string fmtBIU( BIU aValue ) const;
|
|
|
|
std::string fmtBIUPair( BIU first, BIU second ) const;
|
|
|
|
std::string fmtBIUPoint( const wxPoint& aPoint ) const
|
|
{
|
|
return fmtBIUPair( aPoint.x, aPoint.y );
|
|
}
|
|
|
|
std::string fmtBIUSize( const wxSize& aSize ) const
|
|
{
|
|
return fmtBIUPair( aSize.x, aSize.y );
|
|
}
|
|
#endif
|
|
|
|
// all these loadXXX() throw IO_ERROR or ptree_error exceptions:
|
|
|
|
void loadAllSections( CPTREE& aEagleBoard, const std::string& aXpath, bool aAppendToMe );
|
|
|
|
void loadPlain( CPTREE& aPlain, const std::string& aXpath );
|
|
|
|
void loadSignals( CPTREE& aSignals, const std::string& aXpath );
|
|
|
|
void loadLibraries( CPTREE& aLibs, const std::string& aXpath );
|
|
|
|
void loadElements( CPTREE& aElements, const std::string& aXpath );
|
|
|
|
// none of the 'e'funcs do any "to KiCad" conversion, they merely read the XML into binary:
|
|
|
|
/**
|
|
* Function ewire
|
|
* converts a <wire>'s xml attributes to binary without additional conversion.
|
|
* @param aResult is an EWIRE to fill in with the <wire> data converted to binary.
|
|
*/
|
|
EWIRE ewire( CPTREE& aWire ) const;
|
|
|
|
EVIA evia( CPTREE& aVia ) const;
|
|
|
|
ECIRCLE ecircle( CPTREE& aCircle ) const;
|
|
ETEXT etext( CPTREE& aText ) const;
|
|
ERECT erect( CPTREE& aRect ) const;
|
|
|
|
EROT erot( const std::string& aRot ) const;
|
|
EPAD epad( CPTREE& aPad ) const;
|
|
ESMD esmd( CPTREE& aSMD ) const;
|
|
EVERTEX evertex( CPTREE& aVertex ) const;
|
|
EPOLYGON epolygon( CPTREE& aPolygon ) const;
|
|
|
|
/**
|
|
* Function eattr
|
|
* parses an Eagle "attribute" element. Note that an attribute element
|
|
* is different than an XML element attribute. The attribute element is a
|
|
* full XML node in and of itself, and has attributes of its own. Blame Eagle.
|
|
*/
|
|
EATTR eattr( CPTREE& aAttribute ) const;
|
|
|
|
/**
|
|
* Function fmtDEG
|
|
* formats an angle in a way particular to a board file format. This function
|
|
* is the opposite or complement of degParse(). One has to know what the
|
|
* other is doing.
|
|
*/
|
|
std::string fmtDEG( double aAngle ) const;
|
|
|
|
/**
|
|
* Function makeModule
|
|
* creates a MODULE from an Eagle package.
|
|
*/
|
|
MODULE* makeModule( CPTREE& aPackage, const std::string& aPkgName ) const;
|
|
|
|
void packageWire( MODULE* aModule, CPTREE& aTree ) const;
|
|
void packagePad( MODULE* aModule, CPTREE& aTree ) const;
|
|
void packageText( MODULE* aModule, CPTREE& aTree ) const;
|
|
void packageRectangle( MODULE* aModule, CPTREE& aTree ) const;
|
|
void packagePolygon( MODULE* aModule, CPTREE& aTree ) const;
|
|
void packageCircle( MODULE* aModule, CPTREE& aTree ) const;
|
|
void packageHole( MODULE* aModule, CPTREE& aTree ) const;
|
|
void packageSMD( MODULE* aModule, CPTREE& aTree ) const;
|
|
|
|
};
|
|
|
|
#endif // EAGLE_PLUGIN_H_
|