#include <pcb.h>

Inheritance diagram for PCAD2KICAD::PCB:

Public Member Functions
	PCB (BOARD *aBoard)

	~PCB ()

PCB_LAYER_ID	GetKiCadLayer (int aPCadLayer) const override

LAYER_TYPE_T	GetLayerType (int aPCadLayer) const override

wxString	GetLayerNetNameRef (int aPCadLayer) const override

int	GetNetCode (const wxString &aNetName) const override

void	ParseBoard (wxStatusBar aStatusBar, wxXmlDocument aXmlDoc, const wxString &aActualConversion)

void	AddToBoard () override

XNODE *	FindModulePatternDefName (XNODE *aNode, const wxString &aName)

void	DoLayerContentsObjects (XNODE aNode, PCB_FOOTPRINT aFootprint, PCB_COMPONENTS_ARRAY aList, wxStatusBar aStatusBar, const wxString &aDefaultMeasurementUnit, const wxString &aActualConversion)

void	SetName (const wxString &aPin, const wxString &aName)

virtual void	Parse (XNODE aNode, wxStatusBar aStatusBar, const wxString &aDefaultMeasurementUnit, const wxString &aActualConversion)

virtual void	Flip () override

virtual void	SetPosOffset (int aX_offs, int aY_offs)

virtual void	AddToFootprint (FOOTPRINT *aFootprint)

PCB_LAYER_ID	GetKiCadLayer () const

Public Attributes
PCB_COMPONENTS_ARRAY	m_PcbComponents

PCB_NETS_ARRAY	m_PcbNetlist

wxString	m_DefaultMeasurementUnit

std::map< int, TLAYER >	m_LayersMap

int	m_SizeX

int	m_SizeY

TTEXTVALUE	m_Value

PCB_COMPONENTS_ARRAY	m_FootprintItems

int	m_Mirror

VERTICES_ARRAY	m_BoardOutline

int	m_tag

char	m_objType

int	m_PCadLayer

PCB_LAYER_ID	m_KiCadLayer

KIID	m_uuid

int	m_positionX

int	m_positionY

EDA_ANGLE	m_rotation

TTEXTVALUE	m_name

wxString	m_net

int	m_netCode

wxString	m_compRef

wxString	m_patGraphRefName

Protected Attributes
PCB_CALLBACKS *	m_callbacks

BOARD *	m_board

Private Member Functions
XNODE *	FindCompDefName (XNODE *aNode, const wxString &aName) const

void	SetTextProperty (XNODE aNode, TTEXTVALUE aTextValue, const wxString &aPatGraphRefName, const wxString &aXmlName, const wxString &aActualConversion)

void	DoPCBComponents (XNODE aNode, wxXmlDocument aXmlDoc, const wxString &aActualConversion, wxStatusBar *aStatusBar)

void	ConnectPinToNet (const wxString &aCr, const wxString &aPr, const wxString &aNetName)

int	FindLayer (const wxString &aLayerName) const

void	MapLayer (XNODE *aNode)

int	FindOutlinePoint (const VERTICES_ARRAY *aOutline, wxRealPoint aPoint) const

double	GetDistance (const wxRealPoint aPoint1, const wxRealPoint aPoint2) const

void	GetBoardOutline (wxXmlDocument *aXmlDoc, const wxString &aActualConversion)

XNODE *	FindPatternMultilayerSection (XNODE aNode, wxString aPatGraphRefName)

Private Attributes
std::vector< std::pair< wxString, long > >	m_layersStackup

Detailed Description

Definition at line 46 of file pcb.h.

Constructor & Destructor Documentation

◆ PCB()

PCAD2KICAD::PCB::PCB ( BOARD * aBoard )

Definition at line 78 of file pcb.cpp.

 :
 PCB_FOOTPRINT( this, aBoard )
{
 m_DefaultMeasurementUnit = wxT( "mil" );
 
 for( size_t i = 0; i < 8; ++i )
 {
 TLAYER layer;
 layer.KiCadLayer = F_Mask; // default
 layer.layerType = LAYER_TYPE_NONSIGNAL; // default
 layer.netNameRef = wxT( "" ); // default
 
 m_LayersMap.insert( std::make_pair( i, layer ) );
 }
 
 m_SizeX = 0;
 m_SizeY = 0;
 
 m_LayersMap[1].KiCadLayer = F_Cu;
 m_LayersMap[1].layerType = LAYER_TYPE_SIGNAL;
 
 m_LayersMap[2].KiCadLayer = B_Cu;
 m_LayersMap[2].layerType = LAYER_TYPE_SIGNAL;
 
 m_LayersMap[3].KiCadLayer = Eco2_User;
 m_LayersMap[6].KiCadLayer = F_SilkS;
 m_LayersMap[7].KiCadLayer = B_SilkS;
}

References B_Cu, B_SilkS, Eco2_User, F_Cu, F_Mask, F_SilkS, TLAYER::KiCadLayer, LAYER_TYPE_NONSIGNAL, LAYER_TYPE_SIGNAL, TLAYER::layerType, m_DefaultMeasurementUnit, m_LayersMap, m_SizeX, m_SizeY, and TLAYER::netNameRef.

◆ ~PCB()

PCAD2KICAD::PCB::~PCB ( )

Definition at line 108 of file pcb.cpp.

{
 int i;
 
 for( i = 0; i < (int) m_PcbComponents.GetCount(); i++ )
 {
 delete m_PcbComponents[i];
 }
 
 for( i = 0; i < (int) m_PcbNetlist.GetCount(); i++ )
 {
 delete m_PcbNetlist[i];
 }
}

References m_PcbComponents, and m_PcbNetlist.

Member Function Documentation

◆ AddToBoard()

void PCAD2KICAD::PCB::AddToBoard ( )

overridevirtual

Implements PCAD2KICAD::PCB_COMPONENT.

Definition at line 944 of file pcb.cpp.

{
 int i;
 PCB_NET* net;
 
 m_board->SetCopperLayerCount( m_layersStackup.size() );
 
 for( i = 0; i < (int) m_PcbNetlist.GetCount(); i++ )
 {
 net = m_PcbNetlist[i];
 
 m_board->Add( new NETINFO_ITEM( m_board, net->m_Name, net->m_NetCode ) );
 }
 
 for( i = 0; i < (int) m_PcbComponents.GetCount(); i++ )
 {
 m_PcbComponents[i]->AddToBoard();
 }
}

References BOARD::Add(), PCAD2KICAD::PCB_COMPONENT::m_board, m_layersStackup, PCAD2KICAD::PCB_NET::m_Name, PCAD2KICAD::PCB_NET::m_NetCode, m_PcbComponents, m_PcbNetlist, and BOARD::SetCopperLayerCount().

Referenced by PCAD_PLUGIN::Load().

◆ AddToFootprint()

void PCAD2KICAD::PCB_COMPONENT::AddToFootprint ( FOOTPRINT * aFootprint )

virtualinherited

Reimplemented in PCAD2KICAD::PCB_ARC, PCAD2KICAD::PCB_LINE, PCAD2KICAD::PCB_PAD, PCAD2KICAD::PCB_POLYGON, and PCAD2KICAD::PCB_TEXT.

Definition at line 62 of file pcb_component.cpp.

63{

64}

Referenced by PCAD2KICAD::PCB_FOOTPRINT::AddToBoard().

◆ ConnectPinToNet()

void PCAD2KICAD::PCB::ConnectPinToNet	(	const wxString &	aCr,
		const wxString &	aPr,
		const wxString &	aNetName
	)

private

Definition at line 427 of file pcb.cpp.

{
 PCB_FOOTPRINT* footprint;
 PCB_PAD* cp;
 int i, j;
 
 for( i = 0; i < (int) m_PcbComponents.GetCount(); i++ )
 {
 footprint = (PCB_FOOTPRINT*) m_PcbComponents[i];
 
 if( footprint->m_objType == wxT( 'M' ) && footprint->m_name.text == aCompRef )
 {
 for( j = 0; j < (int) footprint->m_FootprintItems.GetCount(); j++ )
 {
 if( footprint->m_FootprintItems[j]->m_objType == wxT( 'P' ) )
 {
 cp = (PCB_PAD*) footprint->m_FootprintItems[j];
 
 if( cp->m_name.text == aPinRef )
 cp->m_net = aNetName;
 }
 }
 }
 }
}

References PCAD2KICAD::PCB_FOOTPRINT::m_FootprintItems, PCAD2KICAD::PCB_COMPONENT::m_name, PCAD2KICAD::PCB_COMPONENT::m_net, PCAD2KICAD::PCB_COMPONENT::m_objType, m_PcbComponents, and PCAD2KICAD::TTEXTVALUE::text.

Referenced by ParseBoard().

◆ DoLayerContentsObjects()

void PCAD2KICAD::PCB_FOOTPRINT::DoLayerContentsObjects	(	XNODE *	aNode,
		PCB_FOOTPRINT *	aFootprint,
		PCB_COMPONENTS_ARRAY *	aList,
		wxStatusBar *	aStatusBar,
		const wxString &	aDefaultMeasurementUnit,
		const wxString &	aActualConversion
	)

inherited

Definition at line 217 of file pcb_footprint.cpp.

{
 PCB_ARC* arc;
 PCB_POLYGON* polygon;
 PCB_POLYGON *plane_layer = nullptr;
 PCB_COPPER_POUR* copperPour;
 PCB_CUTOUT* cutout;
 PCB_PLANE* plane;
 VERTICES_ARRAY* plane_layer_polygon;
 PCB_LINE* line;
 PCB_TEXT* text;
 XNODE* lNode, * tNode;
 wxString propValue;
 long long i;
 int PCadLayer;
 long num = 0;
 
 i = 0;
 
 // aStatusBar->SetStatusText( wxT( "Processing LAYER CONTENT OBJECTS " ) );
 if( FindNode( aNode, wxT( "layerNumRef" ) ) )
 FindNode( aNode, wxT( "layerNumRef" ) )->GetNodeContent().ToLong( &num );
 
 PCadLayer = (int) num;
 
 if( m_callbacks->GetLayerType( PCadLayer ) == LAYER_TYPE_PLANE )
 {
 plane_layer = new PCB_POLYGON( m_callbacks, m_board, PCadLayer );
 plane_layer->AssignNet( m_callbacks->GetLayerNetNameRef( PCadLayer ) );
 plane_layer->SetOutline( &m_BoardOutline );
 aList->Add( plane_layer );
 
 // fill the polygon with the same contour as its outline is
 //plane_layer->AddIsland( &m_boardOutline );
 }
 
 lNode = aNode->GetChildren();
 
 while( lNode )
 {
 i++;
 // aStatusBar->SetStatusText( wxString::Format( "Processing LAYER CONTENT OBJECTS :%lld",
 // i ) );
 
 if( lNode->GetName() == wxT( "line" ) )
 {
 line = new PCB_LINE( m_callbacks, m_board );
 line->Parse( lNode, PCadLayer, aDefaultMeasurementUnit, aActualConversion );
 aList->Add( line );
 }
 
 if( lNode->GetName() == wxT( "text" ) )
 {
 text = new PCB_TEXT( m_callbacks, m_board );
 text->Parse( lNode, PCadLayer, aDefaultMeasurementUnit, aActualConversion );
 aList->Add( text );
 }
 
 // added as Sergeys request 02/2008
 if( lNode->GetName() == wxT( "attr" ) )
 {
 // assign fonts to Module Name,Value,Type,....s
 lNode->GetAttribute( wxT( "Name" ), &propValue );
 propValue.Trim( false );
 propValue.Trim( true );
 
 if( propValue == wxT( "RefDes" ) )
 {
 tNode = FindNode( lNode, wxT( "textStyleRef" ) );
 
 if( tNode && aFootprint )
 {
 // TODO: to understand and may be repair
 // Alexander Lunev: originally in Delphi version of the project there was
 // a strange access to pcbModule->m_name (it was global variable). This access
 // is necessary when the function DoLayerContentsObjects() is called from
 // function CreatePCBModule(). However it is not clear whether the access is
 // required when the function DoLayerContentsObjects() is called from
 // function ProcessXMLtoPCBLib().
 SetFontProperty( tNode, &aFootprint->m_name, aDefaultMeasurementUnit,
 aActualConversion );
 }
 }
 }
 
 // added as Sergeys request 02/2008
 if( lNode->GetName() == wxT( "arc" ) || lNode->GetName() == wxT( "triplePointArc" ) )
 {
 arc = new PCB_ARC( m_callbacks, m_board );
 arc->Parse( lNode, PCadLayer, aDefaultMeasurementUnit, aActualConversion );
 aList->Add( arc );
 }
 
 if( lNode->GetName() == wxT( "pcbPoly" ) )
 {
 if( m_callbacks->GetLayerType( PCadLayer ) == LAYER_TYPE_PLANE )
 {
 plane_layer_polygon = new VERTICES_ARRAY;
 wxASSERT( plane_layer );
 plane_layer->FormPolygon( lNode, plane_layer_polygon, aDefaultMeasurementUnit,
 aActualConversion );
 plane_layer->m_cutouts.Add( plane_layer_polygon );
 }
 else
 {
 polygon = new PCB_POLYGON( m_callbacks, m_board, PCadLayer );
 
 if( polygon->Parse( lNode, aDefaultMeasurementUnit, aActualConversion ) )
 aList->Add( polygon );
 else
 delete polygon;
 }
 }
 
 if( lNode->GetName() == wxT( "copperPour95" ) )
 {
 copperPour = new PCB_COPPER_POUR( m_callbacks, m_board, PCadLayer );
 
 if( copperPour->Parse( lNode, aDefaultMeasurementUnit, aActualConversion ) )
 aList->Add( copperPour );
 else
 delete copperPour;
 }
 
 if( lNode->GetName() == wxT( "polyCutOut" ) )
 {
 cutout = new PCB_CUTOUT( m_callbacks, m_board, PCadLayer );
 
 if( cutout->Parse( lNode, aDefaultMeasurementUnit, aActualConversion ) )
 aList->Add( cutout );
 else
 delete cutout;
 }
 
 if( lNode->GetName() == wxT( "planeObj" ) )
 {
 plane = new PCB_PLANE( m_callbacks, m_board, PCadLayer );
 
 if( plane->Parse( lNode, aDefaultMeasurementUnit, aActualConversion ) )
 aList->Add( plane );
 else
 delete plane;
 }
 
 lNode = lNode->GetNext();
 }
}

References PCAD2KICAD::PCB_POLYGON::AssignNet(), PCAD2KICAD::FindNode(), PCAD2KICAD::PCB_POLYGON::FormPolygon(), XNODE::GetChildren(), PCAD2KICAD::PCB_CALLBACKS::GetLayerNetNameRef(), PCAD2KICAD::PCB_CALLBACKS::GetLayerType(), XNODE::GetNext(), LAYER_TYPE_PLANE, PCAD2KICAD::PCB_COMPONENT::m_board, PCAD2KICAD::PCB_FOOTPRINT::m_BoardOutline, PCAD2KICAD::PCB_COMPONENT::m_callbacks, PCAD2KICAD::PCB_POLYGON::m_cutouts, PCAD2KICAD::PCB_COMPONENT::m_name, PCAD2KICAD::PCB_CUTOUT::Parse(), PCAD2KICAD::PCB_POLYGON::Parse(), PCAD2KICAD::PCB_COPPER_POUR::Parse(), PCAD2KICAD::PCB_PLANE::Parse(), PCAD2KICAD::PCB_ARC::Parse(), PCAD2KICAD::PCB_LINE::Parse(), PCAD2KICAD::SetFontProperty(), PCAD2KICAD::PCB_POLYGON::SetOutline(), and text.

Referenced by PCAD2KICAD::PCB_FOOTPRINT::Parse(), and ParseBoard().

◆ DoPCBComponents()

void PCAD2KICAD::PCB::DoPCBComponents	(	XNODE *	aNode,
		wxXmlDocument *	aXmlDoc,
		const wxString &	aActualConversion,
		wxStatusBar *	aStatusBar
	)

private

Definition at line 238 of file pcb.cpp.

{
 XNODE* lNode, * tNode, * mNode;
 PCB_FOOTPRINT* fp;
 PCB_PAD* pad;
 PCB_VIA* via;
 PCB_KEEPOUT* keepOut;
 wxString cn, str, propValue;
 
 lNode = aNode->GetChildren();
 
 while( lNode )
 {
 fp = nullptr;
 
  if( lNode->GetName().IsSameAs( wxT( "pattern" ), false ) )
 {
 FindNode( lNode, wxT( "patternRef" ) )->GetAttribute( wxT( "Name" ),
 &cn );
 cn = ValidateName( cn );
 tNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "library" ) );
 
 if( tNode && cn.Len() > 0 )
 {
 tNode = FindModulePatternDefName( tNode, cn );
 
 if( tNode )
 {
 fp = new PCB_FOOTPRINT( this, m_board );
 
 mNode = FindNode( lNode, wxT( "patternGraphicsNameRef" ) );
 
 if( mNode )
 mNode->GetAttribute( wxT( "Name" ), &fp->m_patGraphRefName );
 
 fp->Parse( tNode, aStatusBar, m_DefaultMeasurementUnit, aActualConversion );
 }
 }
 
 if( fp )
 {
 fp->m_compRef = cn; // default - in new version of file it is updated later....
 tNode = FindNode( lNode, wxT( "refDesRef" ) );
 
 if( tNode )
 {
 tNode->GetAttribute( wxT( "Name" ), &fp->m_name.text );
 SetTextProperty( lNode, &fp->m_name, fp->m_patGraphRefName, wxT( "RefDes" ),
 aActualConversion );
 SetTextProperty( lNode, &fp->m_Value, fp->m_patGraphRefName, wxT( "Value" ),
 aActualConversion );
 }
 
 tNode = FindNode( lNode, wxT( "pt" ) );
 
 if( tNode )
 {
 SetPosition( tNode->GetNodeContent(), m_DefaultMeasurementUnit,
 &fp->m_positionX, &fp->m_positionY, aActualConversion );
 }
 
 tNode = FindNode( lNode, wxT( "rotation" ) );
 
 if( tNode )
 {
 str = tNode->GetNodeContent();
 str.Trim( false );
 fp->m_rotation = EDA_ANGLE( StrToInt1Units( str ), TENTHS_OF_A_DEGREE_T );
 }
 
 str = FindNodeGetContent( lNode, wxT( "isFlipped" ) );
 
 if( str.IsSameAs( wxT( "True" ), false ) )
 fp->m_Mirror = 1;
 
 tNode = aNode;
 
 while( tNode->GetName() != wxT( "www.lura.sk" ) )
 tNode = tNode->GetParent();
 
 tNode = FindNode( tNode, wxT( "netlist" ) );
 
 if( tNode )
 {
 tNode = FindNode( tNode, wxT( "compInst" ) );
 
 while( tNode )
 {
 tNode->GetAttribute( wxT( "Name" ), &propValue );
 
 if( propValue == fp->m_name.text )
 {
 if( FindNode( tNode, wxT( "compValue" ) ) )
 {
 FindNode( tNode,
 wxT( "compValue" ) )->GetAttribute( wxT( "Name" ),
 &fp->m_Value.text );
 fp->m_Value.text.Trim( false );
 fp->m_Value.text.Trim( true );
 }
 
 if( FindNode( tNode, wxT( "compRef" ) ) )
 {
 FindNode( tNode,
 wxT( "compRef" ) )->GetAttribute( wxT( "Name" ),
 &fp->m_compRef );
 fp->m_compRef.Trim( false );
 fp->m_compRef.Trim( true );
 }
 
 tNode = nullptr;
 }
 else
 {
 tNode = tNode->GetNext();
 }
 }
 }
 
 // map pins
 tNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "library" ) );
 tNode = FindCompDefName( tNode, fp->m_compRef );
 
 if( tNode )
 {
 tNode = FindPinMap( tNode );
 
 if( tNode )
 {
 mNode = tNode->GetChildren();
 
 while( mNode )
 {
 if( mNode->GetName().IsSameAs( wxT( "padNum" ), false ) )
 {
 str = mNode->GetNodeContent();
 mNode = mNode->GetNext();
 
 if( !mNode )
 break;
 
 mNode->GetAttribute( wxT( "Name" ), &propValue );
 fp->SetName( str, propValue );
 mNode = mNode->GetNext();
 }
 else
 {
 mNode = mNode->GetNext();
 
 if( !mNode )
 break;
 
 mNode = mNode->GetNext();
 }
 }
 }
 }
 
 m_PcbComponents.Add( fp );
 }
 }
 else if( lNode->GetName().IsSameAs( wxT( "pad" ), false ) )
 {
 pad = new PCB_PAD( this, m_board );
 pad->Parse( lNode, m_DefaultMeasurementUnit, aActualConversion );
 m_PcbComponents.Add( pad );
 }
 else if( lNode->GetName().IsSameAs( wxT( "via" ), false ) )
 {
 via = new PCB_VIA( this, m_board );
 via->Parse( lNode, m_DefaultMeasurementUnit, aActualConversion );
 m_PcbComponents.Add( via );
 }
 else if( lNode->GetName().IsSameAs( wxT( "polyKeepOut" ), false ) )
 {
 keepOut = new PCB_KEEPOUT( m_callbacks, m_board, 0 );
 
 if( keepOut->Parse( lNode, m_DefaultMeasurementUnit, aActualConversion ) )
 m_PcbComponents.Add( keepOut );
 else
 delete keepOut;
 }
 
 lNode = lNode->GetNext();
 }
}

Referenced by ParseBoard().

◆ FindCompDefName()

XNODE * PCAD2KICAD::PCB::FindCompDefName	(	XNODE *	aNode,
		const wxString &	aName
	)		const

private

Definition at line 141 of file pcb.cpp.

{
 XNODE* result = nullptr, * lNode;
 wxString propValue;
 
 lNode = FindNode( aNode, wxT( "compDef" ) );
 
 while( lNode )
 {
 if( lNode->GetName().IsSameAs( wxT( "compDef" ), false ) )
 {
 lNode->GetAttribute( wxT( "Name" ), &propValue );
 
 if( propValue == aName )
 {
 result = lNode;
 lNode = nullptr;
 }
 }
 
 if( lNode )
 lNode = lNode->GetNext();
 }
 
 return result;
}

References PCAD2KICAD::FindNode(), and XNODE::GetNext().

Referenced by DoPCBComponents().

◆ FindLayer()

int PCAD2KICAD::PCB::FindLayer ( const wxString & aLayerName ) const

private

Definition at line 455 of file pcb.cpp.

{
 for( int i = 0; i < (int) m_layersStackup.size(); ++i )
 {
 if( m_layersStackup[i].first == aLayerName )
 return i;
 }
 
 return -1;
}

References m_layersStackup.

Referenced by MapLayer().

◆ FindModulePatternDefName()

XNODE * PCAD2KICAD::PCB_FOOTPRINT::FindModulePatternDefName	(	XNODE *	aNode,
		const wxString &	aName
	)

inherited

Definition at line 68 of file pcb_footprint.cpp.

{
 XNODE* result, * lNode;
 wxString propValue1, propValue2;
 
 result = nullptr;
 lNode = FindNode( aNode, wxT( "patternDef" ) );
 
 while( lNode )
 {
 if( lNode->GetName() == wxT( "patternDef" ) )
 {
 lNode->GetAttribute( wxT( "Name" ), &propValue1 );
 FindNode( lNode,
 wxT( "originalName" ) )->GetAttribute( wxT( "Name" ), &propValue2 );
 
 if( ValidateName( propValue1 ) == aName || ValidateName( propValue2 ) == aName )
 {
 result = lNode;
 lNode = nullptr;
 }
 }
 
 if( lNode )
 lNode = lNode->GetNext();
 }
 
 if( result == nullptr )
 {
 lNode = FindNode( aNode, wxT( "patternDefExtended" ) ); // New file format
 
 while( lNode )
 {
 if( lNode->GetName() == wxT( "patternDefExtended" ) )
 {
 lNode->GetAttribute( wxT( "Name" ), &propValue1 );
 
 if( ValidateName( propValue1 ) == aName )
 {
 result = lNode;
 lNode = nullptr;
 }
 }
 
 if( lNode )
 lNode = lNode->GetNext();
 }
 }
 
 return result;
}

References PCAD2KICAD::FindNode(), XNODE::GetNext(), and PCAD2KICAD::ValidateName().

Referenced by DoPCBComponents(), and PCAD2KICAD::PCB_FOOTPRINT::FindPatternMultilayerSection().

◆ FindOutlinePoint()

int PCAD2KICAD::PCB::FindOutlinePoint	(	const VERTICES_ARRAY *	aOutline,
		wxRealPoint	aPoint
	)		const

private

Definition at line 562 of file pcb.cpp.

{
 int i;
 
 for( i = 0; i < (int) aOutline->GetCount(); i++ )
 {
 if( *((*aOutline)[i]) == aPoint )
 return i;
 }
 
 return -1;
}

Referenced by GetBoardOutline().

◆ FindPatternMultilayerSection()

XNODE * PCAD2KICAD::PCB_FOOTPRINT::FindPatternMultilayerSection	(	XNODE *	aNode,
		wxString *	aPatGraphRefName
	)

privateinherited

Definition at line 121 of file pcb_footprint.cpp.

{
 XNODE* result, * pNode, * lNode;
 wxString propValue, patName;
 
 result = nullptr;
 pNode = aNode; // pattern;
 lNode = aNode;
 
 // calling from library conversion we need to find pattern
 if( lNode->GetName() == wxT( "compDef" ) )
 {
 lNode->GetAttribute( wxT( "Name" ), &propValue );
 propValue.Trim( false );
 patName = ValidateName( propValue );
 
 if( FindNode( lNode, wxT( "attachedPattern" ) ) )
 {
 FindNode( FindNode( lNode, wxT( "attachedPattern" ) ),
 wxT( "patternName" ) )->GetAttribute( wxT( "Name" ), &propValue );
 propValue.Trim( false );
 propValue.Trim( true );
 patName = ValidateName( propValue );
 }
 
 lNode = FindModulePatternDefName( lNode->GetParent(), patName );
 pNode = lNode; // pattern;
 }
 
 lNode = nullptr;
 
 if( pNode )
 lNode = FindNode( pNode, wxT( "multiLayer" ) ); // Old file format
 
 if( lNode )
 {
 *aPatGraphRefName = wxEmptyString; // default
 result = lNode;
 }
 else
 {
 // New file format
 
 if( *aPatGraphRefName == wxEmptyString ) // default
 {
 if( FindNode( aNode, wxT( "patternGraphicsNameRef" ) ) )
 {
 FindNode( aNode,
 wxT( "patternGraphicsNameRef" ) )->GetAttribute( wxT( "Name" ),
 aPatGraphRefName );
 }
 }
 
 if( FindNode( aNode, wxT( "patternGraphicsDef" ) ) )
 lNode = FindNode( aNode, wxT( "patternGraphicsDef" ) );
 else if( pNode )
 lNode = FindNode( pNode, wxT( "patternGraphicsDef" ) );
 
 if( *aPatGraphRefName == wxEmptyString ) // no pattern detection, the first is actual...
 {
 if( lNode )
 {
 result = FindNode( lNode, wxT( "multiLayer" ) );
 lNode = nullptr;
 }
 }
 
 while( lNode ) // selected by name
 {
 if( lNode->GetName() == wxT( "patternGraphicsDef" ) )
 {
 FindNode( lNode,
 wxT( "patternGraphicsNameDef" ) )->GetAttribute( wxT( "Name" ),
 &propValue );
 
  if( propValue == *aPatGraphRefName )
 {
 result = FindNode( lNode, wxT( "multiLayer" ) );
 lNode = nullptr;
 }
 else
 {
 lNode = lNode->GetNext();
 }
 }
 else
 {
 lNode = lNode->GetNext();
 }
 }
 }
 
 return result;
}

References PCAD2KICAD::PCB_FOOTPRINT::FindModulePatternDefName(), PCAD2KICAD::FindNode(), XNODE::GetNext(), XNODE::GetParent(), and PCAD2KICAD::ValidateName().

Referenced by PCAD2KICAD::PCB_FOOTPRINT::Parse().

◆ Flip()

void PCAD2KICAD::PCB_FOOTPRINT::Flip ( )

overridevirtualinherited

Reimplemented from PCAD2KICAD::PCB_COMPONENT.

Definition at line 604 of file pcb_footprint.cpp.

{
 int i;
 
 if( m_Mirror == 1 )
 {
 m_rotation = -m_rotation;
 
 for( i = 0; i < (int) m_FootprintItems.GetCount(); i++ )
 {
 if( m_FootprintItems[i]->m_objType == wxT( 'L' ) || // lines
 m_FootprintItems[i]->m_objType == wxT( 'A' ) || // arcs
 m_FootprintItems[i]->m_objType == wxT( 'Z' ) || // polygons
 m_FootprintItems[i]->m_objType == wxT( 'P' ) || // pads
 m_FootprintItems[i]->m_objType == wxT( 'V' ) ) // vias
 {
 m_FootprintItems[i]->Flip();
 }
 }
 }
}

References PCAD2KICAD::PCB_FOOTPRINT::m_FootprintItems, PCAD2KICAD::PCB_FOOTPRINT::m_Mirror, PCAD2KICAD::PCB_COMPONENT::m_objType, and PCAD2KICAD::PCB_COMPONENT::m_rotation.

Referenced by ParseBoard().

◆ GetBoardOutline()

void PCAD2KICAD::PCB::GetBoardOutline	(	wxXmlDocument *	aXmlDoc,
		const wxString &	aActualConversion
	)

private

Definition at line 582 of file pcb.cpp.

{
 XNODE* iNode, *lNode, *pNode;
 long PCadLayer = 0;
 int x, y, i, j, targetInd;
 wxRealPoint* xchgPoint;
 double minDistance, distance;
 
 iNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "pcbDesign" ) );
 
 if( iNode )
 {
 // COMPONENTS AND OBJECTS
 iNode = iNode->GetChildren();
 
 while( iNode )
 {
 // objects
 if( iNode->GetName().IsSameAs( wxT( "layerContents" ), false ) )
 {
 if( FindNode( iNode, wxT( "layerNumRef" ) ) )
 FindNode( iNode, wxT( "layerNumRef" ) )->GetNodeContent().ToLong( &PCadLayer );
 
 if( GetKiCadLayer( PCadLayer ) == Edge_Cuts )
 {
 lNode = iNode->GetChildren();
 
 while( lNode )
 {
 if( lNode->GetName().IsSameAs( wxT( "line" ), false ) )
 {
 pNode = FindNode( lNode, wxT( "pt" ) );
 
 if( pNode )
 {
 SetPosition( pNode->GetNodeContent(), m_DefaultMeasurementUnit,
 &x, &y, aActualConversion );
 
 if( FindOutlinePoint( &m_BoardOutline, wxRealPoint( x, y) ) == -1 )
 m_BoardOutline.Add( new wxRealPoint( x, y ) );
 }
 
 if( pNode )
 pNode = pNode->GetNext();
 
 if( pNode )
 {
 SetPosition( pNode->GetNodeContent(), m_DefaultMeasurementUnit,
 &x, &y, aActualConversion );
 
 if( FindOutlinePoint( &m_BoardOutline, wxRealPoint( x, y) ) == -1 )
 m_BoardOutline.Add( new wxRealPoint( x, y ) );
 }
 }
 
 lNode = lNode->GetNext();
 }
 
 //m_boardOutline.Sort( cmpFunc );
 // sort vertices according to the distances between them
 if( m_BoardOutline.GetCount() > 3 )
 {
 for( i = 0; i < (int) m_BoardOutline.GetCount() - 1; i++ )
 {
  minDistance = GetDistance( m_BoardOutline[i], m_BoardOutline[ i + 1] );
 targetInd = i + 1;
 
 for( j = i + 2; j < (int) m_BoardOutline.GetCount(); j++ )
 {
 distance = GetDistance( m_BoardOutline[i], m_BoardOutline[j] );
 
 if( distance < minDistance )
 {
 minDistance = distance;
 targetInd = j;
 }
 }
 
 xchgPoint = m_BoardOutline[ i + 1];
 m_BoardOutline[ i + 1] = m_BoardOutline[targetInd];
 m_BoardOutline[targetInd] = xchgPoint;
 }
 }
 
 break;
 }
 }
 
 iNode = iNode->GetNext();
 }
 }
}

References distance(), Edge_Cuts, PCAD2KICAD::FindNode(), FindOutlinePoint(), XNODE::GetChildren(), GetDistance(), PCAD2KICAD::PCB_COMPONENT::GetKiCadLayer(), XNODE::GetNext(), PCAD2KICAD::PCB_FOOTPRINT::m_BoardOutline, m_DefaultMeasurementUnit, and PCAD2KICAD::SetPosition().

Referenced by ParseBoard().

◆ GetDistance()

double PCAD2KICAD::PCB::GetDistance	(	const wxRealPoint *	aPoint1,
		const wxRealPoint *	aPoint2
	)		const

private

Definition at line 576 of file pcb.cpp.

{
 return sqrt( ( aPoint1->x - aPoint2->x ) * ( aPoint1->x - aPoint2->x ) +
 ( aPoint1->y - aPoint2->y ) * ( aPoint1->y - aPoint2->y ) );
}

Referenced by GetBoardOutline().

◆ GetKiCadLayer() [1/2]

PCB_LAYER_ID PCAD2KICAD::PCB_COMPONENT::GetKiCadLayer ( ) const

inlineinherited

Definition at line 56 of file pcb_component.h.

56{ return m_callbacks->GetKiCadLayer( m_PCadLayer ); }

PCAD2KICAD::PCB_CALLBACKS::GetKiCadLayer

virtual PCB_LAYER_ID GetKiCadLayer(int aPCadLayer) const =0

PCAD2KICAD::PCB_COMPONENT::m_PCadLayer

int m_PCadLayer

Definition: pcb_component.h:65

References PCAD2KICAD::PCB_CALLBACKS::GetKiCadLayer(), PCAD2KICAD::PCB_COMPONENT::m_callbacks, and PCAD2KICAD::PCB_COMPONENT::m_PCadLayer.

Referenced by GetBoardOutline(), PCAD2KICAD::PCB_PAD_SHAPE::Parse(), PCAD2KICAD::PCB_VIA_SHAPE::Parse(), PCAD2KICAD::PCB_ARC::Parse(), PCAD2KICAD::PCB_LINE::Parse(), PCAD2KICAD::PCB_TEXT::Parse(), and PCAD2KICAD::PCB_POLYGON::PCB_POLYGON().

◆ GetKiCadLayer() [2/2]

PCB_LAYER_ID PCAD2KICAD::PCB::GetKiCadLayer ( int aPCadLayer ) const

overridevirtual

Implements PCAD2KICAD::PCB_CALLBACKS.

Definition at line 45 of file pcb.cpp.

{
 auto it = m_LayersMap.find( aPCadLayer );
 
 if( it == m_LayersMap.end() )
 THROW_IO_ERROR( wxString::Format( _( "Unknown PCad layer %u" ), unsigned( aPCadLayer ) ) );
 
 return it->second.KiCadLayer;
}

References _, Format(), m_LayersMap, and THROW_IO_ERROR.

◆ GetLayerNetNameRef()

wxString PCAD2KICAD::PCB::GetLayerNetNameRef ( int aPCadLayer ) const

overridevirtual

Implements PCAD2KICAD::PCB_CALLBACKS.

Definition at line 67 of file pcb.cpp.

{
 auto it = m_LayersMap.find( aPCadLayer );
 
 if( it == m_LayersMap.end() )
 THROW_IO_ERROR( wxString::Format( _( "Unknown PCad layer %u" ), unsigned( aPCadLayer ) ) );
 
 return it->second.netNameRef;
}

References _, Format(), m_LayersMap, and THROW_IO_ERROR.

◆ GetLayerType()

LAYER_TYPE_T PCAD2KICAD::PCB::GetLayerType ( int aPCadLayer ) const

overridevirtual

Implements PCAD2KICAD::PCB_CALLBACKS.

Definition at line 56 of file pcb.cpp.

{
 auto it = m_LayersMap.find( aPCadLayer );
 
 if( it == m_LayersMap.end() )
 THROW_IO_ERROR( wxString::Format( _( "Unknown PCad layer %u" ), unsigned( aPCadLayer ) ) );
 
 return it->second.layerType;
}

References _, Format(), m_LayersMap, and THROW_IO_ERROR.

◆ GetNetCode()

int PCAD2KICAD::PCB::GetNetCode ( const wxString & aNetName ) const

overridevirtual

Implements PCAD2KICAD::PCB_CALLBACKS.

Definition at line 124 of file pcb.cpp.

{
 const PCB_NET* net;
 
 for( int i = 0; i < (int) m_PcbNetlist.GetCount(); i++ )
 {
 net = m_PcbNetlist[i];
 
 if( net->m_Name == aNetName )
 {
 return net->m_NetCode;
 }
 }
 
 return 0;
}

References PCAD2KICAD::PCB_NET::m_Name, PCAD2KICAD::PCB_NET::m_NetCode, and m_PcbNetlist.

◆ MapLayer()

void PCAD2KICAD::PCB::MapLayer ( XNODE * aNode )

private

Definition at line 467 of file pcb.cpp.

{
 wxString lName, layerType;
 PCB_LAYER_ID KiCadLayer;
 long num = 0;
 
 aNode->GetAttribute( wxT( "Name" ), &lName );
 lName = lName.MakeUpper();
 
 if( lName == wxT( "TOP ASSY" ) )
 {
 KiCadLayer = F_Fab;
 }
 else if( lName == wxT( "TOP SILK" ) )
 {
 KiCadLayer = F_SilkS;
 }
 else if( lName == wxT( "TOP PASTE" ) )
 {
 KiCadLayer = F_Paste;
 }
 else if( lName == wxT( "TOP MASK" ) )
 {
 KiCadLayer = F_Mask;
 }
 else if( lName == wxT( "TOP" ) )
 {
 KiCadLayer = F_Cu;
 }
 else if( lName == wxT( "BOTTOM" ) )
 {
 KiCadLayer = B_Cu;
 }
 else if( lName == wxT( "BOT MASK" ) )
 {
 KiCadLayer = B_Mask;
 }
 else if( lName == wxT( "BOT PASTE" ) )
 {
 KiCadLayer = B_Paste;
 }
 else if( lName == wxT( "BOT SILK" ) )
 {
 KiCadLayer = B_SilkS;
 }
 else if( lName == wxT( "BOT ASSY" ) )
 {
 KiCadLayer = B_Fab;
 }
 else if( lName == wxT( "BOARD" ) )
 {
 KiCadLayer = Edge_Cuts;
 }
 else
 {
 int layernum = FindLayer( lName );
 
 if( layernum == -1 )
 KiCadLayer = Dwgs_User; // default
 else
 KiCadLayer = ToLAYER_ID( layernum );
 }
 
 if( FindNode( aNode, wxT( "layerNum" ) ) )
 FindNode( aNode, wxT( "layerNum" ) )->GetNodeContent().ToLong( &num );
 
 if( num < 0 )
 THROW_IO_ERROR( wxString::Format( wxT( "layerNum = %ld is out of range" ), num ) );
 
 TLAYER newlayer;
 newlayer.KiCadLayer = KiCadLayer;
 
 if( FindNode( aNode, wxT( "layerType" ) ) )
 {
 layerType = FindNode( aNode, wxT( "layerType" ) )->GetNodeContent().Trim( false );
 
 if( layerType.IsSameAs( wxT( "NonSignal" ), false ) )
 newlayer.layerType = LAYER_TYPE_NONSIGNAL;
 
 if( layerType.IsSameAs( wxT( "Signal" ), false ) )
 newlayer.layerType = LAYER_TYPE_SIGNAL;
 
 if( layerType.IsSameAs( wxT( "Plane" ), false ) )
 newlayer.layerType = LAYER_TYPE_PLANE;
 }
 
 m_LayersMap.insert( std::make_pair( num, newlayer ) );
 
 if( FindNode( aNode, wxT( "netNameRef" ) ) )
 {
 FindNode( aNode, wxT( "netNameRef" ) )->GetAttribute( wxT( "Name" ),
 &m_LayersMap[(int) num].netNameRef );
 }
}

References B_Cu, B_Fab, B_Mask, B_Paste, B_SilkS, Dwgs_User, Edge_Cuts, F_Cu, F_Fab, F_Mask, F_Paste, F_SilkS, FindLayer(), PCAD2KICAD::FindNode(), Format(), TLAYER::KiCadLayer, LAYER_TYPE_NONSIGNAL, LAYER_TYPE_PLANE, LAYER_TYPE_SIGNAL, TLAYER::layerType, m_LayersMap, THROW_IO_ERROR, and ToLAYER_ID().

Referenced by ParseBoard().

◆ Parse()

void PCAD2KICAD::PCB_FOOTPRINT::Parse	(	XNODE *	aNode,
		wxStatusBar *	aStatusBar,
		const wxString &	aDefaultMeasurementUnit,
		const wxString &	aActualConversion
	)

virtualinherited

Definition at line 387 of file pcb_footprint.cpp.

{
 XNODE* lNode, * tNode, * mNode;
 PCB_PAD* pad;
 PCB_VIA* via;
 wxString propValue, str;
 
 FindNode( aNode, wxT( "originalName" ) )->GetAttribute( wxT( "Name" ), &propValue );
 propValue.Trim( false );
 m_name.text = propValue;
 
 // aStatusBar->SetStatusText( wxT( "Creating Component : " ) + m_name.text );
 lNode = aNode;
 lNode = FindPatternMultilayerSection( lNode, &m_patGraphRefName );
 
 if( lNode )
 {
 tNode = lNode;
 tNode = tNode->GetChildren();
 
 while( tNode )
 {
 if( tNode->GetName() == wxT( "pad" ) )
 {
 pad = new PCB_PAD( m_callbacks, m_board );
 pad->Parse( tNode, aDefaultMeasurementUnit, aActualConversion );
 m_FootprintItems.Add( pad );
 }
 
 if( tNode->GetName() == wxT( "via" ) )
 {
 via = new PCB_VIA( m_callbacks, m_board );
 via->Parse( tNode, aDefaultMeasurementUnit, aActualConversion );
 m_FootprintItems.Add( via );
 }
 
 tNode = tNode->GetNext();
 }
 
 lNode = lNode->GetParent();
 }
 
 if( lNode )
 lNode = FindNode( lNode, wxT( "layerContents" ) );
 
 while( lNode )
 {
 if( lNode->GetName() == wxT( "layerContents" ) )
 DoLayerContentsObjects( lNode, this, &m_FootprintItems, aStatusBar,
 aDefaultMeasurementUnit, aActualConversion );
 
 lNode = lNode->GetNext();
 }
 
 // map pins
 lNode = FindPinMap( aNode );
 
 if( lNode )
 {
 mNode = lNode->GetChildren();
 
 while( mNode )
 {
 if( mNode->GetName() == wxT( "padNum" ) )
 {
 str = mNode->GetNodeContent();
 mNode = mNode->GetNext();
 
 if( !mNode )
 break;
 
 mNode->GetAttribute( wxT( "Name" ), &propValue );
 SetName( str, propValue );
 mNode = mNode->GetNext();
 }
 else
 {
 mNode = mNode->GetNext();
 
 if( !mNode )
 break;
 
 mNode = mNode->GetNext();
 }
 }
 }
}

References PCAD2KICAD::PCB_FOOTPRINT::DoLayerContentsObjects(), PCAD2KICAD::FindNode(), PCAD2KICAD::PCB_FOOTPRINT::FindPatternMultilayerSection(), PCAD2KICAD::FindPinMap(), XNODE::GetChildren(), XNODE::GetNext(), XNODE::GetParent(), PCAD2KICAD::PCB_COMPONENT::m_board, PCAD2KICAD::PCB_COMPONENT::m_callbacks, PCAD2KICAD::PCB_FOOTPRINT::m_FootprintItems, PCAD2KICAD::PCB_COMPONENT::m_name, PCAD2KICAD::PCB_COMPONENT::m_patGraphRefName, pad, PCAD2KICAD::PCB_FOOTPRINT::SetName(), PCAD2KICAD::TTEXTVALUE::text, and via.

Referenced by DoPCBComponents(), and ParseBoard().

◆ ParseBoard()

void PCAD2KICAD::PCB::ParseBoard	(	wxStatusBar *	aStatusBar,
		wxXmlDocument *	aXmlDoc,
		const wxString &	aActualConversion
	)

Definition at line 676 of file pcb.cpp.

{
 XNODE* aNode;//, *aaNode;
 PCB_NET* net;
 PCB_COMPONENT* comp;
 PCB_FOOTPRINT* footprint;
 wxString compRef, pinRef, layerName, layerType;
 int i, j, netCode;
 
 // Default measurement units
 aNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "asciiHeader" ) );
 
 if( aNode )
 {
 aNode = FindNode( aNode, wxT( "fileUnits" ) );
 
 if( aNode )
 {
 m_DefaultMeasurementUnit = aNode->GetNodeContent().Lower();
 m_DefaultMeasurementUnit.Trim( true );
 m_DefaultMeasurementUnit.Trim( false );
 }
 }
 
 // Determine layers stackup
 aNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "pcbDesign" ) );
 
 /*if( aNode )
 {
 aNode = FindNode( aNode, wxT( "layersStackup" ) );
 
 if( aNode )
 {
 aNode = FindNode( aNode, wxT( "layerStackupData" ) );
 
 while( aNode )
 {
 if( aNode->GetName() == wxT( "layerStackupData" ) )
 {
 aaNode = FindNode( aNode, wxT( "layerStackupName" ) );
 
 if( aaNode ) {
 aaNode->GetAttribute( wxT( "Name" ), &layerName );
 layerName = layerName.MakeUpper();
 m_layersStackup.Add( layerName );
 }
 }
 
 aNode = aNode->GetNext();
 }
 }
 }*/
 
 if( aNode )
 {
 aNode = FindNode( aNode, wxT( "layerDef" ) );
 
 while( aNode )
 {
 if( aNode->GetName().IsSameAs( wxT( "layerDef" ), false ) )
 {
 if( FindNode( aNode, wxT( "layerType" ) ) )
 {
 long num = -1;
 
 if( FindNode( aNode, wxT( "layerNum" ) ) )
 FindNode( aNode, wxT( "layerNum" ) )->GetNodeContent().ToLong( &num );
 
 layerType = FindNode( aNode, wxT( "layerType" ) )->GetNodeContent().Trim(
 false );
 
 if( num > 0 && ( layerType.IsSameAs( wxT( "Signal" ), false )
 || layerType.IsSameAs( wxT( "Plane" ), false ) ) )
 {
 aNode->GetAttribute( wxT( "Name" ), &layerName );
 layerName = layerName.MakeUpper();
 m_layersStackup.emplace_back( layerName, num );
 
 if( m_layersStackup.size() > 32 )
 THROW_IO_ERROR( _( "KiCad only supports 32 signal layers." ) );
 }
 }
 }
 
 aNode = aNode->GetNext();
 }
 
 // Ensure that the layers are properly mapped to their order with the bottom
 // copper (layer 2 in PCAD) at the end
 std::sort( m_layersStackup.begin(), m_layersStackup.end(),
 [&]( const std::pair<wxString, long>& a, const std::pair<wxString, long>& b ) {
 long lhs = a.second == 2 ? std::numeric_limits<long>::max() : a.second;
 long rhs = b.second == 2 ? std::numeric_limits<long>::max() : b.second;
 
 return lhs < rhs;
 } );
 }
 
 // Layers mapping
 aNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "pcbDesign" ) );
 
 if( aNode )
 {
 aNode = FindNode( aNode, wxT( "layerDef" ) );
 
 while( aNode )
 {
 if( aNode->GetName().IsSameAs( wxT( "layerDef" ), false ) )
 MapLayer( aNode );
 
 aNode = aNode->GetNext();
 }
 }
 
 GetBoardOutline( aXmlDoc, aActualConversion );
 
 // NETLIST
 // aStatusBar->SetStatusText( wxT( "Loading NETLIST " ) );
 
 aNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "netlist" ) );
 
 if( aNode )
 {
 aNode = FindNode( aNode, wxT( "net" ) );
 
 netCode = 1;
 
 while( aNode )
 {
 net = new PCB_NET( netCode++ );
 net->Parse( aNode );
 m_PcbNetlist.Add( net );
 
 aNode = aNode->GetNext();
 }
 }
 
 // BOARD FILE
 // aStatusBar->SetStatusText( wxT( "Loading BOARD DEFINITION " ) );
 
 aNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "pcbDesign" ) );
 
 if( aNode )
 {
 // COMPONENTS AND OBJECTS
 aNode = aNode->GetChildren();
 
 while( aNode )
 {
 // Components/footprints
 if( aNode->GetName().IsSameAs( wxT( "multiLayer" ), false ) )
 DoPCBComponents( aNode, aXmlDoc, aActualConversion, aStatusBar );
 
 // objects
 if( aNode->GetName().IsSameAs( wxT( "layerContents" ), false ) )
 DoLayerContentsObjects( aNode, nullptr, &m_PcbComponents, aStatusBar,
 m_DefaultMeasurementUnit, aActualConversion );
 
 aNode = aNode->GetNext();
 }
 
 // POSTPROCESS -- SET NETLIST REFERENCES
 // aStatusBar->SetStatusText( wxT( "Processing NETLIST " ) );
 
 for( i = 0; i < (int) m_PcbNetlist.GetCount(); i++ )
 {
 net = m_PcbNetlist[i];
 
 for( j = 0; j < (int) net->m_NetNodes.GetCount(); j++ )
 {
 compRef = net->m_NetNodes[j]->m_CompRef;
 compRef.Trim( false );
 compRef.Trim( true );
 pinRef = net->m_NetNodes[j]->m_PinRef;
 pinRef.Trim( false );
 pinRef.Trim( true );
 ConnectPinToNet( compRef, pinRef, net->m_Name );
 }
 }
 
 // POSTPROCESS -- FLIP COMPONENTS
 for( i = 0; i < (int) m_PcbComponents.GetCount(); i++ )
 {
 if( m_PcbComponents[i]->m_objType == wxT( 'M' ) )
 ( (PCB_FOOTPRINT*) m_PcbComponents[i] )->Flip();
 }
 
 // POSTPROCESS -- SET/OPTIMIZE NEW PCB POSITION
 // aStatusBar->SetStatusText( wxT( "Optimizing BOARD POSITION " ) );
 
 m_SizeX = 10000000;
 m_SizeY = 0;
 
 for( i = 0; i < (int) m_PcbComponents.GetCount(); i++ )
 {
 comp = m_PcbComponents[i];
 
 if( comp->m_positionY < m_SizeY )
 m_SizeY = comp->m_positionY; // max Y
 
 if( comp->m_positionX < m_SizeX && comp->m_positionX > 0 )
 m_SizeX = comp->m_positionX; // Min X
 }
 
 m_SizeY -= 10000;
 m_SizeX -= 10000;
 // aStatusBar->SetStatusText( wxT( " POSITIONING POSTPROCESS " ) );
 
 for( i = 0; i < (int) m_PcbComponents.GetCount(); i++ )
 m_PcbComponents[i]->SetPosOffset( -m_SizeX, -m_SizeY );
 
 m_SizeX = 0;
 m_SizeY = 0;
 
 for( i = 0; i < (int) m_PcbComponents.GetCount(); i++ )
 {
 comp = m_PcbComponents[i];
 
 if( comp->m_positionY < m_SizeY )
 m_SizeY = comp->m_positionY; // max Y
 
 if( comp->m_positionX > m_SizeX )
 m_SizeX = comp->m_positionX; // Min X
 }
 
 // SHEET SIZE CALCULATION
 m_SizeY = -m_SizeY; // it is in absolute units
 m_SizeX += 10000;
 m_SizeY += 10000;
 
 // A4 is minimum $Descr A4 11700 8267
 if( m_SizeX < 11700 )
 m_SizeX = 11700;
 
 if( m_SizeY < 8267 )
 m_SizeY = 8267;
 }
 else
 {
 // LIBRARY FILE
 // aStatusBar->SetStatusText( wxT( "Processing LIBRARY FILE " ) );
 
 aNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "library" ) );
 
 if( aNode )
 {
 aNode = FindNode( aNode, wxT( "compDef" ) );
 
 while( aNode )
 {
 // aStatusBar->SetStatusText( wxT( "Processing COMPONENTS " ) );
 
 if( aNode->GetName().IsSameAs( wxT( "compDef" ), false ) )
 {
 footprint = new PCB_FOOTPRINT( this, m_board );
 footprint->Parse( aNode, aStatusBar, m_DefaultMeasurementUnit,
 aActualConversion );
 m_PcbComponents.Add( footprint );
 }
 
 aNode = aNode->GetNext();
 }
 }
 }
}

References _, ConnectPinToNet(), PCAD2KICAD::PCB_FOOTPRINT::DoLayerContentsObjects(), DoPCBComponents(), PCAD2KICAD::FindNode(), PCAD2KICAD::PCB_FOOTPRINT::Flip(), GetBoardOutline(), XNODE::GetChildren(), XNODE::GetNext(), PCAD2KICAD::PCB_COMPONENT::m_board, m_DefaultMeasurementUnit, m_layersStackup, PCAD2KICAD::PCB_NET::m_Name, PCAD2KICAD::PCB_NET::m_NetNodes, PCAD2KICAD::PCB_COMPONENT::m_objType, m_PcbComponents, m_PcbNetlist, PCAD2KICAD::PCB_COMPONENT::m_positionX, PCAD2KICAD::PCB_COMPONENT::m_positionY, m_SizeX, m_SizeY, MapLayer(), PCAD2KICAD::PCB_NET::Parse(), PCAD2KICAD::PCB_FOOTPRINT::Parse(), PCAD2KICAD::PCB_FOOTPRINT::PCB_FOOTPRINT(), PCAD2KICAD::PCB_COMPONENT::SetPosOffset(), and THROW_IO_ERROR.

Referenced by PCAD_PLUGIN::Load().

◆ SetName()

void PCAD2KICAD::PCB_FOOTPRINT::SetName	(	const wxString &	aPin,
		const wxString &	aName
	)

inherited

Definition at line 369 of file pcb_footprint.cpp.

{
 int i;
 long num;
 
 aPin.ToLong( &num );
 
 for( i = 0; i < (int) m_FootprintItems.GetCount(); i++ )
 {
 if( m_FootprintItems[i]->m_objType == wxT( 'P' ) )
 {
 if( ( (PCB_PAD*) m_FootprintItems[i] )->m_Number == num )
 ( (PCB_PAD*) m_FootprintItems[i] )->m_name.text = aName;
 }
 }
}

References PCAD2KICAD::PCB_FOOTPRINT::m_FootprintItems, PCAD2KICAD::PCB_COMPONENT::m_name, PCAD2KICAD::PCB_COMPONENT::m_objType, and PCAD2KICAD::TTEXTVALUE::text.

Referenced by DoPCBComponents(), and PCAD2KICAD::PCB_FOOTPRINT::Parse().

◆ SetPosOffset()

void PCAD2KICAD::PCB_COMPONENT::SetPosOffset	(	int	aX_offs,
		int	aY_offs
	)

virtualinherited

Reimplemented in PCAD2KICAD::PCB_ARC, PCAD2KICAD::PCB_LINE, and PCAD2KICAD::PCB_POLYGON.

Definition at line 67 of file pcb_component.cpp.

{
 m_positionX += aX_offs;
 m_positionY += aY_offs;
}

References PCAD2KICAD::PCB_COMPONENT::m_positionX, and PCAD2KICAD::PCB_COMPONENT::m_positionY.

Referenced by ParseBoard(), PCAD2KICAD::PCB_ARC::SetPosOffset(), PCAD2KICAD::PCB_LINE::SetPosOffset(), and PCAD2KICAD::PCB_POLYGON::SetPosOffset().

◆ SetTextProperty()

void PCAD2KICAD::PCB::SetTextProperty	(	XNODE *	aNode,
		TTEXTVALUE *	aTextValue,
		const wxString &	aPatGraphRefName,
		const wxString &	aXmlName,
		const wxString &	aActualConversion
	)

private

Definition at line 169 of file pcb.cpp.

{
 XNODE* tNode, * t1Node;
 wxString n, nnew, pn, propValue, str;
 
 // aNode is pattern now
 tNode = aNode;
 t1Node = aNode;
 n = aXmlName;
 
 // new file format version
 if( FindNode( tNode, wxT( "patternGraphicsNameRef" ) ) )
 {
 FindNode( tNode,
 wxT( "patternGraphicsNameRef" ) )->GetAttribute( wxT( "Name" ),
 &pn );
 pn.Trim( false );
 pn.Trim( true );
 tNode = FindNode( tNode, wxT( "patternGraphicsRef" ) );
 
 while( tNode )
 {
 if( tNode->GetName().IsSameAs( wxT( "patternGraphicsRef" ), false ) )
 {
 if( FindNode( tNode, wxT( "patternGraphicsNameRef" ) ) )
 {
 FindNode( tNode,
 wxT( "patternGraphicsNameRef" ) )->GetAttribute( wxT( "Name" ),
 &propValue );
 
 if( propValue == pn )
 {
 t1Node = tNode; // find correct section with same name.
 str = aTextValue->text;
 str.Trim( false );
  str.Trim( true );
 nnew = n; // new file version
 n = n + wxT( ' ' ) + str; // old file version
 tNode = nullptr;
 }
 }
 }
 
 if( tNode )
 tNode = tNode->GetNext();
 }
 }
 
 // old version and compatible for both from this point
 tNode = FindNode( t1Node, wxT( "attr" ) );
 
 while( tNode )
 {
 tNode->GetAttribute( wxT( "Name" ), &propValue );
 propValue.Trim( false );
 propValue.Trim( true );
 
 if( propValue == n || propValue == nnew )
 break;
 
 tNode = tNode->GetNext();
 }
 
 if( tNode )
 SetTextParameters( tNode, aTextValue, m_DefaultMeasurementUnit, aActualConversion );
}

References PCAD2KICAD::FindNode(), XNODE::GetNext(), m_DefaultMeasurementUnit, PCAD2KICAD::SetTextParameters(), and PCAD2KICAD::TTEXTVALUE::text.

Referenced by DoPCBComponents().

Member Data Documentation

◆ m_board

BOARD* PCAD2KICAD::PCB_COMPONENT::m_board

protectedinherited

Definition at line 79 of file pcb_component.h.

Referenced by AddToBoard(), PCAD2KICAD::PCB_ARC::AddToBoard(), PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), PCAD2KICAD::PCB_LINE::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToBoard(), PCAD2KICAD::PCB_POLYGON::AddToBoard(), PCAD2KICAD::PCB_TEXT::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToFootprint(), PCAD2KICAD::PCB_FOOTPRINT::DoLayerContentsObjects(), DoPCBComponents(), PCAD2KICAD::PCB_PAD::Parse(), PCAD2KICAD::PCB_VIA::Parse(), PCAD2KICAD::PCB_FOOTPRINT::Parse(), and ParseBoard().

◆ m_BoardOutline

VERTICES_ARRAY PCAD2KICAD::PCB_FOOTPRINT::m_BoardOutline

inherited

Definition at line 66 of file pcb_footprint.h.

Referenced by PCAD2KICAD::PCB_FOOTPRINT::DoLayerContentsObjects(), and GetBoardOutline().

◆ m_callbacks

PCB_CALLBACKS* PCAD2KICAD::PCB_COMPONENT::m_callbacks

protectedinherited

Definition at line 78 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_FOOTPRINT::DoLayerContentsObjects(), DoPCBComponents(), PCAD2KICAD::PCB_COMPONENT::GetKiCadLayer(), PCAD2KICAD::PCB_COMPONENT::GetNetCode(), PCAD2KICAD::PCB_PAD::Parse(), PCAD2KICAD::PCB_VIA::Parse(), and PCAD2KICAD::PCB_FOOTPRINT::Parse().

◆ m_compRef

wxString PCAD2KICAD::PCB_COMPONENT::m_compRef

inherited

Definition at line 74 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), DoPCBComponents(), and PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT().

◆ m_DefaultMeasurementUnit

wxString PCAD2KICAD::PCB::m_DefaultMeasurementUnit

Definition at line 64 of file pcb.h.

Referenced by DoPCBComponents(), GetBoardOutline(), ParseBoard(), PCB(), and SetTextProperty().

◆ m_FootprintItems

PCB_COMPONENTS_ARRAY PCAD2KICAD::PCB_FOOTPRINT::m_FootprintItems

inherited

Definition at line 64 of file pcb_footprint.h.

Referenced by PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), ConnectPinToNet(), PCAD2KICAD::PCB_FOOTPRINT::Flip(), PCAD2KICAD::PCB_FOOTPRINT::Parse(), PCAD2KICAD::PCB_FOOTPRINT::SetName(), and PCAD2KICAD::PCB_FOOTPRINT::~PCB_FOOTPRINT().

◆ m_KiCadLayer

PCB_LAYER_ID PCAD2KICAD::PCB_COMPONENT::m_KiCadLayer

inherited

Definition at line 66 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_ARC::AddToBoard(), PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), PCAD2KICAD::PCB_LINE::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToBoard(), PCAD2KICAD::PCB_POLYGON::AddToBoard(), PCAD2KICAD::PCB_TEXT::AddToBoard(), PCAD2KICAD::PCB_ARC::AddToFootprint(), PCAD2KICAD::PCB_LINE::AddToFootprint(), PCAD2KICAD::PCB_POLYGON::AddToFootprint(), PCAD2KICAD::PCB_PAD::AddToFootprint(), PCAD2KICAD::PCB_ARC::Flip(), PCAD2KICAD::PCB_LINE::Flip(), PCAD2KICAD::PCB_PAD::Flip(), PCAD2KICAD::PCB_POLYGON::Flip(), PCAD2KICAD::PCB_PAD_SHAPE::Parse(), PCAD2KICAD::PCB_VIA_SHAPE::Parse(), PCAD2KICAD::PCB_ARC::Parse(), PCAD2KICAD::PCB_LINE::Parse(), PCAD2KICAD::PCB_TEXT::Parse(), PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT(), PCAD2KICAD::PCB_FOOTPRINT::PCB_FOOTPRINT(), and PCAD2KICAD::PCB_POLYGON::PCB_POLYGON().

◆ m_LayersMap

std::map<int, TLAYER> PCAD2KICAD::PCB::m_LayersMap

Definition at line 65 of file pcb.h.

Referenced by GetKiCadLayer(), GetLayerNetNameRef(), GetLayerType(), MapLayer(), and PCB().

◆ m_layersStackup

std::vector<std::pair<wxString, long> > PCAD2KICAD::PCB::m_layersStackup

private

Definition at line 86 of file pcb.h.

Referenced by AddToBoard(), FindLayer(), and ParseBoard().

◆ m_Mirror

int PCAD2KICAD::PCB_FOOTPRINT::m_Mirror

inherited

Definition at line 65 of file pcb_footprint.h.

Referenced by PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), DoPCBComponents(), PCAD2KICAD::PCB_FOOTPRINT::Flip(), and PCAD2KICAD::PCB_FOOTPRINT::PCB_FOOTPRINT().

◆ m_name

TTEXTVALUE PCAD2KICAD::PCB_COMPONENT::m_name

inherited

Definition at line 71 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToBoard(), PCAD2KICAD::PCB_TEXT::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToFootprint(), ConnectPinToNet(), PCAD2KICAD::PCB_FOOTPRINT::DoLayerContentsObjects(), DoPCBComponents(), PCAD2KICAD::PCB_PAD::Parse(), PCAD2KICAD::PCB_VIA::Parse(), PCAD2KICAD::PCB_TEXT::Parse(), PCAD2KICAD::PCB_FOOTPRINT::Parse(), PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT(), and PCAD2KICAD::PCB_FOOTPRINT::SetName().

◆ m_net

wxString PCAD2KICAD::PCB_COMPONENT::m_net

inherited

Definition at line 72 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_PAD::AddToFootprint(), PCAD2KICAD::PCB_POLYGON::AssignNet(), ConnectPinToNet(), PCAD2KICAD::PCB_PAD::Parse(), PCAD2KICAD::PCB_POLYGON::Parse(), PCAD2KICAD::PCB_COPPER_POUR::Parse(), PCAD2KICAD::PCB_PLANE::Parse(), PCAD2KICAD::PCB_VIA::Parse(), PCAD2KICAD::PCB_LINE::Parse(), and PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT().

◆ m_netCode

int PCAD2KICAD::PCB_COMPONENT::m_netCode

inherited

Definition at line 73 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_LINE::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToBoard(), PCAD2KICAD::PCB_POLYGON::AddToBoard(), PCAD2KICAD::PCB_POLYGON::AssignNet(), PCAD2KICAD::PCB_PAD::Parse(), PCAD2KICAD::PCB_POLYGON::Parse(), PCAD2KICAD::PCB_COPPER_POUR::Parse(), PCAD2KICAD::PCB_PLANE::Parse(), PCAD2KICAD::PCB_VIA::Parse(), PCAD2KICAD::PCB_LINE::Parse(), and PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT().

◆ m_objType

◆ m_patGraphRefName

wxString PCAD2KICAD::PCB_COMPONENT::m_patGraphRefName

inherited

Definition at line 75 of file pcb_component.h.

Referenced by DoPCBComponents(), PCAD2KICAD::PCB_FOOTPRINT::Parse(), and PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT().

◆ m_PCadLayer

int PCAD2KICAD::PCB_COMPONENT::m_PCadLayer

inherited

Definition at line 65 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_COMPONENT::GetKiCadLayer(), PCAD2KICAD::PCB_PAD_SHAPE::Parse(), PCAD2KICAD::PCB_VIA_SHAPE::Parse(), PCAD2KICAD::PCB_ARC::Parse(), PCAD2KICAD::PCB_LINE::Parse(), PCAD2KICAD::PCB_TEXT::Parse(), PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT(), and PCAD2KICAD::PCB_POLYGON::PCB_POLYGON().

◆ m_PcbComponents

PCB_COMPONENTS_ARRAY PCAD2KICAD::PCB::m_PcbComponents

Definition at line 62 of file pcb.h.

Referenced by AddToBoard(), ConnectPinToNet(), DoPCBComponents(), ParseBoard(), and ~PCB().

◆ m_PcbNetlist

PCB_NETS_ARRAY PCAD2KICAD::PCB::m_PcbNetlist

Definition at line 63 of file pcb.h.

Referenced by AddToBoard(), GetNetCode(), ParseBoard(), and ~PCB().

◆ m_positionX

int PCAD2KICAD::PCB_COMPONENT::m_positionX

inherited

Definition at line 68 of file pcb_component.h.

◆ m_positionY

int PCAD2KICAD::PCB_COMPONENT::m_positionY

inherited

Definition at line 69 of file pcb_component.h.

◆ m_rotation

EDA_ANGLE PCAD2KICAD::PCB_COMPONENT::m_rotation

inherited

Definition at line 70 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), PCAD2KICAD::PCB_TEXT::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToFootprint(), DoPCBComponents(), PCAD2KICAD::PCB_FOOTPRINT::Flip(), PCAD2KICAD::PCB_PAD::Flip(), PCAD2KICAD::PCB_PAD::Parse(), PCAD2KICAD::PCB_VIA::Parse(), PCAD2KICAD::PCB_TEXT::Parse(), and PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT().

◆ m_SizeX

int PCAD2KICAD::PCB::m_SizeX

Definition at line 66 of file pcb.h.

Referenced by ParseBoard(), and PCB().

◆ m_SizeY

int PCAD2KICAD::PCB::m_SizeY

Definition at line 67 of file pcb.h.

Referenced by ParseBoard(), and PCB().

◆ m_tag

int PCAD2KICAD::PCB_COMPONENT::m_tag

inherited

Definition at line 63 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT().

◆ m_uuid

KIID PCAD2KICAD::PCB_COMPONENT::m_uuid

inherited

Definition at line 67 of file pcb_component.h.

◆ m_Value

TTEXTVALUE PCAD2KICAD::PCB_FOOTPRINT::m_Value

inherited

Definition at line 63 of file pcb_footprint.h.

Referenced by PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), DoPCBComponents(), and PCAD2KICAD::PCB_FOOTPRINT::PCB_FOOTPRINT().

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

Public Member Functions

Public Attributes

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PCB()

◆ ~PCB()

Member Function Documentation

◆ AddToBoard()

◆ AddToFootprint()

◆ ConnectPinToNet()

◆ DoLayerContentsObjects()

◆ DoPCBComponents()

◆ FindCompDefName()

◆ FindLayer()

◆ FindModulePatternDefName()

◆ FindOutlinePoint()

◆ FindPatternMultilayerSection()

◆ Flip()

◆ GetBoardOutline()

◆ GetDistance()

◆ GetKiCadLayer() [1/2]

◆ GetKiCadLayer() [2/2]

◆ GetLayerNetNameRef()

◆ GetLayerType()

◆ GetNetCode()

◆ MapLayer()

◆ Parse()

◆ ParseBoard()

◆ SetName()

◆ SetPosOffset()

◆ SetTextProperty()

Member Data Documentation

◆ m_board

◆ m_BoardOutline

◆ m_callbacks

◆ m_compRef

◆ m_DefaultMeasurementUnit

◆ m_FootprintItems

◆ m_KiCadLayer

◆ m_LayersMap

◆ m_layersStackup

◆ m_Mirror

◆ m_name

◆ m_net

◆ m_netCode

◆ m_objType

◆ m_patGraphRefName

◆ m_PCadLayer

◆ m_PcbComponents

◆ m_PcbNetlist

◆ m_positionX

◆ m_positionY

◆ m_rotation

◆ m_SizeX

◆ m_SizeY

◆ m_tag

◆ m_uuid

◆ m_Value