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 STRING_UTF8_MAP *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 STRING_UTF8_MAP *aProperties=nullptr)
virtual void	Save (const wxString &aFileName, SCH_SHEET *aSheet, SCHEMATIC *aSchematic, const STRING_UTF8_MAP *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 STRING_UTF8_MAP *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 STRING_UTF8_MAP *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 STRING_UTF8_MAP *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 STRING_UTF8_MAP *aProperties=nullptr)
	Write aSymbol to an existing library located at aLibraryPath. More...
virtual void	DeleteSymbol (const wxString &aLibraryPath, const wxString &aSymbolName, const STRING_UTF8_MAP *aProperties=nullptr)
	Delete the entire LIB_SYMBOL associated with aAliasName from the library aLibraryPath. More...
virtual void	CreateSymbolLib (const wxString &aLibraryPath, const STRING_UTF8_MAP *aProperties=nullptr)
	Create a new empty symbol library at aLibraryPath. More...
virtual bool	DeleteSymbolLib (const wxString &aLibraryPath, const STRING_UTF8_MAP *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 (STRING_UTF8_MAP *aListToAppendTo) const
	Append supported SCH_PLUGIN options to aListToAppenTo along with internationalized descriptions. More...
virtual bool	SupportsSubLibraries () const
virtual void	GetSubLibraryNames (std::vector< wxString > &aNames)
	Retrieves a list of sub-libraries in this library. More...
virtual void	GetAvailableSymbolFields (std::vector< wxString > &aNames)
	Retrieves a list of (custom) field names that are present on symbols in this library. More...
virtual void	GetDefaultSymbolFields (std::vector< wxString > &aNames)
	Retrieves a list of (custom) field names that should be shown by default for this library in the symbol chooser. More...
virtual const wxString &	GetError () const
	Return an error string to the caller. More...
virtual void	SetLibTable (SYMBOL_LIB_TABLE *aTable)
	Some library plugins need to have access to their parent library table. 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 VECTOR2I &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 VECTOR2I &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
SCH_SHEET *	getCurrentSheet ()
SCH_SCREEN *	getCurrentScreen ()

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_PATH	m_sheetPath
	The current sheet path 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< STRING_UTF8_MAP >	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< VECTOR2I, 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 367 of file sch_eagle_plugin.cpp.

 :
 m_progressReporter( nullptr ),
 m_doneCount( 0 ),
 m_lastProgressCount( 0 ),
 m_totalCount( 0 )
{
 m_rootSheet = nullptr;
 m_schematic = nullptr;
 
 m_reporter = &WXLOG_REPORTER::GetInstance();
}

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

~SCH_EAGLE_PLUGIN()

SCH_EAGLE_PLUGIN::~SCH_EAGLE_PLUGIN

(

)

Definition at line 380 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 2413 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;
 
 SCH_SCREEN* screen = getCurrentScreen();
 
 wxCHECK( screen, /* void */ );
 
 for( SCH_ITEM* ii : screen->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 )
 {
 VECTOR2I wireStart = wire->GetStartPoint();
 VECTOR2I wireEnd = wire->GetEndPoint();
 
 for( SCH_LINE* bus : buses )
 {
 VECTOR2I busStart = bus->GetStartPoint();
 VECTOR2I busEnd = bus->GetEndPoint();
 
 auto entrySize =
 []( int signX, int signY ) -> VECTOR2I
 {
 return VECTOR2I( schIUScale.MilsToIU( DEFAULT_SCH_ENTRY_SIZE ) * signX,
 schIUScale.MilsToIU( DEFAULT_SCH_ENTRY_SIZE ) * signY );
 };
 
 auto testBusHit =
 [&]( const VECTOR2I& 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
 * ⎥⎢
 * ——————⎥⎢
 * ⎥⎢
 */
 VECTOR2I 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 );
 screen->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 );
 screen->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 );
 screen->Append( marker );
 }
 }
 else
 {
 /* the wire end is to the right of the bus
 * ⎥⎢
 * ⎥⎢——————
 * ⎥⎢
 */
 VECTOR2I 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 );
 screen->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 );
 screen->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 );
 screen->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
 * ⎥⎢
 * ——————⎥⎢
 * ⎥⎢
 */
 VECTOR2I 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 );
 screen->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 );
 screen->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 );
 screen->Append( marker );
 }
 }
 else
 {
 /* the start of the wire is to the right of the bus
 * ⎥⎢
 * ⎥⎢——————
 * ⎥⎢
 */
 VECTOR2I 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 );
 screen->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 );
 screen->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 );
 screen->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
 * |
 * |
 * |
 * =======
 */
 VECTOR2I 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 );
 screen->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 );
 screen->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 );
 screen->Append( marker );
 }
 }
 else
 {
 /* wire end is below the bus
 * =======
 * |
 * |
 * |
 */
 VECTOR2I 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 );
 screen->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 );
 screen->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 );
 screen->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
 * |
 * |
 * |
 * =======
 */
 VECTOR2I 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 );
 screen->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 );
 screen->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 );
 screen->Append( marker );
 }
 }
 else
 {
 /* wire start is below the bus
 * =======
 * |
 * |
 * |
 */
 VECTOR2I 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 );
 screen->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 );
 screen->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 );
 screen->Append( marker );
 }
 }
 
 break;
 }
 }
 else
 {
 // Wire isn't horizontal or vertical
 
 if( testBusHit( wireStart ) )
 {
 VECTOR2I wirevector = wireStart - wireEnd;
 
 if( wirevector.x > 0 )
 {
 if( wirevector.y > 0 )
 {
 VECTOR2I p = wireStart + entrySize( -1, -1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 2 );
 busEntry->SetFlags( IS_NEW );
 screen->Append( busEntry );
 
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else
 {
 VECTOR2I p = wireStart + entrySize( -1, 1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 1 );
 busEntry->SetFlags( IS_NEW );
 screen->Append( busEntry );
 
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 }
 else
 {
 if( wirevector.y > 0 )
 {
 VECTOR2I p = wireStart + entrySize( 1, -1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 3 );
 busEntry->SetFlags( IS_NEW );
 screen->Append( busEntry );
 
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 else
 {
 VECTOR2I p = wireStart + entrySize( 1, 1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 4 );
 busEntry->SetFlags( IS_NEW );
 screen->Append( busEntry );
 
 moveLabels( wire, p );
 wire->SetStartPoint( p );
 }
 }
 
 break;
 }
 else if( testBusHit( wireEnd ) )
 {
 VECTOR2I wirevector = wireStart - wireEnd;
 
 if( wirevector.x > 0 )
 {
 if( wirevector.y > 0 )
 {
 VECTOR2I p = wireEnd + entrySize( 1, 1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 4 );
 busEntry->SetFlags( IS_NEW );
 screen->Append( busEntry );
 
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else
 {
 VECTOR2I p = wireEnd + entrySize( 1, -1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 3 );
 busEntry->SetFlags( IS_NEW );
 screen->Append( busEntry );
 
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 }
 else
 {
 if( wirevector.y > 0 )
 {
 VECTOR2I p = wireEnd + entrySize( -1, 1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 1 );
 busEntry->SetFlags( IS_NEW );
 screen->Append( busEntry );
 
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 else
 {
 VECTOR2I p = wireEnd + entrySize( -1, -1 );
 SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, 2 );
 busEntry->SetFlags( IS_NEW );
 screen->Append( busEntry );
 
 moveLabels( wire, p );
 wire->SetEndPoint( p );
 }
 }
 
 break;
 }
 }
 }
 }
}

References SCH_SCREEN::Append(), ERC_ITEM::Create(), DEFAULT_SCH_ENTRY_SIZE, ERCE_BUS_ENTRY_NEEDED, getCurrentScreen(), IS_NEW, SCH_LINE::IsBus(), SCH_LINE::IsWire(), SCH_SCREEN::Items(), EDA_IU_SCALE::MilsToIU(), moveLabels(), EE_RTREE::OfType(), SCH_LINE_T, schIUScale, EDA_ITEM::SetFlags(), TestSegmentHit(), VECTOR2< T >::x, and VECTOR2< T >::y.

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 2997 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( schIUScale.MilsToIU( 40 ),
 schIUScale.MilsToIU( 40 ) ) );
 
 switch( pin->GetOrientation() )
 {
 case PIN_LEFT: netLabel->SetTextSpinStyle( TEXT_SPIN_STYLE::RIGHT ); break;
 case PIN_RIGHT: netLabel->SetTextSpinStyle( TEXT_SPIN_STYLE::LEFT ); break;
 case PIN_UP: netLabel->SetTextSpinStyle( TEXT_SPIN_STYLE::UP ); break;
 case PIN_DOWN: netLabel->SetTextSpinStyle( TEXT_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(), TEXT_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(), TEXT_SPIN_STYLE::LEFT, m_missingCmps, EDA_IU_SCALE::MilsToIU(), pin, PIN_DOWN, PIN_LEFT, PIN_RIGHT, PIN_UP, PT_POWER_IN, REFERENCE_FIELD, TEXT_SPIN_STYLE::RIGHT, schIUScale, SCH_TEXT::SetPosition(), EDA_TEXT::SetText(), EDA_TEXT::SetTextSize(), SCH_GLOBALLABEL::SetTextSpinStyle(), SCH_EAGLE_PLUGIN::EAGLE_MISSING_CMP::units, and TEXT_SPIN_STYLE::UP.

Referenced by loadSchematic(), and loadSheet().

adjustNetLabels()

void SCH_EAGLE_PLUGIN::adjustNetLabels ( )

private

Definition at line 2301 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( schIUScale.MilsToIU( 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 = VECTOR2I( origPos + wireDirection * trial / 2 );
 move = checkPositive = segAttached->Contains( labelPos );
 }
 else
 {
 labelPos = VECTOR2I( origPos - wireDirection * trial / 2 );
 move = checkNegative = segAttached->Contains( labelPos );
 }
 
 ++trial;
 }
 
 if( move )
 label->SetPosition( VECTOR2I( labelPos ) );
 }
 }
 
 m_segments.clear();
 m_wireIntersections.clear();
}

References SEG::A, SEG::B, SEG::Contains(), findNearestLinePoint(), SCH_TEXT::GetPosition(), m_segments, m_wireIntersections, EDA_IU_SCALE::MilsToIU(), move, VECTOR2< T >::Resize(), schIUScale, 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 2979 of file sch_eagle_plugin.cpp.

{
 wxCHECK( aSymbol && aPin, false );
 
 VECTOR2I pinPosition = aSymbol->GetPinPhysicalPosition( aPin );
 auto pointIt = m_connPoints.find( pinPosition );
 
 if( pointIt == m_connPoints.end() )
 return false;
 
 const auto& items = pointIt->second;
 
 wxCHECK( items.find( aPin ) != items.end(), false );
 
 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 2376 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( wxT( "<?xml" ) )
 && secondline.StartsWith( wxT( "<!DOCTYPE eagle SYSTEM" ) )
 && thirdline.StartsWith( wxT( "<eagle version" ) );
}

checkpoint()

void SCH_EAGLE_PLUGIN::checkpoint ( )

private

Definition at line 409 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 570 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, wxT( "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, wxT( "nets" ) );
 
 while( netNode )
 {
 wxString netName = netNode->GetAttribute( wxT( "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 STRING_UTF8_MAP *  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_SEXPR_PLUGIN, and SCH_LEGACY_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().

Referenced by SYMBOL_LIB_TABLE::CreateSymbolLib(), SYMBOL_EDIT_FRAME::ExportSymbol(), SCH_ALTIUM_PLUGIN::Load(), CADSTAR_SCH_ARCHIVE_PLUGIN::Load(), and Load().

DeleteSymbol()

void SCH_PLUGIN::DeleteSymbol ( const wxString &  aLibraryPath, const wxString &  aSymbolName, const STRING_UTF8_MAP *  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_SEXPR_PLUGIN, and SCH_LEGACY_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_LIB_TABLE::DeleteSymbol(), and SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer().

DeleteSymbolLib()

bool SCH_PLUGIN::DeleteSymbolLib ( const wxString &  aLibraryPath, const STRING_UTF8_MAP *  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_SEXPR_PLUGIN, and SCH_LEGACY_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().

Referenced by SYMBOL_LIB_TABLE::DeleteSymbolLib().

EnumerateSymbolLib() [1/2]

void SCH_PLUGIN::EnumerateSymbolLib ( std::vector< LIB_SYMBOL * > &  aSymbolList, const wxString &  aLibraryPath, const STRING_UTF8_MAP *  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_DATABASE_PLUGIN, SCH_SEXPR_PLUGIN, and SCH_LEGACY_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().

EnumerateSymbolLib() [2/2]

void SCH_PLUGIN::EnumerateSymbolLib ( wxArrayString &  aSymbolNameList, const wxString &  aLibraryPath, const STRING_UTF8_MAP *  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_DATABASE_PLUGIN, SCH_SEXPR_PLUGIN, and SCH_LEGACY_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().

Referenced by PANEL_SYM_LIB_TABLE::convertLibrary(), SYMBOL_LIB_TABLE::EnumerateSymbolLib(), SYMBOL_EDIT_FRAME::ImportSymbol(), SYMBOL_LIB_TABLE::LoadSymbolLib(), and SYMBOL_LIB_TABLE_ROW::Refresh().

findNearestLinePoint()

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

private

Definition at line 1262 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 std::abs(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by adjustNetLabels().

GetAvailableSymbolFields()

virtual void SCH_PLUGIN::GetAvailableSymbolFields ( std::vector< wxString > &  aNames )

inlinevirtualinherited

Retrieves a list of (custom) field names that are present on symbols in this library.

The plugin is responsible for guaranteeing that this list contains the set of unique custom field names present on any symbols contained in the library.

The required KiCad fields are not included in this list.

Parameters

aNames

will be filled with any custom fields present in this library.

Reimplemented in SCH_DATABASE_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 474 of file sch_io_mgr.h.

{}

Referenced by SYMBOL_LIB_TABLE_ROW::GetAvailableSymbolFields(), and SCH_PLUGIN::GetDefaultSymbolFields().

getCurrentScreen()

SCH_SCREEN * SCH_EAGLE_PLUGIN::getCurrentScreen ( )

private

Definition at line 138 of file sch_eagle_plugin.cpp.

{
 SCH_SHEET* currentSheet = m_sheetPath.Last();
 wxCHECK( currentSheet, nullptr );
 return currentSheet->GetScreen();
}

References SCH_SHEET::GetScreen(), SCH_SHEET_PATH::Last(), and m_sheetPath.

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

getCurrentSheet()

SCH_SHEET * SCH_EAGLE_PLUGIN::getCurrentSheet ( )

private

Definition at line 132 of file sch_eagle_plugin.cpp.

{
 return m_sheetPath.Last();
}

References SCH_SHEET_PATH::Last(), and m_sheetPath.

Referenced by loadSheet().

GetDefaultSymbolFields()

virtual void SCH_PLUGIN::GetDefaultSymbolFields ( std::vector< wxString > &  aNames )

inlinevirtualinherited

Retrieves a list of (custom) field names that should be shown by default for this library in the symbol chooser.

This list should be a subset of the result returned by GetAvailableSymbolFields().

The preference for which fields to hide and show for a given library is stored on a per-library basis in a user's preferences (or in the project local settings for a project- local library). The set of fields returned by GetDefaultSymbolFields() will be used if this preference is missing.

Parameters

aNames

will be filled with the custom field names that should be shown by default

Reimplemented in SCH_DATABASE_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 488 of file sch_io_mgr.h.

 {
 return GetAvailableSymbolFields( aNames );
 }

References SCH_PLUGIN::GetAvailableSymbolFields().

Referenced by SYMBOL_LIB_TABLE_ROW::GetDefaultSymbolFields().

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_SEXPR_PLUGIN, and SCH_LEGACY_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 KI_TEST::SCHEMATIC_TEST_FIXTURE::LoadSchematic(), SCH_EDIT_FRAME::LoadSheetFromFile(), and SCH_EDIT_FRAME::OpenProjectFiles().

GetFileExtension()

const wxString SCH_EAGLE_PLUGIN::GetFileExtension ( ) const

overridevirtual

Return the file extension for the SCH_PLUGIN.

Implements SCH_PLUGIN.

Definition at line 391 of file sch_eagle_plugin.cpp.

{
 return wxT( "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 170 of file sch_eagle_plugin.cpp.

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

References getLibName(), PROJECT::GetProjectPath(), KiCadSymbolLibFileExtension, m_schematic, and SCHEMATIC::Prj().

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

getLibName()

wxString SCH_EAGLE_PLUGIN::getLibName ( )

private

Definition at line 146 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 = wxT( "noname" );
 
 m_libName += wxT( "-eagle-import" );
 m_libName = LIB_ID::FixIllegalChars( m_libName, true );
 }
 
 return m_libName;
}

References LIB_ID::FixIllegalChars(), SCH_SHEET::GetFileName(), PROJECT::GetProjectName(), m_libName, m_rootSheet, m_schematic, and SCHEMATIC::Prj().

Referenced by getLibFileName(), 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 397 of file sch_eagle_plugin.cpp.

{
 return wxT( "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 403 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 385 of file sch_eagle_plugin.cpp.

{
 return wxT( "EAGLE" );
}

GetSubLibraryNames()

virtual void SCH_PLUGIN::GetSubLibraryNames ( std::vector< wxString > &  aNames )

inlinevirtualinherited

Retrieves a list of sub-libraries in this library.

Some types of symbol library support sub-libraries, which are a single-level organizational hierarchy that is implementation-defined per plugin. Most of KiCad ignores sub-libraries and treats the hierarchy between library and symbol as flat, but the sub-libraries are used for sorting and grouping symbols in the symbol chooser.

Has no effect if SupportsSubLibraries() returns false.

Parameters

aNames

will be filled with a list of sub-libraries within this symbol library

Reimplemented in SCH_DATABASE_PLUGIN.

Definition at line 463 of file sch_io_mgr.h.

{}

Referenced by SYMBOL_LIB_TABLE_ROW::GetSubLibraryNames().

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_DATABASE_PLUGIN, SCH_SEXPR_PLUGIN, and SCH_LEGACY_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().

Referenced by SYMBOL_LIB_TABLE::IsSymbolLibWritable(), and SYMBOL_LIB_TABLE::SaveSymbol().

kiCadLayer()

SCH_LAYER_ID SCH_EAGLE_PLUGIN::kiCadLayer ( int  aEagleLayer )

private

Return the matching layer or return LAYER_NOTES.

Definition at line 229 of file sch_eagle_plugin.cpp.

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

References LAYER_NOTES, and m_layerMap.

Referenced by loadWire().

Load()

SCH_SHEET * SCH_EAGLE_PLUGIN::Load ( const wxString &  aFileName, SCHEMATIC *  aSchematic, SCH_SHEET *  aAppendToMe = nullptr, const STRING_UTF8_MAP *  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 429 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,
 wxT( "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() );
 aSchematic->SetRoot( m_rootSheet );
 }
 
 if( !m_rootSheet->GetScreen() )
 {
 SCH_SCREEN* screen = new SCH_SCREEN( m_schematic );
 screen->SetFileName( newFilename.GetFullPath() );
 m_rootSheet->SetScreen( screen );
 
 // Virtual root sheet UUID must be the same as the schematic file UUID.
 const_cast<KIID&>( m_rootSheet->m_Uuid ) = screen->GetUuid();
 }
 
 SYMBOL_LIB_TABLE* libTable = m_schematic->Prj().SchSymbolLibTable();
 
 wxCHECK_MSG( libTable, nullptr, wxT( "Could not load symbol lib table." ) );
 
 m_pi.set( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
 m_properties = std::make_unique<STRING_UTF8_MAP>();
 ( *m_properties )[SCH_LEGACY_PLUGIN::PropBuffering] = "";
 
 if( !libTable->HasLibrary( getLibName() ) )
 {
 // Create a new empty symbol library.
 m_pi->CreateSymbolLib( getLibFileName().GetFullPath() );
 wxString libTableUri = wxT( "${KIPRJMOD}/" ) + getLibFileName().GetFullName();
 
 // Add the new library to the project symbol library table.
 libTable->InsertRow( new SYMBOL_LIB_TABLE_ROW( getLibName(), libTableUri,
  wxT( "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( wxT( "version" ), wxT( "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 _, SCH_PLUGIN::CreateSymbolLib(), PROJECT::ELEM_SYMBOL_LIB_TABLE, SYMBOL_LIB_TABLE::Format(), Format(), getLibFileName(), getLibName(), PROJECT::GetProjectPath(), SCH_SHEET::GetScreen(), SYMBOL_LIB_TABLE::GetSymbolLibTableFileName(), SCH_SCREEN::GetUuid(), 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, EDA_ITEM::m_Uuid, m_version, MapChildren(), SCHEMATIC::Prj(), SCH_LEGACY_PLUGIN::PropBuffering, PROGRESS_REPORTER::Report(), SCHEMATIC::Root(), SCH_PLUGIN::SaveLibrary(), SCH_PLUGIN::SCH_PLUGIN_RELEASER::set(), PROJECT::SetElem(), SCH_SCREEN::SetFileName(), SCH_SHEET::SetFileName(), SCHEMATIC::SetRoot(), SCH_SHEET::SetScreen(), THROW_IO_ERROR, and SCH_SCREENS::UpdateSymbolLinks().

loadDrawing()

void SCH_EAGLE_PLUGIN::loadDrawing ( wxXmlNode *  aDrawingNode )

private

Definition at line 543 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 2289 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< LIB_ITEM * > &  aLines  )

private

Definition at line 2046 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( VECTOR2I( xMin, yMin ) );
 lines->AddPoint( VECTOR2I( xMax, yMin ) );
 lines->AddPoint( VECTOR2I( xMax, yMax ) );
 lines->AddPoint( VECTOR2I( xMin, yMax ) );
 lines->AddPoint( VECTOR2I( xMin, yMin ) );
 aItems.push_back( lines );
 
 if( !eframe.border_left )
 {
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( VECTOR2I( xMin + schIUScale.MilsToIU( 150 ),
 yMin + schIUScale.MilsToIU( 150 ) ) );
 lines->AddPoint( VECTOR2I( xMin + schIUScale.MilsToIU( 150 ),
 yMax - schIUScale.MilsToIU( 150 ) ) );
 aItems.push_back( lines );
 
 int i;
 int height = yMax - yMin;
 int x1 = xMin;
 int x2 = x1 + schIUScale.MilsToIU( 150 );
 int legendPosX = xMin + schIUScale.MilsToIU( 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( VECTOR2I( x1, newY ) );
 lines->AddPoint( VECTOR2I( 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( VECTOR2I( legendPosX, KiROUND( legendPosY ) ) );
 legendText->SetText( wxString( legendChar ) );
 legendText->SetTextSize( wxSize( schIUScale.MilsToIU( 90 ),
 schIUScale.MilsToIU( 100 ) ) );
 aItems.push_back( legendText );
 legendChar++;
 legendPosY -= rowSpacing;
 }
 }
 
 if( !eframe.border_right )
 {
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
  lines->AddPoint( VECTOR2I( xMax - schIUScale.MilsToIU( 150 ),
 yMin + schIUScale.MilsToIU( 150 ) ) );
 lines->AddPoint( VECTOR2I( xMax - schIUScale.MilsToIU( 150 ),
 yMax - schIUScale.MilsToIU( 150 ) ) );
 aItems.push_back( lines );
 
 int i;
 int height = yMax - yMin;
 int x1 = xMax - schIUScale.MilsToIU( 150 );
 int x2 = xMax;
 int legendPosX = xMax - schIUScale.MilsToIU( 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( VECTOR2I( x1, newY ) );
 lines->AddPoint( VECTOR2I( 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( VECTOR2I( legendPosX, KiROUND( legendPosY ) ) );
 legendText->SetText( wxString( legendChar ) );
 legendText->SetTextSize( wxSize( schIUScale.MilsToIU( 90 ),
 schIUScale.MilsToIU( 100 ) ) );
 aItems.push_back( legendText );
 legendChar++;
 legendPosY -= rowSpacing;
 }
 }
 
 if( !eframe.border_top )
 {
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( VECTOR2I( xMax - schIUScale.MilsToIU( 150 ),
 yMax - schIUScale.MilsToIU( 150 ) ) );
 lines->AddPoint( VECTOR2I( xMin + schIUScale.MilsToIU( 150 ),
 yMax - schIUScale.MilsToIU( 150 ) ) );
 aItems.push_back( lines );
 
 int i;
 int width = xMax - xMin;
 int y1 = yMin;
 int y2 = yMin + schIUScale.MilsToIU( 150 );
 int legendPosY = yMax - schIUScale.MilsToIU( 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( VECTOR2I( newX, y1 ) );
 lines->AddPoint( VECTOR2I( 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( VECTOR2I( KiROUND( legendPosX ), legendPosY ) );
 legendText->SetText( wxString( legendChar ) );
 legendText->SetTextSize( wxSize( schIUScale.MilsToIU( 90 ),
 schIUScale.MilsToIU( 100 ) ) );
 aItems.push_back( legendText );
 legendChar++;
 legendPosX += columnSpacing;
 }
 }
 
 if( !eframe.border_bottom )
 {
 lines = new LIB_SHAPE( nullptr, SHAPE_T::POLY );
 lines->AddPoint( VECTOR2I( xMax - schIUScale.MilsToIU( 150 ),
  yMin + schIUScale.MilsToIU( 150 ) ) );
 lines->AddPoint( VECTOR2I( xMin + schIUScale.MilsToIU( 150 ),
 yMin + schIUScale.MilsToIU( 150 ) ) );
 aItems.push_back( lines );
 
 int i;
 int width = xMax - xMin;
 int y1 = yMax - schIUScale.MilsToIU( 150 );
 int y2 = yMax;
 int legendPosY = yMin + schIUScale.MilsToIU( 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( VECTOR2I( newX, y1 ) );
 lines->AddPoint( VECTOR2I( 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( VECTOR2I( KiROUND( legendPosX ), legendPosY ) );
 legendText->SetText( wxString( legendChar ) );
 legendText->SetTextSize( wxSize( schIUScale.MilsToIU( 90 ),
 schIUScale.MilsToIU( 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(), EDA_IU_SCALE::MilsToIU(), POLY, EFRAME::rows, schIUScale, LIB_ITEM::SetPosition(), EDA_TEXT::SetText(), EDA_TEXT::SetTextSize(), ECOORD::ToSchUnits(), EFRAME::x1, EFRAME::x2, EFRAME::y1, and EFRAME::y2.

loadFrame() [2/2]

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

private

Definition at line 1017 of file sch_eagle_plugin.cpp.

{
 EFRAME eframe( aFrameNode );
 
 VECTOR2I corner1( eframe.x1.ToSchUnits(), -eframe.y1.ToSchUnits() );
 VECTOR2I corner3( eframe.x2.ToSchUnits(), -eframe.y2.ToSchUnits() );
 VECTOR2I corner2( corner3.x, corner1.y );
 VECTOR2I 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(), VECTOR2< T >::x, EFRAME::x1, EFRAME::x2, VECTOR2< T >::y, EFRAME::y1, and EFRAME::y2.

Referenced by loadSheet(), and loadSymbol().

loadInstance()

void SCH_EAGLE_PLUGIN::loadInstance ( wxXmlNode *  aInstanceNode )

private

Definition at line 1308 of file sch_eagle_plugin.cpp.

{
 EINSTANCE einstance = EINSTANCE( aInstanceNode );
 SCH_SCREEN* screen = getCurrentScreen();
 
 wxCHECK( screen, /* void */ );
 
 // 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( wxT( "*" ), wxEmptyString );
 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( VECTOR2I( einstance.x.ToSchUnits(), -einstance.y.ToSchUnits() ) );
 
 // assume that footprint library is identical to project name
 wxString footprint = m_schematic->Prj().GetProjectName() + wxT( ":" ) + package;
 symbol->GetField( FOOTPRINT_FIELD )->SetText( footprint );
 
 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( (VECTOR2I)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;
 
 // reference must end with a number but EAGLE does not enforce this
 if( reference.find_last_not_of( wxT( "0123456789" ) ) == ( reference.Length()-1 ) )
 reference.Append( wxT( "0" ) );
 
 // 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( wxT( "0123456789" ) ) != 0 )
 reference.Prepend( wxT( "UNK" ) );
 
 // EAGLE allows designator to start with # but that is used in KiCad
 // for symbols which do not have a footprint
 if( einstance.part.find_first_not_of( wxT( "#" ) ) != 0 )
 reference.Prepend( wxT( "UNK" ) );
 
 symbol->GetField( REFERENCE_FIELD )->SetText( reference );
 
 wxString value = ( epart->value ) ? *epart->value : kisymbolname;
 
 symbol->GetField( VALUE_FIELD )->SetText( value );
 
 // 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( wxT( "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() == wxT( "attribute" ) )
 {
 EATTR attr = EATTR( attributeNode );
 SCH_FIELD* field = nullptr;
 
 if( attr.name.Lower() == wxT( "name" ) )
 {
 field = symbol->GetField( REFERENCE_FIELD );
 nameAttributeFound = true;
 }
 else if( attr.name.Lower() == wxT( "value" ) )
 {
 field = symbol->GetField( VALUE_FIELD );
 valueAttributeFound = true;
 }
 else
 {
 field = symbol->FindField( attr.name );
 
 if( field )
 field->SetVisible( false );
 }
 
 if( field )
 {
 
 field->SetPosition( VECTOR2I( 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() == wxT( "variant" ) )
 {
 wxString variantName, fieldValue;
 
 if( attributeNode->GetAttribute( wxT( "name" ), &variantName )
 && attributeNode->GetAttribute( wxT( "value" ), &fieldValue ) )
 {
 SCH_FIELD field( VECTOR2I( 0, 0 ), -1, symbol.get() );
 field.SetName( wxT( "VARIANT_" ) + variantName );
 field.SetText( fieldValue );
 field.SetVisible( false );
 symbol->AddField( field );
 }
 }
 
 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 );
 }
 
 symbol->AddHierarchicalReference( m_sheetPath.Path(), reference, unit );
 
 // 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(), getCurrentScreen(), LIB_SYMBOL::GetFieldById(), LIB_SYMBOL::GetFields(), getLibFileName(), getLibName(), PROJECT::GetProjectName(), LIB_SYMBOL::IsPower(), EDA_TEXT::IsVisible(), kiCadComponentRotation(), EPART::library, SCH_PLUGIN::LoadSymbol(), SYMBOL_LIB_TABLE::LoadSymbol(), m_connPoints, m_eagleLibs, m_partlist, m_pi, m_powerPorts, m_properties, m_reporter, m_schematic, m_sheetPath, EROT::mirror, EATTR::name, EATTR::NAME, EATTR::Off, EAGLE_LIBRARY::package, EINSTANCE::part, SCH_SHEET_PATH::Path(), 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 1212 of file sch_eagle_plugin.cpp.

{
 std::unique_ptr<SCH_JUNCTION> junction = std::make_unique<SCH_JUNCTION>();
 
 EJUNCTION ejunction = EJUNCTION( aJunction );
 VECTOR2I 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 1225 of file sch_eagle_plugin.cpp.

{
 ELABEL elabel = ELABEL( aLabelNode, aNetName );
 VECTOR2I 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->SetTextSpinStyle( TEXT_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, TEXT_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 178 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 == wxT( "Nets" ) )
 {
 m_layerMap[elayer.number] = LAYER_WIRE;
 }
 else if( elayer.name == wxT( "Info" ) || elayer.name == wxT( "Guide" ) )
 {
 m_layerMap[elayer.number] = LAYER_NOTES;
 }
 else if( elayer.name == wxT( "Busses" ) )
 {
 m_layerMap[elayer.number] = LAYER_BUS;
 }
 }
}

References LAYER_BUS, LAYER_NOTES, LAYER_WIRE, and m_layerMap.

Referenced by loadDrawing().

loadLibrary()

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

private

Definition at line 1541 of file sch_eagle_plugin.cpp.

{
 NODE_MAP libraryChildren = MapChildren( aLibraryNode );
 
 // Loop through the symbols and load each of them
 wxXmlNode* symbolNode = getChildrenNodes( libraryChildren, wxT( "symbols" ) );
 
 while( symbolNode )
 {
 wxString symbolName = symbolNode->GetAttribute( wxT( "name" ) );
 aEagleLibrary->SymbolNodes[symbolName] = symbolNode;
 symbolNode = symbolNode->GetNext();
 }
 
 // Loop through the device sets and load each of them
 wxXmlNode* devicesetNode = getChildrenNodes( libraryChildren, wxT( "devicesets" ) );
 
 while( devicesetNode )
 {
 // Get Device set information
 EDEVICE_SET edeviceset = EDEVICE_SET( devicesetNode );
 
 wxString prefix = edeviceset.prefix ? edeviceset.prefix.Get() : wxT( "" );
 
 NODE_MAP deviceSetChildren = MapChildren( devicesetNode );
 wxXmlNode* deviceNode = getChildrenNodes( deviceSetChildren, wxT( "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( wxT( "*" ), wxEmptyString );
 wxASSERT( !symbolName.IsEmpty() );
 symbolName = EscapeString( symbolName, CTX_LIBID );
 
 if( edevice.package )
 aEagleLibrary->package[symbolName] = edevice.package.Get();
 
 // Create KiCad symbol.
 std::unique_ptr<LIB_SYMBOL> libSymbol = std::make_unique<LIB_SYMBOL>( symbolName );
 
 // Process each gate in the deviceset for this device.
 wxXmlNode* gateNode = getChildrenNodes( deviceSetChildren, wxT( "gates" ) );
 int gates_count = countChildren( deviceSetChildren["gates"], wxT( "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();
 
 // assume that footprint library is identical to project name
 wxString packageString = m_schematic->Prj().GetProjectName() + wxT( ":" ) + aEagleLibrary->package[symbolName];
 libSymbol->GetFootprintField().SetText( packageString );
 
 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(), PROJECT::GetProjectName(), EAGLE_LIBRARY::KiCadSymbols, loadSymbol(), m_pi, m_properties, m_schematic, MapChildren(), name, EGATE::name, EDEVICE::name, EDEVICE_SET::name, EDEVICE::package, EAGLE_LIBRARY::package, EDEVICE_SET::prefix, SCHEMATIC::Prj(), REFERENCE_FIELD, SCH_PLUGIN::SaveSymbol(), 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 1944 of file sch_eagle_plugin.cpp.

{
 std::unique_ptr<LIB_PIN> pin = std::make_unique<LIB_PIN>( aSymbol.get() );
 pin->SetPosition( VECTOR2I( 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( wxT( "Unhandled orientation (%d degrees)." ), roti ) );
 }
 
 pin->SetLength( schIUScale.MilsToIU( 300 ) ); // Default pin length when not defined.
 
 if( aEPin->length )
 {
 wxString length = aEPin->length.Get();
 
 if( length == wxT( "short" ) )
 pin->SetLength( schIUScale.MilsToIU( 100 ) );
 else if( length == wxT( "middle" ) )
 pin->SetLength( schIUScale.MilsToIU( 200 ) );
 else if( length == wxT( "long" ) )
 pin->SetLength( schIUScale.MilsToIU( 300 ) );
 else if( length == wxT( "point" ) )
 pin->SetLength( schIUScale.MilsToIU( 0 ) );
 }
 
 // emulate the visibility of pin elements
 if( aEPin->visible )
 {
 wxString visible = aEPin->visible.Get();
 
 if( visible == wxT( "off" ) )
 {
 pin->SetNameTextSize( 0 );
 pin->SetNumberTextSize( 0 );
 }
 else if( visible == wxT( "pad" ) )
 {
 pin->SetNameTextSize( 0 );
 }
 else if( visible == wxT( "pin" ) )
 {
 pin->SetNumberTextSize( 0 );
 }
 
 /*
 * else if( visible == wxT( "both" ) )
 * {
 * }
 */
 }
 
 if( aEPin->function )
 {
 wxString function = aEPin->function.Get();
 
 if( function == wxT( "dot" ) )
 pin->SetShape( GRAPHIC_PINSHAPE::INVERTED );
 else if( function == wxT( "clk" ) )
 pin->SetShape( GRAPHIC_PINSHAPE::CLOCK );
 else if( function == wxT( "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, EDA_IU_SCALE::MilsToIU(), EPIN::name, pin, EPIN::rot, schIUScale, 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 2235 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() ? wxT( "\" \"" ) : escapeName( adjustedText ) );
 schtext->SetPosition( VECTOR2I( 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 604 of file sch_eagle_plugin.cpp.

{
 // Map all children into a readable dictionary
 NODE_MAP schematicChildren = MapChildren( aSchematicNode );
 wxXmlNode* partNode = getChildrenNodes( schematicChildren, wxT( "parts" ) );
 wxXmlNode* libraryNode = getChildrenNodes( schematicChildren, wxT( "libraries" ) );
 wxXmlNode* sheetNode = getChildrenNodes( schematicChildren, wxT( "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, wxT( "devicesets" ) );
 
 while( devicesetNode )
 {
 NODE_MAP deviceSetChildren = MapChildren( devicesetNode );
 wxXmlNode* deviceNode = getChildrenNodes( deviceSetChildren, wxT( "devices" ) );
 wxXmlNode* gateNode = getChildrenNodes( deviceSetChildren, wxT( "gates" ) );
 
 m_totalCount += count_nodes( deviceNode ) * count_nodes( gateNode );
 
 devicesetNode = devicesetNode->GetNext();
 }
 
 libraryNode = libraryNode->GetNext();
 }
 
 // Rewind
 libraryNode = getChildrenNodes( schematicChildren, wxT( "libraries" ) );
 
 while( sheetNode )
 {
 NODE_MAP sheetChildren = MapChildren( sheetNode );
 
 m_totalCount += count_nodes( getChildrenNodes( sheetChildren, wxT( "instances" ) ) );
 m_totalCount += count_nodes( getChildrenNodes( sheetChildren, wxT( "busses" ) ) );
 m_totalCount += count_nodes( getChildrenNodes( sheetChildren, wxT( "nets" ) ) );
 m_totalCount += count_nodes( getChildrenNodes( sheetChildren, wxT( "plain" ) ) );
 
 sheetNode = sheetNode->GetNext();
 }
 
 // Rewind
 sheetNode = getChildrenNodes( schematicChildren, wxT( "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( wxT( "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 );
 
 // There is always at least a root sheet.
 m_sheetPath.push_back( m_rootSheet );
 
 SCH_SHEET_PATH rootPath;
 m_rootSheet->AddInstance( m_sheetPath );
 rootPath.SetPageNumber( wxT( "1" ) );
 
 int sheetCount = countChildren( sheetNode->GetParent(), wxT( "sheet" ) );
 
 if( sheetCount > 1 )
 {
 int x, y, i;
 i = 1;
 x = 1;
 y = 1;
 
 while( sheetNode )
 {
 VECTOR2I pos = VECTOR2I( x * schIUScale.MilsToIU( 1000 ),
 y * schIUScale.MilsToIU( 1000 ) );
 
 // Eagle schematics are never more than one sheet deep so the parent sheet is
 // always the root sheet.
 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 );
 screen->SetFileName( sheet->GetFileName() );
 
 wxCHECK2( sheet && screen, continue );
 
 wxString pageNo = wxString::Format( wxT( "%d" ), i );
 
 m_sheetPath.push_back( sheet.get() );
 loadSheet( sheetNode, i );
 
 m_sheetPath.SetPageNumber( pageNo );
 m_sheetPath.pop_back();
 
 SCH_SCREEN* currentScreen = m_rootSheet->GetScreen();
 
 wxCHECK2( currentScreen, continue );
 
 currentScreen->Append( sheet.release() );
 
 sheetNode = sheetNode->GetNext();
 x += 2;
 
 if( x > 10 ) // Start next row of sheets.
 {
 x = 1;
 y += 2;
 }
 
 i++;
 }
 }
 else
 {
 // There is only one sheet so we make that the root schematic.
 while( sheetNode )
 {
 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( schIUScale.IU_PER_MILS );
 BOX2I sheetBbox = getSheetBbox( m_rootSheet );
 VECTOR2I 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
 BOX2I cmpBbox = symbol->GetBoundingBox();
 int posY = newCmpPosition.y + cmpBbox.GetHeight();
 symbol->SetPosition( VECTOR2I( newCmpPosition.x, posY ) );
 newCmpPosition.x += cmpBbox.GetWidth();
 maxY = std::max( maxY, posY );
 
 if( newCmpPosition.x >= pageSizeIU.GetWidth() ) // reached the page boundary?
 newCmpPosition = VECTOR2I( 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_SHEET::AddInstance(), SCH_SCREEN::Append(), checkpoint(), countChildren(), countNets(), SCH_ITEM::Duplicate(), Format(), BOX2< Vec >::GetBottom(), getChildrenNodes(), SCH_SYMBOL::GetField(), BOX2< Vec >::GetHeight(), BOX2< Vec >::GetLeft(), getLibFileName(), SCH_SCREEN::GetPageSettings(), SCH_SHEET::GetScreen(), getSheetBbox(), PAGE_INFO::GetSizeIU(), EDA_TEXT::GetText(), BOX2< Vec >::GetWidth(), BOX2< Vec >::GetY(), EDA_IU_SCALE::IU_PER_MILS, loadLibrary(), loadSheet(), SCH_SHEET::LocatePathOfScreen(), m_doneCount, m_eagleLibs, m_missingCmps, m_partlist, m_pi, m_progressReporter, m_rootSheet, m_schematic, m_sheetPath, m_totalCount, MapChildren(), EDA_IU_SCALE::MilsToIU(), EAGLE_LIBRARY::name, SCH_SHEET_PATH::Path(), SCH_SHEET_PATH::pop_back(), SCH_SHEET_PATH::push_back(), REFERENCE_FIELD, SCH_PLUGIN::SaveLibrary(), schIUScale, SCH_SCREEN::SetFileName(), SCH_SHEET_PATH::SetPageNumber(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by loadDrawing().

loadSegments()

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

private

Definition at line 1052 of file sch_eagle_plugin.cpp.

{
 // Loop through all segments
 wxXmlNode* currentSegment = aSegmentsNode->GetChildren();
 SCH_SCREEN* screen = getCurrentScreen();
 
 wxCHECK( screen, /* void */ );
 
 int segmentCount = countChildren( aSegmentsNode, wxT( "segment" ) );
 
 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() == wxT( "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 == wxT( "junction" ) )
 {
 screen->Append( loadJunction( segmentAttribute ) );
 }
 else if( nodeName == wxT( "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 == wxT( "pinref" ) )
 {
 segmentAttribute->GetAttribute( wxT( "gate" ) ); // REQUIRED
 wxString part = segmentAttribute->GetAttribute( wxT( "part" ) ); // REQUIRED
 wxString pin = segmentAttribute->GetAttribute( wxT( "pin" ) ); // REQUIRED
 
 auto powerPort = m_powerPorts.find( wxT( "#" ) + part );
 
 if( powerPort != m_powerPorts.end()
 && powerPort->second == EscapeString( pin, CTX_NETNAME ) )
 {
 labelled = true;
 }
 }
 else if( nodeName == wxT( "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( schIUScale.MilsToIU( 40 ),
 schIUScale.MilsToIU( 40 ) ) );
 
 if( firstWire->GetEndPoint().x > firstWire->GetStartPoint().x )
 label->SetTextSpinStyle( TEXT_SPIN_STYLE::LEFT );
 else
 label->SetTextSpinStyle( TEXT_SPIN_STYLE::RIGHT );
 
 screen->Append( label.release() );
 }
 }
 
 currentSegment = currentSegment->GetNext();
 }
}

References SCH_SCREEN::Append(), countChildren(), CTX_NETNAME, escapeName(), EscapeString(), getCurrentScreen(), SCH_LINE::GetEndPoint(), SCH_LINE::GetStartPoint(), EDA_TEXT::GetText(), SEG::Intersect(), SCH_EAGLE_PLUGIN::SEG_DESC::labels, TEXT_SPIN_STYLE::LEFT, loadJunction(), loadLabel(), loadWire(), m_netCounts, m_powerPorts, m_segments, m_wireIntersections, MapChildren(), EDA_IU_SCALE::MilsToIU(), pin, TEXT_SPIN_STYLE::RIGHT, schIUScale, SCH_EAGLE_PLUGIN::SEG_DESC::segs, and VECTOR2< T >::x.

Referenced by loadSheet().

loadSheet()

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

private

Definition at line 825 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, wxT( "description" ) );
 
 SCH_SHEET* sheet = getCurrentSheet();
 
 wxCHECK( sheet, /* void */ );
 
 wxString des;
 std::string filename;
 SCH_FIELD& sheetNameField = sheet->GetFields()[SHEETNAME];
 SCH_FIELD& filenameField = sheet->GetFields()[SHEETFILENAME];
 
 if( descriptionNode )
 {
 des = descriptionNode->GetContent();
 des.Replace( wxT( "\n" ), wxT( "_" ), true );
 sheetNameField.SetText( des );
 filename = des.ToStdString();
 }
 else
 {
 filename = wxString::Format( wxT( "%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() );
 
 SCH_SCREEN* screen = getCurrentScreen();
 
 wxCHECK( screen, /* void */ );
 
 screen->SetFileName( fn.GetFullPath() );
 sheet->AutoplaceFields( screen, true );
 
 // Loop through all of the symbol instances.
 wxXmlNode* instanceNode = getChildrenNodes( sheetChildren, wxT( "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, wxT( "busses" ) );
 
 while( busNode )
 {
 checkpoint();
 
 // Get the bus name
 wxString busName = translateEagleBusName( busNode->GetAttribute( wxT( "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, wxT( "nets" ) );
 
 while( netNode )
 {
 checkpoint();
 
 // Get the net name and class
 wxString netName = netNode->GetAttribute( wxT( "name" ) );
 wxString netClass = netNode->GetAttribute( wxT( "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, wxT( "plain" ) );
 
 while( plainNode )
 {
 checkpoint();
 
 wxString nodeName = plainNode->GetName();
 
 if( nodeName == wxT( "text" ) )
 {
 screen->Append( loadPlainText( plainNode ) );
 }
 else if( nodeName == wxT( "wire" ) )
 {
 screen->Append( loadWire( plainNode ) );
 }
 else if( nodeName == wxT( "frame" ) )
 {
 std::vector<SCH_LINE*> lines;
 
 loadFrame( plainNode, lines );
 
 for( SCH_LINE* line : lines )
 screen->Append( line );
 }
 
 plainNode = plainNode->GetNext();
 }
 
 // Calculate the new sheet size.
 BOX2I sheetBoundingBox = getSheetBbox( sheet );
 VECTOR2I targetSheetSize = sheetBoundingBox.GetSize();
 targetSheetSize += VECTOR2I( schIUScale.MilsToIU( 1500 ), schIUScale.MilsToIU( 1500 ) );
 
 // Get current Eeschema sheet size.
 wxSize pageSizeIU = screen->GetPageSettings().GetSizeIU( schIUScale.IU_PER_MILS );
 PAGE_INFO pageInfo = screen->GetPageSettings();
 
 // Increase if necessary
 if( pageSizeIU.x < targetSheetSize.x )
 pageInfo.SetWidthMils( schIUScale.IUToMils( targetSheetSize.x ) );
 
 if( pageSizeIU.y < targetSheetSize.y )
 pageInfo.SetHeightMils( schIUScale.IUToMils( targetSheetSize.y ) );
 
 // Set the new sheet size.
 screen->SetPageSettings( pageInfo );
 
 pageSizeIU = screen->GetPageSettings().GetSizeIU( schIUScale.IU_PER_MILS );
 VECTOR2I sheetcentre( pageSizeIU.x / 2, pageSizeIU.y / 2 );
 VECTOR2I itemsCentre = sheetBoundingBox.Centre();
 
 // round the translation to nearest 100mil to place it on the grid.
 VECTOR2I translation = sheetcentre - itemsCentre;
 translation.x = translation.x - translation.x % schIUScale.MilsToIU( 100 );
 translation.y = translation.y - translation.y % schIUScale.MilsToIU( 100 );
 
 // Add global net labels for the named power input pins in this sheet
 for( SCH_ITEM* item : screen->Items().OfType( SCH_SYMBOL_T ) )
 {
 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
 addImplicitConnections( symbol, screen, true );
 }
 
 m_connPoints.clear();
 
 // Translate the items.
 std::vector<SCH_ITEM*> allItems;
 
 std::copy( screen->Items().begin(), screen->Items().end(), std::back_inserter( allItems ) );
 
 for( SCH_ITEM* item : allItems )
 {
 item->SetPosition( item->GetPosition() + translation );
 item->ClearFlags();
 screen->Update( item );
 
 }
}

References addBusEntries(), addImplicitConnections(), adjustNetLabels(), SCH_SCREEN::Append(), SCH_SHEET::AutoplaceFields(), EE_RTREE::begin(), BOX2< Vec >::Centre(), checkpoint(), EE_RTREE::end(), Format(), getChildrenNodes(), getCurrentScreen(), getCurrentSheet(), SCH_SHEET::GetFields(), SCH_SCREEN::GetPageSettings(), getSheetBbox(), BOX2< Vec >::GetSize(), PAGE_INFO::GetSizeIU(), SCH_SCREEN::Items(), EDA_IU_SCALE::IU_PER_MILS, EDA_IU_SCALE::IUToMils(), KiCadSchematicFileExtension, loadFrame(), loadInstance(), loadPlainText(), loadSegments(), loadWire(), m_connPoints, m_filename, MapChildren(), EDA_IU_SCALE::MilsToIU(), EE_RTREE::OfType(), ReplaceIllegalFileNameChars(), SCH_SYMBOL_T, schIUScale, SCH_SCREEN::SetFileName(), PAGE_INFO::SetHeightMils(), SCH_SCREEN::SetPageSettings(), EDA_TEXT::SetText(), PAGE_INFO::SetWidthMils(), SHEETFILENAME, SHEETNAME, translateEagleBusName(), SCH_SCREEN::Update(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by loadSchematic().

LoadSymbol()

LIB_SYMBOL * SCH_PLUGIN::LoadSymbol ( const wxString &  aLibraryPath, const wxString &  aPartName, const STRING_UTF8_MAP *  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_DATABASE_PLUGIN, SCH_SEXPR_PLUGIN, and SCH_LEGACY_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_EDIT_FRAME::ExportSymbol(), SYMBOL_EDIT_FRAME::ImportSymbol(), loadInstance(), SYMBOL_LIB_TABLE::LoadSymbol(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer(), SYMBOL_LIBRARY_MANAGER::SaveLibrary(), and SYMBOL_LIB_TABLE::SaveSymbol().

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 1648 of file sch_eagle_plugin.cpp.

{
 wxString symbolName = aSymbolNode->GetAttribute( wxT( "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 == wxT( "circle" ) )
 {
 aSymbol->AddDrawItem( loadSymbolCircle( aSymbol, currentNode, aGateNumber ) );
 }
 else if( nodeName == wxT( "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 == wxT( "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( wxT( "%i" ), pincount ) );
 aSymbol->AddDrawItem( pin.release() );
 }
 }
 else if( nodeName == wxT( "polygon" ) )
 {
 aSymbol->AddDrawItem( loadSymbolPolyLine( aSymbol, currentNode, aGateNumber ) );
 }
 else if( nodeName == wxT( "rectangle" ) )
 {
 aSymbol->AddDrawItem( loadSymbolRectangle( aSymbol, currentNode, aGateNumber ) );
 }
 else if( nodeName == wxT( "text" ) )
 {
 std::unique_ptr<LIB_TEXT> libtext( loadSymbolText( aSymbol, currentNode,
 aGateNumber ) );
 
 if( libtext->GetText().Upper() == wxT( ">NAME" ) )
 {
 LIB_FIELD* field = aSymbol->GetFieldById( REFERENCE_FIELD );
 loadFieldAttributes( field, libtext.get() );
 foundName = true;
 }
 else if( libtext->GetText().Upper() == wxT( ">VALUE" ) )
 {
 LIB_FIELD* field = aSymbol->GetFieldById( VALUE_FIELD );
 loadFieldAttributes( field, libtext.get() );
 foundValue = true;
 }
 else
 {
 aSymbol->AddDrawItem( libtext.release() );
 }
 }
 else if( nodeName == wxT( "wire" ) )
 {
 aSymbol->AddDrawItem( loadSymbolWire( aSymbol, currentNode, aGateNumber ) );
 }
 else if( nodeName == wxT( "frame" ) )
 {
 std::vector<LIB_ITEM*> frameItems;
 
 loadFrame( currentNode, frameItems );
 
 for( LIB_ITEM* item : frameItems )
 {
 item->SetParent( aSymbol.get() );
 item->SetUnit( aGateNumber );
 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, ECONNECT::pin, pin, pinDirectionsMap, PT_BIDI, REFERENCE_FIELD, LIB_PIN::SetNumber(), and VALUE_FIELD.

Referenced by loadLibrary().

loadSymbolCircle()

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

private

Definition at line 1799 of file sch_eagle_plugin.cpp.

{
 // Parse the circle properties
 ECIRCLE c( aCircleNode );
 LIB_SHAPE* circle = new LIB_SHAPE( aSymbol.get(), SHAPE_T::CIRCLE );
 VECTOR2I center( c.x.ToSchUnits(), c.y.ToSchUnits() );
 
 circle->SetPosition( center );
 circle->SetEnd( VECTOR2I( center.x + c.radius.ToSchUnits(), center.y ) );
 circle->SetStroke( STROKE_PARAMS( c.width.ToSchUnits(), PLOT_DASH_TYPE::SOLID ) );
 circle->SetUnit( aGateNumber );
 
 return circle;
}

References CIRCLE, ECIRCLE::radius, EDA_SHAPE::SetEnd(), LIB_SHAPE::SetPosition(), LIB_SHAPE::SetStroke(), LIB_ITEM::SetUnit(), SOLID, ECOORD::ToSchUnits(), ECIRCLE::width, ECIRCLE::x, VECTOR2< T >::x, ECIRCLE::y, and VECTOR2< T >::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 1917 of file sch_eagle_plugin.cpp.

{
 LIB_SHAPE* poly = new LIB_SHAPE( aSymbol.get(), SHAPE_T::POLY );
 EPOLYGON epoly( aPolygonNode );
 wxXmlNode* vertex = aPolygonNode->GetChildren();
 VECTOR2I pt;
 
 while( vertex )
 {
 if( vertex->GetName() == wxT( "vertex" ) ) // skip <xmlattr> node
 {
 EVERTEX evertex( vertex );
 pt = VECTOR2I( 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 1816 of file sch_eagle_plugin.cpp.

{
 ERECT rect( aRectNode );
 LIB_SHAPE* rectangle = new LIB_SHAPE( aSymbol.get(), SHAPE_T::RECT );
 
 rectangle->SetPosition( VECTOR2I( rect.x1.ToSchUnits(), rect.y1.ToSchUnits() ) );
 rectangle->SetEnd( VECTOR2I( rect.x2.ToSchUnits(), rect.y2.ToSchUnits() ) );
 
 if( rect.rot )
 {
 VECTOR2I pos( rectangle->GetPosition() );
 VECTOR2I end( rectangle->GetEnd() );
 VECTOR2I center( rectangle->GetCenter() );
 
 RotatePoint( pos, center, EDA_ANGLE( rect.rot->degrees, DEGREES_T ) );
 RotatePoint( end, center, EDA_ANGLE( rect.rot->degrees, DEGREES_T ) );
 
 rectangle->SetPosition( pos );
 rectangle->SetEnd( end );
 }
 
 rectangle->SetUnit( aGateNumber );
 
 // Eagle rectangles are filled by definition.
 rectangle->SetFillMode( FILL_T::FILLED_SHAPE );
 
 return rectangle;
}

References EROT::degrees, DEGREES_T, FILLED_SHAPE, LIB_SHAPE::GetCenter(), EDA_SHAPE::GetEnd(), LIB_SHAPE::GetPosition(), RECT, ERECT::rot, RotatePoint(), 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 2021 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( VECTOR2I( 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() ? wxT( "~" ) : text );
 loadTextAttributes( libtext.get(), etext );
 
 return libtext.release();
}

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

Referenced by loadSymbol().

loadSymbolWire()

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

private

Definition at line 1847 of file sch_eagle_plugin.cpp.

{
 EWIRE ewire = EWIRE( aWireNode );
 
 VECTOR2I 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 );
 VECTOR2I 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 )
 {
 VECTOR2I centerStartVector = begin - center;
 VECTOR2I 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->SetStroke( STROKE_PARAMS( 1, PLOT_DASH_TYPE::SOLID ) );
 arc->SetFillMode( FILL_T::FILLED_SHAPE );
 }
 else
 {
 arc->SetStroke( STROKE_PARAMS( ewire.width.ToSchUnits(), PLOT_DASH_TYPE::SOLID ) );
 }
 
 arc->SetArcGeometry( begin, 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->SetStroke( STROKE_PARAMS( ewire.width.ToSchUnits(), PLOT_DASH_TYPE::SOLID ) );
 
 return poly;
 }
}

References std::abs(), LIB_SHAPE::AddPoint(), ARC, CalcArcMid(), ConvertArcCenter(), EWIRE::curve, FILLED_SHAPE, POLY, EDA_SHAPE::SetArcGeometry(), EDA_SHAPE::SetFillMode(), LIB_SHAPE::SetStroke(), LIB_ITEM::SetUnit(), SOLID, ECOORD::ToSchUnits(), EWIRE::width, VECTOR2< T >::x, EWIRE::x1, EWIRE::x2, VECTOR2< T >::y, 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 2267 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 1187 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 ) );
 
 VECTOR2I 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(), VECTOR2< T >::x, EWIRE::x1, EWIRE::x2, VECTOR2< T >::y, EWIRE::y1, and EWIRE::y2.

Referenced by loadSegments(), and loadSheet().

moveLabels()

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

private

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

Definition at line 2396 of file sch_eagle_plugin.cpp.

{
 SCH_SCREEN* screen = getCurrentScreen();
 
 wxCHECK( screen, /* void */ );
 
 for( SCH_ITEM* item : screen->Items().Overlapping( aWire->GetBoundingBox() ) )
 {
 if( !item->IsType( { SCH_LABEL_LOCATE_ANY_T } ) )
 continue;
 
 if( TestSegmentHit( item->GetPosition(), aWire->GetStartPoint(), aWire->GetEndPoint(), 0 ) )
 item->SetPosition( aNewEndPoint );
 }
}

References SCH_LINE::GetBoundingBox(), getCurrentScreen(), SCH_LINE::GetEndPoint(), SCH_LINE::GetStartPoint(), SCH_SCREEN::Items(), EE_RTREE::Overlapping(), 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 STRING_UTF8_MAP *  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().

Referenced by DIALOG_SHEET_PROPERTIES::onSheetFilenameChanged(), and SCH_EDIT_FRAME::saveSchematicFile().

SaveLibrary()

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

virtualinherited

Reimplemented in SCH_SEXPR_PLUGIN, and SCH_LEGACY_PLUGIN.

Definition at line 45 of file sch_plugin.cpp.

{
 not_implemented( this, __FUNCTION__ );
}

References not_implemented().

Referenced by SCH_ALTIUM_PLUGIN::Load(), CADSTAR_SCH_ARCHIVE_PLUGIN::Load(), Load(), loadSchematic(), SYMBOL_LIBRARY_MANAGER::SaveLibrary(), and SYMBOL_LIB_TABLE_RESCUER::WriteRescueLibrary().

SaveSymbol()

void SCH_PLUGIN::SaveSymbol ( const wxString &  aLibraryPath, const LIB_SYMBOL *  aSymbol, const STRING_UTF8_MAP *  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_SEXPR_PLUGIN, and SCH_LEGACY_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 PANEL_SYM_LIB_TABLE::convertLibrary(), SYMBOL_EDIT_FRAME::ExportSymbol(), SCH_EDITOR_CONTROL::ExportSymbolsToLibrary(), loadLibrary(), SCH_ALTIUM_PLUGIN::ParseFileHeader(), SCH_ALTIUM_PLUGIN::ParsePowerPort(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer(), SYMBOL_LIBRARY_MANAGER::SaveLibrary(), SYMBOL_LIB_TABLE::SaveSymbol(), and SYMBOL_LIB_TABLE_RESCUER::WriteRescueLibrary().

SetLibTable()

virtual void SCH_PLUGIN::SetLibTable ( SYMBOL_LIB_TABLE *  aTable )

inlinevirtualinherited

Some library plugins need to have access to their parent library table.

Parameters

aTable

is the table this plugin is registered within.

Reimplemented in SCH_DATABASE_PLUGIN.

Definition at line 515 of file sch_io_mgr.h.

{}

Referenced by SYMBOL_LIB_TABLE::FindRow(), and SYMBOL_LIB_TABLE_ROW::Refresh().

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.

SupportsSubLibraries()

virtual bool SCH_PLUGIN::SupportsSubLibraries ( ) const

inlinevirtualinherited

Returns

true if this plugin supports libraries that contain sub-libraries.

Reimplemented in SCH_DATABASE_PLUGIN.

Definition at line 449 of file sch_io_mgr.h.

{ return false; }

Referenced by SYMBOL_LIB_TABLE_ROW::SupportsSubLibraries().

SymbolLibOptions()

void SCH_PLUGIN::SymbolLibOptions ( STRING_UTF8_MAP *  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 3087 of file sch_eagle_plugin.cpp.

{
 if( NET_SETTINGS::ParseBusVector( aEagleName, nullptr, nullptr ) )
 return aEagleName;
 
 wxString ret = wxT( "{" );
 
 wxStringTokenizer tokenizer( aEagleName, wxT( "," ) );
 
 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 << wxT( "!" );
 
 ret << member << wxS( " " );
 }
 
 ret.Trim( true );
 ret << wxT( "}" );
 
 return ret;
}

References NET_SETTINGS::ParseBusVector().

Referenced by loadSheet().

Member Data Documentation

m_connPoints

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

private

Definition at line 264 of file sch_eagle_plugin.h.

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

m_doneCount

unsigned SCH_EAGLE_PLUGIN::m_doneCount

private

Definition at line 234 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 228 of file sch_eagle_plugin.h.

Referenced by loadInstance(), and loadSchematic().

m_filename

wxFileName SCH_EAGLE_PLUGIN::m_filename

private

Definition at line 223 of file sch_eagle_plugin.h.

Referenced by Load(), and loadSheet().

m_lastProgressCount

unsigned SCH_EAGLE_PLUGIN::m_lastProgressCount

private

Definition at line 235 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 239 of file sch_eagle_plugin.h.

Referenced by kiCadLayer(), and loadLayerDefs().

m_libName

wxString SCH_EAGLE_PLUGIN::m_libName

private

Library name to save symbols.

Definition at line 224 of file sch_eagle_plugin.h.

Referenced by getLibName().

m_missingCmps

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

private

Definition at line 218 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 238 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 261 of file sch_eagle_plugin.h.

m_partlist

EPART_MAP SCH_EAGLE_PLUGIN::m_partlist

private

Definition at line 227 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 230 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 240 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 233 of file sch_eagle_plugin.h.

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

m_properties

std::unique_ptr<STRING_UTF8_MAP> SCH_EAGLE_PLUGIN::m_properties

private

Library plugin properties.

Definition at line 231 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 215 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 220 of file sch_eagle_plugin.h.

Referenced by getLibName(), Load(), 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 225 of file sch_eagle_plugin.h.

Referenced by getLibFileName(), getLibName(), Load(), loadInstance(), loadLibrary(), 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 258 of file sch_eagle_plugin.h.

Referenced by adjustNetLabels(), and loadSegments().

m_sheetPath

SCH_SHEET_PATH SCH_EAGLE_PLUGIN::m_sheetPath

private

The current sheet path of the schematic being loaded.

Definition at line 221 of file sch_eagle_plugin.h.

Referenced by getCurrentScreen(), getCurrentSheet(), loadInstance(), and loadSchematic().

m_totalCount

unsigned SCH_EAGLE_PLUGIN::m_totalCount

private

for progress reporting

Definition at line 236 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 222 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 245 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