SCH_EAGLE_PLUGIN Class Reference

A SCH_PLUGIN derivation for loading 6.x+ Eagle schematic files. More...

#include <sch_eagle_plugin.h>

Inheritance diagram for SCH_EAGLE_PLUGIN:

Classes
struct	EAGLE_MISSING_CMP
struct	SEG_DESC
	Segments representing wires for intersection checking. More...

Public Member Functions
	SCH_EAGLE_PLUGIN ()
	~SCH_EAGLE_PLUGIN ()
const wxString	GetName () const override
	Return a brief hard coded name for this SCH_PLUGIN. More...
void	SetReporter (REPORTER *aReporter) override
	Set an optional reporter for warnings/errors. More...
void	SetProgressReporter (PROGRESS_REPORTER *aReporter) override
	Set an optional progress reporter. More...
const wxString	GetFileExtension () const override
	Return the file extension for the SCH_PLUGIN. More...
const wxString	GetLibraryFileExtension () const override
	Return the library file extension for the SCH_PLUGIN object. More...
int	GetModifyHash () const override
	Return the modification hash from the library cache. More...
SCH_SHEET *	Load (const wxString &aFileName, SCHEMATIC *aSchematic, SCH_SHEET *aAppendToMe=nullptr, const PROPERTIES *aProperties=nullptr) override
	Load information from some input file format that this SCH_PLUGIN implementation knows about, into either a new SCH_SHEET or an existing one. More...
bool	CheckHeader (const wxString &aFileName) override
	Return true if the first line in aFileName begins with the expected header. More...
virtual void	SaveLibrary (const wxString &aFileName, const PROPERTIES *aProperties=nullptr)
virtual void	Save (const wxString &aFileName, SCH_SHEET *aSheet, SCHEMATIC *aSchematic, const PROPERTIES *aProperties=nullptr)
	Write aSchematic to a storage file in a format that this SCH_PLUGIN implementation knows about, or it can be used to write a portion of aSchematic to a special kind of export file. More...
virtual void	EnumerateSymbolLib (wxArrayString &aSymbolNameList, const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr)
	Populate a list of LIB_SYMBOL alias names contained within the library aLibraryPath. More...
virtual void	EnumerateSymbolLib (std::vector< LIB_SYMBOL * > &aSymbolList, const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr)
	Populate a list of LIB_SYMBOL aliases contained within the library aLibraryPath. More...
virtual LIB_SYMBOL *	LoadSymbol (const wxString &aLibraryPath, const wxString &aPartName, const PROPERTIES *aProperties=nullptr)
	Load a LIB_SYMBOL object having aPartName from the aLibraryPath containing a library format that this SCH_PLUGIN knows about. More...
virtual void	SaveSymbol (const wxString &aLibraryPath, const LIB_SYMBOL *aSymbol, const PROPERTIES *aProperties=nullptr)
	Write aSymbol to an existing library located at aLibraryPath. More...
virtual void	DeleteSymbol (const wxString &aLibraryPath, const wxString &aSymbolName, const PROPERTIES *aProperties=nullptr)
	Delete the entire LIB_SYMBOL associated with aAliasName from the library aLibraryPath. More...
virtual void	CreateSymbolLib (const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr)
	Create a new empty symbol library at aLibraryPath. More...
virtual bool	DeleteSymbolLib (const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr)
	Delete an existing symbol library and returns true if successful, or if library does not exist returns false, or throws an exception if library exists but is read only or cannot be deleted for some other reason. More...
virtual bool	IsSymbolLibWritable (const wxString &aLibraryPath)
	Return true if the library at aLibraryPath is writable. More...
virtual void	SymbolLibOptions (PROPERTIES *aListToAppendTo) const
	Append supported SCH_PLUGIN options to aListToAppenTo along with internationalized descriptions. More...
virtual const wxString &	GetError () const
	Return an error string to the caller. More...

Private Member Functions
void	checkpoint ()
void	loadDrawing (wxXmlNode *aDrawingNode)
void	loadLayerDefs (wxXmlNode *aLayers)
void	loadSchematic (wxXmlNode *aSchematicNode)
void	loadSheet (wxXmlNode *aSheetNode, int sheetcount)
void	loadInstance (wxXmlNode *aInstanceNode)
EAGLE_LIBRARY *	loadLibrary (wxXmlNode *aLibraryNode, EAGLE_LIBRARY *aEagleLib)
void	countNets (wxXmlNode *aSchematicNode)
void	moveLabels (SCH_LINE *aWire, const wxPoint &aNewEndPoint)
	Move any labels on the wire to the new end point of the wire. More...
void	addBusEntries ()
	This function finds best way to place a bus entry symbol for when an Eagle wire segment ends on an Eagle bus segment. More...
SCH_LAYER_ID	kiCadLayer (int aEagleLayer)
	Return the matching layer or return LAYER_NOTES. More...
std::pair< VECTOR2I, const SEG * >	findNearestLinePoint (const wxPoint &aPoint, const std::vector< SEG > &aLines) const
void	loadSegments (wxXmlNode *aSegmentsNode, const wxString &aNetName, const wxString &aNetClass)
SCH_LINE *	loadWire (wxXmlNode *aWireNode)
SCH_TEXT *	loadLabel (wxXmlNode *aLabelNode, const wxString &aNetName)
SCH_JUNCTION *	loadJunction (wxXmlNode *aJunction)
SCH_TEXT *	loadPlainText (wxXmlNode *aSchText)
void	loadFrame (wxXmlNode *aFrameNode, std::vector< SCH_LINE * > &aLines)
bool	loadSymbol (wxXmlNode *aSymbolNode, std::unique_ptr< LIB_SYMBOL > &aSymbol, EDEVICE *aDevice, int aGateNumber, const wxString &aGateName)
LIB_SHAPE *	loadSymbolCircle (std::unique_ptr< LIB_SYMBOL > &aSymbol, wxXmlNode *aCircleNode, int aGateNumber)
LIB_SHAPE *	loadSymbolRectangle (std::unique_ptr< LIB_SYMBOL > &aSymbol, wxXmlNode *aRectNode, int aGateNumber)
LIB_SHAPE *	loadSymbolPolyLine (std::unique_ptr< LIB_SYMBOL > &aSymbol, wxXmlNode *aPolygonNode, int aGateNumber)
LIB_ITEM *	loadSymbolWire (std::unique_ptr< LIB_SYMBOL > &aSymbol, wxXmlNode *aWireNode, int aGateNumber)
LIB_PIN *	loadPin (std::unique_ptr< LIB_SYMBOL > &aSymbol, wxXmlNode *, EPIN *epin, int aGateNumber)
LIB_TEXT *	loadSymbolText (std::unique_ptr< LIB_SYMBOL > &aSymbol, wxXmlNode *aLibText, int aGateNumber)
void	loadFrame (wxXmlNode *aFrameNode, std::vector< LIB_ITEM * > &aLines)
void	loadTextAttributes (EDA_TEXT *aText, const ETEXT &aAttribs) const
void	loadFieldAttributes (LIB_FIELD *aField, const LIB_TEXT *aText) const
	Move net labels that are detached from any wire to the nearest wire. More...
void	adjustNetLabels ()
wxString	translateEagleBusName (const wxString &aEagleName) const
	Translate an Eagle-style bus name into one that is KiCad-compatible. More...
wxString	getLibName ()
wxFileName	getLibFileName ()
	Checks if there are other wires or pins at the position of the tested pin. More...
bool	checkConnections (const SCH_SYMBOL *aSymbol, const LIB_PIN *aPin) const
void	addImplicitConnections (SCH_SYMBOL *aSymbol, SCH_SCREEN *aScreen, bool aUpdateSet)
	Create net labels to emulate implicit connections in Eagle. More...
bool	netHasPowerDriver (SCH_LINE *aLine, const wxString &aNetName) const

Private Attributes
REPORTER *	m_reporter
	Reporter for warnings/errors. More...
std::map< wxString, EAGLE_MISSING_CMP >	m_missingCmps
SCH_SHEET *	m_rootSheet
	The root sheet of the schematic being loaded. More...
SCH_SHEET *	m_currentSheet
	The current sheet of the schematic being loaded. More...
wxString	m_version
	Eagle file version. More...
wxFileName	m_filename
wxString	m_libName
	Library name to save symbols. More...
SCHEMATIC *	m_schematic
	Passed to Load(), the schematic object being loaded. More...
EPART_MAP	m_partlist
std::map< wxString, EAGLE_LIBRARY >	m_eagleLibs
SCH_PLUGIN::SCH_PLUGIN_RELEASER	m_pi
	PI to create KiCad symbol library. More...
std::unique_ptr< PROPERTIES >	m_properties
	Library plugin properties. More...
PROGRESS_REPORTER *	m_progressReporter
	optional; may be nullptr More...
unsigned	m_doneCount
unsigned	m_lastProgressCount
unsigned	m_totalCount
	for progress reporting More...
std::map< wxString, int >	m_netCounts
std::map< int, SCH_LAYER_ID >	m_layerMap
std::map< wxString, wxString >	m_powerPorts
	map from symbol reference to global label equivalent More...
std::vector< VECTOR2I >	m_wireIntersections
	Wires and labels of a single connection (segment in Eagle nomenclature) More...
std::vector< SEG_DESC >	m_segments
	Nets as defined in the <nets> sections of an Eagle schematic file. More...
std::map< wxString, ENET >	m_nets
	Positions of pins and wire endings mapped to its parent. More...
std::map< wxPoint, std::set< const EDA_ITEM * > >	m_connPoints

Detailed Description

A SCH_PLUGIN derivation for loading 6.x+ Eagle schematic files.

As with all SCH_PLUGINs there is no UI dependencies i.e. windowing calls allowed.

Definition at line 80 of file sch_eagle_plugin.h.

Constructor & Destructor Documentation

SCH_EAGLE_PLUGIN()

SCH_EAGLE_PLUGIN::SCH_EAGLE_PLUGIN

(

)

Definition at line 353 of file sch_eagle_plugin.cpp.

 :
 m_progressReporter( nullptr ),
 m_doneCount( 0 ),
 m_lastProgressCount( 0 ),
 m_totalCount( 0 )
{
 m_rootSheet = nullptr;
 m_currentSheet = nullptr;
 m_schematic = nullptr;

 m_reporter = &WXLOG_REPORTER::GetInstance();
}

References WXLOG_REPORTER::GetInstance(), m_currentSheet, m_reporter, m_rootSheet, and m_schematic.

~SCH_EAGLE_PLUGIN()

SCH_EAGLE_PLUGIN::~SCH_EAGLE_PLUGIN

(

)

Definition at line 367 of file sch_eagle_plugin.cpp.

{
}

Member Function Documentation

addBusEntries()

void SCH_EAGLE_PLUGIN::addBusEntries ( )

private

This function finds best way to place a bus entry symbol for when an Eagle wire segment ends on an Eagle bus segment.

Definition at line 2325 of file sch_eagle_plugin.cpp.

{
 // Add bus entry symbols
 // TODO: Cleanup this function and break into pieces

 // for each wire segment, compare each end with all busses.
 // If the wire end is found to end on a bus segment, place a bus entry symbol.

 std::vector<SCH_LINE*> buses;
 std::vector<SCH_LINE*> wires;

 for( SCH_ITEM* ii : m_currentSheet->GetScreen()->Items().OfType( SCH_LINE_T ) )
 {
 SCH_LINE* line = static_cast<SCH_LINE*>( ii );

 if( line->IsBus() )
 buses.push_back( line );
 else if( line->IsWire() )
 wires.push_back( line );
 }

 for( SCH_LINE* wire : wires )
 {
 wxPoint wireStart = wire->GetStartPoint();
 wxPoint wireEnd = wire->GetEndPoint();

 for( SCH_LINE* bus : buses )
 {
 wxPoint busStart = bus->GetStartPoint();
 wxPoint busEnd = bus->GetEndPoint();

 auto entrySize =
 []( int signX, int signY ) -> wxPoint
 {
 return wxPoint( Mils2iu( DEFAULT_SCH_ENTRY_SIZE ) * signX,
 Mils2iu( DEFAULT_SCH_ENTRY_SIZE ) * signY );
 };

 auto testBusHit =
 [&]( const wxPoint& aPt ) -> bool
 {
 return TestSegmentHit( aPt, busStart, busEnd, 0 );
 };

 if( wireStart.y == wireEnd.y && busStart.x == busEnd.x )
 {
 // Horizontal wire and vertical bus

 if( testBusHit( wireStart ) )
 {
 // Wire start is on the vertical bus

 if( wireEnd.x < busStart.x )
 {
 /* the end of the wire is to the left of the bus
 * ⎥⎢
 * ——————⎥⎢
 * ⎥⎢
 */
 wxPoint p = wireStart + entrySize( -1, 0 );

 if( testBusHit( wireStart + entrySize( 0, -1 ) ) )
 {
 /* there is room above the wire for the bus entry
 * ⎥⎢
 * _____/⎥⎢
 * ⎥⎢
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 1 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else if( testBusHit( wireStart + entrySize( 0, 1 ) ) )
 {
 /* there is room below the wire for the bus entry
 * _____ ⎥⎢
 * \⎥⎢
 * ⎥⎢
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 2 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else
 {
 auto ercItem = ERC_ITEM::Create( ERCE_BUS_ENTRY_NEEDED );
 SCH_MARKER* marker = new SCH_MARKER( ercItem, wireStart );
 m_currentSheet->GetScreen()->Append( marker );
 }
 }
 else
 {
 /* the wire end is to the right of the bus
 * ⎥⎢
 * ⎥⎢——————
 * ⎥⎢
 */
 wxPoint p = wireStart + entrySize( 1, 0 );

 if( testBusHit( wireStart + entrySize( 0, -1 ) ) )
 {
 /* There is room above the wire for the bus entry
 * ⎥⎢
 * ⎥⎢\_____
 * ⎥⎢
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p , 4 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else if( testBusHit( wireStart + entrySize( 0, 1 ) ) )
 {
 /* There is room below the wire for the bus entry
 * ⎥⎢ _____
 * ⎥⎢/
 * ⎥⎢
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 3 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else
 {
 auto ercItem = ERC_ITEM::Create( ERCE_BUS_ENTRY_NEEDED );
 SCH_MARKER* marker = new SCH_MARKER( ercItem, wireStart );
 m_currentSheet->GetScreen()->Append( marker );
 }
 }

 break;
 }
 else if( testBusHit( wireEnd ) )
 {
 // Wire end is on the vertical bus

 if( wireStart.x < busStart.x )
 {
 /* start of the wire is to the left of the bus
 * ⎥⎢
 * ——————⎥⎢
 * ⎥⎢
 */
 wxPoint p = wireEnd + entrySize( -1, 0 );

 if( testBusHit( wireEnd + entrySize( 0, -1 ) ) )
 {
 /* there is room above the wire for the bus entry
 * ⎥⎢
 * _____/⎥⎢
 * ⎥⎢
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 1 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else if( testBusHit( wireEnd + entrySize( 0, -1 ) ) )
 {
 /* there is room below the wire for the bus entry
 * _____ ⎥⎢
 * \⎥⎢
 * ⎥⎢
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 2 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, wireEnd + entrySize( -1, 0 ) );
 wire->SetEndPoint( wireEnd + entrySize( -1, 0 ) );
 }
 else
 {
 auto ercItem = ERC_ITEM::Create( ERCE_BUS_ENTRY_NEEDED );
 SCH_MARKER* marker = new SCH_MARKER( ercItem, wireEnd );
 m_currentSheet->GetScreen()->Append( marker );
 }
 }
 else
 {
 /* the start of the wire is to the right of the bus
 * ⎥⎢
 * ⎥⎢——————
 * ⎥⎢
 */
 wxPoint p = wireEnd + entrySize( 1, 0 );

 if( testBusHit( wireEnd + entrySize( 0, -1 ) ) )
 {
 /* There is room above the wire for the bus entry
 * ⎥⎢
 * ⎥⎢\_____
 * ⎥⎢
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 4 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else if( testBusHit( wireEnd + entrySize( 0, 1 ) ) )
 {
 /* There is room below the wire for the bus entry
 * ⎥⎢ _____
 * ⎥⎢/
 * ⎥⎢
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 3 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else
 {
 auto ercItem = ERC_ITEM::Create( ERCE_BUS_ENTRY_NEEDED );
 SCH_MARKER* marker = new SCH_MARKER( ercItem, wireEnd );
 m_currentSheet->GetScreen()->Append( marker );
 }
 }

 break;
 }
 }
 else if( wireStart.x == wireEnd.x && busStart.y == busEnd.y )
 {
 // Vertical wire and horizontal bus

 if( testBusHit( wireStart ) )
 {
 // Wire start is on the bus

 if( wireEnd.y < busStart.y )
 {
 /* the end of the wire is above the bus
 * |
 * |
 * |
 * =======
 */
 wxPoint p = wireStart + entrySize( 0, -1 );

 if( testBusHit( wireStart + entrySize( -1, 0 ) ) )
 {
 /* there is room to the left of the wire for the bus entry
 * |
 * |
 * /
 * =======
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 3 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else if( testBusHit( wireStart + entrySize( 1, 0 ) ) )
 {
 /* there is room to the right of the wire for the bus entry
 * |
 * |
 * \
 * =======
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 2 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else
 {
 auto ercItem = ERC_ITEM::Create( ERCE_BUS_ENTRY_NEEDED );
 SCH_MARKER* marker = new SCH_MARKER( ercItem, wireStart );
 m_currentSheet->GetScreen()->Append( marker );
 }
 }
 else
 {
 /* wire end is below the bus
 * =======
 * |
 * |
 * |
 */
 wxPoint p = wireStart + entrySize( 0, 1 );

 if( testBusHit( wireStart + entrySize( -1, 0 ) ) )
 {
 /* there is room to the left of the wire for the bus entry
 * =======
 * \
 * |
 * |
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 4 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else if( testBusHit( wireStart + entrySize( 1, 0 ) ) )
 {
 /* there is room to the right of the wire for the bus entry
 * =======
 * /
 * |
 * |
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 1 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else
 {
 auto ercItem = ERC_ITEM::Create( ERCE_BUS_ENTRY_NEEDED );
 SCH_MARKER* marker = new SCH_MARKER( ercItem, wireStart );
 m_currentSheet->GetScreen()->Append( marker );
 }
 }

 break;
 }
 else if( testBusHit( wireEnd ) )
 {
 // Wire end is on the bus

 if( wireStart.y < busStart.y )
 {
 /* the start of the wire is above the bus
 * |
 * |
 * |
 * =======
 */
 wxPoint p = wireEnd + entrySize( 0, -1 );

 if( testBusHit( wireEnd + entrySize( -1, 0 ) ) )
 {
 /* there is room to the left of the wire for the bus entry
 * |
 * |
 * /
 * =======
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 3 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else if( testBusHit( wireEnd + entrySize( 1, 0 ) ) )
 {
 /* there is room to the right of the wire for the bus entry
 * |
 * |
 * \
 * =======
  */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 2 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else
 {
 auto ercItem = ERC_ITEM::Create( ERCE_BUS_ENTRY_NEEDED );
 SCH_MARKER* marker = new SCH_MARKER( ercItem, wireEnd );
 m_currentSheet->GetScreen()->Append( marker );
 }
 }
 else
 {
 /* wire start is below the bus
 * =======
 * |
 * |
  * |
 */
 wxPoint p = wireEnd + entrySize( 0, 1 );

 if( testBusHit( wireEnd + entrySize( -1, 0 ) ) )
 {
 /* there is room to the left of the wire for the bus entry
 * =======
 * \
 * |
 * |
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 4 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else if( testBusHit( wireEnd + entrySize( 1, 0 ) ) )
 {
 /* there is room to the right of the wire for the bus entry
 * =======
 * /
 * |
 * |
 */
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 1 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else
 {
 auto ercItem = ERC_ITEM::Create( ERCE_BUS_ENTRY_NEEDED );
 SCH_MARKER* marker = new SCH_MARKER( ercItem, wireEnd );
 m_currentSheet->GetScreen()->Append( marker );
 }
 }

 break;
 }
 }
 else
  {
 // Wire isn't horizontal or vertical

 if( testBusHit( wireStart ) )
 {
 wxPoint wirevector = wireStart - wireEnd;

 if( wirevector.x > 0 )
 {
 if( wirevector.y > 0 )
 {
 wxPoint p = wireStart + entrySize( -1, -1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 2 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );

 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else
 {
 wxPoint p = wireStart + entrySize( -1, 1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 1 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );

 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 }
 else
 {
 if( wirevector.y > 0 )
 {
 wxPoint p = wireStart + entrySize( 1, -1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 3 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );

 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else
 {
 wxPoint p = wireStart + entrySize( 1, 1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 4 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );

 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 }

 break;
 }
 else if( testBusHit( wireEnd ) )
 {
 wxPoint wirevector = wireStart - wireEnd;

 if( wirevector.x > 0 )
 {
 if( wirevector.y > 0 )
 {
 wxPoint p = wireEnd + entrySize( 1, 1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 4 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );

 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else
 {
 wxPoint p = wireEnd + entrySize( 1, -1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 3 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );

 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 }
 else
 {
 if( wirevector.y > 0 )
 {
 wxPoint p = wireEnd + entrySize( -1, 1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 1 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );

 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else
 {
 wxPoint p = wireEnd + entrySize( -1, -1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 2 );
 busEntry->SetFlags( IS_NEW );
 m_currentSheet->GetScreen()->Append( busEntry );

 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 }

 break;
 }
 }
 }
 }
}

References SCH_SCREEN::Append(), ERC_ITEM::Create(), DEFAULT_SCH_ENTRY_SIZE, ERCE_BUS_ENTRY_NEEDED, SCH_SHEET::GetScreen(), IS_NEW, SCH_LINE::IsBus(), SCH_LINE::IsWire(), SCH_SCREEN::Items(), m_currentSheet, moveLabels(), EE_RTREE::OfType(), SCH_LINE_T, EDA_ITEM::SetFlags(), and TestSegmentHit().

Referenced by loadSheet().

addImplicitConnections()

void SCH_EAGLE_PLUGIN::addImplicitConnections ( SCH_SYMBOL *  aSymbol, SCH_SCREEN *  aScreen, bool  aUpdateSet  )

private

Create net labels to emulate implicit connections in Eagle.

Each named power input pin creates an implicit connection in Eagle. To emulate this behavior one needs to attach global net labels to the mentioned pins. This is is also expected for the units that are not instantiated in the schematics, therefore such units need to be stored in order to create them at later stage.

Parameters

aSymbol	is the symbol to process.
aScreen	is the screen where net labels should be added.
aUpdateSet	decides whether the missing units data should be updated.

Definition at line 2901 of file sch_eagle_plugin.cpp.

{
 wxCHECK( aSymbol->GetLibSymbolRef(), /*void*/ );

 // Normally power parts also have power input pins,
 // but they already force net names on the attached wires
 if( aSymbol->GetLibSymbolRef()->IsPower() )
 return;

 int unit = aSymbol->GetUnit();
 const wxString reference = aSymbol->GetField( REFERENCE_FIELD )->GetText();
 std::vector<LIB_PIN*> pins;
 aSymbol->GetLibSymbolRef()->GetPins( pins );
 std::set<int> missingUnits;

 // Search all units for pins creating implicit connections
 for( const LIB_PIN* pin : pins )
 {
 if( pin->GetType() == ELECTRICAL_PINTYPE::PT_POWER_IN )
 {
 bool pinInUnit = !unit || pin->GetUnit() == unit; // pin belongs to the tested unit

 // Create a global net label only if there are no other wires/pins attached
 if( pinInUnit )
 {
 if( !checkConnections( aSymbol, pin ) )
 {
 // Create a net label to force the net name on the pin
 SCH_GLOBALLABEL* netLabel = new SCH_GLOBALLABEL;
 netLabel->SetPosition( aSymbol->GetPinPhysicalPosition( pin ) );
 netLabel->SetText( extractNetName( pin->GetName() ) );
 netLabel->SetTextSize( wxSize( Mils2iu( 40 ), Mils2iu( 40 ) ) );

 switch( pin->GetOrientation() )
 {
 case PIN_LEFT: netLabel->SetLabelSpinStyle( LABEL_SPIN_STYLE::RIGHT ); break;
 case PIN_RIGHT: netLabel->SetLabelSpinStyle( LABEL_SPIN_STYLE::LEFT ); break;
 case PIN_UP: netLabel->SetLabelSpinStyle( LABEL_SPIN_STYLE::UP ); break;
 case PIN_DOWN: netLabel->SetLabelSpinStyle( LABEL_SPIN_STYLE::BOTTOM ); break;
 }

 aScreen->Append( netLabel );
 }
 }
 else if( aUpdateSet )
 {
 // Found a pin creating implicit connection information in another unit.
 // Such units will be instantiated if they do not appear in another sheet and
 // processed later.
 wxASSERT( pin->GetUnit() );
 missingUnits.insert( pin->GetUnit() );
 }
 }
 }

 if( aUpdateSet && aSymbol->GetLibSymbolRef()->GetUnitCount() > 1 )
 {
 auto cmpIt = m_missingCmps.find( reference );

 // The first unit found has always already been processed.
 if( cmpIt == m_missingCmps.end() )
 {
 EAGLE_MISSING_CMP& entry = m_missingCmps[reference];
 entry.cmp = aSymbol;
 entry.units.emplace( unit, false );
 }
 else
 {
 // Set the flag indicating this unit has been processed.
 cmpIt->second.units[unit] = false;
 }

 if( !missingUnits.empty() ) // Save the units that need later processing
 {
 EAGLE_MISSING_CMP& entry = m_missingCmps[reference];
 entry.cmp = aSymbol;

 // Add units that haven't already been processed.
 for( int i : missingUnits )
 {
 if( entry.units.find( i ) != entry.units.end() )
 entry.units.emplace( i, true );
 }
 }
 }
}

References SCH_SCREEN::Append(), LABEL_SPIN_STYLE::BOTTOM, checkConnections(), SCH_EAGLE_PLUGIN::EAGLE_MISSING_CMP::cmp, extractNetName(), SCH_SYMBOL::GetField(), SCH_SYMBOL::GetLibSymbolRef(), SCH_SYMBOL::GetPinPhysicalPosition(), EDA_TEXT::GetText(), SCH_SYMBOL::GetUnit(), LABEL_SPIN_STYLE::LEFT, m_missingCmps, pin, PIN_DOWN, PIN_LEFT, PIN_RIGHT, PIN_UP, PT_POWER_IN, REFERENCE_FIELD, LABEL_SPIN_STYLE::RIGHT, SCH_GLOBALLABEL::SetLabelSpinStyle(), SCH_TEXT::SetPosition(), EDA_TEXT::SetText(), EDA_TEXT::SetTextSize(), SCH_EAGLE_PLUGIN::EAGLE_MISSING_CMP::units, and LABEL_SPIN_STYLE::UP.

Referenced by loadSchematic(), and loadSheet().

adjustNetLabels()

void SCH_EAGLE_PLUGIN::adjustNetLabels ( )

private

Definition at line 2215 of file sch_eagle_plugin.cpp.

{
 // Eagle supports detached labels, so a label does not need to be placed on a wire
 // to be associated with it. KiCad needs to move them, so the labels actually touch the
 // corresponding wires.

 // Sort the intersection points to speed up the search process
 std::sort( m_wireIntersections.begin(), m_wireIntersections.end() );

 auto onIntersection =
 [&]( const VECTOR2I& aPos )
 {
 return std::binary_search( m_wireIntersections.begin(),
 m_wireIntersections.end(), aPos );
 };

 for( SEG_DESC& segDesc : m_segments )
 {
 for( SCH_TEXT* label : segDesc.labels )
 {
 VECTOR2I labelPos( label->GetPosition() );
 const SEG* segAttached = segDesc.LabelAttached( label );

 if( segAttached && !onIntersection( labelPos ) )
 continue; // label is placed correctly

 // Move the label to the nearest wire
 if( !segAttached )
 {
 std::tie( labelPos, segAttached ) = findNearestLinePoint( label->GetPosition(),
 segDesc.segs );

 if( !segAttached ) // we cannot do anything
 continue;
 }

 // Create a vector pointing in the direction of the wire, 50 mils long
 VECTOR2I wireDirection( segAttached->B - segAttached->A );
 wireDirection = wireDirection.Resize( Mils2iu( 50 ) );
 const VECTOR2I origPos( labelPos );

 // Flags determining the search direction
 bool checkPositive = true, checkNegative = true, move = false;
 int trial = 0;

 // Be sure the label is not placed on a wire intersection
 while( ( !move || onIntersection( labelPos ) ) && ( checkPositive || checkNegative ) )
 {
 move = false;

 // Move along the attached wire to find the new label position
 if( trial % 2 == 1 )
 {
 labelPos = wxPoint( origPos + wireDirection * trial / 2 );
 move = checkPositive = segAttached->Contains( labelPos );
 }
 else
 {
 labelPos = wxPoint( origPos - wireDirection * trial / 2 );
 move = checkNegative = segAttached->Contains( labelPos );
 }

 ++trial;
 }

 if( move )
 label->SetPosition( wxPoint( labelPos ) );
 }
 }

 m_segments.clear();
 m_wireIntersections.clear();
}

References findNearestLinePoint(), SCH_TEXT::GetPosition(), m_segments, m_wireIntersections, move, VECTOR2< T >::Resize(), and SCH_TEXT::SetPosition().

Referenced by loadSheet().

checkConnections()

bool SCH_EAGLE_PLUGIN::checkConnections ( const SCH_SYMBOL *  aSymbol, const LIB_PIN *  aPin  ) const

private

Definition at line 2887 of file sch_eagle_plugin.cpp.

{
 wxPoint pinPosition = aSymbol->GetPinPhysicalPosition( aPin );
 auto pointIt = m_connPoints.find( pinPosition );

 if( pointIt == m_connPoints.end() )
 return false;

 const auto& items = pointIt->second;
 wxASSERT( items.find( aPin ) != items.end() );
 return items.size() > 1;
}

References SCH_SYMBOL::GetPinPhysicalPosition(), and m_connPoints.

Referenced by addImplicitConnections().

CheckHeader()

bool SCH_EAGLE_PLUGIN::CheckHeader ( const wxString &  aFileName )

overridevirtual

Return true if the first line in aFileName begins with the expected header.

Parameters

aFileName

is the name of the file to use as input

Reimplemented from SCH_PLUGIN.

Definition at line 2290 of file sch_eagle_plugin.cpp.

{
 // Open file and check first line
 wxTextFile tempFile;

 tempFile.Open( aFileName );
 wxString firstline;

 // read the first line
 firstline = tempFile.GetFirstLine();
 wxString secondline = tempFile.GetNextLine();
 wxString thirdline = tempFile.GetNextLine();
 tempFile.Close();

 return firstline.StartsWith( "<?xml" ) && secondline.StartsWith( "<!DOCTYPE eagle SYSTEM" )
 && thirdline.StartsWith( "<eagle version" );
}

checkpoint()

void SCH_EAGLE_PLUGIN::checkpoint ( )

private

Definition at line 396 of file sch_eagle_plugin.cpp.

{
 const unsigned PROGRESS_DELTA = 5;

 if( m_progressReporter )
 {
 if( ++m_doneCount > m_lastProgressCount + PROGRESS_DELTA )
 {
 m_progressReporter->SetCurrentProgress( ( (double) m_doneCount )
 / std::max( 1U, m_totalCount ) );

 if( !m_progressReporter->KeepRefreshing() )
  THROW_IO_ERROR( ( "Open canceled by user." ) );

 m_lastProgressCount = m_doneCount;
 }
 }
}

References PROGRESS_REPORTER::KeepRefreshing(), m_doneCount, m_lastProgressCount, m_progressReporter, m_totalCount, PROGRESS_REPORTER::SetCurrentProgress(), and THROW_IO_ERROR.

Referenced by loadLibrary(), loadSchematic(), and loadSheet().

countNets()

void SCH_EAGLE_PLUGIN::countNets ( wxXmlNode *  aSchematicNode )

private

Definition at line 551 of file sch_eagle_plugin.cpp.

{
 // Map all children into a readable dictionary
 NODE_MAP schematicChildren = MapChildren( aSchematicNode );

 // Loop through all the sheets
 wxXmlNode* sheetNode = getChildrenNodes( schematicChildren, "sheets" );

 while( sheetNode )
 {
 NODE_MAP sheetChildren = MapChildren( sheetNode );

 // Loop through all nets
 // From the DTD: "Net is an electrical connection in a schematic."
 wxXmlNode* netNode = getChildrenNodes( sheetChildren, "nets" );

 while( netNode )
 {
 wxString netName = netNode->GetAttribute( "name" );

 if( m_netCounts.count( netName ) )
 m_netCounts[netName] = m_netCounts[netName] + 1;
 else
 m_netCounts[netName] = 1;

 // Get next net
 netNode = netNode->GetNext();
 }

 sheetNode = sheetNode->GetNext();
 }
}

References getChildrenNodes(), m_netCounts, and MapChildren().

Referenced by loadSchematic().

CreateSymbolLib()

void SCH_PLUGIN::CreateSymbolLib ( const wxString &  aLibraryPath, const PROPERTIES *  aProperties = nullptr  )

virtualinherited

Create a new empty symbol library at aLibraryPath.

It is an error to attempt to create an existing library or to attempt to create on a "read only" location.

Parameters

aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing several footprints.
aProperties	is an associative array that can be used to tell the library create function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR

if there is a problem finding the library, or creating it.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 110 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
}

References not_implemented().

DeleteSymbol()

void SCH_PLUGIN::DeleteSymbol ( const wxString &  aLibraryPath, const wxString &  aSymbolName, const PROPERTIES *  aProperties = nullptr  )

virtualinherited

Delete the entire LIB_SYMBOL associated with aAliasName from the library aLibraryPath.

Parameters

aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing several symbols.
aSymbolName	is the name of a LIB_SYMBOL associated with it's root LIB_SYMBOL object to delete from the specified library.
aProperties	is an associative array that can be used to tell the library delete function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR

if there is a problem finding the alias or the library or deleting it.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 102 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
}

References not_implemented().

Referenced by SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer().

DeleteSymbolLib()

bool SCH_PLUGIN::DeleteSymbolLib ( const wxString &  aLibraryPath, const PROPERTIES *  aProperties = nullptr  )

virtualinherited

Delete an existing symbol library and returns true if successful, or if library does not exist returns false, or throws an exception if library exists but is read only or cannot be deleted for some other reason.

Parameters

aLibraryPath	is a locator for the "library", usually a directory or file which will contain symbols.
aProperties	is an associative array that can be used to tell the library delete implementation function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Returns

true if library deleted or false if library did not exist.

Exceptions

IO_ERROR

if there is a problem deleting an existing library.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 117 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
 return false;
}

References not_implemented().

EnumerateSymbolLib() [1/2]

void SCH_PLUGIN::EnumerateSymbolLib ( wxArrayString &  aSymbolNameList, const wxString &  aLibraryPath, const PROPERTIES *  aProperties = nullptr  )

virtualinherited

Populate a list of LIB_SYMBOL alias names contained within the library aLibraryPath.

Parameters

aSymbolNameList	is an array to populate with the LIB_SYMBOL names associated with the library.
aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing one or more LIB_SYMBOL objects.
aProperties	is an associative array that can be used to tell the plugin anything needed about how to perform with respect to aLibraryPath. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR

if the library cannot be found, the part library cannot be loaded.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 67 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
}

References not_implemented().

EnumerateSymbolLib() [2/2]

void SCH_PLUGIN::EnumerateSymbolLib ( std::vector< LIB_SYMBOL * > &  aSymbolList, const wxString &  aLibraryPath, const PROPERTIES *  aProperties = nullptr  )

virtualinherited

Populate a list of LIB_SYMBOL aliases contained within the library aLibraryPath.

Note

It is the responsibility of the caller to delete the returned object from the heap. Failure to do this will result in memory leaks.

Parameters

aSymbolList	is an array to populate with the LIB_SYMBOL pointers associated with the library.
aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing one or more LIB_SYMBOL objects.
aProperties	is an associative array that can be used to tell the plugin anything needed about how to perform with respect to aLibraryPath. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR

if the library cannot be found, the part library cannot be loaded.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 76 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
}

References not_implemented().

findNearestLinePoint()

std::pair< VECTOR2I, const SEG * > SCH_EAGLE_PLUGIN::findNearestLinePoint ( const wxPoint &  aPoint, const std::vector< SEG > &  aLines  ) const

private

Definition at line 1213 of file sch_eagle_plugin.cpp.

{
 VECTOR2I nearestPoint;
 const SEG* nearestLine = nullptr;

 float d, mindistance = std::numeric_limits<float>::max();

 // Find the nearest start, middle or end of a line from the list of lines.
 for( const SEG& line : aLines )
 {
 VECTOR2I testpoint = line.A;
 d = sqrt( abs( ( ( aPoint.x - testpoint.x ) ^ 2 ) + ( ( aPoint.y - testpoint.y ) ^ 2 ) ) );

 if( d < mindistance )
 {
 mindistance = d;
 nearestPoint = testpoint;
 nearestLine = &line;
 }

 testpoint = line.Center();
 d = sqrt( abs( ( ( aPoint.x - testpoint.x ) ^ 2 ) + ( ( aPoint.y - testpoint.y ) ^ 2 ) ) );

 if( d < mindistance )
 {
 mindistance = d;
 nearestPoint = testpoint;
 nearestLine = &line;
 }

 testpoint = line.B;
 d = sqrt( abs( ( ( aPoint.x - testpoint.x ) ^ 2 ) + ( ( aPoint.y - testpoint.y ) ^ 2 ) ) );

 if( d < mindistance )
 {
 mindistance = d;
 nearestPoint = testpoint;
 nearestLine = &line;
 }
 }

 return std::make_pair( nearestPoint, nearestLine );
}

References VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by adjustNetLabels().

GetError()

const wxString & SCH_PLUGIN::GetError ( ) const

virtualinherited

Return an error string to the caller.

This is useful for schematic loaders that can load partial schematics where throwing an exception would be problematic such as the KiCad legacy plugin.

Returns

an unformatted string containing errors if any.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 177 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
 static wxString error;
 return error;
}

References not_implemented().

Referenced by TEST_SCH_SHEET_LIST_FIXTURE::loadSchematic(), and TEST_NETLISTS_FIXTURE::loadSchematic().

GetFileExtension()

const wxString SCH_EAGLE_PLUGIN::GetFileExtension ( ) const

overridevirtual

Return the file extension for the SCH_PLUGIN.

Implements SCH_PLUGIN.

Definition at line 378 of file sch_eagle_plugin.cpp.

{
 return "sch";
}

getLibFileName()

wxFileName SCH_EAGLE_PLUGIN::getLibFileName ( )

private

Checks if there are other wires or pins at the position of the tested pin.

Definition at line 156 of file sch_eagle_plugin.cpp.

{
 wxFileName fn( m_schematic->Prj().GetProjectPath(), getLibName(), KiCadSymbolLibFileExtension );

 return fn;
}

References KiCadSymbolLibFileExtension.

Referenced by Load(), loadInstance(), loadLibrary(), and loadSchematic().

getLibName()

wxString SCH_EAGLE_PLUGIN::getLibName ( )

private

Definition at line 132 of file sch_eagle_plugin.cpp.

{
 if( m_libName.IsEmpty() )
 {
 // Try to come up with a meaningful name
 m_libName = m_schematic->Prj().GetProjectName();

 if( m_libName.IsEmpty() )
 {
 wxFileName fn( m_rootSheet->GetFileName() );
 m_libName = fn.GetName();
 }

 if( m_libName.IsEmpty() )
 m_libName = "noname";

 m_libName += "-eagle-import";
 m_libName = LIB_ID::FixIllegalChars( m_libName, true );
 }

 return m_libName;
}

References LIB_ID::FixIllegalChars().

Referenced by Load(), and loadInstance().

GetLibraryFileExtension()

const wxString SCH_EAGLE_PLUGIN::GetLibraryFileExtension ( ) const

overridevirtual

Return the library file extension for the SCH_PLUGIN object.

Implements SCH_PLUGIN.

Definition at line 384 of file sch_eagle_plugin.cpp.

{
 return "lbr";
}

GetModifyHash()

int SCH_EAGLE_PLUGIN::GetModifyHash ( ) const

overridevirtual

Return the modification hash from the library cache.

Note

This is temporary until the new s-expr file format is implement. The new file format will embed symbols instead of referencing them from the library. This function can be removed when the new file format is implemented.

Returns

the modification hash of the library cache.

Implements SCH_PLUGIN.

Definition at line 390 of file sch_eagle_plugin.cpp.

{
 return 0;
}

GetName()

const wxString SCH_EAGLE_PLUGIN::GetName ( ) const

overridevirtual

Return a brief hard coded name for this SCH_PLUGIN.

Implements SCH_PLUGIN.

Definition at line 372 of file sch_eagle_plugin.cpp.

{
 return "EAGLE";
}

IsSymbolLibWritable()

bool SCH_PLUGIN::IsSymbolLibWritable ( const wxString &  aLibraryPath )

virtualinherited

Return true if the library at aLibraryPath is writable.

(Often system libraries are read only because of where they are installed.)

Parameters

aLibraryPath

is a locator for the "library", usually a directory, file, or URL containing several symbols.

Exceptions

IO_ERROR

if no library at aLibraryPath exists.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 125 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
 return false;
}

References not_implemented().

kiCadLayer()

SCH_LAYER_ID SCH_EAGLE_PLUGIN::kiCadLayer ( int  aEagleLayer )

private

Return the matching layer or return LAYER_NOTES.

Definition at line 215 of file sch_eagle_plugin.cpp.

{
 auto it = m_layerMap.find( aEagleLayer );
 return it == m_layerMap.end() ? LAYER_NOTES : it->second;
}

References LAYER_NOTES.

Referenced by loadWire().

Load()

SCH_SHEET * SCH_EAGLE_PLUGIN::Load ( const wxString &  aFileName, SCHEMATIC *  aSchematic, SCH_SHEET *  aAppendToMe = nullptr, const PROPERTIES *  aProperties = nullptr  )

overridevirtual

Load information from some input file format that this SCH_PLUGIN implementation knows about, into either a new SCH_SHEET or an existing one.

This may be used to load an entire new SCH_SHEET, or to augment an existing one if aAppendToMe is not NULL.

Parameters

aFileName	is the name of the file to use as input and may be foreign in nature or native in nature.
aKiway	is the KIWAY object used to access the symbol libraries loaded by the project.
aAppendToMe	is an existing SCH_SHEET to append to, but if NULL then this means "do not append, rather load anew".
aProperties	is an associative array that can be used to tell the loader how to load the file, because it can take any number of additional named arguments that the plugin is known to support. These are tuning parameters for the import or load. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Returns

the successfully loaded schematic, or the same one as aAppendToMe if aAppendToMe was not NULL, and the caller owns it.

Exceptions

IO_ERROR

if there is a problem loading, and its contents should say what went wrong, using line number and character offsets of the input file if possible.

Note

No check is being done here to see if the existing symbol library exists so this will overwrite the existing one.

Reimplemented from SCH_PLUGIN.

Definition at line 416 of file sch_eagle_plugin.cpp.

{
 wxASSERT( !aFileName || aSchematic != nullptr );
 LOCALE_IO toggle; // toggles on, then off, the C locale.

 m_filename = aFileName;
 m_schematic = aSchematic;

 if( m_progressReporter )
 {
 m_progressReporter->Report( wxString::Format( _( "Loading %s..." ), aFileName ) );

 if( !m_progressReporter->KeepRefreshing() )
 THROW_IO_ERROR( ( "Open canceled by user." ) );
 }

 // Load the document
 wxXmlDocument xmlDocument;
 wxFFileInputStream stream( m_filename.GetFullPath() );

 if( !stream.IsOk() || !xmlDocument.Load( stream ) )
 {
 THROW_IO_ERROR( wxString::Format( _( "Unable to read file '%s'." ),
 m_filename.GetFullPath() ) );
 }

 // Delete on exception, if I own m_rootSheet, according to aAppendToMe
 unique_ptr<SCH_SHEET> deleter( aAppendToMe ? nullptr : m_rootSheet );

 wxFileName newFilename( m_filename );
 newFilename.SetExt( KiCadSchematicFileExtension );

 if( aAppendToMe )
 {
 wxCHECK_MSG( aSchematic->IsValid(), nullptr, "Can't append to a schematic with no root!" );
 m_rootSheet = &aSchematic->Root();
 }
 else
 {
 m_rootSheet = new SCH_SHEET( aSchematic );
 m_rootSheet->SetFileName( newFilename.GetFullPath() );
 }

 if( !m_rootSheet->GetScreen() )
 {
 SCH_SCREEN* screen = new SCH_SCREEN( m_schematic );
 screen->SetFileName( newFilename.GetFullPath() );
 m_rootSheet->SetScreen( screen );
 }

 SYMBOL_LIB_TABLE* libTable = m_schematic->Prj().SchSymbolLibTable();

 wxCHECK_MSG( libTable, nullptr, "Could not load symbol lib table." );

 m_pi.set( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
 m_properties = std::make_unique<PROPERTIES>();
 ( *m_properties )[SCH_LEGACY_PLUGIN::PropBuffering] = "";

 if( !libTable->HasLibrary( getLibName() ) )
 {
 // Create a new empty symbol library.
 m_pi->CreateSymbolLib( getLibFileName().GetFullPath() );
 wxString libTableUri = "${KIPRJMOD}/" + getLibFileName().GetFullName();

 // Add the new library to the project symbol library table.
 libTable->InsertRow(
 new SYMBOL_LIB_TABLE_ROW( getLibName(), libTableUri, wxString( "KiCad" ) ) );

 // Save project symbol library table.
 wxFileName fn( m_schematic->Prj().GetProjectPath(),
 SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );

 // So output formatter goes out of scope and closes the file before reloading.
 {
 FILE_OUTPUTFORMATTER formatter( fn.GetFullPath() );
 libTable->Format( &formatter, 0 );
 }

 // Reload the symbol library table.
 m_schematic->Prj().SetElem( PROJECT::ELEM_SYMBOL_LIB_TABLE, nullptr );
 m_schematic->Prj().SchSymbolLibTable();
 }

 // Retrieve the root as current node
 wxXmlNode* currentNode = xmlDocument.GetRoot();

 // If the attribute is found, store the Eagle version;
 // otherwise, store the dummy "0.0" version.
 m_version = currentNode->GetAttribute( "version", "0.0" );

 // Map all children into a readable dictionary
 NODE_MAP children = MapChildren( currentNode );

 // Load drawing
 loadDrawing( children["drawing"] );

 m_pi->SaveLibrary( getLibFileName().GetFullPath() );

 SCH_SCREENS allSheets( m_rootSheet );
 allSheets.UpdateSymbolLinks(); // Update all symbol library links for all sheets.

 return m_rootSheet;
}

References _, PROJECT::ELEM_SYMBOL_LIB_TABLE, SYMBOL_LIB_TABLE::Format(), Format(), getLibFileName(), getLibName(), PROJECT::GetProjectPath(), SCH_SHEET::GetScreen(), SYMBOL_LIB_TABLE::GetSymbolLibTableFileName(), LIB_TABLE::HasLibrary(), LIB_TABLE::InsertRow(), SCHEMATIC::IsValid(), PROGRESS_REPORTER::KeepRefreshing(), KiCadSchematicFileExtension, loadDrawing(), m_filename, m_pi, m_progressReporter, m_properties, m_rootSheet, m_schematic, m_version, MapChildren(), SCHEMATIC::Prj(), SCH_LEGACY_PLUGIN::PropBuffering, PROGRESS_REPORTER::Report(), SCHEMATIC::Root(), SCH_PLUGIN::SCH_PLUGIN_RELEASER::set(), PROJECT::SetElem(), SCH_SCREEN::SetFileName(), SCH_SHEET::SetFileName(), SCH_SHEET::SetScreen(), THROW_IO_ERROR, and SCH_SCREENS::UpdateSymbolLinks().

loadDrawing()

void SCH_EAGLE_PLUGIN::loadDrawing ( wxXmlNode *  aDrawingNode )

private

Definition at line 524 of file sch_eagle_plugin.cpp.

{
 // Map all children into a readable dictionary
 NODE_MAP drawingChildren = MapChildren( aDrawingNode );

 // Board nodes should not appear in .sch files
 // wxXmlNode* board = drawingChildren["board"]

 // wxXmlNode* grid = drawingChildren["grid"]

 auto layers = drawingChildren["layers"];

 if( layers )
 loadLayerDefs( layers );

 // wxXmlNode* library = drawingChildren["library"]

 // wxXmlNode* settings = drawingChildren["settings"]

 // Load schematic
 auto schematic = drawingChildren["schematic"];

 if( schematic )
 loadSchematic( schematic );
}

References loadLayerDefs(), loadSchematic(), and MapChildren().

Referenced by Load().

loadFieldAttributes()

void SCH_EAGLE_PLUGIN::loadFieldAttributes ( LIB_FIELD *  aField, const LIB_TEXT *  aText  ) const

private

Move net labels that are detached from any wire to the nearest wire.

Definition at line 2203 of file sch_eagle_plugin.cpp.

{
 aField->SetTextPos( aText->GetPosition() );
 aField->SetTextSize( aText->GetTextSize() );
 aField->SetTextAngle( aText->GetTextAngle() );
 aField->SetBold( aText->IsBold() );
 aField->SetVertJustify( aText->GetVertJustify() );
 aField->SetHorizJustify( aText->GetHorizJustify() );
 aField->SetVisible( true );
}

References EDA_TEXT::GetHorizJustify(), LIB_TEXT::GetPosition(), EDA_TEXT::GetTextAngle(), EDA_TEXT::GetTextSize(), EDA_TEXT::GetVertJustify(), EDA_TEXT::IsBold(), EDA_TEXT::SetBold(), EDA_TEXT::SetHorizJustify(), EDA_TEXT::SetTextAngle(), EDA_TEXT::SetTextPos(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetVertJustify(), and EDA_TEXT::SetVisible().

Referenced by loadSymbol().

loadFrame() [1/2]

void SCH_EAGLE_PLUGIN::loadFrame ( wxXmlNode *  aFrameNode, std::vector< SCH_LINE * > &  aLines  )

private

Definition at line 970 of file sch_eagle_plugin.cpp.

{
 EFRAME eframe( aFrameNode );

 wxPoint corner1( eframe.x1.ToSchUnits(), -eframe.y1.ToSchUnits() );
 wxPoint corner3( eframe.x2.ToSchUnits(), -eframe.y2.ToSchUnits() );
 wxPoint corner2( corner3.x, corner1.y );
 wxPoint corner4( corner1.x, corner3.y );

 SCH_LINE* line = new SCH_LINE();
 line->SetLineStyle( PLOT_DASH_TYPE::SOLID );
 line->SetStartPoint( corner1 );
 line->SetEndPoint( corner2 );
 aLines.push_back( line );

 line = new SCH_LINE();
 line->SetLineStyle( PLOT_DASH_TYPE::SOLID );
 line->SetStartPoint( corner2 );
 line->SetEndPoint( corner3 );
 aLines.push_back( line );

 line = new SCH_LINE();
 line->SetLineStyle( PLOT_DASH_TYPE::SOLID );
 line->SetStartPoint( corner3 );
 line->SetEndPoint( corner4 );
 aLines.push_back( line );

 line = new SCH_LINE();
 line->SetLineStyle( PLOT_DASH_TYPE::SOLID );
 line->SetStartPoint( corner4 );
 line->SetEndPoint( corner1 );
 aLines.push_back( line );
}

References SCH_LINE::SetEndPoint(), SCH_LINE::SetLineStyle(), SCH_LINE::SetStartPoint(), SOLID, ECOORD::ToSchUnits(), EFRAME::x1, EFRAME::x2, EFRAME::y1, and EFRAME::y2.

Referenced by loadSheet(), and loadSymbol().

loadFrame() [2/2]

void SCH_EAGLE_PLUGIN::loadFrame ( wxXmlNode *  aFrameNode, std::vector< LIB_ITEM * > &  aLines  )

private

Definition at line 1972 of file sch_eagle_plugin.cpp.

{
 EFRAME eframe( aFrameNode );

 int xMin = eframe.x1.ToSchUnits();
 int xMax = eframe.x2.ToSchUnits();
 int yMin = eframe.y1.ToSchUnits();
 int yMax = eframe.y2.ToSchUnits();

 if( xMin > xMax )
 std::swap( xMin, xMax );

 if( yMin > yMax )
 std::swap( yMin, yMax );

 LIB_SHAPE* lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( wxPoint( xMin, yMin ) );
 lines->AddPoint( wxPoint( xMax, yMin ) );
 lines->AddPoint( wxPoint( xMax, yMax ) );
 lines->AddPoint( wxPoint( xMin, yMax ) );
 lines->AddPoint( wxPoint( xMin, yMin ) );
 aItems.push_back( lines );

 if( !eframe.border_left )
 {
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( wxPoint( xMin + Mils2iu( 150 ), yMin + Mils2iu( 150 ) ) );
 lines->AddPoint( wxPoint( xMin + Mils2iu( 150 ), yMax - Mils2iu( 150 ) ) );
 aItems.push_back( lines );

 int i;
 int height = yMax - yMin;
 int x1 = xMin;
 int x2 = x1 + Mils2iu( 150 );
 int legendPosX = xMin + Mils2iu( 75 );
 double rowSpacing = height / double( eframe.rows );
 double legendPosY = yMax - ( rowSpacing / 2 );

 for( i = 1; i < eframe.rows; i++ )
 {
 int newY = KiROUND( yMin + ( rowSpacing * (double) i ) );
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( wxPoint( x1, newY ) );
 lines->AddPoint( wxPoint( x2, newY ) );
 aItems.push_back( lines );
 }

 char legendChar = 'A';

 for( i = 0; i < eframe.rows; i++ )
 {
 LIB_TEXT* legendText = new LIB_TEXT( nullptr );
 legendText->SetPosition( wxPoint( legendPosX, KiROUND( legendPosY ) ) );
 legendText->SetText( wxString( legendChar ) );
 legendText->SetTextSize( wxSize( Mils2iu( 90 ), Mils2iu( 100 ) ) );
 aItems.push_back( legendText );
 legendChar++;
 legendPosY -= rowSpacing;
 }
 }

 if( !eframe.border_right )
 {
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( wxPoint( xMax - Mils2iu( 150 ), yMin + Mils2iu( 150 ) ) );
 lines->AddPoint( wxPoint( xMax - Mils2iu( 150 ), yMax - Mils2iu( 150 ) ) );
 aItems.push_back( lines );

 int i;
 int height = yMax - yMin;
 int x1 = xMax - Mils2iu( 150 );
 int x2 = xMax;
 int legendPosX = xMax - Mils2iu( 75 );
 double rowSpacing = height / double( eframe.rows );
 double legendPosY = yMax - ( rowSpacing / 2 );

 for( i = 1; i < eframe.rows; i++ )
 {
 int newY = KiROUND( yMin + ( rowSpacing * (double) i ) );
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( wxPoint( x1, newY ) );
 lines->AddPoint( wxPoint( x2, newY ) );
 aItems.push_back( lines );
 }

 char legendChar = 'A';

 for( i = 0; i < eframe.rows; i++ )
 {
 LIB_TEXT* legendText = new LIB_TEXT( nullptr );
 legendText->SetPosition( wxPoint( legendPosX, KiROUND( legendPosY ) ) );
 legendText->SetText( wxString( legendChar ) );
 legendText->SetTextSize( wxSize( Mils2iu( 90 ), Mils2iu( 100 ) ) );
 aItems.push_back( legendText );
 legendChar++;
 legendPosY -= rowSpacing;
 }
 }

 if( !eframe.border_top )
 {
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( wxPoint( xMax - Mils2iu( 150 ), yMax - Mils2iu( 150 ) ) );
 lines->AddPoint( wxPoint( xMin + Mils2iu( 150 ), yMax - Mils2iu( 150 ) ) );
 aItems.push_back( lines );

 int i;
 int width = xMax - xMin;
 int y1 = yMin;
 int y2 = yMin + Mils2iu( 150 );
 int legendPosY = yMax - Mils2iu( 75 );
 double columnSpacing = width / double( eframe.columns );
 double legendPosX = xMin + ( columnSpacing / 2 );

 for( i = 1; i < eframe.columns; i++ )
 {
 int newX = KiROUND( xMin + ( columnSpacing * (double) i ) );
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( wxPoint( newX, y1 ) );
 lines->AddPoint( wxPoint( newX, y2 ) );
 aItems.push_back( lines );
 }

 char legendChar = '1';

 for( i = 0; i < eframe.columns; i++ )
 {
 LIB_TEXT* legendText = new LIB_TEXT( nullptr );
 legendText->SetPosition( wxPoint( KiROUND( legendPosX ), legendPosY ) );
 legendText->SetText( wxString( legendChar ) );
 legendText->SetTextSize( wxSize( Mils2iu( 90 ), Mils2iu( 100 ) ) );
 aItems.push_back( legendText );
 legendChar++;
 legendPosX += columnSpacing;
 }
 }

 if( !eframe.border_bottom )
 {
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( wxPoint( xMax - Mils2iu( 150 ), yMin + Mils2iu( 150 ) ) );
 lines->AddPoint( wxPoint( xMin + Mils2iu( 150 ), yMin + Mils2iu( 150 ) ) );
 aItems.push_back( lines );

 int i;
 int width = xMax - xMin;
 int y1 = yMax - Mils2iu( 150 );
 int y2 = yMax;
 int legendPosY = yMin + Mils2iu( 75 );
 double columnSpacing = width / double( eframe.columns );
 double legendPosX = xMin + ( columnSpacing / 2 );

 for( i = 1; i < eframe.columns; i++ )
 {
 int newX = KiROUND( xMin + ( columnSpacing * (double) i ) );
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( wxPoint( newX, y1 ) );
 lines->AddPoint( wxPoint( newX, y2 ) );
 aItems.push_back( lines );
 }

 char legendChar = '1';

 for( i = 0; i < eframe.columns; i++ )
 {
 LIB_TEXT* legendText = new LIB_TEXT( nullptr );
 legendText->SetPosition( wxPoint( KiROUND( legendPosX ), legendPosY ) );
 legendText->SetText( wxString( legendChar ) );
 legendText->SetTextSize( wxSize( Mils2iu( 90 ), Mils2iu( 100 ) ) );
 aItems.push_back( legendText );
 legendChar++;
 legendPosX += columnSpacing;
 }
 }
}

References LIB_SHAPE::AddPoint(), EFRAME::border_bottom, EFRAME::border_left, EFRAME::border_right, EFRAME::border_top, EFRAME::columns, KiROUND(), POLY, EFRAME::rows, LIB_ITEM::SetPosition(), EDA_TEXT::SetText(), EDA_TEXT::SetTextSize(), ECOORD::ToSchUnits(), EFRAME::x1, EFRAME::x2, EFRAME::y1, and EFRAME::y2.

loadInstance()

void SCH_EAGLE_PLUGIN::loadInstance ( wxXmlNode *  aInstanceNode )

private

Definition at line 1259 of file sch_eagle_plugin.cpp.

{
 EINSTANCE einstance = EINSTANCE( aInstanceNode );
 SCH_SCREEN* screen = m_currentSheet->GetScreen();

 // Find the part in the list for the sheet.
 // Assign the symbol its value from the part entry
 // Calculate the unit number from the gate entry of the instance
 // Assign the LIB_ID from device set and device names

 auto part_it = m_partlist.find( einstance.part.Upper() );

 if( part_it == m_partlist.end() )
 {
 m_reporter->Report( wxString::Format( _( "Error parsing Eagle file. Could not find '%s' "
 "instance but it is referenced in the schematic." ),
 einstance.part ),
 RPT_SEVERITY_ERROR );

 return;
 }

 EPART* epart = part_it->second.get();

 wxString libraryname = epart->library;
 wxString gatename = epart->deviceset + epart->device + einstance.gate;
 wxString symbolname = wxString( epart->deviceset + epart->device );
 symbolname.Replace( "*", "" );
 wxString kisymbolname = EscapeString( symbolname, CTX_LIBID );

 int unit = m_eagleLibs[libraryname].GateUnit[gatename];

 wxString package;
 EAGLE_LIBRARY* elib = &m_eagleLibs[libraryname];

 auto p = elib->package.find( kisymbolname );

 if( p != elib->package.end() )
 package = p->second;

 LIB_SYMBOL* part = m_pi->LoadSymbol( getLibFileName().GetFullPath(), kisymbolname,
 m_properties.get() );

 if( !part )
 {
 m_reporter->Report( wxString::Format( _( "Could not find '%s' in the imported library." ),
 UnescapeString( kisymbolname ) ),
 RPT_SEVERITY_ERROR );
 return;
 }

 LIB_ID libId( getLibName(), kisymbolname );
 std::unique_ptr<SCH_SYMBOL> symbol = std::make_unique<SCH_SYMBOL>();
 symbol->SetLibId( libId );
 symbol->SetUnit( unit );
 symbol->SetPosition( wxPoint( einstance.x.ToSchUnits(), -einstance.y.ToSchUnits() ) );
 symbol->GetField( FOOTPRINT_FIELD )->SetText( package );

 if( einstance.rot )
 {
 symbol->SetOrientation( kiCadComponentRotation( einstance.rot->degrees ) );

 if( einstance.rot->mirror )
 symbol->MirrorHorizontally( einstance.x.ToSchUnits() );
 }

 std::vector<LIB_FIELD*> partFields;
 part->GetFields( partFields );

 for( const LIB_FIELD* field : partFields )
 {
 symbol->GetFieldById( field->GetId() )->ImportValues( *field );
 symbol->GetFieldById( field->GetId() )->SetTextPos( symbol->GetPosition()
 + field->GetTextPos() );
 }

 // If there is no footprint assigned, then prepend the reference value
 // with a hash character to mute netlist updater complaints
 wxString reference = package.IsEmpty() ? '#' + einstance.part : einstance.part;

 // EAGLE allows references to be single digits. This breaks KiCad netlisting, which requires
 // parts to have non-digit + digit annotation. If the reference begins with a number,
 // we prepend 'UNK' (unknown) for the symbol designator
 if( reference.find_first_not_of( "0123456789" ) == wxString::npos )
 reference.Prepend( "UNK" );

 SCH_SHEET_PATH sheetpath;
 m_rootSheet->LocatePathOfScreen( screen, &sheetpath );
 wxString current_sheetpath = sheetpath.PathAsString() + symbol->m_Uuid.AsString();

 symbol->GetField( REFERENCE_FIELD )->SetText( reference );
 symbol->AddHierarchicalReference( current_sheetpath, reference, unit );

 if( epart->value )
 symbol->GetField( VALUE_FIELD )->SetText( *epart->value );
 else
 symbol->GetField( VALUE_FIELD )->SetText( kisymbolname );

 // Set the visibility of fields.
 symbol->GetField( REFERENCE_FIELD )->SetVisible(
 part->GetFieldById( REFERENCE_FIELD )->IsVisible() );
 symbol->GetField( VALUE_FIELD )->SetVisible( part->GetFieldById( VALUE_FIELD )->IsVisible() );

 for( const auto& a : epart->attribute )
 {
 SCH_FIELD* field = symbol->AddField( *symbol->GetField( VALUE_FIELD ) );
 field->SetName( a.first );
 field->SetText( a.second );
 field->SetVisible( false );
 }

 for( const auto& a : epart->variant )
 {
 SCH_FIELD* field = symbol->AddField( *symbol->GetField( VALUE_FIELD ) );
 field->SetName( "VARIANT_" + a.first );
 field->SetText( a.second );
 field->SetVisible( false );
 }

 bool valueAttributeFound = false;
 bool nameAttributeFound = false;

 wxXmlNode* attributeNode = aInstanceNode->GetChildren();

 // Parse attributes for the instance
 while( attributeNode )
 {
 if( attributeNode->GetName() == "attribute" )
 {
 EATTR attr = EATTR( attributeNode );
 SCH_FIELD* field = nullptr;

 if( attr.name.Lower() == "name" )
 {
 field = symbol->GetField( REFERENCE_FIELD );
 nameAttributeFound = true;
 }
 else if( attr.name.Lower() == "value" )
 {
 field = symbol->GetField( VALUE_FIELD );
 valueAttributeFound = true;
 }
 else
 {
 field = symbol->FindField( attr.name );

 if( field )
 field->SetVisible( false );
 }

 if( field )
 {

 field->SetPosition( wxPoint( attr.x->ToSchUnits(), -attr.y->ToSchUnits() ) );
 int align = attr.align ? *attr.align : ETEXT::BOTTOM_LEFT;
 int absdegrees = attr.rot ? attr.rot->degrees : 0;
 bool mirror = attr.rot ? attr.rot->mirror : false;

 if( einstance.rot && einstance.rot->mirror )
 mirror = !mirror;

 bool spin = attr.rot ? attr.rot->spin : false;

 if( attr.display == EATTR::Off || attr.display == EATTR::NAME )
 field->SetVisible( false );

 int rotation = einstance.rot ? einstance.rot->degrees : 0;
 int reldegrees = ( absdegrees - rotation + 360.0 );
 reldegrees %= 360;

 eagleToKicadAlignment( (EDA_TEXT*) field, align, reldegrees, mirror, spin,
 absdegrees );
 }
 }
 else if( attributeNode->GetName() == "variant" )
 {
 wxString variant, value;

 if( attributeNode->GetAttribute( "name", &variant )
 && attributeNode->GetAttribute( "value", &value ) )
 {
 SCH_FIELD* field = symbol->AddField( *symbol->GetField( VALUE_FIELD ) );
 field->SetName( "VARIANT_" + variant );
 field->SetText( value );
 field->SetVisible( false );
 }
 }

 attributeNode = attributeNode->GetNext();
 }

 if( einstance.smashed && einstance.smashed.Get() )
 {
 if( !valueAttributeFound )
 symbol->GetField( VALUE_FIELD )->SetVisible( false );

 if( !nameAttributeFound )
 symbol->GetField( REFERENCE_FIELD )->SetVisible( false );
 }

 // Save the pin positions
 SYMBOL_LIB_TABLE& schLibTable = *m_schematic->Prj().SchSymbolLibTable();
 LIB_SYMBOL* libSymbol = schLibTable.LoadSymbol( symbol->GetLibId() );

 wxCHECK( libSymbol, /*void*/ );

 symbol->SetLibSymbol( new LIB_SYMBOL( *libSymbol ) );

 std::vector<LIB_PIN*> pins;
 symbol->GetLibPins( pins );

 for( const LIB_PIN* pin : pins )
 m_connPoints[symbol->GetPinPhysicalPosition( pin )].emplace( pin );

 if( part->IsPower() )
 m_powerPorts[ reference ] = symbol->GetField( VALUE_FIELD )->GetText();

 symbol->ClearFlags();

 screen->Append( symbol.release() );
}

References _, EATTR::align, SCH_SCREEN::Append(), EPART::attribute, ETEXT::BOTTOM_LEFT, CTX_LIBID, EROT::degrees, EPART::device, EPART::deviceset, EATTR::display, eagleToKicadAlignment(), EscapeString(), FOOTPRINT_FIELD, Format(), EINSTANCE::gate, OPTIONAL_XML_ATTRIBUTE< T >::Get(), getLibFileName(), getLibName(), SCH_SHEET::GetScreen(), kiCadComponentRotation(), EPART::library, SYMBOL_LIB_TABLE::LoadSymbol(), SCH_SHEET::LocatePathOfScreen(), m_connPoints, m_currentSheet, m_eagleLibs, m_partlist, m_pi, m_powerPorts, m_properties, m_reporter, m_rootSheet, m_schematic, EROT::mirror, EATTR::name, EATTR::NAME, EATTR::Off, EAGLE_LIBRARY::package, EINSTANCE::part, SCH_SHEET_PATH::PathAsString(), pin, SCHEMATIC::Prj(), REFERENCE_FIELD, REPORTER::Report(), EATTR::rot, EINSTANCE::rot, RPT_SEVERITY_ERROR, SCH_FIELD::SetName(), SCH_FIELD::SetPosition(), EDA_TEXT::SetText(), EDA_TEXT::SetVisible(), EINSTANCE::smashed, EROT::spin, ECOORD::ToSchUnits(), UnescapeString(), EPART::value, VALUE_FIELD, EPART::variant, EATTR::x, EINSTANCE::x, EATTR::y, and EINSTANCE::y.

Referenced by loadSheet().

loadJunction()

SCH_JUNCTION * SCH_EAGLE_PLUGIN::loadJunction ( wxXmlNode *  aJunction )

private

Definition at line 1163 of file sch_eagle_plugin.cpp.

{
 std::unique_ptr<SCH_JUNCTION> junction = std::make_unique<SCH_JUNCTION>();

 EJUNCTION ejunction = EJUNCTION( aJunction );
 wxPoint pos( ejunction.x.ToSchUnits(), -ejunction.y.ToSchUnits() );

 junction->SetPosition( pos );

 return junction.release();
}

References ECOORD::ToSchUnits(), EJUNCTION::x, and EJUNCTION::y.

Referenced by loadSegments().

loadLabel()

SCH_TEXT * SCH_EAGLE_PLUGIN::loadLabel ( wxXmlNode *  aLabelNode, const wxString &  aNetName  )

private

Definition at line 1176 of file sch_eagle_plugin.cpp.

{
 ELABEL elabel = ELABEL( aLabelNode, aNetName );
 wxPoint elabelpos( elabel.x.ToSchUnits(), -elabel.y.ToSchUnits() );

 // Determine if the label is local or global depending on
 // the number of sheets the net appears in
 bool global = m_netCounts[aNetName] > 1;
 std::unique_ptr<SCH_TEXT> label;

 wxSize textSize = wxSize( KiROUND( elabel.size.ToSchUnits() * 0.7 ),
 KiROUND( elabel.size.ToSchUnits() * 0.7 ) );

 if( global )
 label = std::make_unique<SCH_GLOBALLABEL>();
 else
 label = std::make_unique<SCH_LABEL>();

 label->SetPosition( elabelpos );
 label->SetText( escapeName( elabel.netname ) );
 label->SetTextSize( textSize );
 label->SetLabelSpinStyle( LABEL_SPIN_STYLE::RIGHT );

 if( elabel.rot )
 {
 for( int i = 0; i < KiROUND( elabel.rot->degrees / 90 ) %4; ++i )
 label->Rotate90( false );

 if( elabel.rot->mirror )
 label->MirrorSpinStyle( false );
 }

 return label.release();
}

References EROT::degrees, escapeName(), KiROUND(), m_netCounts, EROT::mirror, ELABEL::netname, LABEL_SPIN_STYLE::RIGHT, ELABEL::rot, ELABEL::size, ECOORD::ToSchUnits(), ELABEL::x, and ELABEL::y.

Referenced by loadSegments().

loadLayerDefs()

void SCH_EAGLE_PLUGIN::loadLayerDefs ( wxXmlNode *  aLayers )

private

Layers in KiCad schematics are not actually layers, but abstract groups mainly used to decide item colors.

<layers> <layer number="90" name="Modules" color="5" fill="1" visible="yes" active="yes"> <layer number="91" name="Nets" color="2" fill="1" visible="yes" active="yes"> <layer number="92" name="Busses" color="1" fill="1" visible="yes" active="yes"> <layer number="93" name="Pins" color="2" fill="1" visible="no" active="yes"> <layer number="94" name="Symbols" color="4" fill="1" visible="yes" active="yes"> <layer number="95" name="Names" color="7" fill="1" visible="yes" active="yes"> <layer number="96" name="Values" color="7" fill="1" visible="yes" active="yes"> <layer number="97" name="Info" color="7" fill="1" visible="yes" active="yes"> <layer number="98" name="Guide" color="6" fill="1" visible="yes" active="yes"> </layers>

Definition at line 164 of file sch_eagle_plugin.cpp.

{
 std::vector<ELAYER> eagleLayers;

 // Get the first layer and iterate
 wxXmlNode* layerNode = aLayers->GetChildren();

 while( layerNode )
 {
 ELAYER elayer( layerNode );
 eagleLayers.push_back( elayer );

 layerNode = layerNode->GetNext();
 }

 // match layers based on their names
 for( const ELAYER& elayer : eagleLayers )
 {
 if( elayer.name == "Nets" )
 {
 m_layerMap[elayer.number] = LAYER_WIRE;
 }
 else if( elayer.name == "Info" || elayer.name == "Guide" )
 {
 m_layerMap[elayer.number] = LAYER_NOTES;
 }
 else if( elayer.name == "Busses" )
 {
 m_layerMap[elayer.number] = LAYER_BUS;
 }
 }
}

References LAYER_BUS, LAYER_NOTES, and LAYER_WIRE.

Referenced by loadDrawing().

loadLibrary()

EAGLE_LIBRARY * SCH_EAGLE_PLUGIN::loadLibrary ( wxXmlNode *  aLibraryNode, EAGLE_LIBRARY *  aEagleLib  )

private

Definition at line 1482 of file sch_eagle_plugin.cpp.

{
 NODE_MAP libraryChildren = MapChildren( aLibraryNode );

 // Loop through the symbols and load each of them
 wxXmlNode* symbolNode = getChildrenNodes( libraryChildren, "symbols" );

 while( symbolNode )
 {
 wxString symbolName = symbolNode->GetAttribute( "name" );
 aEagleLibrary->SymbolNodes[symbolName] = symbolNode;
 symbolNode = symbolNode->GetNext();
 }

 // Loop through the device sets and load each of them
 wxXmlNode* devicesetNode = getChildrenNodes( libraryChildren, "devicesets" );

 while( devicesetNode )
 {
 // Get Device set information
 EDEVICE_SET edeviceset = EDEVICE_SET( devicesetNode );

 wxString prefix = edeviceset.prefix ? edeviceset.prefix.Get() : "";

 NODE_MAP deviceSetChildren = MapChildren( devicesetNode );
 wxXmlNode* deviceNode = getChildrenNodes( deviceSetChildren, "devices" );

 // For each device in the device set:
 while( deviceNode )
 {
 // Get device information
 EDEVICE edevice = EDEVICE( deviceNode );

 // Create symbol name from deviceset and device names.
 wxString symbolName = edeviceset.name + edevice.name;
 symbolName.Replace( "*", "" );
 wxASSERT( !symbolName.IsEmpty() );
 symbolName = EscapeString( symbolName, CTX_LIBID );

 if( edevice.package )
 aEagleLibrary->package[symbolName] = edevice.package.Get();

 // Create KiCad symbol.
 unique_ptr<LIB_SYMBOL> libSymbol( new LIB_SYMBOL( symbolName ) );

 // Process each gate in the deviceset for this device.
 wxXmlNode* gateNode = getChildrenNodes( deviceSetChildren, "gates" );
 int gates_count = countChildren( deviceSetChildren["gates"], "gate" );
 libSymbol->SetUnitCount( gates_count );
 libSymbol->LockUnits( true );

 LIB_FIELD* reference = libSymbol->GetFieldById( REFERENCE_FIELD );

 if( prefix.length() == 0 )
 {
 reference->SetVisible( false );
 }
 else
 {
 // If there is no footprint assigned, then prepend the reference value
 // with a hash character to mute netlist updater complaints
 reference->SetText( edevice.package ? prefix : '#' + prefix );
 }

 int gateindex = 1;
 bool ispower = false;

 while( gateNode )
 {
 checkpoint();

 EGATE egate = EGATE( gateNode );

 aEagleLibrary->GateUnit[edeviceset.name + edevice.name + egate.name] = gateindex;
 ispower = loadSymbol( aEagleLibrary->SymbolNodes[egate.symbol], libSymbol, &edevice,
 gateindex, egate.name );

 gateindex++;
 gateNode = gateNode->GetNext();
 } // gateNode

 libSymbol->SetUnitCount( gates_count );

 if( gates_count == 1 && ispower )
 libSymbol->SetPower();

 wxString name = libSymbol->GetName();
 libSymbol->SetName( name );
 m_pi->SaveSymbol( getLibFileName().GetFullPath(), new LIB_SYMBOL( *libSymbol.get() ),
 m_properties.get() );
 aEagleLibrary->KiCadSymbols.insert( name, libSymbol.release() );

 deviceNode = deviceNode->GetNext();
 } // devicenode

 devicesetNode = devicesetNode->GetNext();
 } // devicesetNode

 return aEagleLibrary;
}

References checkpoint(), countChildren(), CTX_LIBID, EscapeString(), EAGLE_LIBRARY::GateUnit, OPTIONAL_XML_ATTRIBUTE< T >::Get(), getChildrenNodes(), getLibFileName(), EAGLE_LIBRARY::KiCadSymbols, loadSymbol(), m_pi, m_properties, MapChildren(), name, EGATE::name, EDEVICE::name, EDEVICE_SET::name, EAGLE_LIBRARY::package, EDEVICE::package, EDEVICE_SET::prefix, REFERENCE_FIELD, EDA_TEXT::SetText(), EDA_TEXT::SetVisible(), EGATE::symbol, and EAGLE_LIBRARY::SymbolNodes.

Referenced by loadSchematic().

loadPin()

LIB_PIN * SCH_EAGLE_PLUGIN::loadPin ( std::unique_ptr< LIB_SYMBOL > &  aSymbol, wxXmlNode *  aPin, EPIN *  epin, int  aGateNumber  )

private

Definition at line 1870 of file sch_eagle_plugin.cpp.

{
 std::unique_ptr<LIB_PIN> pin = std::make_unique<LIB_PIN>( aSymbol.get() );
 pin->SetPosition( wxPoint( aEPin->x.ToSchUnits(), aEPin->y.ToSchUnits() ) );
 pin->SetName( aEPin->name );
 pin->SetUnit( aGateNumber );

 int roti = aEPin->rot ? aEPin->rot->degrees : 0;

 switch( roti )
 {
 case 0: pin->SetOrientation( 'R' ); break;
 case 90: pin->SetOrientation( 'U' ); break;
 case 180: pin->SetOrientation( 'L' ); break;
 case 270: pin->SetOrientation( 'D' ); break;
 default: wxFAIL_MSG( wxString::Format( "Unhandled orientation (%d degrees).", roti ) );
 }

 pin->SetLength( Mils2iu( 300 ) ); // Default pin length when not defined.

 if( aEPin->length )
 {
 wxString length = aEPin->length.Get();

 if( length == "short" )
 pin->SetLength( Mils2iu( 100 ) );
 else if( length == "middle" )
 pin->SetLength( Mils2iu( 200 ) );
 else if( length == "long" )
 pin->SetLength( Mils2iu( 300 ) );
 else if( length == "point" )
 pin->SetLength( Mils2iu( 0 ) );
 }

 // emulate the visibility of pin elements
 if( aEPin->visible )
 {
 wxString visible = aEPin->visible.Get();

 if( visible == "off" )
 {
 pin->SetNameTextSize( 0 );
 pin->SetNumberTextSize( 0 );
 }
 else if( visible == "pad" )
 {
 pin->SetNameTextSize( 0 );
 }
 else if( visible == "pin" )
 {
 pin->SetNumberTextSize( 0 );
 }

 /*
 * else if( visible == "both" )
 * {
 * }
 */
 }

 if( aEPin->function )
 {
 wxString function = aEPin->function.Get();

 if( function == "dot" )
 pin->SetShape( GRAPHIC_PINSHAPE::INVERTED );
 else if( function == "clk" )
 pin->SetShape( GRAPHIC_PINSHAPE::CLOCK );
 else if( function == "dotclk" )
 pin->SetShape( GRAPHIC_PINSHAPE::INVERTED_CLOCK );
 }

 return pin.release();
}

References CLOCK, EROT::degrees, Format(), EPIN::function, OPTIONAL_XML_ATTRIBUTE< T >::Get(), INVERTED, INVERTED_CLOCK, EPIN::length, EPIN::name, pin, EPIN::rot, ECOORD::ToSchUnits(), EPIN::visible, EPIN::x, and EPIN::y.

Referenced by loadSymbol().

loadPlainText()

SCH_TEXT * SCH_EAGLE_PLUGIN::loadPlainText ( wxXmlNode *  aSchText )

private

Definition at line 2149 of file sch_eagle_plugin.cpp.

{
 std::unique_ptr<SCH_TEXT> schtext = std::make_unique<SCH_TEXT>();
 ETEXT etext = ETEXT( aSchText );

 const wxString& thetext = aSchText->GetNodeContent();

 wxString adjustedText;
 wxStringTokenizer tokenizer( thetext, "\r\n" );

 // Strip the whitespace from both ends of each line.
 while( tokenizer.HasMoreTokens() )
 {
 wxString tmp = tokenizer.GetNextToken().Trim();

 tmp = tmp.Trim( false );

 if( tokenizer.HasMoreTokens() )
 tmp += wxT( "\n" );

 adjustedText += tmp;
 }

 schtext->SetText( adjustedText.IsEmpty() ? "\" \"" : escapeName( adjustedText ) );
 schtext->SetPosition( wxPoint( etext.x.ToSchUnits(), -etext.y.ToSchUnits() ) );
 loadTextAttributes( schtext.get(), etext );
 schtext->SetItalic( false );

 return schtext.release();
}

References escapeName(), loadTextAttributes(), ECOORD::ToSchUnits(), ETEXT::x, and ETEXT::y.

Referenced by loadSheet().

loadSchematic()

void SCH_EAGLE_PLUGIN::loadSchematic ( wxXmlNode *  aSchematicNode )

private

Definition at line 585 of file sch_eagle_plugin.cpp.

{
 // Map all children into a readable dictionary
 NODE_MAP schematicChildren = MapChildren( aSchematicNode );
 wxXmlNode* partNode = getChildrenNodes( schematicChildren, "parts" );
 wxXmlNode* libraryNode = getChildrenNodes( schematicChildren, "libraries" );
 wxXmlNode* sheetNode = getChildrenNodes( schematicChildren, "sheets" );

 if( !sheetNode )
 return;

 auto count_nodes =
 []( wxXmlNode* aNode ) -> unsigned
 {
 unsigned count = 0;

 while( aNode )
 {
 count++;
 aNode = aNode->GetNext();
 }

 return count;
 };

 if( m_progressReporter )
 {
 m_totalCount = 0;
 m_doneCount = 0;

 m_totalCount += count_nodes( partNode );

 while( libraryNode )
 {
 NODE_MAP libraryChildren = MapChildren( libraryNode );
 wxXmlNode* devicesetNode = getChildrenNodes( libraryChildren, "devicesets" );

 while( devicesetNode )
 {
 NODE_MAP deviceSetChildren = MapChildren( devicesetNode );
 wxXmlNode* deviceNode = getChildrenNodes( deviceSetChildren, "devices" );
 wxXmlNode* gateNode = getChildrenNodes( deviceSetChildren, "gates" );

 m_totalCount += count_nodes( deviceNode ) * count_nodes( gateNode );

 devicesetNode = devicesetNode->GetNext();
 }

 libraryNode = libraryNode->GetNext();
 }

 // Rewind
 libraryNode = getChildrenNodes( schematicChildren, "libraries" );

 while( sheetNode )
 {
 NODE_MAP sheetChildren = MapChildren( sheetNode );

 m_totalCount += count_nodes( getChildrenNodes( sheetChildren, "instances" ) );
 m_totalCount += count_nodes( getChildrenNodes( sheetChildren, "busses" ) );
 m_totalCount += count_nodes( getChildrenNodes( sheetChildren, "nets" ) );
 m_totalCount += count_nodes( getChildrenNodes( sheetChildren, "plain" ) );

 sheetNode = sheetNode->GetNext();
 }

 // Rewind
 sheetNode = getChildrenNodes( schematicChildren, "sheets" );
 }

 while( partNode )
 {
 checkpoint();

 std::unique_ptr<EPART> epart = std::make_unique<EPART>( partNode );

 // N.B. Eagle parts are case-insensitive in matching but we keep the display case
 m_partlist[epart->name.Upper()] = std::move( epart );
 partNode = partNode->GetNext();
 }

 if( libraryNode )
 {
 while( libraryNode )
 {
 // Read the library name
 wxString libName = libraryNode->GetAttribute( "name" );

 EAGLE_LIBRARY* elib = &m_eagleLibs[libName];
 elib->name = libName;

 loadLibrary( libraryNode, &m_eagleLibs[libName] );

 libraryNode = libraryNode->GetNext();
 }
 m_pi->SaveLibrary( getLibFileName().GetFullPath() );
 }

 // find all nets and count how many sheets they appear on.
 // local labels will be used for nets found only on that sheet.
 countNets( aSchematicNode );

 // Loop through all the sheets
 int sheet_count = countChildren( sheetNode->GetParent(), "sheet" );

 // If eagle schematic has multiple sheets then create corresponding subsheets on the root sheet
 if( sheet_count > 1 )
 {
 int x, y, i;
 i = 1;
 x = 1;
 y = 1;

 while( sheetNode )
 {
 wxPoint pos = wxPoint( x * Mils2iu( 1000 ), y * Mils2iu( 1000 ) );
 std::unique_ptr<SCH_SHEET> sheet = std::make_unique<SCH_SHEET>( m_rootSheet, pos );
 SCH_SCREEN* screen = new SCH_SCREEN( m_schematic );

 sheet->SetScreen( screen );
 sheet->GetScreen()->SetFileName( sheet->GetFileName() );

 m_currentSheet = sheet.get();
 loadSheet( sheetNode, i );
 m_rootSheet->GetScreen()->Append( sheet.release() );

 sheetNode = sheetNode->GetNext();
 x += 2;

 if( x > 10 ) // start next row
 {
 x = 1;
 y += 2;
 }

 i++;
 }
 }
 else
 {
 while( sheetNode )
 {
 m_currentSheet = m_rootSheet;
 loadSheet( sheetNode, 0 );
 sheetNode = sheetNode->GetNext();
 }
 }

 // Handle the missing symbol units that need to be instantiated
 // to create the missing implicit connections

 // Calculate the already placed items bounding box and the page size to determine
 // placement for the new symbols
 wxSize pageSizeIU = m_rootSheet->GetScreen()->GetPageSettings().GetSizeIU();
 EDA_RECT sheetBbox = getSheetBbox( m_rootSheet );
 wxPoint newCmpPosition( sheetBbox.GetLeft(), sheetBbox.GetBottom() );
 int maxY = sheetBbox.GetY();

 SCH_SHEET_PATH sheetpath;
 m_rootSheet->LocatePathOfScreen( m_rootSheet->GetScreen(), &sheetpath );

 for( auto& cmp : m_missingCmps )
 {
 const SCH_SYMBOL* origSymbol = cmp.second.cmp;

 for( auto unitEntry : cmp.second.units )
 {
 if( unitEntry.second == false )
 continue; // unit has been already processed

 // Instantiate the missing symbol unit
 int unit = unitEntry.first;
 const wxString reference = origSymbol->GetField( REFERENCE_FIELD )->GetText();
 std::unique_ptr<SCH_SYMBOL> symbol( (SCH_SYMBOL*) origSymbol->Duplicate() );

 symbol->SetUnitSelection( &sheetpath, unit );
 symbol->SetUnit( unit );
 symbol->SetOrientation( 0 );
 symbol->AddHierarchicalReference( sheetpath.Path(), reference, unit );

 // Calculate the placement position
 EDA_RECT cmpBbox = symbol->GetBoundingBox();
 int posY = newCmpPosition.y + cmpBbox.GetHeight();
 symbol->SetPosition( wxPoint( newCmpPosition.x, posY ) );
 newCmpPosition.x += cmpBbox.GetWidth();
 maxY = std::max( maxY, posY );

 if( newCmpPosition.x >= pageSizeIU.GetWidth() ) // reached the page boundary?
 newCmpPosition = wxPoint( sheetBbox.GetLeft(), maxY ); // then start a new row

 // Add the global net labels to recreate the implicit connections
 addImplicitConnections( symbol.get(), m_rootSheet->GetScreen(), false );
 m_rootSheet->GetScreen()->Append( symbol.release() );
 }
 }

 m_missingCmps.clear();
}

References addImplicitConnections(), SCH_SCREEN::Append(), checkpoint(), countChildren(), countNets(), SCH_ITEM::Duplicate(), EDA_RECT::GetBottom(), getChildrenNodes(), SCH_SYMBOL::GetField(), EDA_RECT::GetHeight(), EDA_RECT::GetLeft(), getLibFileName(), SCH_SCREEN::GetPageSettings(), SCH_SHEET::GetScreen(), getSheetBbox(), EDA_TEXT::GetText(), EDA_RECT::GetWidth(), EDA_RECT::GetY(), loadLibrary(), loadSheet(), SCH_SHEET::LocatePathOfScreen(), m_currentSheet, m_doneCount, m_eagleLibs, m_missingCmps, m_partlist, m_pi, m_progressReporter, m_rootSheet, m_schematic, m_totalCount, MapChildren(), EAGLE_LIBRARY::name, SCH_SHEET_PATH::Path(), and REFERENCE_FIELD.

Referenced by loadDrawing().

loadSegments()

void SCH_EAGLE_PLUGIN::loadSegments ( wxXmlNode *  aSegmentsNode, const wxString &  aNetName, const wxString &  aNetClass  )

private

Definition at line 1005 of file sch_eagle_plugin.cpp.

{
 // Loop through all segments
 wxXmlNode* currentSegment = aSegmentsNode->GetChildren();
 SCH_SCREEN* screen = m_currentSheet->GetScreen();

 int segmentCount = countChildren( aSegmentsNode, "segment" );

 // wxCHECK( screen, [>void<] );
 while( currentSegment )
 {
 bool labelled = false; // has a label been added to this continuously connected segment
 NODE_MAP segmentChildren = MapChildren( currentSegment );
 SCH_LINE* firstWire = nullptr;
 m_segments.emplace_back();
 SEG_DESC& segDesc = m_segments.back();

 // Loop through all segment children
 wxXmlNode* segmentAttribute = currentSegment->GetChildren();

 while( segmentAttribute )
 {
 if( segmentAttribute->GetName() == "wire" )
 {
 SCH_LINE* wire = loadWire( segmentAttribute );

 if( !firstWire )
 firstWire = wire;

 // Test for intersections with other wires
 SEG thisWire( wire->GetStartPoint(), wire->GetEndPoint() );

 for( SEG_DESC& desc : m_segments )
 {
 if( !desc.labels.empty() && desc.labels.front()->GetText() == netName )
 continue; // no point in saving intersections of the same net

 for( const SEG& seg : desc.segs )
 {
 OPT_VECTOR2I intersection = thisWire.Intersect( seg, true );

 if( intersection )
 m_wireIntersections.push_back( *intersection );
 }
 }

 segDesc.segs.push_back( thisWire );
 screen->Append( wire );
 }

 segmentAttribute = segmentAttribute->GetNext();
 }

 segmentAttribute = currentSegment->GetChildren();

 while( segmentAttribute )
 {
 wxString nodeName = segmentAttribute->GetName();

 if( nodeName == "junction" )
 {
  screen->Append( loadJunction( segmentAttribute ) );
 }
 else if( nodeName == "label" )
 {
 SCH_TEXT* label = loadLabel( segmentAttribute, netName );
 screen->Append( label );
 wxASSERT( segDesc.labels.empty()
 || segDesc.labels.front()->GetText() == label->GetText() );
 segDesc.labels.push_back( label );
 labelled = true;
 }
 else if( nodeName == "pinref" )
 {
 segmentAttribute->GetAttribute( "gate" ); // REQUIRED
 wxString part = segmentAttribute->GetAttribute( "part" ); // REQUIRED
 wxString pin = segmentAttribute->GetAttribute( "pin" ); // REQUIRED

 auto powerPort = m_powerPorts.find( "#" + part );

 if( powerPort != m_powerPorts.end()
 && powerPort->second == EscapeString( pin, CTX_NETNAME ) )
 {
 labelled = true;
 }
 }
 else if( nodeName == "wire" )
 {
 // already handled;
 }
 else // DEFAULT
 {
 // THROW_IO_ERROR( wxString::Format( _( "XML node '%s' unknown" ), nodeName ) );
 }

 // Get next segment attribute
 segmentAttribute = segmentAttribute->GetNext();
 }

 // Add a small label to the net segment if it hasn't been labeled already or is not
 // connect to a power symbol with a pin on the same net. This preserves the named net
 // feature of Eagle schematics.
 if( !labelled && firstWire )
 {
 std::unique_ptr<SCH_TEXT> label;

 // Add a global label if the net appears on more than one Eagle sheet
 if( m_netCounts[netName.ToStdString()] > 1 )
 label.reset( new SCH_GLOBALLABEL );
 else if( segmentCount > 1 )
 label.reset( new SCH_LABEL );

 if( label )
 {
 label->SetPosition( firstWire->GetStartPoint() );
 label->SetText( escapeName( netName ) );
 label->SetTextSize( wxSize( Mils2iu( 40 ), Mils2iu( 40 ) ) );

 if( firstWire->GetEndPoint().x > firstWire->GetStartPoint().x )
 label->SetLabelSpinStyle( LABEL_SPIN_STYLE::LEFT );
 else
 label->SetLabelSpinStyle( LABEL_SPIN_STYLE::RIGHT );

 screen->Append( label.release() );
 }
 }

 currentSegment = currentSegment->GetNext();
 }
}

References SCH_SCREEN::Append(), countChildren(), CTX_NETNAME, escapeName(), EscapeString(), SCH_LINE::GetEndPoint(), SCH_SHEET::GetScreen(), SCH_LINE::GetStartPoint(), EDA_TEXT::GetText(), SEG::Intersect(), SCH_EAGLE_PLUGIN::SEG_DESC::labels, LABEL_SPIN_STYLE::LEFT, loadJunction(), loadLabel(), loadWire(), m_currentSheet, m_netCounts, m_powerPorts, m_segments, m_wireIntersections, MapChildren(), pin, LABEL_SPIN_STYLE::RIGHT, and SCH_EAGLE_PLUGIN::SEG_DESC::segs.

Referenced by loadSheet().

loadSheet()

void SCH_EAGLE_PLUGIN::loadSheet ( wxXmlNode *  aSheetNode, int  sheetcount  )

private

Definition at line 785 of file sch_eagle_plugin.cpp.

{
 // Map all children into a readable dictionary
 NODE_MAP sheetChildren = MapChildren( aSheetNode );

 // Get description node
 wxXmlNode* descriptionNode = getChildrenNodes( sheetChildren, "description" );

 wxString des;
 std::string filename;
 SCH_FIELD& sheetNameField = m_currentSheet->GetFields()[SHEETNAME];
 SCH_FIELD& filenameField = m_currentSheet->GetFields()[SHEETFILENAME];

 if( descriptionNode )
 {
 des = descriptionNode->GetContent();
 des.Replace( "\n", "_", true );
 sheetNameField.SetText( des );
 filename = des.ToStdString();
 }
 else
 {
 filename = wxString::Format( "%s_%d", m_filename.GetName(), aSheetIndex );
 sheetNameField.SetText( filename );
 }

 ReplaceIllegalFileNameChars( &filename );
 replace( filename.begin(), filename.end(), ' ', '_' );

 wxFileName fn( m_filename );
 fn.SetName( filename );
 fn.SetExt( KiCadSchematicFileExtension );

 filenameField.SetText( fn.GetFullName() );
 m_currentSheet->GetScreen()->SetFileName( fn.GetFullPath() );
 m_currentSheet->AutoplaceFields( m_currentSheet->GetScreen(), true );


 // Loop through all of the symbol instances.
 wxXmlNode* instanceNode = getChildrenNodes( sheetChildren, "instances" );

 while( instanceNode )
 {
 checkpoint();

 loadInstance( instanceNode );
 instanceNode = instanceNode->GetNext();
 }

 // Loop through all buses
 // From the DTD: "Buses receive names which determine which signals they include.
 // A bus is a drawing object. It does not create any electrical connections.
 // These are always created by means of the nets and their names."
 wxXmlNode* busNode = getChildrenNodes( sheetChildren, "busses" );

 while( busNode )
 {
 checkpoint();

 // Get the bus name
 wxString busName = translateEagleBusName( busNode->GetAttribute( "name" ) );

 // Load segments of this bus
 loadSegments( busNode, busName, wxString() );

 // Get next bus
 busNode = busNode->GetNext();
 }

 // Loop through all nets
 // From the DTD: "Net is an electrical connection in a schematic."
 wxXmlNode* netNode = getChildrenNodes( sheetChildren, "nets" );

 while( netNode )
 {
 checkpoint();

 // Get the net name and class
 wxString netName = netNode->GetAttribute( "name" );
 wxString netClass = netNode->GetAttribute( "class" );

 // Load segments of this net
 loadSegments( netNode, netName, netClass );

 // Get next net
 netNode = netNode->GetNext();
 }

 adjustNetLabels(); // needs to be called before addBusEntries()
 addBusEntries();

 /* moduleinst is a design block definition and is an EagleCad 8 feature,
 *
 * // Loop through all moduleinsts
 * wxXmlNode* moduleinstNode = getChildrenNodes( sheetChildren, "moduleinsts" );
 *
 * while( moduleinstNode )
 * {
 * loadModuleinst( moduleinstNode );
 * moduleinstNode = moduleinstNode->GetNext();
 * }
 */

 wxXmlNode* plainNode = getChildrenNodes( sheetChildren, "plain" );

 while( plainNode )
 {
 checkpoint();

 wxString nodeName = plainNode->GetName();

 if( nodeName == "text" )
 {
 m_currentSheet->GetScreen()->Append( loadPlainText( plainNode ) );
 }
 else if( nodeName == "wire" )
 {
 m_currentSheet->GetScreen()->Append( loadWire( plainNode ) );
 }
 else if( nodeName == "frame" )
 {
 std::vector<SCH_LINE*> lines;

 loadFrame( plainNode, lines );

 for( SCH_LINE* line : lines )
 m_currentSheet->GetScreen()->Append( line );
 }

 plainNode = plainNode->GetNext();
 }

 // Calculate the new sheet size.
 EDA_RECT sheetBoundingBox = getSheetBbox( m_currentSheet );
 wxSize targetSheetSize = sheetBoundingBox.GetSize();
 targetSheetSize.IncBy( Mils2iu( 1500 ), Mils2iu( 1500 ) );

 // Get current Eeschema sheet size.
 wxSize pageSizeIU = m_currentSheet->GetScreen()->GetPageSettings().GetSizeIU();
 PAGE_INFO pageInfo = m_currentSheet->GetScreen()->GetPageSettings();

 // Increase if necessary
 if( pageSizeIU.x < targetSheetSize.x )
 pageInfo.SetWidthMils( Iu2Mils( targetSheetSize.x ) );

 if( pageSizeIU.y < targetSheetSize.y )
 pageInfo.SetHeightMils( Iu2Mils( targetSheetSize.y ) );

 // Set the new sheet size.
 m_currentSheet->GetScreen()->SetPageSettings( pageInfo );

 pageSizeIU = m_currentSheet->GetScreen()->GetPageSettings().GetSizeIU();
 wxPoint sheetcentre( pageSizeIU.x / 2, pageSizeIU.y / 2 );
 wxPoint itemsCentre = sheetBoundingBox.Centre();

 // round the translation to nearest 100mil to place it on the grid.
 wxPoint translation = sheetcentre - itemsCentre;
 translation.x = translation.x - translation.x % Mils2iu( 100 );
 translation.y = translation.y - translation.y % Mils2iu( 100 );

 // Add global net labels for the named power input pins in this sheet
 for( SCH_ITEM* item : m_currentSheet->GetScreen()->Items().OfType( SCH_SYMBOL_T ) )
 {
 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
 addImplicitConnections( symbol, m_currentSheet->GetScreen(), true );
 }

 m_connPoints.clear();

 // Translate the items.
 std::vector<SCH_ITEM*> allItems;

 std::copy( m_currentSheet->GetScreen()->Items().begin(),
 m_currentSheet->GetScreen()->Items().end(), std::back_inserter( allItems ) );

 for( SCH_ITEM* item : allItems )
 {
 item->SetPosition( item->GetPosition() + translation );
 item->ClearFlags();
 m_currentSheet->GetScreen()->Update( item );

 }
}

References addBusEntries(), addImplicitConnections(), adjustNetLabels(), SCH_SCREEN::Append(), SCH_SHEET::AutoplaceFields(), EE_RTREE::begin(), EDA_RECT::Centre(), checkpoint(), EE_RTREE::end(), Format(), getChildrenNodes(), SCH_SHEET::GetFields(), SCH_SCREEN::GetPageSettings(), SCH_SHEET::GetScreen(), getSheetBbox(), EDA_RECT::GetSize(), SCH_SCREEN::Items(), KiCadSchematicFileExtension, loadFrame(), loadInstance(), loadPlainText(), loadSegments(), loadWire(), m_connPoints, m_currentSheet, m_filename, MapChildren(), EE_RTREE::OfType(), ReplaceIllegalFileNameChars(), SCH_SYMBOL_T, SCH_SCREEN::SetFileName(), PAGE_INFO::SetHeightMils(), SCH_SCREEN::SetPageSettings(), EDA_TEXT::SetText(), PAGE_INFO::SetWidthMils(), SHEETFILENAME, SHEETNAME, translateEagleBusName(), and SCH_SCREEN::Update().

Referenced by loadSchematic().

loadSymbol()

bool SCH_EAGLE_PLUGIN::loadSymbol ( wxXmlNode *  aSymbolNode, std::unique_ptr< LIB_SYMBOL > &  aSymbol, EDEVICE *  aDevice, int  aGateNumber, const wxString &  aGateName  )

private

Definition at line 1585 of file sch_eagle_plugin.cpp.

{
 wxString symbolName = aSymbolNode->GetAttribute( "name" );
 std::vector<LIB_ITEM*> items;

 wxXmlNode* currentNode = aSymbolNode->GetChildren();

 bool foundName = false;
 bool foundValue = false;
 bool ispower = false;
 int pincount = 0;

 while( currentNode )
 {
 wxString nodeName = currentNode->GetName();

 if( nodeName == "circle" )
 {
 aSymbol->AddDrawItem( loadSymbolCircle( aSymbol, currentNode, aGateNumber ) );
 }
 else if( nodeName == "pin" )
 {
 EPIN ePin = EPIN( currentNode );
 std::unique_ptr<LIB_PIN> pin( loadPin( aSymbol, currentNode, &ePin, aGateNumber ) );
 pincount++;

 pin->SetType( ELECTRICAL_PINTYPE::PT_BIDI );

 if( ePin.direction )
 {
 for( const auto& pinDir : pinDirectionsMap )
 {
 if( ePin.direction->Lower() == pinDir.first )
 {
 pin->SetType( pinDir.second );

 if( pinDir.first == "sup" ) // power supply symbol
 ispower = true;

 break;
 }
 }
 }

 if( aDevice->connects.size() != 0 )
 {
 for( const ECONNECT& connect : aDevice->connects )
 {
 if( connect.gate == aGateName && pin->GetName() == connect.pin )
 {
 wxArrayString pads = wxSplit( wxString( connect.pad ), ' ' );

 pin->SetUnit( aGateNumber );
 pin->SetName( escapeName( pin->GetName() ) );

 if( pads.GetCount() > 1 )
 {
 pin->SetNumberTextSize( 0 );
 }

 for( unsigned i = 0; i < pads.GetCount(); i++ )
 {
 LIB_PIN* apin = new LIB_PIN( *pin );

 wxString padname( pads[i] );
 apin->SetNumber( padname );
 aSymbol->AddDrawItem( apin );
 }

 break;
 }
 }
 }
 else
 {
 pin->SetUnit( aGateNumber );
 pin->SetNumber( wxString::Format( "%i", pincount ) );
 aSymbol->AddDrawItem( pin.release() );
 }
 }
 else if( nodeName == "polygon" )
 {
 aSymbol->AddDrawItem( loadSymbolPolyLine( aSymbol, currentNode, aGateNumber ) );
 }
 else if( nodeName == "rectangle" )
 {
 aSymbol->AddDrawItem( loadSymbolRectangle( aSymbol, currentNode, aGateNumber ) );
 }
 else if( nodeName == "text" )
 {
 std::unique_ptr<LIB_TEXT> libtext( loadSymbolText( aSymbol, currentNode,
 aGateNumber ) );

 if( libtext->GetText().Upper() == ">NAME" )
 {
 LIB_FIELD* field = aSymbol->GetFieldById( REFERENCE_FIELD );
 loadFieldAttributes( field, libtext.get() );
 foundName = true;
 }
 else if( libtext->GetText().Upper() == ">VALUE" )
 {
 LIB_FIELD* field = aSymbol->GetFieldById( VALUE_FIELD );
 loadFieldAttributes( field, libtext.get() );
 foundValue = true;
 }
 else
 {
 aSymbol->AddDrawItem( libtext.release() );
 }
 }
 else if( nodeName == "wire" )
 {
 aSymbol->AddDrawItem( loadSymbolWire( aSymbol, currentNode, aGateNumber ) );
 }
 else if( nodeName == "frame" )
 {
 std::vector<LIB_ITEM*> frameItems;

 loadFrame( currentNode, frameItems );

 for( LIB_ITEM* item : frameItems )
 {
 item->SetParent( aSymbol.get() );
 aSymbol->AddDrawItem( item );
 }
 }

 /*
 * else if( nodeName == "description" )
 * {
 * }
 * else if( nodeName == "dimension" )
 * {
 * }
 */

 currentNode = currentNode->GetNext();
 }

 if( foundName == false )
 aSymbol->GetFieldById( REFERENCE_FIELD )->SetVisible( false );

 if( foundValue == false )
 aSymbol->GetFieldById( VALUE_FIELD )->SetVisible( false );

 return pincount == 1 ? ispower : false;
}

References EDEVICE::connects, EPIN::direction, escapeName(), Format(), ECONNECT::gate, loadFieldAttributes(), loadFrame(), loadPin(), loadSymbolCircle(), loadSymbolPolyLine(), loadSymbolRectangle(), loadSymbolText(), loadSymbolWire(), ECONNECT::pad, pin, ECONNECT::pin, pinDirectionsMap, PT_BIDI, REFERENCE_FIELD, LIB_PIN::SetNumber(), and VALUE_FIELD.

Referenced by loadLibrary().

LoadSymbol()

LIB_SYMBOL * SCH_PLUGIN::LoadSymbol ( const wxString &  aLibraryPath, const wxString &  aPartName, const PROPERTIES *  aProperties = nullptr  )

virtualinherited

Load a LIB_SYMBOL object having aPartName from the aLibraryPath containing a library format that this SCH_PLUGIN knows about.

Parameters

aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing several symbols.
aPartName	is the name of the LIB_SYMBOL to load.
aProperties	is an associative array that can be used to tell the loader implementation to do something special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Returns

the part created on the heap if found caller shares it or NULL if not found.

Exceptions

IO_ERROR

if the library cannot be found or read. No exception is thrown in the case where aAliasName cannot be found.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 85 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
 return nullptr;
}

References not_implemented().

Referenced by SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer().

loadSymbolCircle()

LIB_SHAPE * SCH_EAGLE_PLUGIN::loadSymbolCircle ( std::unique_ptr< LIB_SYMBOL > &  aSymbol, wxXmlNode *  aCircleNode, int  aGateNumber  )

private

Definition at line 1735 of file sch_eagle_plugin.cpp.

{
 // Parse the circle properties
 ECIRCLE c( aCircleNode );
 LIB_SHAPE* circle = new LIB_SHAPE( aSymbol.get(), SHAPE_T::CIRCLE );
 wxPoint center( c.x.ToSchUnits(), c.y.ToSchUnits() );

 circle->SetPosition( center );
 circle->SetEnd( wxPoint( center.x + c.radius.ToSchUnits(), center.y ) );
 circle->SetWidth( c.width.ToSchUnits() );
 circle->SetUnit( aGateNumber );

 return circle;
}

References CIRCLE, ECIRCLE::radius, EDA_SHAPE::SetEnd(), LIB_SHAPE::SetPosition(), LIB_ITEM::SetUnit(), EDA_SHAPE::SetWidth(), ECOORD::ToSchUnits(), ECIRCLE::width, ECIRCLE::x, and ECIRCLE::y.

Referenced by loadSymbol().

loadSymbolPolyLine()

LIB_SHAPE * SCH_EAGLE_PLUGIN::loadSymbolPolyLine ( std::unique_ptr< LIB_SYMBOL > &  aSymbol, wxXmlNode *  aPolygonNode, int  aGateNumber  )

private

Definition at line 1843 of file sch_eagle_plugin.cpp.

{
 LIB_SHAPE* poly = new LIB_SHAPE( aSymbol.get(), SHAPE_T::POLY );
 EPOLYGON epoly( aPolygonNode );
 wxXmlNode* vertex = aPolygonNode->GetChildren();
 wxPoint pt;

 while( vertex )
 {
 if( vertex->GetName() == "vertex" ) // skip <xmlattr> node
 {
 EVERTEX evertex( vertex );
 pt = wxPoint( evertex.x.ToSchUnits(), evertex.y.ToSchUnits() );
 poly->AddPoint( pt );
 }

 vertex = vertex->GetNext();
 }

 poly->SetFillMode( FILL_T::FILLED_SHAPE );
 poly->SetUnit( aGateNumber );

 return poly;
}

References LIB_SHAPE::AddPoint(), FILLED_SHAPE, POLY, EDA_SHAPE::SetFillMode(), LIB_ITEM::SetUnit(), ECOORD::ToSchUnits(), EVERTEX::x, and EVERTEX::y.

Referenced by loadSymbol().

loadSymbolRectangle()

LIB_SHAPE * SCH_EAGLE_PLUGIN::loadSymbolRectangle ( std::unique_ptr< LIB_SYMBOL > &  aSymbol, wxXmlNode *  aRectNode, int  aGateNumber  )

private

Definition at line 1752 of file sch_eagle_plugin.cpp.

{
 ERECT rect( aRectNode );
 LIB_SHAPE* rectangle = new LIB_SHAPE( aSymbol.get(), SHAPE_T::RECT );

 rectangle->SetPosition( wxPoint( rect.x1.ToSchUnits(), rect.y1.ToSchUnits() ) );
 rectangle->SetEnd( wxPoint( rect.x2.ToSchUnits(), rect.y2.ToSchUnits() ) );

 rectangle->SetUnit( aGateNumber );

 // Eagle rectangles are filled by definition.
 rectangle->SetFillMode( FILL_T::FILLED_SHAPE );

 return rectangle;
}

References FILLED_SHAPE, RECT, EDA_SHAPE::SetEnd(), EDA_SHAPE::SetFillMode(), LIB_SHAPE::SetPosition(), LIB_ITEM::SetUnit(), ECOORD::ToSchUnits(), ERECT::x1, ERECT::x2, ERECT::y1, and ERECT::y2.

Referenced by loadSymbol().

loadSymbolText()

LIB_TEXT * SCH_EAGLE_PLUGIN::loadSymbolText ( std::unique_ptr< LIB_SYMBOL > &  aSymbol, wxXmlNode *  aLibText, int  aGateNumber  )

private

Definition at line 1947 of file sch_eagle_plugin.cpp.

{
 std::unique_ptr<LIB_TEXT> libtext = std::make_unique<LIB_TEXT>( aSymbol.get() );
 ETEXT etext( aLibText );

 libtext->SetUnit( aGateNumber );
 libtext->SetPosition( wxPoint( etext.x.ToSchUnits(), etext.y.ToSchUnits() ) );

 // Eagle supports multiple line text in library symbols. Legacy library symbol text cannot
 // contain CRs or LFs.
 //
 // @todo Split this into multiple text objects and offset the Y position so that it looks
 // more like the original Eagle schematic.
 wxString text = aLibText->GetNodeContent();
 std::replace( text.begin(), text.end(), '\n', '_' );
 std::replace( text.begin(), text.end(), '\r', '_' );

 libtext->SetText( text.IsEmpty() ? "~" : text );
 loadTextAttributes( libtext.get(), etext );

 return libtext.release();
}

References loadTextAttributes(), and text.

Referenced by loadSymbol().

loadSymbolWire()

LIB_ITEM * SCH_EAGLE_PLUGIN::loadSymbolWire ( std::unique_ptr< LIB_SYMBOL > &  aSymbol, wxXmlNode *  aWireNode, int  aGateNumber  )

private

Definition at line 1770 of file sch_eagle_plugin.cpp.

{
 EWIRE ewire = EWIRE( aWireNode );

 wxPoint begin, end;

 begin.x = ewire.x1.ToSchUnits();
 begin.y = ewire.y1.ToSchUnits();
 end.x = ewire.x2.ToSchUnits();
 end.y = ewire.y2.ToSchUnits();

 if( begin == end )
 return nullptr;

 // if the wire is an arc
 if( ewire.curve )
 {
 LIB_SHAPE* arc = new LIB_SHAPE( aSymbol.get(), SHAPE_T::ARC );
 wxPoint center = ConvertArcCenter( begin, end, *ewire.curve * -1 );
 double radius = sqrt( abs( ( ( center.x - begin.x ) * ( center.x - begin.x ) )
 + ( ( center.y - begin.y ) * ( center.y - begin.y ) ) ) )
 * 2;

 // this emulates the filled semicircles created by a thick arc with flat ends caps.
 if( ewire.width.ToSchUnits() * 2 > radius )
 {
 wxPoint centerStartVector = begin - center;
 wxPoint centerEndVector = end - center;

 centerStartVector.x = centerStartVector.x * ewire.width.ToSchUnits() * 2 / radius;
 centerStartVector.y = centerStartVector.y * ewire.width.ToSchUnits() * 2 / radius;

 centerEndVector.x = centerEndVector.x * ewire.width.ToSchUnits() * 2 / radius;
 centerEndVector.y = centerEndVector.y * ewire.width.ToSchUnits() * 2 / radius;

 begin = center + centerStartVector;
 end = center + centerEndVector;

 radius = sqrt( abs( ( ( center.x - begin.x ) * ( center.x - begin.x ) )
 + ( ( center.y - begin.y ) * ( center.y - begin.y ) ) ) )
 * 2;

 arc->SetWidth( 1 );
 arc->SetFillMode( FILL_T::FILLED_SHAPE );
 }
 else
 {
 arc->SetWidth( ewire.width.ToSchUnits() );
 }

 if( *ewire.curve <= 0 )
 std::swap( begin, end );

 arc->SetArcGeometry( begin, (wxPoint) CalcArcMid( begin, end, center ), end );
 arc->SetUnit( aGateNumber );

 return arc;
 }
 else
 {
 LIB_SHAPE* poly = new LIB_SHAPE( aSymbol.get(), SHAPE_T::POLY );

 poly->AddPoint( begin );
 poly->AddPoint( end );
 poly->SetUnit( aGateNumber );
 poly->SetWidth( ewire.width.ToSchUnits() );

 return poly;
 }
}

References LIB_SHAPE::AddPoint(), ARC, CalcArcMid(), ConvertArcCenter(), EWIRE::curve, FILLED_SHAPE, POLY, EDA_SHAPE::SetArcGeometry(), EDA_SHAPE::SetFillMode(), LIB_ITEM::SetUnit(), EDA_SHAPE::SetWidth(), ECOORD::ToSchUnits(), EWIRE::width, EWIRE::x1, EWIRE::x2, EWIRE::y1, and EWIRE::y2.

Referenced by loadSymbol().

loadTextAttributes()

void SCH_EAGLE_PLUGIN::loadTextAttributes ( EDA_TEXT *  aText, const ETEXT &  aAttribs  ) const

private

Definition at line 2181 of file sch_eagle_plugin.cpp.

{
 aText->SetTextSize( aAttribs.ConvertSize() );

 if( aAttribs.ratio )
 {
 if( aAttribs.ratio.CGet() > 12 )
 {
 aText->SetBold( true );
 aText->SetTextThickness( GetPenSizeForBold( aText->GetTextWidth() ) );
 }
 }

 int align = aAttribs.align ? *aAttribs.align : ETEXT::BOTTOM_LEFT;
 int degrees = aAttribs.rot ? aAttribs.rot->degrees : 0;
 bool mirror = aAttribs.rot ? aAttribs.rot->mirror : false;
 bool spin = aAttribs.rot ? aAttribs.rot->spin : false;

 eagleToKicadAlignment( aText, align, degrees, mirror, spin, 0 );
}

References ETEXT::align, ETEXT::BOTTOM_LEFT, OPTIONAL_XML_ATTRIBUTE< T >::CGet(), ETEXT::ConvertSize(), EROT::degrees, eagleToKicadAlignment(), GetPenSizeForBold(), EDA_TEXT::GetTextWidth(), EROT::mirror, ETEXT::ratio, ETEXT::rot, EDA_TEXT::SetBold(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetTextThickness(), and EROT::spin.

Referenced by loadPlainText(), and loadSymbolText().

loadWire()

SCH_LINE * SCH_EAGLE_PLUGIN::loadWire ( wxXmlNode *  aWireNode )

private

Definition at line 1138 of file sch_eagle_plugin.cpp.

{
 std::unique_ptr<SCH_LINE> wire = std::make_unique<SCH_LINE>();

 EWIRE ewire = EWIRE( aWireNode );

 wire->SetLayer( kiCadLayer( ewire.layer ) );

 wxPoint begin, end;

 begin.x = ewire.x1.ToSchUnits();
 begin.y = -ewire.y1.ToSchUnits();
 end.x = ewire.x2.ToSchUnits();
 end.y = -ewire.y2.ToSchUnits();

 wire->SetStartPoint( begin );
 wire->SetEndPoint( end );

 m_connPoints[begin].emplace( wire.get() );
 m_connPoints[end].emplace( wire.get() );

 return wire.release();
}

References kiCadLayer(), EWIRE::layer, m_connPoints, ECOORD::ToSchUnits(), EWIRE::x1, EWIRE::x2, EWIRE::y1, and EWIRE::y2.

Referenced by loadSegments(), and loadSheet().

moveLabels()

void SCH_EAGLE_PLUGIN::moveLabels ( SCH_LINE *  aWire, const wxPoint &  aNewEndPoint  )

private

Move any labels on the wire to the new end point of the wire.

Definition at line 2309 of file sch_eagle_plugin.cpp.

{
 for( SCH_ITEM* item : m_currentSheet->GetScreen()->Items().Overlapping( aWire->GetBoundingBox() ) )
 {
 if( item->Type() == SCH_LABEL_T || item->Type() == SCH_GLOBAL_LABEL_T )
 {
 if( TestSegmentHit( item->GetPosition(), aWire->GetStartPoint(), aWire->GetEndPoint(),
  0 ) )
 {
 item->SetPosition( aNewEndPoint );
 }
 }
 }
}

References SCH_LINE::GetBoundingBox(), SCH_LINE::GetEndPoint(), SCH_SHEET::GetScreen(), SCH_LINE::GetStartPoint(), SCH_SCREEN::Items(), m_currentSheet, EE_RTREE::Overlapping(), SCH_GLOBAL_LABEL_T, SCH_LABEL_T, and TestSegmentHit().

Referenced by addBusEntries().

netHasPowerDriver()

bool SCH_EAGLE_PLUGIN::netHasPowerDriver ( SCH_LINE *  aLine, const wxString &  aNetName  ) const

private

Save()

void SCH_PLUGIN::Save ( const wxString &  aFileName, SCH_SHEET *  aSheet, SCHEMATIC *  aSchematic, const PROPERTIES *  aProperties = nullptr  )

virtualinherited

Write aSchematic to a storage file in a format that this SCH_PLUGIN implementation knows about, or it can be used to write a portion of aSchematic to a special kind of export file.

Parameters

aFileName	is the name of a file to save to on disk.
aSheet	is the class SCH_SHEET in memory document tree from which to extract information when writing to aFileName. The caller continues to own the SCHEMATIC, and the plugin should refrain from modifying the SCHEMATIC if possible.
aSchematic	is the SCHEMATIC object used to access any schematic-wide or project information needed to save the document.
aProperties	is an associative array that can be used to tell the saver how to save the file, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL. Set the #PropSaveCurrentSheetOnly property to only save the current sheet. Otherwise, all hierarchical sheets are saved.

Exceptions

IO_ERROR

if there is a problem saving or exporting.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 59 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
}

References not_implemented().

SaveLibrary()

void SCH_PLUGIN::SaveLibrary ( const wxString &  aFileName, const PROPERTIES *  aProperties = nullptr  )

virtualinherited

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 45 of file sch_plugin.cpp.

{
 not_implemented( this, __FUNCTION__ );
}

References not_implemented().

SaveSymbol()

void SCH_PLUGIN::SaveSymbol ( const wxString &  aLibraryPath, const LIB_SYMBOL *  aSymbol, const PROPERTIES *  aProperties = nullptr  )

virtualinherited

Write aSymbol to an existing library located at aLibraryPath.

If a LIB_SYMBOL by the same name already exists or there are any conflicting alias names, the new LIB_SYMBOL will silently overwrite any existing aliases and/or part because libraries cannot have duplicate alias names. It is the responsibility of the caller to check the library for conflicts before saving.

Parameters

aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing several symbols.
aSymbol	is what to store in the library. The library is refreshed and the caller must update any LIB_SYMBOL pointers that may have changed.
aProperties	is an associative array that can be used to tell the saver how to save the symbol, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR

if there is a problem saving.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 94 of file sch_plugin.cpp.

{
 // not pure virtual so that plugins only have to implement subset of the SCH_PLUGIN interface.
 not_implemented( this, __FUNCTION__ );
}

References not_implemented().

Referenced by SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer().

SetProgressReporter()

void SCH_EAGLE_PLUGIN::SetProgressReporter ( PROGRESS_REPORTER *  aReporter )

inlineoverridevirtual

Set an optional progress reporter.

Reimplemented from SCH_PLUGIN.

Definition at line 90 of file sch_eagle_plugin.h.

 {
 m_progressReporter = aReporter;
 }

References m_progressReporter.

SetReporter()

void SCH_EAGLE_PLUGIN::SetReporter ( REPORTER *  aReporter )

inlineoverridevirtual

Set an optional reporter for warnings/errors.

Reimplemented from SCH_PLUGIN.

Definition at line 88 of file sch_eagle_plugin.h.

{ m_reporter = aReporter; }

References m_reporter.

SymbolLibOptions()

void SCH_PLUGIN::SymbolLibOptions ( PROPERTIES *  aListToAppendTo ) const

virtualinherited

Append supported SCH_PLUGIN options to aListToAppenTo along with internationalized descriptions.

Options are typically appended so that a derived SCH_PLUGIN can call its base class function by the same name first, thus inheriting options declared there. (Some base class options could pertain to all Symbol*() functions in all derived SCH_PLUGINs.) Note that since aListToAppendTo is a PROPERTIES object, all options will be unique and last guy wins.

Parameters

aListToAppendTo

holds a tuple of option This eventually is what shows up into the fp-lib-table "options" field, possibly combined with others. internationalized description The internationalized description is displayed in DIALOG_FP_SCH_PLUGIN_OPTIONS. It may be multi-line and be quite explanatory of the option. In the future perhaps aListToAppendTo evolves to something capable of also holding a wxValidator for the cells in said dialog: http://forums.wxwidgets.org/viewtopic.php?t=23277&p=104180. This would require a 3 column list, and introducing wx GUI knowledge to SCH_PLUGIN, which has been avoided to date.

Definition at line 133 of file sch_plugin.cpp.

{
 // disable all these in another couple of months, after everyone has seen them:
#if 1
 (*aListToAppendTo)["debug_level"] = UTF8( _(
  "Enable <b>debug</b> logging for Symbol*() functions in this SCH_PLUGIN."
 ) );

 (*aListToAppendTo)["read_filter_regex"] = UTF8( _(
 "Regular expression <b>symbol name</b> filter."
 ) );

 (*aListToAppendTo)["enable_transaction_logging"] = UTF8( _(
 "Enable transaction logging. The mere presence of this option turns on the "
 "logging, no need to set a Value."
 ) );

 (*aListToAppendTo)["username"] = UTF8( _(
 "User name for <b>login</b> to some special library server."
 ) );

 (*aListToAppendTo)["password"] = UTF8( _(
 "Password for <b>login</b> to some special library server."
 ) );
#endif

#if 1
 // Suitable for a C++ to python SCH_PLUGIN::Footprint*() adapter, move it to the adapter
 // if and when implemented.
 (*aListToAppendTo)["python_symbol_plugin"] = UTF8( _(
 "Enter the python symbol which implements the SCH_PLUGIN::Symbol*() functions."
 ) );
#endif
}

References _.

translateEagleBusName()

wxString SCH_EAGLE_PLUGIN::translateEagleBusName ( const wxString &  aEagleName ) const

private

Translate an Eagle-style bus name into one that is KiCad-compatible.

For vector buses such as A[7..0] this has no impact. For group buses, we translate from Eagle-style to KiCad-style.

Parameters

aEagleName

is the name of the bus from the Eagle schematic

Definition at line 2990 of file sch_eagle_plugin.cpp.

{
 if( NET_SETTINGS::ParseBusVector( aEagleName, nullptr, nullptr ) )
 return aEagleName;

 wxString ret = "{";

 wxStringTokenizer tokenizer( aEagleName, "," );

 while( tokenizer.HasMoreTokens() )
 {
 wxString member = tokenizer.GetNextToken();

 // In Eagle, overbar text is automatically stopped at the end of the net name, even when
 // that net name is part of a bus definition. In KiCad, we don't (currently) do that, so
 // if there is an odd number of overbar markers in this net name, we need to append one
 // to close it out before appending the space.

 if( member.Freq( '!' ) % 2 > 0 )
 member << "!";

 ret << member << " ";
 }

 ret.Trim( true );
 ret << "}";

 return ret;
}

References NET_SETTINGS::ParseBusVector().

Referenced by loadSheet().

Member Data Documentation

m_connPoints

std::map<wxPoint, std::set<const EDA_ITEM*> > SCH_EAGLE_PLUGIN::m_connPoints

private

Definition at line 261 of file sch_eagle_plugin.h.

Referenced by checkConnections(), loadInstance(), loadSheet(), and loadWire().

m_currentSheet

SCH_SHEET* SCH_EAGLE_PLUGIN::m_currentSheet

private

The current sheet of the schematic being loaded.

Definition at line 218 of file sch_eagle_plugin.h.

Referenced by addBusEntries(), loadInstance(), loadSchematic(), loadSegments(), loadSheet(), moveLabels(), and SCH_EAGLE_PLUGIN().

m_doneCount

unsigned SCH_EAGLE_PLUGIN::m_doneCount

private

Definition at line 231 of file sch_eagle_plugin.h.

Referenced by checkpoint(), and loadSchematic().

m_eagleLibs

std::map<wxString, EAGLE_LIBRARY> SCH_EAGLE_PLUGIN::m_eagleLibs

private

Definition at line 225 of file sch_eagle_plugin.h.

Referenced by loadInstance(), and loadSchematic().

m_filename

wxFileName SCH_EAGLE_PLUGIN::m_filename

private

Definition at line 220 of file sch_eagle_plugin.h.

Referenced by Load(), and loadSheet().

m_lastProgressCount

unsigned SCH_EAGLE_PLUGIN::m_lastProgressCount

private

Definition at line 232 of file sch_eagle_plugin.h.

Referenced by checkpoint().

m_layerMap

std::map<int, SCH_LAYER_ID> SCH_EAGLE_PLUGIN::m_layerMap

private

Definition at line 236 of file sch_eagle_plugin.h.

m_libName

wxString SCH_EAGLE_PLUGIN::m_libName

private

Library name to save symbols.

Definition at line 221 of file sch_eagle_plugin.h.

m_missingCmps

std::map<wxString, EAGLE_MISSING_CMP> SCH_EAGLE_PLUGIN::m_missingCmps

private

Definition at line 215 of file sch_eagle_plugin.h.

Referenced by addImplicitConnections(), and loadSchematic().

m_netCounts

std::map<wxString, int> SCH_EAGLE_PLUGIN::m_netCounts

private

Definition at line 235 of file sch_eagle_plugin.h.

Referenced by countNets(), loadLabel(), and loadSegments().

m_nets

std::map<wxString, ENET> SCH_EAGLE_PLUGIN::m_nets

private

Positions of pins and wire endings mapped to its parent.

Definition at line 258 of file sch_eagle_plugin.h.

m_partlist

EPART_MAP SCH_EAGLE_PLUGIN::m_partlist

private

Definition at line 224 of file sch_eagle_plugin.h.

Referenced by loadInstance(), and loadSchematic().

m_pi

SCH_PLUGIN::SCH_PLUGIN_RELEASER SCH_EAGLE_PLUGIN::m_pi

private

PI to create KiCad symbol library.

Definition at line 227 of file sch_eagle_plugin.h.

Referenced by Load(), loadInstance(), loadLibrary(), and loadSchematic().

m_powerPorts

std::map<wxString, wxString> SCH_EAGLE_PLUGIN::m_powerPorts

private

map from symbol reference to global label equivalent

Wire intersection points, used for quick checks whether placing a net label in a particular place would short two nets.

Definition at line 237 of file sch_eagle_plugin.h.

Referenced by loadInstance(), and loadSegments().

m_progressReporter

PROGRESS_REPORTER* SCH_EAGLE_PLUGIN::m_progressReporter

private

optional; may be nullptr

Definition at line 230 of file sch_eagle_plugin.h.

Referenced by checkpoint(), Load(), loadSchematic(), and SetProgressReporter().

m_properties

std::unique_ptr< PROPERTIES > SCH_EAGLE_PLUGIN::m_properties

private

Library plugin properties.

Definition at line 228 of file sch_eagle_plugin.h.

Referenced by Load(), loadInstance(), and loadLibrary().

m_reporter

REPORTER* SCH_EAGLE_PLUGIN::m_reporter

private

Reporter for warnings/errors.

Map references to missing symbol units data

Definition at line 212 of file sch_eagle_plugin.h.

Referenced by loadInstance(), SCH_EAGLE_PLUGIN(), and SetReporter().

m_rootSheet

SCH_SHEET* SCH_EAGLE_PLUGIN::m_rootSheet

private

The root sheet of the schematic being loaded.

Definition at line 217 of file sch_eagle_plugin.h.

Referenced by Load(), loadInstance(), loadSchematic(), and SCH_EAGLE_PLUGIN().

m_schematic

SCHEMATIC* SCH_EAGLE_PLUGIN::m_schematic

private

Passed to Load(), the schematic object being loaded.

Definition at line 222 of file sch_eagle_plugin.h.

Referenced by Load(), loadInstance(), loadSchematic(), and SCH_EAGLE_PLUGIN().

m_segments

std::vector<SEG_DESC> SCH_EAGLE_PLUGIN::m_segments

private

Nets as defined in the <nets> sections of an Eagle schematic file.

Definition at line 255 of file sch_eagle_plugin.h.

Referenced by adjustNetLabels(), and loadSegments().

m_totalCount

unsigned SCH_EAGLE_PLUGIN::m_totalCount

private

for progress reporting

Definition at line 233 of file sch_eagle_plugin.h.

Referenced by checkpoint(), and loadSchematic().

m_version

wxString SCH_EAGLE_PLUGIN::m_version

private

Eagle file version.

Definition at line 219 of file sch_eagle_plugin.h.

Referenced by Load().

m_wireIntersections

std::vector<VECTOR2I> SCH_EAGLE_PLUGIN::m_wireIntersections

private

Wires and labels of a single connection (segment in Eagle nomenclature)

Definition at line 242 of file sch_eagle_plugin.h.

Referenced by adjustNetLabels(), and loadSegments().

---

The documentation for this class was generated from the following files:

• sch_eagle_plugin.h
• sch_eagle_plugin.cpp