#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 = wxEmptyString; // 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

◆ 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