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_STRUCT

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

Private Types
typedef struct SCH_EAGLE_PLUGIN::SEG_DESC_STRUCT	SEG_DESC
	Segments representing wires for intersection checking. More...

Private Member Functions
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_ITEM *aWire, const wxPoint &aNewEndPoint)
	Move any labels on the wire to the new end point of the wire. More...
void	addBusEntries ()
	This function finds best way to place a bus entry symbol for when an Eagle wire segment ends on an Eagle bus segment. More...
SCH_LAYER_ID	kiCadLayer (int aEagleLayer)
	Return the matching layer or return LAYER_NOTES. More...
std::pair< VECTOR2I, const SEG * >	findNearestLinePoint (const wxPoint &aPoint, const std::vector< SEG > &aLines) const
void	loadSegments (wxXmlNode *aSegmentsNode, const wxString &aNetName, const wxString &aNetClass)
SCH_LINE *	loadWire (wxXmlNode *aWireNode)
SCH_TEXT *	loadLabel (wxXmlNode *aLabelNode, const wxString &aNetName)
SCH_JUNCTION *	loadJunction (wxXmlNode *aJunction)
SCH_TEXT *	loadPlainText (wxXmlNode *aSchText)
void	loadFrame (wxXmlNode *aFrameNode, std::vector< SCH_LINE * > &aLines)
bool	loadSymbol (wxXmlNode *aSymbolNode, std::unique_ptr< LIB_PART > &aPart, EDEVICE *aDevice, int aGateNumber, const wxString &aGateName)
LIB_CIRCLE *	loadSymbolCircle (std::unique_ptr< LIB_PART > &aPart, wxXmlNode *aCircleNode, int aGateNumber)
LIB_RECTANGLE *	loadSymbolRectangle (std::unique_ptr< LIB_PART > &aPart, wxXmlNode *aRectNode, int aGateNumber)
LIB_POLYLINE *	loadSymbolPolyLine (std::unique_ptr< LIB_PART > &aPart, wxXmlNode *aPolygonNode, int aGateNumber)
LIB_ITEM *	loadSymbolWire (std::unique_ptr< LIB_PART > &aPart, wxXmlNode *aWireNode, int aGateNumber)
LIB_PIN *	loadPin (std::unique_ptr< LIB_PART > &aPart, wxXmlNode *, EPIN *epin, int aGateNumber)
LIB_TEXT *	loadSymbolText (std::unique_ptr< LIB_PART > &aPart, 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_COMPONENT *aComponent, const LIB_PIN *aPin) const
void	addImplicitConnections (SCH_COMPONENT *aComponent, SCH_SCREEN *aScreen, bool aUpdateSet)
	Create net labels to emulate implicit connections in Eagle. More...
bool	netHasPowerDriver (SCH_LINE *aLine, const wxString &aNetName) const

Static Private Member Functions
static wxString	fixSymbolName (const wxString &aName)
	Fix invalid characters in Eagle symbol names. More...

Private Attributes
REPORTER *	m_reporter
	Reporter for warnings/errors. More...
std::map< wxString, EAGLE_MISSING_CMP >	m_missingCmps
SCH_SHEET *	m_rootSheet
	The root sheet of the schematic being loaded. More...
SCH_SHEET *	m_currentSheet
	The current sheet of the schematic being loaded. More...
wxString	m_version
	Eagle file version. More...
wxFileName	m_filename
wxString	m_libName
	Library name to save symbols. More...
SCHEMATIC *	m_schematic
	Passed to Load(), the schematic object being loaded. More...
EPART_MAP	m_partlist
std::map< wxString, EAGLE_LIBRARY >	m_eagleLibs
SCH_PLUGIN::SCH_PLUGIN_RELEASER	m_pi
	Plugin to create the KiCad symbol library. More...
std::unique_ptr< PROPERTIES >	m_properties
	Library plugin properties. More...
std::map< wxString, int >	m_netCounts
std::map< int, SCH_LAYER_ID >	m_layerMap
	Wire intersection points, used for quick checks whether placing a net label in a particular place would short two nets. More...
std::vector< VECTOR2I >	m_wireIntersections
	Wires and labels of a single connection (segment in Eagle nomenclature) More...
std::vector< SEG_DESC >	m_segments
	Nets as defined in the <nets> sections of an Eagle schematic file. More...
std::map< wxString, ENET >	m_nets
	Positions of pins and wire endings mapped to its parent. More...
std::map< wxPoint, std::set< const EDA_ITEM * > >	m_connPoints

Detailed Description

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

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

Definition at line 81 of file sch_eagle_plugin.h.

Member Typedef Documentation

SEG_DESC

typedef struct SCH_EAGLE_PLUGIN::SEG_DESC_STRUCT SCH_EAGLE_PLUGIN::SEG_DESC

private

Segments representing wires for intersection checking.

Constructor & Destructor Documentation

SCH_EAGLE_PLUGIN()

SCH_EAGLE_PLUGIN::SCH_EAGLE_PLUGIN

(

)

Definition at line 352 of file sch_eagle_plugin.cpp.

{
    m_rootSheet    = nullptr;
    m_currentSheet = nullptr;
    m_schematic    = nullptr;

    m_reporter     = &WXLOG_REPORTER::GetInstance();
}

References WXLOG_REPORTER::GetInstance().

~SCH_EAGLE_PLUGIN()

SCH_EAGLE_PLUGIN::~SCH_EAGLE_PLUGIN

(

)

Definition at line 362 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 2240 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.

    for( auto it1 = m_currentSheet->GetScreen()->Items().OfType( SCH_LINE_T ).begin();
            it1 != m_currentSheet->GetScreen()->Items().end(); ++it1 )
    {
        SCH_LINE* bus = static_cast<SCH_LINE*>( *it1 );

        // Check line type for wire
        if( bus->GetLayer() != LAYER_BUS )
            continue;

        wxPoint busstart = bus->GetStartPoint();
        wxPoint busend   = bus->GetEndPoint();

        auto it2 = it1;
        ++it2;

        for( ; it2 != m_currentSheet->GetScreen()->Items().end(); ++it2 )
        {
            SCH_LINE* line = static_cast<SCH_LINE*>( *it2 );

            // Check line type for bus
            if( ( (SCH_LINE*) *it2 )->GetLayer() == LAYER_WIRE )
            {
                // Get points of both segments.
                wxPoint linestart = line->GetStartPoint();
                wxPoint lineend   = line->GetEndPoint();

                // Test for horizontal wire and vertical bus
                if( linestart.y == lineend.y && busstart.x == busend.x )
                {
                    if( TestSegmentHit( linestart, busstart, busend, 0 ) )
                    {
                        // Wire start is on a bus.
                        // Wire start is on the vertical bus

                        // if the end of the wire is to the left of the bus
                        if( lineend.x < busstart.x )
                        {
                            // |
                            // ---|
                            // |
                            if( TestSegmentHit(
                                        linestart + wxPoint( 0, -100 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        linestart + wxPoint( -100, 0 ), true );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, linestart + wxPoint( -100, 0 ) );
                                line->SetStartPoint( linestart + wxPoint( -100, 0 ) );
                            }
                            else if( TestSegmentHit(
                                             linestart + wxPoint( 0, 100 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        linestart + wxPoint( -100, 0 ), false );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, linestart + wxPoint( -100, 0 ) );
                                line->SetStartPoint( linestart + wxPoint( -100, 0 ) );
                            }
                            else
                            {
                                std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( 0 );
                                ercItem->SetErrorMessage( _( "Bus Entry needed" ) );

                                SCH_MARKER* marker = new SCH_MARKER( ercItem, linestart );
                                m_currentSheet->GetScreen()->Append( marker );
                            }
                        }
                        // else the wire end is to the right of the bus
                        // Wire is to the right of the bus
                        // |
                        // |----
                        // |
                        else
                        {
                            // test is bus exists above the wire
                            if( TestSegmentHit(
                                        linestart + wxPoint( 0, -100 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        linestart + wxPoint( 0, -100 ), false );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, linestart + wxPoint( 100, 0 ) );
                                line->SetStartPoint( linestart + wxPoint( 100, 0 ) );
                            }
                            // test is bus exists below the wire
                            else if( TestSegmentHit(
                                             linestart + wxPoint( 0, 100 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        linestart + wxPoint( 0, 100 ), true );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, linestart + wxPoint( 100, 0 ) );
                                line->SetStartPoint( linestart + wxPoint( 100, 0 ) );
                            }
                            else
                            {
                                std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( 0 );
                                ercItem->SetErrorMessage( _( "Bus Entry needed" ) );

                                SCH_MARKER* marker = new SCH_MARKER( ercItem, linestart );
                                m_currentSheet->GetScreen()->Append( marker );
                            }
                        }
                    }

                    // Same thing but test end of the wire instead.
                    if( TestSegmentHit( lineend, busstart, busend, 0 ) )
                    {
                        // Wire end is on the vertical bus

                        // if the start of the wire is to the left of the bus
                        if( linestart.x < busstart.x )
                        {
                            // Test if bus exists above the wire
                            if( TestSegmentHit( lineend + wxPoint( 0, 100 ), busstart, busend, 0 ) )
                            {
                                // |
                                // ___/|
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        lineend + wxPoint( -100, 0 ), false );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, lineend + wxPoint( -100, 0 ) );
                                line->SetEndPoint( lineend + wxPoint( -100, 0 ) );
                            }
                            // Test if bus exists below the wire
                            else if( TestSegmentHit(
                                             lineend + wxPoint( 0, -100 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry =
                                        new SCH_BUS_WIRE_ENTRY( lineend + wxPoint( -100, 0 ),
                                                                true );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, lineend + wxPoint( -100, 0 ) );
                                line->SetEndPoint( lineend + wxPoint( -100, 0 ) );
                            }
                            else
                            {
                                std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( 0 );
                                ercItem->SetErrorMessage( _( "Bus Entry needed" ) );

                                SCH_MARKER* marker = new SCH_MARKER( ercItem, lineend );
                                m_currentSheet->GetScreen()->Append( marker );
                            }
                        }
                        // else the start of the wire is to the right of the bus
                        // |
                        // |----
                        // |
                        else
                        {
                            // test if bus existed above the wire
                            if( TestSegmentHit(
                                        lineend + wxPoint( 0, -100 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        lineend + wxPoint( 0, -100 ), false );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, lineend + wxPoint( 100, 0 ) );
                                line->SetEndPoint( lineend + wxPoint( 100, 0 ) );
                            }
                            // test if bus existed below the wire
                            else if( TestSegmentHit(
                                             lineend + wxPoint( 0, 100 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry =
                                        new SCH_BUS_WIRE_ENTRY( lineend + wxPoint( 0, 100 ), true );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, lineend + wxPoint( 100, 0 ) );
                                line->SetEndPoint( lineend + wxPoint( 100, 0 ) );
                            }
                            else
                            {
                                std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( 0 );
                                ercItem->SetErrorMessage( _( "Bus Entry needed" ) );

                                SCH_MARKER* marker = new SCH_MARKER( ercItem, lineend );
                                m_currentSheet->GetScreen()->Append( marker );
                            }
                        }
                    }
                } // if( linestart.y == lineend.y && busstart.x == busend.x)

                // Test for horizontal wire and vertical bus
                if( linestart.x == lineend.x && busstart.y == busend.y )
                {
                    if( TestSegmentHit( linestart, busstart, busend, 0 ) )
                    {
                        // Wire start is on the bus
                        // If wire end is above the bus,
                        if( lineend.y < busstart.y )
                        {
                            // Test for bus existence to the left of the wire
                            if( TestSegmentHit(
                                        linestart + wxPoint( -100, 0 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        linestart + wxPoint( -100, 0 ), true );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, linestart + wxPoint( 0, -100 ) );
                                line->SetStartPoint( linestart + wxPoint( 0, -100 ) );
                            }
                            else if( TestSegmentHit(
                                             linestart + wxPoint( 100, 0 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        linestart + wxPoint( 0, 100 ), false );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, linestart + wxPoint( 0, -100 ) );
                                line->SetStartPoint( linestart + wxPoint( 0, -100 ) );
                            }
                            else
                            {
                                std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( 0 );
                                ercItem->SetErrorMessage( _( "Bus Entry needed" ) );

                                SCH_MARKER* marker = new SCH_MARKER( ercItem, linestart );
                                m_currentSheet->GetScreen()->Append( marker );
                            }
                        }
                        else // wire end is below the bus.
                        {
                            // Test for bus existence to the left of the wire
                            if( TestSegmentHit(
                                        linestart + wxPoint( -100, 0 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        linestart + wxPoint( -100, 0 ), false );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, linestart + wxPoint( 0, 100 ) );
                                line->SetStartPoint( linestart + wxPoint( 0, 100 ) );
                            }
                            else if( TestSegmentHit(
                                             linestart + wxPoint( 100, 0 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        linestart + wxPoint( 100, 0 ), true );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, linestart + wxPoint( 0, 100 ) );
                                line->SetStartPoint( linestart + wxPoint( 0, 100 ) );
                            }
                            else
                            {
                                std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( 0 );
                                ercItem->SetErrorMessage( _( "Bus Entry needed" ) );

                                SCH_MARKER* marker = new SCH_MARKER( ercItem, linestart );
                                m_currentSheet->GetScreen()->Append( marker );
                            }
                        }
                    }

                    if( TestSegmentHit( lineend, busstart, busend, 0 ) )
                    {
                        // Wire end is on the bus
                        // If wire start is above the bus,

                        if( linestart.y < busstart.y )
                        {
                            // Test for bus existence to the left of the wire
                            if( TestSegmentHit(
                                        lineend + wxPoint( -100, 0 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry =
                                        new SCH_BUS_WIRE_ENTRY( lineend + wxPoint( -100, 0 ),
                                                                true );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, lineend + wxPoint( 0, -100 ) );
                                line->SetEndPoint( lineend + wxPoint( 0, -100 ) );
                            }
                            else if( TestSegmentHit(
                                             lineend + wxPoint( 100, 0 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        lineend + wxPoint( 0, -100 ), false );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, lineend + wxPoint( 0, -100 ) );
                                line->SetEndPoint( lineend + wxPoint( 0, -100 ) );
                            }
                            else
                            {
                                std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( 0 );
                                ercItem->SetErrorMessage( _( "Bus Entry needed" ) );

                                SCH_MARKER* marker = new SCH_MARKER( ercItem, lineend );
                                m_currentSheet->GetScreen()->Append( marker );
                            }
                        }
                        else // wire end is below the bus.
                        {
                            // Test for bus existence to the left of the wire
                            if( TestSegmentHit(
                                        lineend + wxPoint( -100, 0 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY(
                                        lineend + wxPoint( -100, 0 ), false );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, lineend + wxPoint( 0, 100 ) );
                                line->SetEndPoint( lineend + wxPoint( 0, 100 ) );
                            }
                            else if( TestSegmentHit(
                                             lineend + wxPoint( 100, 0 ), busstart, busend, 0 ) )
                            {
                                SCH_BUS_WIRE_ENTRY* busEntry =
                                        new SCH_BUS_WIRE_ENTRY( lineend + wxPoint( 0, 100 ), true );
                                busEntry->SetFlags( IS_NEW );
                                m_currentSheet->GetScreen()->Append( busEntry );
                                moveLabels( line, lineend + wxPoint( 0, 100 ) );
                                line->SetEndPoint( lineend + wxPoint( 0, 100 ) );
                            }
                            else
                            {
                                std::shared_ptr<ERC_ITEM> ercItem = ERC_ITEM::Create( 0 );
                                ercItem->SetErrorMessage( _( "Bus Entry needed" ) );

                                SCH_MARKER* marker = new SCH_MARKER( ercItem, lineend );
                                m_currentSheet->GetScreen()->Append( marker );
                            }
                        }
                    }
                }

                linestart = line->GetStartPoint();
                lineend   = line->GetEndPoint();
                busstart  = bus->GetStartPoint();
                busend    = bus->GetEndPoint();

                // bus entry wire isn't horizontal or vertical
                if( TestSegmentHit( linestart, busstart, busend, 0 ) )
                {
                    wxPoint wirevector = linestart - lineend;

                    if( wirevector.x > 0 )
                    {
                        if( wirevector.y > 0 )
                        {
                            wxPoint             p        = linestart + wxPoint( -100, -100 );
                            SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, false );
                            busEntry->SetFlags( IS_NEW );
                            m_currentSheet->GetScreen()->Append( busEntry );
                            moveLabels( line, p );

                            if( p == lineend ) // wire is overlapped by bus entry symbol
                            {
                                m_currentSheet->GetScreen()->DeleteItem( line );
                                line = nullptr;
                            }
                            else
                            {
                                line->SetStartPoint( p );
                            }
                        }
                        else
                        {
                            wxPoint             p        = linestart + wxPoint( -100, 100 );
                            SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, true );
                            busEntry->SetFlags( IS_NEW );
                            m_currentSheet->GetScreen()->Append( busEntry );

                            moveLabels( line, p );

                            if( p == lineend ) // wire is overlapped by bus entry symbol
                            {
                                m_currentSheet->GetScreen()->DeleteItem( line );
                                line = nullptr;
                            }
                            else
                            {
                                line->SetStartPoint( p );
                            }
                        }
                    }
                    else
                    {
                        if( wirevector.y > 0 )
                        {
                            SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( linestart,
                                                                                   true );
                            busEntry->SetFlags( IS_NEW );
                            m_currentSheet->GetScreen()->Append( busEntry );

                            moveLabels( line, linestart + wxPoint( 100, -100 ) );

                            if( linestart + wxPoint( 100, -100 )
                                    == lineend ) // wire is overlapped by bus entry symbol
                            {
                                m_currentSheet->GetScreen()->DeleteItem( line );
                                line = nullptr;
                            }
                            else
                            {
                                line->SetStartPoint( linestart + wxPoint( 100, -100 ) );
                            }
                        }
                        else
                        {
                            SCH_BUS_WIRE_ENTRY* busEntry =
                                    new SCH_BUS_WIRE_ENTRY( linestart, false );
                            busEntry->SetFlags( IS_NEW );
                            m_currentSheet->GetScreen()->Append( busEntry );
                            moveLabels( line, linestart + wxPoint( 100, 100 ) );

                            if( linestart + wxPoint( 100, 100 )
                                    == lineend ) // wire is overlapped by bus entry symbol
                            {
                                m_currentSheet->GetScreen()->DeleteItem( line );
                                line = nullptr;
                            }
                            else
                            {
                                line->SetStartPoint( linestart + wxPoint( 100, 100 ) );
                            }
                        }
                    }
                }

                if( line && TestSegmentHit( lineend, busstart, busend, 0 ) )
                {
                    wxPoint wirevector = linestart - lineend;

                    if( wirevector.x > 0 )
                    {
                        if( wirevector.y > 0 )
                        {
                            wxPoint             p        = lineend + wxPoint( 100, 100 );
                            SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( lineend, false );
                            busEntry->SetFlags( IS_NEW );
                            m_currentSheet->GetScreen()->Append( busEntry );

                            moveLabels( line, p );

                            if( p == linestart ) // wire is overlapped by bus entry symbol
                            {
                                m_currentSheet->GetScreen()->DeleteItem( line );
                            }
                            else
                            {
                                line->SetEndPoint( p );
                            }
                        }
                        else
                        {
                            wxPoint             p        = lineend + wxPoint( 100, -100 );
                            SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( lineend, true );
                            busEntry->SetFlags( IS_NEW );
                            m_currentSheet->GetScreen()->Append( busEntry );

                            moveLabels( line, p );

                            if( p == linestart ) // wire is overlapped by bus entry symbol
                            {
                                m_currentSheet->GetScreen()->DeleteItem( line );
                            }
                            else
                            {
                                line->SetEndPoint( p );
                            }
                        }
                    }
                    else
                    {
                        if( wirevector.y > 0 )
                        {
                            wxPoint             p        = lineend + wxPoint( -100, 100 );
                            SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, true );
                            busEntry->SetFlags( IS_NEW );
                            m_currentSheet->GetScreen()->Append( busEntry );
                            moveLabels( line, p );

                            if( p == linestart ) // wire is overlapped by bus entry symbol
                            {
                                m_currentSheet->GetScreen()->DeleteItem( line );
                            }
                            else
                            {
                                line->SetEndPoint( p );
                            }
                        }
                        else
                        {
                            wxPoint             p        = lineend + wxPoint( -100, -100 );
                            SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( p, false );
                            busEntry->SetFlags( IS_NEW );
                            m_currentSheet->GetScreen()->Append( busEntry );
                            moveLabels( line, p );

                            if( p == linestart ) // wire is overlapped by bus entry symbol
                            {
                                m_currentSheet->GetScreen()->DeleteItem( line );
                            }
                            else
                            {
                                line->SetEndPoint( p );
                            }
                        }
                    }
                }
            }
        }
    } // for ( bus ..
}

References _, ERC_ITEM::Create(), SCH_LINE::GetEndPoint(), SCH_ITEM::GetLayer(), SCH_LINE::GetStartPoint(), IS_NEW, LAYER_BUS, LAYER_WIRE, SCH_LINE_T, SCH_LINE::SetEndPoint(), EDA_ITEM::SetFlags(), SCH_LINE::SetStartPoint(), and TestSegmentHit().

addImplicitConnections()

void SCH_EAGLE_PLUGIN::addImplicitConnections ( SCH_COMPONENT *  aComponent, 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

aComponent	is the component 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 2796 of file sch_eagle_plugin.cpp.

{
    wxCHECK( aComponent->GetPartRef(), /*void*/ );

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

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

    // Search all units for pins creating implicit connections
    for( const auto& 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( aComponent, pin ) )
                {
                    // Create a net label to force the net name on the pin
                    SCH_GLOBALLABEL* netLabel = new SCH_GLOBALLABEL;
                    netLabel->SetPosition( aComponent->GetPinPhysicalPosition( pin ) );
                    netLabel->SetText( extractNetName( pin->GetName() ) );
                    netLabel->SetTextSize( wxSize( Mils2iu( 40 ), Mils2iu( 40 ) ) );
                    netLabel->SetLabelSpinStyle( LABEL_SPIN_STYLE::LEFT );
                    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 && aComponent->GetPartRef()->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                = aComponent;
            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                = aComponent;

            // 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(), SCH_EAGLE_PLUGIN::EAGLE_MISSING_CMP::cmp, extractNetName(), SCH_COMPONENT::GetField(), SCH_COMPONENT::GetPartRef(), SCH_COMPONENT::GetPinPhysicalPosition(), EDA_TEXT::GetText(), SCH_COMPONENT::GetUnit(), LABEL_SPIN_STYLE::LEFT, pin, PT_POWER_IN, REFERENCE_FIELD, SCH_GLOBALLABEL::SetLabelSpinStyle(), SCH_TEXT::SetPosition(), EDA_TEXT::SetText(), EDA_TEXT::SetTextSize(), and SCH_EAGLE_PLUGIN::EAGLE_MISSING_CMP::units.

adjustNetLabels()

void SCH_EAGLE_PLUGIN::adjustNetLabels ( )

private

Definition at line 2128 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( auto& segDesc : m_segments )
    {
        for( SCH_TEXT* label : segDesc.labels )
        {
            VECTOR2I   labelPos( label->GetPosition() );
            const SEG* segAttached = segDesc.LabelAttached( label );

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


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

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


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

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

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

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

                ++trial;
            }

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

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

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

checkConnections()

bool SCH_EAGLE_PLUGIN::checkConnections ( const SCH_COMPONENT *  aComponent, const LIB_PIN *  aPin  ) const

private

Definition at line 2781 of file sch_eagle_plugin.cpp.

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

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

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

References SCH_COMPONENT::GetPinPhysicalPosition().

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

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

    tempFile.Open( aFileName );
    wxString firstline;

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

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

countNets()

void SCH_EAGLE_PLUGIN::countNets ( wxXmlNode *  aSchematicNode )

private

Definition at line 517 of file sch_eagle_plugin.cpp.

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

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

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

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

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

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

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

        sheetNode = sheetNode->GetNext();
    }
}

References getChildrenNodes(), and MapChildren().

CreateSymbolLib()

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

virtualinherited

Create a new empty symbol library at aLibraryPath.

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

Parameters

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

Exceptions

IO_ERROR

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

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 110 of file sch_plugin.cpp.

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

References not_implemented().

DeleteSymbol()

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

virtualinherited

Delete the entire LIB_PART 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_PART associated with it's root LIB_PART object to delete from the specified library.
aProperties	is an associative array that can be used to tell the library delete function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR

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

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 102 of file sch_plugin.cpp.

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

References not_implemented().

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

DeleteSymbolLib()

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

virtualinherited

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

Parameters

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

Returns

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

Exceptions

IO_ERROR

if there is a problem deleting an existing library.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 117 of file sch_plugin.cpp.

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

References not_implemented().

EnumerateSymbolLib() [1/2]

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

virtualinherited

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

Parameters

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

Exceptions

IO_ERROR

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

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 67 of file sch_plugin.cpp.

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

References not_implemented().

EnumerateSymbolLib() [2/2]

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

virtualinherited

Populate a list of LIB_PART 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_PART pointers associated with the library.
aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing one or more LIB_PART objects.
aProperties	is an associative array that can be used to tell the plugin anything needed about how to perform with respect to aLibraryPath. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR

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

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 76 of file sch_plugin.cpp.

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

References not_implemented().

findNearestLinePoint()

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

private

Definition at line 1100 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 )
    {
        auto 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 SEG::B, and SEG::Center().

fixSymbolName()

wxString SCH_EAGLE_PLUGIN::fixSymbolName ( const wxString &  aName )

staticprivate

Fix invalid characters in Eagle symbol names.

It changes invalid characters to underscores.

Parameters

aName

is the symbol name to be fixed.

Returns

Fixed symbol name.

Definition at line 2877 of file sch_eagle_plugin.cpp.

{
    wxString ret = LIB_ID::FixIllegalChars( aName );

    return ret;
}

References LIB_ID::FixIllegalChars().

GetError()

const wxString & SCH_PLUGIN::GetError ( ) const

virtualinherited

Return an error string to the caller.

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

Returns

an unformatted string containing errors if any.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 177 of file sch_plugin.cpp.

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

References not_implemented().

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

GetFileExtension()

const wxString SCH_EAGLE_PLUGIN::GetFileExtension ( ) const

overridevirtual

Return the file extension for the SCH_PLUGIN.

Implements SCH_PLUGIN.

Definition at line 373 of file sch_eagle_plugin.cpp.

{
    return "sch";
}

getLibFileName()

wxFileName SCH_EAGLE_PLUGIN::getLibFileName ( )

private

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

Definition at line 155 of file sch_eagle_plugin.cpp.

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

    return fn;
}

References KiCadSymbolLibFileExtension.

getLibName()

wxString SCH_EAGLE_PLUGIN::getLibName ( )

private

Definition at line 131 of file sch_eagle_plugin.cpp.

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

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

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

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

    return m_libName;
}

References LIB_ID::FixIllegalChars().

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

{
    return "lbr";
}

GetModifyHash()

int SCH_EAGLE_PLUGIN::GetModifyHash ( ) const

overridevirtual

Return the modification hash from the library cache.

Note

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

Returns

the modification hash of the library cache.

Implements SCH_PLUGIN.

Definition at line 385 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 367 of file sch_eagle_plugin.cpp.

{
    return "EAGLE";
}

IsSymbolLibWritable()

bool SCH_PLUGIN::IsSymbolLibWritable ( const wxString &  aLibraryPath )

virtualinherited

Return true if the library at aLibraryPath is writable.

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

Parameters

aLibraryPath

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

Exceptions

IO_ERROR

if no library at aLibraryPath exists.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 125 of file sch_plugin.cpp.

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

References not_implemented().

kiCadLayer()

SCH_LAYER_ID SCH_EAGLE_PLUGIN::kiCadLayer ( int  aEagleLayer )

private

Return the matching layer or return LAYER_NOTES.

Definition at line 214 of file sch_eagle_plugin.cpp.

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

References LAYER_NOTES.

Load()

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

overridevirtual

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

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

Parameters

aFileName	is the name of the file to use as input and may be foreign in nature or native in nature.
aKiway	is the KIWAY object used to access the component 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 391 of file sch_eagle_plugin.cpp.

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

    // Load the document
    wxXmlDocument xmlDocument;

    m_filename  = aFileName;
    m_schematic = aSchematic;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return m_rootSheet;
}

References _, PROJECT::ELEM_SYMBOL_LIB_TABLE, SYMBOL_LIB_TABLE::Format(), Format(), SYMBOL_LIB_TABLE::GetSymbolLibTableFileName(), LIB_TABLE::HasLibrary(), LIB_TABLE::InsertRow(), SCHEMATIC::IsValid(), KiCadSchematicFileExtension, MapChildren(), NULL, SCH_LEGACY_PLUGIN::PropBuffering, SCHEMATIC::Root(), SCH_SCREEN::SetFileName(), THROW_IO_ERROR, and SCH_SCREENS::UpdateSymbolLinks().

loadDrawing()

void SCH_EAGLE_PLUGIN::loadDrawing ( wxXmlNode *  aDrawingNode )

private

Definition at line 490 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 MapChildren().

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 2116 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().

loadFrame() [1/2]

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

private

Definition at line 862 of file sch_eagle_plugin.cpp.

{
    EFRAME eframe( aFrameNode );

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

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

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

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

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

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

loadFrame() [2/2]

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

private

Definition at line 1885 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_POLYLINE* lines = new LIB_POLYLINE( nullptr );
    lines->AddPoint( wxPoint( xMin, yMin ) );
    lines->AddPoint( wxPoint( xMax, yMin ) );
    lines->AddPoint( wxPoint( xMax, yMax ) );
    lines->AddPoint( wxPoint( xMin, yMax ) );
    lines->AddPoint( wxPoint( xMin, yMin ) );
    aItems.push_back( lines );

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

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

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

        char legendChar = 'A';

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

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

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

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

        char legendChar = 'A';

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

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

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

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

        char legendChar = '1';

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

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

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

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

        char legendChar = '1';

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

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

loadInstance()

void SCH_EAGLE_PLUGIN::loadInstance ( wxXmlNode *  aInstanceNode )

private

Definition at line 1146 of file sch_eagle_plugin.cpp.

{
    auto einstance = EINSTANCE( aInstanceNode );

    SCH_SCREEN* screen = m_currentSheet->GetScreen();

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

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

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

        return;
    }

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

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

    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_PART* 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." ),
                                              kisymbolname ),
                            RPT_SEVERITY_ERROR );
        return;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    bool valueAttributeFound = false;
    bool nameAttributeFound  = false;

    wxXmlNode* attributeNode = aInstanceNode->GetChildren();

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

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

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

            if( field )
            {

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

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

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

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

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

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

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

        attributeNode = attributeNode->GetNext();
    }

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

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

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

    wxCHECK( libSymbol, /*void*/ );

    component->SetLibSymbol( new LIB_PART( *libSymbol ) );

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

    for( const auto& pin : pins )
        m_connPoints[component->GetPinPhysicalPosition( pin )].emplace( pin );

    component->ClearFlags();

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

References _, SCH_SCREEN::Append(), EPART::attribute, ETEXT::BOTTOM_LEFT, EPART::device, EPART::deviceset, eagleToKicadAlignment(), FOOTPRINT_FIELD, Format(), kiCadComponentRotation(), EPART::library, SYMBOL_LIB_TABLE::LoadSymbol(), EATTR::NAME, NULL, EATTR::Off, EAGLE_LIBRARY::package, SCH_SHEET_PATH::PathAsString(), pin, REFERENCE_FIELD, RPT_SEVERITY_ERROR, SCH_FIELD::SetPosition(), EDA_TEXT::SetVisible(), EPART::value, VALUE_FIELD, and EPART::variant.

loadJunction()

SCH_JUNCTION * SCH_EAGLE_PLUGIN::loadJunction ( wxXmlNode *  aJunction )

private

Definition at line 1042 of file sch_eagle_plugin.cpp.

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

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

    junction->SetPosition( pos );

    return junction.release();
}

loadLabel()

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

private

Definition at line 1055 of file sch_eagle_plugin.cpp.

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

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

    wxSize textSize;

    if( global )
    {
        label = std::make_unique<SCH_GLOBALLABEL>();
        textSize = wxSize( KiROUND( elabel.size.ToSchUnits() * 0.75 ),
                           KiROUND( elabel.size.ToSchUnits() * 0.75 ) );
    }
    else
    {
        label = std::make_unique<SCH_LABEL>();
        textSize = wxSize( KiROUND( elabel.size.ToSchUnits() * 0.85 ),
                           KiROUND( elabel.size.ToSchUnits() * 0.85 ) );
    }

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

    if( elabel.rot )
    {
        label->SetLabelSpinStyle(
                (LABEL_SPIN_STYLE::SPIN) ( KiROUND( elabel.rot->degrees / 90 ) % 4 ) );

        if( elabel.rot->mirror )
        {
            label->SetLabelSpinStyle( label->GetLabelSpinStyle().MirrorY() );
        }
    }

    return label.release();
}

References escapeName(), KiROUND(), and LABEL_SPIN_STYLE::RIGHT.

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 163 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 auto& elayer : eagleLayers )
    {
        if( elayer.name == "Nets" )
        {
            m_layerMap[elayer.number] = LAYER_WIRE;
        }
        else if( elayer.name == "Info" || elayer.name == "Guide" )
        {
            m_layerMap[elayer.number] = LAYER_NOTES;
        }
        else if( elayer.name == "Busses" )
        {
            m_layerMap[elayer.number] = LAYER_BUS;
        }
    }
}

References LAYER_BUS, LAYER_NOTES, and LAYER_WIRE.

loadLibrary()

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

private

Definition at line 1366 of file sch_eagle_plugin.cpp.

{
    NODE_MAP libraryChildren = MapChildren( aLibraryNode );

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

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

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

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

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

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

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

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

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

            // Create KiCad symbol.
            unique_ptr<LIB_PART> kpart( new LIB_PART( symbolName ) );

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

            LIB_FIELD* reference = kpart->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 )
            {
                EGATE egate = EGATE( gateNode );

                aEagleLibrary->GateUnit[edeviceset.name + edevice.name + egate.name] = gateindex;

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

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

            kpart->SetUnitCount( gates_count );

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

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

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

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

    return aEagleLibrary;
}

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

loadPin()

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

private

Definition at line 1763 of file sch_eagle_plugin.cpp.

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

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

    switch( roti )
    {
    default:
        wxASSERT_MSG( false, wxString::Format( "Unhandled orientation (%d degrees)", roti ) );
        KI_FALLTHROUGH;

    case 0:
        pin->SetOrientation( 'R' );
        break;

    case 90:
        pin->SetOrientation( 'U' );
        break;

    case 180:
        pin->SetOrientation( 'L' );
        break;

    case 270:
        pin->SetOrientation( 'D' );
        break;
    }

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

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

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

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

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

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

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

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

    return pin.release();
}

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

loadPlainText()

SCH_TEXT * SCH_EAGLE_PLUGIN::loadPlainText ( wxXmlNode *  aSchText )

private

Definition at line 2062 of file sch_eagle_plugin.cpp.

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

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

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

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

        tmp = tmp.Trim( false );

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

        adjustedText += tmp;
    }

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

    return schtext.release();
}

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

loadSchematic()

void SCH_EAGLE_PLUGIN::loadSchematic ( wxXmlNode *  aSchematicNode )

private

Definition at line 551 of file sch_eagle_plugin.cpp.

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

    if( !partNode || !libraryNode || !sheetNode )
        return;

    while( partNode )
    {
        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();
    }

    // Loop through all the libraries
    while( libraryNode )
    {
        // Read the library name
        wxString libName = libraryNode->GetAttribute( "name" );

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

        loadLibrary( libraryNode, &m_eagleLibs[libName] );

        libraryNode = libraryNode->GetNext();
    }

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

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

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

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

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

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

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

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

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

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

    // Handle the missing component 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 components
    wxSize   pageSizeIU = m_rootSheet->GetScreen()->GetPageSettings().GetSizeIU();
    EDA_RECT sheetBbox  = getSheetBbox( m_rootSheet );
    wxPoint  newCmpPosition( sheetBbox.GetLeft(), sheetBbox.GetBottom() );
    int      maxY = sheetBbox.GetY();

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

    for( auto& cmp : m_missingCmps )
    {
        const SCH_COMPONENT* origCmp = cmp.second.cmp;

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

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

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

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

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

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

    m_missingCmps.clear();
}

References countChildren(), SCH_ITEM::Duplicate(), EDA_RECT::GetBottom(), getChildrenNodes(), SCH_COMPONENT::GetField(), EDA_RECT::GetHeight(), EDA_RECT::GetLeft(), getSheetBbox(), EDA_TEXT::GetText(), EDA_RECT::GetWidth(), EDA_RECT::GetY(), MapChildren(), EAGLE_LIBRARY::name, SCH_SHEET_PATH::Path(), and REFERENCE_FIELD.

loadSegments()

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

private

Definition at line 897 of file sch_eagle_plugin.cpp.

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

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

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

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

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

                if( !firstWire )
                    firstWire = wire;

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

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

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

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

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

            segmentAttribute = segmentAttribute->GetNext();
        }

        segmentAttribute = currentSegment->GetChildren();

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

            if( nodeName == "junction" )
            {
                screen->Append( loadJunction( segmentAttribute ) );
            }
            else if( nodeName == "label" )
            {
                SCH_TEXT* label = loadLabel( segmentAttribute, netName );
                screen->Append( label );
                wxASSERT( segDesc.labels.empty()
                          || segDesc.labels.front()->GetText() == label->GetText() );
                segDesc.labels.push_back( label );
                labelled = true;
            }
            else if( nodeName == "pinref" )
            {
                segmentAttribute->GetAttribute( "gate" ); // REQUIRED
                segmentAttribute->GetAttribute( "part" ); // REQUIRED
                segmentAttribute->GetAttribute( "pin" );  // REQUIRED
            }
            else if( nodeName == "wire" )
            {
                // already handled;
            }
            else // DEFAULT
            {
                // THROW_IO_ERROR( wxString::Format( _( "XML node \"%s\" unknown" ), nodeName ) );
            }

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

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

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

            if( label )
            {
                label->SetPosition( firstWire->GetStartPoint() );
                label->SetText( escapeName( netName ) );
                label->SetTextSize( wxSize( Mils2iu( 40 ), Mils2iu( 40 ) ) );
                label->SetLabelSpinStyle( LABEL_SPIN_STYLE::LEFT );
                screen->Append( label.release() );
            }
        }

        currentSegment = currentSegment->GetNext();
    }
}

References SCH_SCREEN::Append(), countChildren(), escapeName(), SCH_LINE::GetEndPoint(), SCH_LINE::GetStartPoint(), EDA_TEXT::GetText(), SEG::Intersect(), SCH_EAGLE_PLUGIN::SEG_DESC_STRUCT::labels, LABEL_SPIN_STYLE::LEFT, MapChildren(), and SCH_EAGLE_PLUGIN::SEG_DESC_STRUCT::segs.

loadSheet()

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

private

Definition at line 689 of file sch_eagle_plugin.cpp.

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

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

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

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

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

    wxString fn = wxString( filename + "." + KiCadSchematicFileExtension );
    filenameField.SetText( fn );
    wxFileName fileName( fn );
    m_currentSheet->GetScreen()->SetFileName( fileName.GetFullPath() );
    m_currentSheet->AutoplaceFields( m_currentSheet->GetScreen(), true );


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            loadFrame( plainNode, lines );

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

        plainNode = plainNode->GetNext();
    }

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

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

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

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

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

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

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

    // Add global net labels for the named power input pins in this sheet
    for( auto item : m_currentSheet->GetScreen()->Items().OfType( SCH_COMPONENT_T ) )
        addImplicitConnections(
                static_cast<SCH_COMPONENT*>( item ), m_currentSheet->GetScreen(), true );

    m_connPoints.clear();

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

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

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

    }
}

References EDA_RECT::Centre(), Format(), getChildrenNodes(), getSheetBbox(), EDA_RECT::GetSize(), KiCadSchematicFileExtension, MapChildren(), SCH_FIELD::Replace(), ReplaceIllegalFileNameChars(), SCH_COMPONENT_T, PAGE_INFO::SetHeightMils(), EDA_TEXT::SetText(), PAGE_INFO::SetWidthMils(), SHEETFILENAME, and SHEETNAME.

loadSymbol()

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

private

Definition at line 1464 of file sch_eagle_plugin.cpp.

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

    wxXmlNode* currentNode = aSymbolNode->GetChildren();

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

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

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

            pin->SetType( ELECTRICAL_PINTYPE::PT_BIDI );

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

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

                        break;
                    }
                }
            }


            if( aDevice->connects.size() != 0 )
            {
                for( const auto& 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 );
                            aPart->AddDrawItem( apin );
                        }

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

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

            loadFrame( currentNode, frameItems );

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

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

        currentNode = currentNode->GetNext();
    }

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

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

    return pincount == 1 ? ispower : false;
}

References EDEVICE::connects, EPIN::direction, escapeName(), Format(), pin, pinDirectionsMap, PT_BIDI, REFERENCE_FIELD, LIB_PIN::SetNumber(), and VALUE_FIELD.

LoadSymbol()

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

virtualinherited

Load a LIB_PART 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_PART to load.
aProperties	is an associative array that can be used to tell the loader implementation to do something special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Returns

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

Exceptions

IO_ERROR

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

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 85 of file sch_plugin.cpp.

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

References not_implemented(), and NULL.

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

loadSymbolCircle()

LIB_CIRCLE * SCH_EAGLE_PLUGIN::loadSymbolCircle ( std::unique_ptr< LIB_PART > &  aPart, wxXmlNode *  aCircleNode, int  aGateNumber  )

private

Definition at line 1614 of file sch_eagle_plugin.cpp.

{
    // Parse the circle properties
    ECIRCLE c( aCircleNode );

    unique_ptr<LIB_CIRCLE> circle( new LIB_CIRCLE( aPart.get() ) );

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

    return circle.release();
}

References ECIRCLE::radius, ECOORD::ToSchUnits(), ECIRCLE::width, ECIRCLE::x, and ECIRCLE::y.

loadSymbolPolyLine()

LIB_POLYLINE * SCH_EAGLE_PLUGIN::loadSymbolPolyLine ( std::unique_ptr< LIB_PART > &  aPart, wxXmlNode *  aPolygonNode, int  aGateNumber  )

private

Definition at line 1735 of file sch_eagle_plugin.cpp.

{
    std::unique_ptr<LIB_POLYLINE> polyLine = std::make_unique<LIB_POLYLINE>( aPart.get() );

    EPOLYGON   epoly( aPolygonNode );
    wxXmlNode* vertex = aPolygonNode->GetChildren();
    wxPoint    pt;

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

        vertex = vertex->GetNext();
    }

    polyLine->SetFillMode( FILL_TYPE::FILLED_SHAPE );
    polyLine->SetUnit( aGateNumber );

    return polyLine.release();
}

References FILLED_SHAPE, ECOORD::ToSchUnits(), EVERTEX::x, and EVERTEX::y.

loadSymbolRectangle()

LIB_RECTANGLE * SCH_EAGLE_PLUGIN::loadSymbolRectangle ( std::unique_ptr< LIB_PART > &  aPart, wxXmlNode *  aRectNode, int  aGateNumber  )

private

Definition at line 1631 of file sch_eagle_plugin.cpp.

{
    ERECT rect( aRectNode );

    unique_ptr<LIB_RECTANGLE> rectangle( new LIB_RECTANGLE( aPart.get() ) );

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

    rectangle->SetUnit( aGateNumber );

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

    return rectangle.release();
}

References FILLED_SHAPE, ECOORD::ToSchUnits(), ERECT::x1, ERECT::x2, ERECT::y1, and ERECT::y2.

loadSymbolText()

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

private

Definition at line 1860 of file sch_eagle_plugin.cpp.

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

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

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

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

    return libtext.release();
}

References text.

loadSymbolWire()

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

private

Definition at line 1650 of file sch_eagle_plugin.cpp.

{
    auto ewire = EWIRE( aWireNode );

    wxPoint begin, end;

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

    if( begin == end )
        return nullptr;

    // if the wire is an arc
    if( ewire.curve )
    {
        std::unique_ptr<LIB_ARC> arc    = std::make_unique<LIB_ARC>( aPart.get() );
        wxPoint                  center = ConvertArcCenter( begin, end, *ewire.curve * -1 );

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

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

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

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

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

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

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

        arc->SetPosition( center );

        if( *ewire.curve > 0 )
        {
            arc->SetStart( begin );
            arc->SetEnd( end );
        }
        else
        {
            arc->SetStart( end );
            arc->SetEnd( begin );
        }

        arc->SetRadius( radius );
        arc->CalcRadiusAngles();
        arc->SetUnit( aGateNumber );

        return (LIB_ITEM*) arc.release();
    }
    else
    {
        std::unique_ptr<LIB_POLYLINE> polyLine = std::make_unique<LIB_POLYLINE>( aPart.get() );

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

        return (LIB_ITEM*) polyLine.release();
    }
}

References ConvertArcCenter(), and FILLED_SHAPE.

loadTextAttributes()

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

private

Definition at line 2094 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.

loadWire()

SCH_LINE * SCH_EAGLE_PLUGIN::loadWire ( wxXmlNode *  aWireNode )

private

Definition at line 1017 of file sch_eagle_plugin.cpp.

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

    auto ewire = EWIRE( aWireNode );

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

    wxPoint begin, end;

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

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

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

    return wire.release();
}

moveLabels()

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

private

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

Definition at line 2224 of file sch_eagle_plugin.cpp.

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

References EDA_ITEM::GetBoundingBox(), SCH_GLOBAL_LABEL_T, SCH_LABEL_T, and TestSegmentHit().

netHasPowerDriver()

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

private

Save()

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

virtualinherited

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

Parameters

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

Exceptions

IO_ERROR

if there is a problem saving or exporting.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 59 of file sch_plugin.cpp.

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

References not_implemented().

SaveLibrary()

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

virtualinherited

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 45 of file sch_plugin.cpp.

{
    not_implemented( this, __FUNCTION__ );
}

References not_implemented().

SaveSymbol()

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

virtualinherited

Write aSymbol to an existing library located at aLibraryPath.

If a LIB_PART by the same name already exists or there are any conflicting alias names, the new LIB_PART 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_PART pointers that may have changed.
aProperties	is an associative array that can be used to tell the saver how to save the symbol, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR

if there is a problem saving.

Reimplemented in SCH_LEGACY_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 94 of file sch_plugin.cpp.

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

References not_implemented().

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

SetReporter()

void SCH_EAGLE_PLUGIN::SetReporter ( REPORTER *  aReporter )

inlineoverridevirtual

Set an optional reporter for warnings/errors.

Reimplemented from SCH_PLUGIN.

Definition at line 89 of file sch_eagle_plugin.h.

{ m_reporter = aReporter; }

References m_reporter.

SymbolLibOptions()

void SCH_PLUGIN::SymbolLibOptions ( PROPERTIES *  aListToAppendTo ) const

virtualinherited

Append supported SCH_PLUGIN options to aListToAppenTo along with internationalized descriptions.

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

Parameters

aListToAppendTo

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

Definition at line 133 of file sch_plugin.cpp.

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

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

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

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

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

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

References _.

translateEagleBusName()

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

private

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

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

Parameters

aEagleName

is the name of the bus from the Eagle schematic

Definition at line 2885 of file sch_eagle_plugin.cpp.

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

    wxString ret = "{";

    wxStringTokenizer tokenizer( aEagleName, "," );

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

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

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

        ret << member << " ";
    }

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

    return ret;
}

References NET_SETTINGS::ParseBusVector().

Member Data Documentation

m_connPoints

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

private

Definition at line 259 of file sch_eagle_plugin.h.

m_currentSheet

SCH_SHEET* SCH_EAGLE_PLUGIN::m_currentSheet

private

The current sheet of the schematic being loaded.

Definition at line 223 of file sch_eagle_plugin.h.

m_eagleLibs

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

private

Definition at line 230 of file sch_eagle_plugin.h.

m_filename

wxFileName SCH_EAGLE_PLUGIN::m_filename

private

Definition at line 225 of file sch_eagle_plugin.h.

m_layerMap

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

private

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

Definition at line 236 of file sch_eagle_plugin.h.

m_libName

wxString SCH_EAGLE_PLUGIN::m_libName

private

Library name to save symbols.

Definition at line 226 of file sch_eagle_plugin.h.

m_missingCmps

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

private

Definition at line 220 of file sch_eagle_plugin.h.

m_netCounts

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

private

Definition at line 235 of file sch_eagle_plugin.h.

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 256 of file sch_eagle_plugin.h.

m_partlist

EPART_MAP SCH_EAGLE_PLUGIN::m_partlist

private

Definition at line 229 of file sch_eagle_plugin.h.

m_pi

SCH_PLUGIN::SCH_PLUGIN_RELEASER SCH_EAGLE_PLUGIN::m_pi

private

Plugin to create the KiCad symbol library.

Definition at line 232 of file sch_eagle_plugin.h.

m_properties

std::unique_ptr< PROPERTIES > SCH_EAGLE_PLUGIN::m_properties

private

Library plugin properties.

Definition at line 233 of file sch_eagle_plugin.h.

m_reporter

REPORTER* SCH_EAGLE_PLUGIN::m_reporter

private

Reporter for warnings/errors.

Map references to missing component units data

Definition at line 217 of file sch_eagle_plugin.h.

Referenced by SetReporter().

m_rootSheet

SCH_SHEET* SCH_EAGLE_PLUGIN::m_rootSheet

private

The root sheet of the schematic being loaded.

Definition at line 222 of file sch_eagle_plugin.h.

m_schematic

SCHEMATIC* SCH_EAGLE_PLUGIN::m_schematic

private

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

Definition at line 227 of file sch_eagle_plugin.h.

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 253 of file sch_eagle_plugin.h.

m_version

wxString SCH_EAGLE_PLUGIN::m_version

private

Eagle file version.

Definition at line 224 of file sch_eagle_plugin.h.

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 240 of file sch_eagle_plugin.h.

---

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

• sch_eagle_plugin.h
• sch_eagle_plugin.cpp