#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

int	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)

Private Attributes
wxArrayString	m_layersStackup

Detailed Description

Definition at line 46 of file pcb.h.

Constructor & Destructor Documentation

◆ PCB()

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

Definition at line 79 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 109 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 942 of file pcb.cpp.

 {
     int i;
     PCB_NET* net;
 
     m_board->SetCopperLayerCount( m_layersStackup.GetCount() );
 
     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_LINE, PCAD2KICAD::PCB_POLYGON, PCAD2KICAD::PCB_ARC, PCAD2KICAD::PCB_PAD, 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 428 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 218 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_PLANE::Parse(), PCAD2KICAD::PCB_COPPER_POUR::Parse(), PCAD2KICAD::PCB_CUTOUT::Parse(), PCAD2KICAD::PCB_ARC::Parse(), PCAD2KICAD::PCB_LINE::Parse(), PCAD2KICAD::PCB_POLYGON::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 239 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() == wxT( "pattern" ) )
         {
             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 = StrToInt1Units( str );
                 }
 
                 str = FindNodeGetContent( lNode, wxT( "isFlipped" ) );
 
                 if( str == wxT( "True" ) )
                     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() == wxT( "padNum" ) )
                             {
                                 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() == wxT( "pad" ) )
         {
             pad = new PCB_PAD( this, m_board );
             pad->Parse( lNode, m_DefaultMeasurementUnit, aActualConversion );
             m_PcbComponents.Add( pad );
         }
         else if( lNode->GetName() == wxT( "via" ) )
         {
             via = new PCB_VIA( this, m_board );
             via->Parse( lNode, m_DefaultMeasurementUnit, aActualConversion );
             m_PcbComponents.Add( via );
         }
         else if( lNode->GetName() == wxT( "polyKeepOut" ) )
         {
             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 142 of file pcb.cpp.

 {
     XNODE*      result = nullptr, * lNode;
     wxString    propValue;
 
     lNode = FindNode( aNode, wxT( "compDef" ) );
 
     while( lNode )
     {
         if( lNode->GetName() == wxT( "compDef" ) )
         {
             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 456 of file pcb.cpp.

 {
     for( LAYER_NUM i = 0; i < (int)m_layersStackup.GetCount(); ++i )
     {
         if( m_layersStackup[i] == 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 69 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 567 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().

◆ Flip()

void PCAD2KICAD::PCB_FOOTPRINT::Flip ( )

overridevirtualinherited

Reimplemented from PCAD2KICAD::PCB_COMPONENT.

Definition at line 623 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 596 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() == wxT( "layerContents" ) )
             {
                 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() == wxT( "line" ) )
                         {
                             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 590 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::GetKiCadLayer ( int aPCadLayer ) const

overridevirtual

Implements PCAD2KICAD::PCB_CALLBACKS.

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

◆ GetKiCadLayer() [2/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_COMPONENT::m_PCadLayer

int m_PCadLayer

Definition: pcb_component.h:65

PCAD2KICAD::PCB_CALLBACKS::GetKiCadLayer

virtual PCB_LAYER_ID GetKiCadLayer(int aPCadLayer) const =0

PCAD2KICAD::PCB_COMPONENT::m_callbacks

PCB_CALLBACKS * m_callbacks

Definition: pcb_component.h:78

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

◆ GetLayerNetNameRef()

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

overridevirtual

Implements PCAD2KICAD::PCB_CALLBACKS.

Definition at line 68 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 57 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 125 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 468 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
 #if 0 // was:
             KiCadLayer = FIRST_COPPER_LAYER + m_layersStackup.GetCount() - 1 - layernum;
 #else
             KiCadLayer = ToLAYER_ID( layernum );
 #endif
     }
 
     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 == wxT( "NonSignal" ) )
             newlayer.layerType = LAYER_TYPE_NONSIGNAL;
 
         if( layerType == wxT( "Signal" ) )
             newlayer.layerType = LAYER_TYPE_SIGNAL;
 
         if( layerType == wxT( "Plane" ) )
             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(), FIRST_COPPER_LAYER, Format(), TLAYER::KiCadLayer, LAYER_TYPE_NONSIGNAL, LAYER_TYPE_PLANE, LAYER_TYPE_SIGNAL, TLAYER::layerType, m_LayersMap, m_layersStackup, 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 388 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 690 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() == wxT( "layerDef" ) )
             {
                 if( FindNode( aNode, wxT( "layerType" ) ) )
                 {
                     layerType = FindNode( aNode,
                                           wxT( "layerType" ) )->GetNodeContent().Trim( false );
 
                     if( layerType == wxT( "Signal" ) || layerType == wxT( "Plane" ) )
                     {
                         aNode->GetAttribute( wxT( "Name" ), &layerName );
                         layerName = layerName.MakeUpper();
                         m_layersStackup.Add( layerName );
 
                         if( m_layersStackup.size() > 32 )
                             THROW_IO_ERROR( _( "KiCad only supports 32 signal layers." ) );
                     }
                 }
             }
 
             aNode = aNode->GetNext();
         }
     }
 
     // Layers mapping
     aNode = FindNode( (XNODE *)aXmlDoc->GetRoot(), wxT( "pcbDesign" ) );
 
     if( aNode )
     {
         aNode = FindNode( aNode, wxT( "layerDef" ) );
 
         while( aNode )
         {
             if( aNode->GetName() == wxT( "layerDef" ) )
                 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() == wxT( "multiLayer" ) )
                 DoPCBComponents( aNode, aXmlDoc, aActualConversion, aStatusBar );
 
             // objects
             if( aNode->GetName() == wxT( "layerContents" ) )
                 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() == wxT( "compDef" ) )
                 {
                     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 370 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_LINE, PCAD2KICAD::PCB_POLYGON, and PCAD2KICAD::PCB_ARC.

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 170 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() == wxT( "patternGraphicsRef" ) )
             {
                 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 PCAD2KICAD::PCB_TEXT::AddToBoard(), PCAD2KICAD::PCB_ARC::AddToBoard(), PCAD2KICAD::PCB_LINE::AddToBoard(), PCAD2KICAD::PCB_POLYGON::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToBoard(), AddToBoard(), PCAD2KICAD::PCB_FOOTPRINT::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_VIA::Parse(), PCAD2KICAD::PCB_PAD::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_TEXT::AddToBoard(), PCAD2KICAD::PCB_ARC::AddToBoard(), PCAD2KICAD::PCB_LINE::AddToBoard(), PCAD2KICAD::PCB_POLYGON::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToBoard(), PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), PCAD2KICAD::PCB_ARC::AddToFootprint(), PCAD2KICAD::PCB_POLYGON::AddToFootprint(), PCAD2KICAD::PCB_LINE::AddToFootprint(), PCAD2KICAD::PCB_PAD::AddToFootprint(), PCAD2KICAD::PCB_PAD::Flip(), PCAD2KICAD::PCB_ARC::Flip(), PCAD2KICAD::PCB_LINE::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

wxArrayString PCAD2KICAD::PCB::m_layersStackup

private

Definition at line 86 of file pcb.h.

Referenced by AddToBoard(), FindLayer(), MapLayer(), 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_TEXT::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToBoard(), PCAD2KICAD::PCB_FOOTPRINT::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_PLANE::Parse(), PCAD2KICAD::PCB_COPPER_POUR::Parse(), PCAD2KICAD::PCB_PAD::Parse(), PCAD2KICAD::PCB_VIA::Parse(), PCAD2KICAD::PCB_LINE::Parse(), PCAD2KICAD::PCB_POLYGON::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_POLYGON::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToBoard(), PCAD2KICAD::PCB_POLYGON::AssignNet(), PCAD2KICAD::PCB_PLANE::Parse(), PCAD2KICAD::PCB_COPPER_POUR::Parse(), PCAD2KICAD::PCB_VIA::Parse(), PCAD2KICAD::PCB_PAD::Parse(), PCAD2KICAD::PCB_POLYGON::Parse(), PCAD2KICAD::PCB_LINE::Parse(), and PCAD2KICAD::PCB_COMPONENT::PCB_COMPONENT().

◆ m_objType

char PCAD2KICAD::PCB_COMPONENT::m_objType

inherited

◆ 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

int PCAD2KICAD::PCB_COMPONENT::m_rotation

inherited

Definition at line 70 of file pcb_component.h.

Referenced by PCAD2KICAD::PCB_TEXT::AddToBoard(), PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToFootprint(), DoPCBComponents(), PCAD2KICAD::PCB_PAD::Flip(), PCAD2KICAD::PCB_FOOTPRINT::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()

◆ 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