AllSpiceMirrors/kicad
7
Fork 0
mirror of https://gitlab.com/kicad/code/kicad.git synced 2024-11-25 00:35:01 +00:00
Files Issues Releases Activity
master
kicad/pcbnew/pcb_io/ipc2581/pcb_io_ipc2581.cpp
Jon Evans 2a605e4a4e Infrastructure and file format for via stacks
2024-10-06 18:45:25 -04:00

3035 lines
102 KiB
C++
Raw Permalink Blame History

/**
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2023, 2024 KiCad Developers, see AUTHORS.txt for contributors.
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "pcb_io_ipc2581.h"
#include <base_units.h>
#include <bezier_curves.h>
#include <board.h>
#include <board_design_settings.h>
#include <board_stackup_manager/stackup_predefined_prms.h>
#include <build_version.h>
#include <callback_gal.h>
#include <connectivity/connectivity_data.h>
#include <connectivity/connectivity_algo.h>
#include <convert_basic_shapes_to_polygon.h>
#include <font/font.h>
#include <hash_eda.h>
#include <pcb_dimension.h>
#include <pcb_textbox.h>
#include <pgm_base.h>
#include <progress_reporter.h>
#include <settings/settings_manager.h>
#include <wx_fstream_progress.h>
#include <geometry/shape_line_chain.h>
#include <geometry/shape_poly_set.h>
#include <geometry/shape_segment.h>
#include <wx/log.h>
#include <wx/numformatter.h>
#include <wx/xml/xml.h>
/**
* Flag to enable IPC-2581 debugging output.
*
* @ingroup trace_env_vars
*/
static const wxChar traceIpc2581[] = wxT( "KICAD_IPC_2581" );
PCB_IO_IPC2581::~PCB_IO_IPC2581()
{
clearLoadedFootprints();
}
void PCB_IO_IPC2581::clearLoadedFootprints()
{
for( FOOTPRINT* fp : m_loaded_footprints )
delete fp;
m_loaded_footprints.clear();
}
std::vector<FOOTPRINT*> PCB_IO_IPC2581::GetImportedCachedLibraryFootprints()
{
std::vector<FOOTPRINT*> retval;
for( FOOTPRINT* fp : m_loaded_footprints )
retval.push_back( static_cast<FOOTPRINT*>( fp->Clone() ) );
return retval;
}
void PCB_IO_IPC2581::insertNode( wxXmlNode* aParent, wxXmlNode* aNode )
{
// insertNode places the node at the start of the list of children
if( aParent->GetChildren() )
aNode->SetNext( aParent->GetChildren() );
else
aNode->SetNext( nullptr );
aParent->SetChildren( aNode );
aNode->SetParent( aParent );
m_total_bytes += 2 * aNode->GetName().size() + 5;
}
void PCB_IO_IPC2581::insertNodeAfter( wxXmlNode* aPrev, wxXmlNode* aNode )
{
// insertNode places the node directly after aPrev
aNode->SetNext( aPrev->GetNext() );
aPrev->SetNext( aNode );
aNode->SetParent( aPrev->GetParent() );
m_total_bytes += 2 * aNode->GetName().size() + 5;
}
wxXmlNode* PCB_IO_IPC2581::insertNode( wxXmlNode* aParent, const wxString& aName )
{
// Opening tag, closing tag, brackets and the closing slash
m_total_bytes += 2 * aName.size() + 5;
wxXmlNode* node = new wxXmlNode( wxXML_ELEMENT_NODE, aName );
insertNode( aParent, node );
return node;
}
void PCB_IO_IPC2581::appendNode( wxXmlNode* aParent, wxXmlNode* aNode )
{
// AddChild iterates through the entire list of children, so we want to avoid
// that if possible. When we share a parent and our next sibling is null,
// then we are the last child and can just append to the end of the list.
static wxXmlNode* lastNode = nullptr;
if( lastNode && lastNode->GetParent() == aParent && lastNode->GetNext() == nullptr )
{
aNode->SetParent( aParent );
lastNode->SetNext( aNode );
}
else
{
aParent->AddChild( aNode );
}
lastNode = aNode;
// Opening tag, closing tag, brackets and the closing slash
m_total_bytes += 2 * aNode->GetName().size() + 5;
}
wxXmlNode* PCB_IO_IPC2581::appendNode( wxXmlNode* aParent, const wxString& aName )
{
wxXmlNode* node = new wxXmlNode( wxXML_ELEMENT_NODE, aName );
appendNode( aParent, node );
return node;
}
wxString PCB_IO_IPC2581::genString( const wxString& aStr, const char* aPrefix ) const
{
wxString str;
if( m_version == 'C' )
{
str = aStr;
str.Replace( wxT( ":" ), wxT( "_" ) );
if( aPrefix )
str.Prepend( wxString( aPrefix ) + wxT( ":" ) );
else
str.Prepend( wxT( "KI:" ) );
}
else
{
if( aPrefix )
str = wxString::Format( "%s_", aPrefix );
for( wxString::const_iterator iter = aStr.begin(); iter != aStr.end(); ++iter )
{
if( !m_acceptable_chars.count( *iter ) )
str.Append( '_' );
else
str.Append( *iter );
}
}
return str;
}
wxString PCB_IO_IPC2581::genLayerString( PCB_LAYER_ID aLayer, const char* aPrefix ) const
{
return genString( m_board->GetLayerName( aLayer ), aPrefix );
}
wxString PCB_IO_IPC2581::genLayersString( PCB_LAYER_ID aTop, PCB_LAYER_ID aBottom,
const char* aPrefix ) const
{
return genString( wxString::Format( wxS( "%s_%s" ),
m_board->GetLayerName( aTop ),
m_board->GetLayerName( aBottom ) ), aPrefix );
}
wxString PCB_IO_IPC2581::pinName( const PAD* aPad ) const
{
wxString name = aPad->GetNumber();
FOOTPRINT* fp = aPad->GetParentFootprint();
size_t ii = 0;
if( name.empty() && fp )
{
for( ii = 0; ii < fp->GetPadCount(); ++ii )
{
if( fp->Pads()[ii] == aPad )
break;
}
}
// Pins are required to have names, so if our pad doesn't have a name, we need to
// generate one that is unique
if( aPad->GetAttribute() == PAD_ATTRIB::NPTH )
name = wxString::Format( "NPTH%zu", ii );
else if( name.empty() )
name = wxString::Format( "PAD%zu", ii );
return genString( name, "PIN" );
}
wxString PCB_IO_IPC2581::componentName( FOOTPRINT* aFootprint )
{
auto tryInsert =
[&]( const wxString& aName )
{
if( m_footprint_refdes_dict.count( aName ) )
{
if( m_footprint_refdes_dict.at( aName ) != aFootprint )
return false;
}
else
{
m_footprint_refdes_dict.insert( { aName, aFootprint } );
}
return true;
};
if( m_footprint_refdes_reverse_dict.count( aFootprint ) )
return m_footprint_refdes_reverse_dict.at( aFootprint );
wxString baseName = genString( aFootprint->GetReference(), "CMP" );
wxString name = baseName;
int suffix = 1;
while( !tryInsert( name ) )
name = wxString::Format( "%s_%d", baseName, suffix++ );
m_footprint_refdes_reverse_dict[aFootprint] = name;
return name;
}
wxString PCB_IO_IPC2581::floatVal( double aVal )
{
wxString str = wxString::FromCDouble( aVal, m_sigfig );
// Remove all but the last trailing zeros from str
while( str.EndsWith( wxT( "00" ) ) )
str.RemoveLast();
// We don't want to output -0.0 as this value is just 0 for fabs
if( str == wxT( "-0.0" ) )
return wxT( "0.0" );
return str;
}
void PCB_IO_IPC2581::addXY( wxXmlNode* aNode, const VECTOR2I& aVec, const char* aXName,
const char* aYName )
{
if( aXName )
addAttribute( aNode, aXName, floatVal( m_scale * aVec.x ) );
else
addAttribute( aNode, "x", floatVal( m_scale * aVec.x ) );
if( aYName )
addAttribute( aNode, aYName, floatVal( -m_scale * aVec.y ) );
else
addAttribute( aNode, "y", floatVal( -m_scale * aVec.y ) );
}
void PCB_IO_IPC2581::addAttribute( wxXmlNode* aNode, const wxString& aName, const wxString& aValue )
{
m_total_bytes += aName.size() + aValue.size() + 4;
aNode->AddAttribute( aName, aValue );
}
wxXmlNode* PCB_IO_IPC2581::generateXmlHeader()
{
wxXmlNode* xmlHeaderNode = new wxXmlNode(wxXML_ELEMENT_NODE, "IPC-2581");
addAttribute( xmlHeaderNode, "revision", m_version);
addAttribute( xmlHeaderNode, "xmlns", "http://webstds.ipc.org/2581");
addAttribute( xmlHeaderNode, "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
addAttribute( xmlHeaderNode, "xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
if( m_version == 'B' )
{
addAttribute( xmlHeaderNode, "xsi:schemaLocation",
"http://webstds.ipc.org/2581 http://webstds.ipc.org/2581/IPC-2581B1.xsd" );
}
else
{
addAttribute( xmlHeaderNode, "xsi:schemaLocation",
"http://webstds.ipc.org/2581 http://webstds.ipc.org/2581/IPC-2581C.xsd" );
}
m_xml_doc->SetRoot( xmlHeaderNode );
return xmlHeaderNode;
}
wxXmlNode* PCB_IO_IPC2581::generateContentSection()
{
if( m_progressReporter )
m_progressReporter->AdvancePhase( _( "Generating content section" ) );
wxXmlNode* contentNode = appendNode( m_xml_root, "Content" );
addAttribute( contentNode, "roleRef", "Owner" );
wxXmlNode* node = appendNode( contentNode, "FunctionMode" );
addAttribute( node, "mode", "ASSEMBLY" );
// This element is deprecated in revision 'C' and later
if( m_version == 'B' )
addAttribute( node, "level", "3" );
node = appendNode( contentNode, "StepRef" );
wxFileName fn( m_board->GetFileName() );
addAttribute( node, "name", genString( fn.GetName(), "BOARD" ) );
wxXmlNode* color_node = generateContentStackup( contentNode );
if( m_version == 'C' )
{
contentNode->AddChild( color_node );
m_line_node = appendNode( contentNode, "DictionaryLineDesc" );
addAttribute( m_line_node, "units", m_units_str );
wxXmlNode* fillNode = appendNode( contentNode, "DictionaryFillDesc" );
addAttribute( fillNode, "units", m_units_str );
m_shape_std_node = appendNode( contentNode, "DictionaryStandard" );
addAttribute( m_shape_std_node, "units", m_units_str );
m_shape_user_node = appendNode( contentNode, "DictionaryUser" );
addAttribute( m_shape_user_node, "units", m_units_str );
}
else
{
m_shape_std_node = appendNode( contentNode, "DictionaryStandard" );
addAttribute( m_shape_std_node, "units", m_units_str );
m_shape_user_node = appendNode( contentNode, "DictionaryUser" );
addAttribute( m_shape_user_node, "units", m_units_str );
m_line_node = appendNode( contentNode, "DictionaryLineDesc" );
addAttribute( m_line_node, "units", m_units_str );
contentNode->AddChild( color_node );
}
return contentNode;
}
void PCB_IO_IPC2581::addLocationNode( wxXmlNode* aNode, double aX, double aY )
{
wxXmlNode* location_node = appendNode( aNode, "Location" );
addXY( location_node, VECTOR2I( aX, aY ) );
}
void PCB_IO_IPC2581::addLocationNode( wxXmlNode* aNode, const PAD& aPad, bool aRelative )
{
VECTOR2D pos{};
if( aRelative )
pos = aPad.GetFPRelativePosition();
else
pos = aPad.GetPosition();
if( aPad.GetOffset( PADSTACK::ALL_LAYERS ).x != 0 || aPad.GetOffset( PADSTACK::ALL_LAYERS ).y != 0 )
pos += aPad.GetOffset( PADSTACK::ALL_LAYERS );
addLocationNode( aNode, pos.x, pos.y );
}
void PCB_IO_IPC2581::addLocationNode( wxXmlNode* aNode, const PCB_SHAPE& aShape )
{
VECTOR2D pos{};
switch( aShape.GetShape() )
{
// Rectangles in KiCad are mapped by their corner while IPC2581 uses the center
case SHAPE_T::RECTANGLE:
pos = aShape.GetPosition()
+ VECTOR2I( aShape.GetRectangleWidth() / 2.0, aShape.GetRectangleHeight() / 2.0 );
break;
// Both KiCad and IPC2581 use the center of the circle
case SHAPE_T::CIRCLE:
pos = aShape.GetPosition();
break;
// KiCad uses the exact points on the board, so we want the reference location to be 0,0
case SHAPE_T::POLY:
case SHAPE_T::BEZIER:
case SHAPE_T::SEGMENT:
case SHAPE_T::ARC:
pos = VECTOR2D( 0, 0 );
break;
case SHAPE_T::UNDEFINED:
wxFAIL;
}
addLocationNode( aNode, pos.x, pos.y );
}
size_t PCB_IO_IPC2581::lineHash( int aWidth, LINE_STYLE aDashType )
{
size_t hash = hash_val( aWidth );
hash_combine( hash, aDashType );
return hash;
}
size_t PCB_IO_IPC2581::shapeHash( const PCB_SHAPE& aShape )
{
return hash_fp_item( &aShape, HASH_POS | REL_COORD );
}
wxXmlNode* PCB_IO_IPC2581::generateContentStackup( wxXmlNode* aContentNode )
{
BOARD_DESIGN_SETTINGS& bds = m_board->GetDesignSettings();
BOARD_STACKUP& stackup = bds.GetStackupDescriptor();
stackup.SynchronizeWithBoard( &bds );
wxXmlNode* color_node = new wxXmlNode( wxXML_ELEMENT_NODE, "DictionaryColor" );
for( BOARD_STACKUP_ITEM* item: stackup.GetList() )
{
wxString layer_name = item->GetLayerName();
int sub_layer_count = 1;
if( layer_name.empty() )
layer_name = m_board->GetLayerName( item->GetBrdLayerId() );
layer_name = genString( layer_name, "LAYER" );
if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
{
layer_name = genString( wxString::Format( "DIELECTRIC_%d", item->GetDielectricLayerId() ),
"LAYER" );
sub_layer_count = item->GetSublayersCount();
}
else
{
m_layer_name_map.emplace( item->GetBrdLayerId(), layer_name );
}
for( int sub_idx = 0; sub_idx < sub_layer_count; sub_idx++ )
{
wxString sub_layer_name = layer_name;
if( sub_idx > 0 )
sub_layer_name += wxString::Format( "_%d", sub_idx );
wxXmlNode* node = appendNode( aContentNode, "LayerRef" );
addAttribute( node, "name", sub_layer_name );
if( !IsPrmSpecified( item->GetColor( sub_idx ) ) )
continue;
wxXmlNode* entry_color = appendNode( color_node, "EntryColor" );
addAttribute( entry_color, "id", genString( sub_layer_name, "COLOR" ) );
wxXmlNode* color = appendNode( entry_color, "Color" );
wxString colorName = item->GetColor( sub_idx );
if( colorName.StartsWith( wxT( "#" ) ) ) // This is a user defined color,
// not in standard color list.
{
COLOR4D layer_color( colorName );
addAttribute( color, "r", wxString::Format( "%d",
KiROUND( layer_color.r * 255 ) ) );
addAttribute( color, "g", wxString::Format( "%d",
KiROUND( layer_color.g * 255 ) ) );
addAttribute( color, "b", wxString::Format( "%d",
KiROUND( layer_color.b * 255 ) ) );
}
else
{
for( const FAB_LAYER_COLOR& fab_color : GetStandardColors( item->GetType() ) )
{
if( fab_color.GetName() == colorName )
{
addAttribute( color, "r", wxString::Format( "%d", KiROUND( fab_color.GetColor( item->GetType() ).r * 255 ) ) );
addAttribute( color, "g", wxString::Format( "%d", KiROUND( fab_color.GetColor( item->GetType() ).g * 255 ) ) );
addAttribute( color, "b", wxString::Format( "%d", KiROUND( fab_color.GetColor( item->GetType() ).b * 255 ) ) );
break;
}
}
}
}
}
return color_node;
}
void PCB_IO_IPC2581::addFillDesc( wxXmlNode* aNode, FILL_T aFill, bool aForce )
{
if( aFill == FILL_T::FILLED_SHAPE )
{
// By default, we do not fill shapes because FILL is the default value for most.
// But for some outlines, we may need to force a fill.
if( aForce )
{
wxXmlNode* fillDesc_node = appendNode( aNode, "FillDesc" );
addAttribute( fillDesc_node, "fillProperty", "FILL" );
}
}
else
{
wxXmlNode* fillDesc_node = appendNode( aNode, "FillDesc" );
addAttribute( fillDesc_node, "fillProperty", "HOLLOW" );
}
}
void PCB_IO_IPC2581::addLineDesc( wxXmlNode* aNode, int aWidth, LINE_STYLE aDashType, bool aForce )
{
wxCHECK_RET( aNode, "aNode is null" );
if( aWidth < 0 )
return;
wxXmlNode* entry_node = nullptr;
if( !aForce )
{
size_t hash = lineHash( aWidth, aDashType );
wxString name = wxString::Format( "LINE_%zu", m_line_dict.size() + 1 );
auto[ iter, inserted ] = m_line_dict.emplace( hash, name );
// Either add a new entry or reference an existing one
wxXmlNode* lineDesc_node = appendNode( aNode, "LineDescRef" );
addAttribute( lineDesc_node, "id", iter->second );
if( !inserted )
return;
entry_node = appendNode( m_line_node, "EntryLineDesc" );
addAttribute( entry_node, "id", name );
}
else
{
// Force the LineDesc to be added directly to the parent node
entry_node = aNode;
}
wxXmlNode* line_node = appendNode( entry_node, "LineDesc" );
addAttribute( line_node, "lineWidth", floatVal( m_scale * aWidth ) );
addAttribute( line_node, "lineEnd", "ROUND" );
switch( aDashType )
{
case LINE_STYLE::DOT:
addAttribute( line_node, "lineProperty", "DOTTED" );
break;
case LINE_STYLE::DASH:
addAttribute( line_node, "lineProperty", "DASHED" );
break;
case LINE_STYLE::DASHDOT:
addAttribute( line_node, "lineProperty", "CENTER" );
break;
case LINE_STYLE::DASHDOTDOT:
addAttribute( line_node, "lineProperty", "PHANTOM" );
break;
default:
break;
}
}
void PCB_IO_IPC2581::addKnockoutText( wxXmlNode* aContentNode, PCB_TEXT* aText )
{
SHAPE_POLY_SET finalPoly;
aText->TransformTextToPolySet( finalPoly, 0, ARC_HIGH_DEF, ERROR_INSIDE );
finalPoly.Fracture( SHAPE_POLY_SET::PM_FAST );
for( int ii = 0; ii < finalPoly.OutlineCount(); ++ii )
addContourNode( aContentNode, finalPoly, ii );
}
void PCB_IO_IPC2581::addText( wxXmlNode* aContentNode, EDA_TEXT* aText,
const KIFONT::METRICS& aFontMetrics )
{
if( !aText->IsVisible() )
return;
KIGFX::GAL_DISPLAY_OPTIONS empty_opts;
KIFONT::FONT* font = aText->GetFont();
TEXT_ATTRIBUTES attrs = aText->GetAttributes();
attrs.m_StrokeWidth = aText->GetEffectiveTextPenWidth();
attrs.m_Angle = aText->GetDrawRotation();
attrs.m_Multiline = false;
wxXmlNode* text_node = appendNode( aContentNode, "UserSpecial" );
if( !font )
font = KIFONT::FONT::GetFont();
std::list<VECTOR2I> pts;
auto push_pts =
[&]()
{
if( pts.size() < 2 )
return;
wxXmlNode* line_node = nullptr;
// Polylines are only allowed for more than 3 points (in version B).
// Otherwise, we have to use a line
if( pts.size() < 3 )
{
line_node = appendNode( text_node, "Line" );
addXY( line_node, pts.front(), "startX", "startY" );
addXY( line_node, pts.back(), "endX", "endY" );
}
else
{
line_node = appendNode( text_node, "Polyline" );
wxXmlNode* point_node = appendNode( line_node, "PolyBegin" );
addXY( point_node, pts.front() );
auto iter = pts.begin();
for( ++iter; iter != pts.end(); ++iter )
{
wxXmlNode* point_node = appendNode( line_node, "PolyStepSegment" );
addXY( point_node, *iter );
}
}
addLineDesc( line_node, attrs.m_StrokeWidth, LINE_STYLE::SOLID );
pts.clear();
};
CALLBACK_GAL callback_gal( empty_opts,
// Stroke callback
[&]( const VECTOR2I& aPt1, const VECTOR2I& aPt2 )
{
if( !pts.empty() )
{
if( aPt1 == pts.back() )
pts.push_back( aPt2 );
else if( aPt2 == pts.front() )
pts.push_front( aPt1 );
else if( aPt1 == pts.front() )
pts.push_front( aPt2 );
else if( aPt2 == pts.back() )
pts.push_back( aPt1 );
else
{
push_pts();
pts.push_back( aPt1 );
pts.push_back( aPt2 );
}
}
else
{
pts.push_back( aPt1 );
pts.push_back( aPt2 );
}
},
// Polygon callback
[&]( const SHAPE_LINE_CHAIN& aPoly )
{
if( aPoly.PointCount() < 3 )
return;
wxXmlNode* outline_node = appendNode( text_node, "Outline" );
wxXmlNode* poly_node = appendNode( outline_node, "Polygon" );
addLineDesc( outline_node, 0, LINE_STYLE::SOLID );
const std::vector<VECTOR2I>& pts = aPoly.CPoints();
wxXmlNode* point_node = appendNode( poly_node, "PolyBegin" );
addXY( point_node, pts.front() );
for( size_t ii = 1; ii < pts.size(); ++ii )
{
wxXmlNode* point_node =
appendNode( poly_node, "PolyStepSegment" );
addXY( point_node, pts[ii] );
}
point_node = appendNode( poly_node, "PolyStepSegment" );
addXY( point_node, pts.front() );
} );
//TODO: handle multiline text
font->Draw( &callback_gal, aText->GetShownText( true ), aText->GetTextPos(), attrs,
aFontMetrics );
if( !pts.empty() )
push_pts();
if( text_node->GetChildren() == nullptr )
{
aContentNode->RemoveChild( text_node );
delete text_node;
}
}
void PCB_IO_IPC2581::addShape( wxXmlNode* aContentNode, const PAD& aPad, PCB_LAYER_ID aLayer )
{
size_t hash = hash_fp_item( &aPad, 0 );
auto iter = m_std_shape_dict.find( hash );
if( iter != m_std_shape_dict.end() )
{
wxXmlNode* shape_node = appendNode( aContentNode, "StandardPrimitiveRef" );
addAttribute( shape_node, "id", iter->second );
return;
}
int maxError = m_board->GetDesignSettings().m_MaxError;
wxString name;
VECTOR2I expansion{ 0, 0 };
if( LSET( { F_Mask, B_Mask } ).Contains( aLayer ) )
expansion.x = expansion.y = 2 * aPad.GetSolderMaskExpansion( PADSTACK::ALL_LAYERS );
if( LSET( { F_Paste, B_Paste } ).Contains( aLayer ) )
expansion = 2 * aPad.GetSolderPasteMargin( PADSTACK::ALL_LAYERS );
switch( aPad.GetShape( PADSTACK::ALL_LAYERS ) )
{
case PAD_SHAPE::CIRCLE:
{
name = wxString::Format( "CIRCLE_%zu", m_std_shape_dict.size() + 1 );
m_std_shape_dict.emplace( hash, name );
wxXmlNode* entry_node = appendNode( m_shape_std_node, "EntryStandard" );
addAttribute( entry_node, "id", name );
wxXmlNode* circle_node = appendNode( entry_node, "Circle" );
circle_node->AddAttribute( "diameter",
floatVal( m_scale * ( expansion.x + aPad.GetSizeX() ) ) );
break;
}
case PAD_SHAPE::RECTANGLE:
{
name = wxString::Format( "RECT_%zu", m_std_shape_dict.size() + 1 );
m_std_shape_dict.emplace( hash, name );
wxXmlNode* entry_node = appendNode( m_shape_std_node, "EntryStandard" );
addAttribute( entry_node, "id", name );
wxXmlNode* rect_node = appendNode( entry_node, "RectCenter" );
VECTOR2D pad_size = aPad.GetSize( PADSTACK::ALL_LAYERS ) + expansion;
addAttribute( rect_node, "width", floatVal( m_scale * std::abs( pad_size.x ) ) );
addAttribute( rect_node, "height", floatVal( m_scale * std::abs( pad_size.y ) ) );
break;
}
case PAD_SHAPE::OVAL:
{
name = wxString::Format( "OVAL_%zu", m_std_shape_dict.size() + 1 );
m_std_shape_dict.emplace( hash, name );
wxXmlNode* entry_node = appendNode( m_shape_std_node, "EntryStandard" );
addAttribute( entry_node, "id", name );
wxXmlNode* oval_node = appendNode( entry_node, "Oval" );
VECTOR2D pad_size = aPad.GetSize( PADSTACK::ALL_LAYERS ) + expansion;
addAttribute( oval_node, "width", floatVal( m_scale * pad_size.x ) );
addAttribute( oval_node, "height", floatVal( m_scale * pad_size.y ) );
break;
}
case PAD_SHAPE::ROUNDRECT:
{
name = wxString::Format( "ROUNDRECT_%zu", m_std_shape_dict.size() + 1 );
m_std_shape_dict.emplace( hash, name );
wxXmlNode* entry_node = appendNode( m_shape_std_node, "EntryStandard" );
addAttribute( entry_node, "id", name );
wxXmlNode* roundrect_node = appendNode( entry_node, "RectRound" );
VECTOR2D pad_size = aPad.GetSize( PADSTACK::ALL_LAYERS ) + expansion;
addAttribute( roundrect_node, "width", floatVal( m_scale * pad_size.x ) );
addAttribute( roundrect_node, "height", floatVal( m_scale * pad_size.y ) );
roundrect_node->AddAttribute( "radius",
floatVal( m_scale * aPad.GetRoundRectCornerRadius( PADSTACK::ALL_LAYERS ) ) );
addAttribute( roundrect_node, "upperRight", "true" );
addAttribute( roundrect_node, "upperLeft", "true" );
addAttribute( roundrect_node, "lowerRight", "true" );
addAttribute( roundrect_node, "lowerLeft", "true" );
break;
}
case PAD_SHAPE::CHAMFERED_RECT:
{
name = wxString::Format( "RECTCHAMFERED_%zu", m_std_shape_dict.size() + 1 );
m_std_shape_dict.emplace( hash, name );
wxXmlNode* entry_node = appendNode( m_shape_std_node, "EntryStandard" );
addAttribute( entry_node, "id", name );
wxXmlNode* chamfered_node = appendNode( entry_node, "RectCham" );
VECTOR2D pad_size = aPad.GetSize( PADSTACK::ALL_LAYERS ) + expansion;
addAttribute( chamfered_node, "width", floatVal( m_scale * pad_size.x ) );
addAttribute( chamfered_node, "height", floatVal( m_scale * pad_size.y ) );
int shorterSide = std::min( pad_size.x, pad_size.y );
int chamfer = std::max( 0, KiROUND( aPad.GetChamferRectRatio( PADSTACK::ALL_LAYERS ) * shorterSide ) );
addAttribute( chamfered_node, "chamfer", floatVal( m_scale * chamfer ) );
int positions = aPad.GetChamferPositions( PADSTACK::ALL_LAYERS );
if( positions & RECT_CHAMFER_TOP_LEFT )
addAttribute( chamfered_node, "upperLeft", "true" );
if( positions & RECT_CHAMFER_TOP_RIGHT )
addAttribute( chamfered_node, "upperRight", "true" );
if( positions & RECT_CHAMFER_BOTTOM_LEFT )
addAttribute( chamfered_node, "lowerLeft", "true" );
if( positions & RECT_CHAMFER_BOTTOM_RIGHT )
addAttribute( chamfered_node, "lowerRight", "true" );
break;
}
case PAD_SHAPE::TRAPEZOID:
{
name = wxString::Format( "TRAPEZOID_%zu", m_std_shape_dict.size() + 1 );
m_std_shape_dict.emplace( hash, name );
wxXmlNode* entry_node = appendNode( m_shape_std_node, "EntryStandard" );
addAttribute( entry_node, "id", name );
VECTOR2I pad_size = aPad.GetSize( PADSTACK::ALL_LAYERS );
VECTOR2I trap_delta = aPad.GetDelta( PADSTACK::ALL_LAYERS );
SHAPE_POLY_SET outline;
outline.NewOutline();
int dx = pad_size.x / 2;
int dy = pad_size.y / 2;
int ddx = trap_delta.x / 2;
int ddy = trap_delta.y / 2;
outline.Append( -dx - ddy, dy + ddx );
outline.Append( dx + ddy, dy - ddx );
outline.Append( dx - ddy, -dy + ddx );
outline.Append( -dx + ddy, -dy - ddx );
// Shape polygon can have holes so use InflateWithLinkedHoles(), not Inflate()
// which can create bad shapes if margin.x is < 0
if( expansion.x )
{
outline.InflateWithLinkedHoles( expansion.x, CORNER_STRATEGY::ROUND_ALL_CORNERS,
maxError, SHAPE_POLY_SET::PM_FAST );
}
addContourNode( entry_node, outline );
break;
}
case PAD_SHAPE::CUSTOM:
{
name = wxString::Format( "CUSTOM_%zu", m_std_shape_dict.size() + 1 );
m_std_shape_dict.emplace( hash, name );
wxXmlNode* entry_node = appendNode( m_shape_std_node, "EntryStandard" );
addAttribute( entry_node, "id", name );
SHAPE_POLY_SET shape;
aPad.MergePrimitivesAsPolygon( PADSTACK::ALL_LAYERS, &shape );
if( expansion != VECTOR2I( 0, 0 ) )
{
shape.InflateWithLinkedHoles( std::max( expansion.x, expansion.y ),
CORNER_STRATEGY::ROUND_ALL_CORNERS, maxError,
SHAPE_POLY_SET::PM_FAST );
}
addContourNode( entry_node, shape );
break;
}
default:
wxLogError( "Unknown pad type" );
break;
}
if( !name.empty() )
{
m_std_shape_dict.emplace( hash, name );
wxXmlNode* shape_node = appendNode( aContentNode, "StandardPrimitiveRef" );
addAttribute( shape_node, "id", name );
}
}
void PCB_IO_IPC2581::addShape( wxXmlNode* aContentNode, const PCB_SHAPE& aShape )
{
size_t hash = shapeHash( aShape );
auto iter = m_user_shape_dict.find( hash );
wxString name;
if( iter != m_user_shape_dict.end() )
{
wxXmlNode* shape_node = appendNode( aContentNode, "UserPrimitiveRef" );
addAttribute( shape_node, "id", iter->second );
return;
}
switch( aShape.GetShape() )
{
case SHAPE_T::CIRCLE:
{
name = wxString::Format( "UCIRCLE_%zu", m_user_shape_dict.size() + 1 );
m_user_shape_dict.emplace( hash, name );
int diameter = aShape.GetRadius() * 2.0;
int width = aShape.GetStroke().GetWidth();
LINE_STYLE dash = aShape.GetStroke().GetLineStyle();
wxXmlNode* entry_node = appendNode( m_shape_user_node, "EntryUser" );
addAttribute( entry_node, "id", name );
wxXmlNode* special_node = appendNode( entry_node, "UserSpecial" );
wxXmlNode* circle_node = appendNode( special_node, "Circle" );
if( aShape.GetFillMode() == FILL_T::NO_FILL )
{
addAttribute( circle_node, "diameter", floatVal( m_scale * diameter ) );
addLineDesc( circle_node, width, dash, true );
}
else
{
// IPC2581 does not allow strokes on filled elements
addAttribute( circle_node, "diameter", floatVal( m_scale * ( diameter + width ) ) );
}
addFillDesc( circle_node, aShape.GetFillMode() );
break;
}
case SHAPE_T::RECTANGLE:
{
name = wxString::Format( "URECT_%zu", m_user_shape_dict.size() + 1 );
m_user_shape_dict.emplace( hash, name );
wxXmlNode* entry_node = appendNode( m_shape_user_node, "EntryUser" );
addAttribute( entry_node, "id", name );
wxXmlNode* special_node = appendNode( entry_node, "UserSpecial" );
int width = std::abs( aShape.GetRectangleWidth() );
int height = std::abs( aShape.GetRectangleHeight() );
int stroke_width = aShape.GetStroke().GetWidth();
LINE_STYLE dash = aShape.GetStroke().GetLineStyle();
wxXmlNode* rect_node = appendNode( special_node, "RectRound" );
addLineDesc( rect_node, aShape.GetStroke().GetWidth(), aShape.GetStroke().GetLineStyle(),
true );
if( aShape.GetFillMode() == FILL_T::NO_FILL )
{
addAttribute( rect_node, "upperRight", "false" );
addAttribute( rect_node, "upperLeft", "false" );
addAttribute( rect_node, "lowerRight", "false" );
addAttribute( rect_node, "lowerLeft", "false" );
}
else
{
addAttribute( rect_node, "upperRight", "true" );
addAttribute( rect_node, "upperLeft", "true" );
addAttribute( rect_node, "lowerRight", "true" );
addAttribute( rect_node, "lowerLeft", "true" );
width += stroke_width;
height += stroke_width;
}
addFillDesc( rect_node, aShape.GetFillMode() );
addAttribute( rect_node, "width", floatVal( m_scale * width ) );
addAttribute( rect_node, "height", floatVal( m_scale * height ) );
addAttribute( rect_node, "radius", floatVal( m_scale * ( stroke_width / 2.0 ) ) );
break;
}
case SHAPE_T::POLY:
{
name = wxString::Format( "UPOLY_%zu", m_user_shape_dict.size() + 1 );
m_user_shape_dict.emplace( hash, name );
wxXmlNode* entry_node = appendNode( m_shape_user_node, "EntryUser" );
addAttribute( entry_node, "id", name );
// If we are stroking a polygon, we need two contours. This is only allowed
// inside a "UserSpecial" shape
wxXmlNode* special_node = appendNode( entry_node, "UserSpecial" );
const SHAPE_POLY_SET& poly_set = aShape.GetPolyShape();
for( int ii = 0; ii < poly_set.OutlineCount(); ++ii )
{
if( aShape.GetFillMode() != FILL_T::NO_FILL )
{
// IPC2581 does not allow strokes on filled elements
addContourNode( special_node, poly_set, ii, FILL_T::FILLED_SHAPE, 0,
LINE_STYLE::SOLID );
}
addContourNode( special_node, poly_set, ii, FILL_T::NO_FILL,
aShape.GetStroke().GetWidth(), aShape.GetStroke().GetLineStyle() );
}
break;
}
case SHAPE_T::ARC:
{
wxXmlNode* arc_node = appendNode( aContentNode, "Arc" );
addXY( arc_node, aShape.GetStart(), "startX", "startY" );
addXY( arc_node, aShape.GetEnd(), "endX", "endY" );
addXY( arc_node, aShape.GetCenter(), "centerX", "centerY" );
//N.B. because our coordinate system is flipped, we need to flip the arc direction
addAttribute( arc_node, "clockwise", !aShape.IsClockwiseArc() ? "true" : "false" );
if( aShape.GetStroke().GetWidth() > 0 )
{
addLineDesc( arc_node, aShape.GetStroke().GetWidth(),
aShape.GetStroke().GetLineStyle(), true );
}
break;
}
case SHAPE_T::BEZIER:
{
wxXmlNode* polyline_node = appendNode( aContentNode, "Polyline" );
std::vector<VECTOR2I> ctrlPoints = { aShape.GetStart(), aShape.GetBezierC1(),
aShape.GetBezierC2(), aShape.GetEnd() };
BEZIER_POLY converter( ctrlPoints );
std::vector<VECTOR2I> points;
converter.GetPoly( points, ARC_HIGH_DEF );
wxXmlNode* point_node = appendNode( polyline_node, "PolyBegin" );
addXY( point_node, points[0] );
for( size_t i = 1; i < points.size(); i++ )
{
wxXmlNode* point_node = appendNode( polyline_node, "PolyStepSegment" );
addXY( point_node, points[i] );
}
if( aShape.GetStroke().GetWidth() > 0 )
{
addLineDesc( polyline_node, aShape.GetStroke().GetWidth(),
aShape.GetStroke().GetLineStyle(), true );
}
break;
}
case SHAPE_T::SEGMENT:
{
wxXmlNode* line_node = appendNode( aContentNode, "Line" );
addXY( line_node, aShape.GetStart(), "startX", "startY" );
addXY( line_node, aShape.GetEnd(), "endX", "endY" );
if( aShape.GetStroke().GetWidth() > 0 )
{
addLineDesc( line_node, aShape.GetStroke().GetWidth(),
aShape.GetStroke().GetLineStyle(), true );
}
break;
}
case SHAPE_T::UNDEFINED:
wxFAIL;
}
if( !name.empty() )
{
wxXmlNode* shape_node = appendNode( aContentNode, "UserPrimitiveRef" );
addAttribute( shape_node, "id", name );
}
}
void PCB_IO_IPC2581::addSlotCavity( wxXmlNode* aNode, const PAD& aPad, const wxString& aName )
{
wxXmlNode* slotNode = appendNode( aNode, "SlotCavity" );
addAttribute( slotNode, "name", aName );
addAttribute( slotNode, "platingStatus", aPad.GetAttribute() == PAD_ATTRIB::PTH ? "PLATED"
: "NONPLATED" );
addAttribute( slotNode, "plusTol", "0.0" );
addAttribute( slotNode, "minusTol", "0.0" );
if( m_version > 'B' )
addLocationNode( slotNode, 0.0, 0.0 );
SHAPE_POLY_SET poly_set;
aPad.GetEffectiveShape( PADSTACK::ALL_LAYERS )->TransformToPolygon( poly_set, 0, ERROR_INSIDE );
addOutlineNode( slotNode, poly_set );
}
wxXmlNode* PCB_IO_IPC2581::generateLogisticSection()
{
wxXmlNode* logisticNode = appendNode( m_xml_root, "LogisticHeader" );
wxXmlNode* roleNode = appendNode( logisticNode, "Role" );
addAttribute( roleNode, "id", "Owner" );
addAttribute( roleNode, "roleFunction", "SENDER" );
m_enterpriseNode = appendNode( logisticNode, "Enterprise" );
addAttribute( m_enterpriseNode, "id", "UNKNOWN" );
addAttribute( m_enterpriseNode, "code", "NONE" );
wxXmlNode* personNode = appendNode( logisticNode, "Person" );
addAttribute( personNode, "name", "UNKNOWN" );
addAttribute( personNode, "enterpriseRef", "UNKNOWN" );
addAttribute( personNode, "roleRef", "Owner" );
return logisticNode;
}
wxXmlNode* PCB_IO_IPC2581::generateHistorySection()
{
if( m_progressReporter )
m_progressReporter->AdvancePhase( _( "Generating history section" ) );
wxXmlNode* historyNode = appendNode( m_xml_root, "HistoryRecord" );
addAttribute( historyNode, "number", "1" );
addAttribute( historyNode, "origination", wxDateTime::Now().FormatISOCombined() );
addAttribute( historyNode, "software", "KiCad EDA" );
addAttribute( historyNode, "lastChange", wxDateTime::Now().FormatISOCombined() );
wxXmlNode* fileRevisionNode = appendNode( historyNode, "FileRevision" );
addAttribute( fileRevisionNode, "fileRevisionId", "1" );
addAttribute( fileRevisionNode, "comment", "NO COMMENT" );
addAttribute( fileRevisionNode, "label", "NO LABEL" );
wxXmlNode* softwarePackageNode = appendNode( fileRevisionNode, "SoftwarePackage" );
addAttribute( softwarePackageNode, "name", "KiCad" );
addAttribute( softwarePackageNode, "revision", GetMajorMinorPatchVersion() );
addAttribute( softwarePackageNode, "vendor", "KiCad EDA" );
wxXmlNode* certificationNode = appendNode( softwarePackageNode, "Certification" );
addAttribute( certificationNode, "certificationStatus", "SELFTEST" );
return historyNode;
}
wxXmlNode* PCB_IO_IPC2581::generateBOMSection( wxXmlNode* aEcadNode )
{
if( m_progressReporter )
m_progressReporter->AdvancePhase( _( "Generating BOM section" ) );
struct REFDES
{
wxString m_name;
wxString m_pkg;
bool m_populate;
wxString m_layer;
};
struct BOM_ENTRY
{
BOM_ENTRY()
{
m_refdes = new std::vector<REFDES>();
m_props = new std::map<wxString, wxString>();
m_count = 0;
m_pads = 0;
}
~BOM_ENTRY()
{
delete m_refdes;
delete m_props;
}
wxString m_OEMDesignRef; // String combining LIB+FP+VALUE
int m_count;
int m_pads;
wxString m_type;
std::vector<REFDES>* m_refdes;
std::map<wxString, wxString>* m_props;
};
std::set<std::unique_ptr<struct BOM_ENTRY>,
std::function<bool( const std::unique_ptr<struct BOM_ENTRY>&,
const std::unique_ptr<struct BOM_ENTRY>& )>> bom_entries(
[]( const std::unique_ptr<struct BOM_ENTRY>& a,
const std::unique_ptr<struct BOM_ENTRY>& b )
{
return a->m_OEMDesignRef < b->m_OEMDesignRef;
} );
for( FOOTPRINT* fp_it : m_board->Footprints() )
{
std::unique_ptr<FOOTPRINT> fp( static_cast<FOOTPRINT*>( fp_it->Clone() ) );
fp->SetParentGroup( nullptr );
fp->SetPosition( {0, 0} );
if( fp->GetLayer() != F_Cu )
fp->Flip( fp->GetPosition(), FLIP_DIRECTION::TOP_BOTTOM );
fp->SetOrientation( ANGLE_0 );
size_t hash = hash_fp_item( fp.get(), HASH_POS | REL_COORD );
auto iter = m_footprint_dict.find( hash );
if( iter == m_footprint_dict.end() )
{
wxLogError( "Footprint %s not found in dictionary",
fp->GetFPID().GetLibItemName().wx_str() );
continue;
}
auto entry = std::make_unique<struct BOM_ENTRY>();
/// We assume that the m_OEMRef_dict is populated already by the generateComponents function
/// This will either place a unique string in the dictionary or field reference.
if( auto it = m_OEMRef_dict.find( fp_it ); it != m_OEMRef_dict.end() )
{
entry->m_OEMDesignRef = it->second;
}
else
{
wxLogError( "Footprint %s not found in OEMRef dictionary",
fp->GetFPID().GetLibItemName().wx_str() );
}
entry->m_OEMDesignRef = genString( entry->m_OEMDesignRef, "REF" );
entry->m_count = 1;
entry->m_pads = fp->GetPadCount();
// TODO: The options are "ELECTRICAL", "MECHANICAL", "PROGRAMMABLE", "DOCUMENT", "MATERIAL"
// We need to figure out how to determine this.
if( entry->m_pads == 0 || fp_it->GetAttributes() & FP_EXCLUDE_FROM_BOM )
entry->m_type = "DOCUMENT";
else
entry->m_type = "ELECTRICAL";
auto[ bom_iter, inserted ] = bom_entries.insert( std::move( entry ) );
if( !inserted )
( *bom_iter )->m_count++;
REFDES refdes;
refdes.m_name = componentName( fp_it );
refdes.m_pkg = fp->GetFPID().GetLibItemName().wx_str();
refdes.m_populate = !fp->IsDNP() && !( fp->GetAttributes() & FP_EXCLUDE_FROM_BOM );
refdes.m_layer = m_layer_name_map[fp_it->GetLayer()];
( *bom_iter )->m_refdes->push_back( refdes );
// TODO: This amalgamates all the properties from all the footprints. We need to decide
// if we want to group footprints by their properties
for( PCB_FIELD* prop : fp->GetFields() )
{
// We don't need ref, footprint or datasheet in the BOM characteristics. Just value
// and any additional fields the user has added. Ref and footprint are captured above.
if( prop->IsMandatoryField() && !prop->IsValue() )
continue;
( *bom_iter )->m_props->emplace( prop->GetName(), prop->GetText() );
}
}
if( bom_entries.empty() )
return nullptr;
wxFileName fn( m_board->GetFileName() );
wxXmlNode* bomNode = new wxXmlNode( wxXML_ELEMENT_NODE, "Bom" );
m_xml_root->InsertChild( bomNode, aEcadNode );
addAttribute( bomNode, "name", genString( fn.GetName(), "BOM" ) );
wxXmlNode* bomHeaderNode = appendNode( bomNode, "BomHeader" );
addAttribute( bomHeaderNode, "revision", "1.0" );
addAttribute( bomHeaderNode, "assembly", genString( fn.GetName() ) );
wxXmlNode* stepRefNode = appendNode( bomHeaderNode, "StepRef" );
addAttribute( stepRefNode, "name", genString( fn.GetName(), "BOARD" ) );
for( const auto& entry : bom_entries )
{
wxXmlNode* bomEntryNode = appendNode( bomNode, "BomItem" );
addAttribute( bomEntryNode, "OEMDesignNumberRef", entry->m_OEMDesignRef );
addAttribute( bomEntryNode, "quantity", wxString::Format( "%d", entry->m_count ) );
addAttribute( bomEntryNode, "pinCount", wxString::Format( "%d", entry->m_pads ) );
addAttribute( bomEntryNode, "category", entry->m_type );
for( const REFDES& refdes : *( entry->m_refdes ) )
{
wxXmlNode* refdesNode = appendNode( bomEntryNode, "RefDes" );
addAttribute( refdesNode, "name", refdes.m_name );
addAttribute( refdesNode, "packageRef", genString( refdes.m_pkg, "PKG" ) );
addAttribute( refdesNode, "populate", refdes.m_populate ? "true" : "false" );
addAttribute( refdesNode, "layerRef", refdes.m_layer );
}
wxXmlNode* characteristicsNode = appendNode( bomEntryNode, "Characteristics" );
addAttribute( characteristicsNode, "category", entry->m_type );
for( const auto& prop : *( entry->m_props ) )
{
wxXmlNode* textualDefNode = appendNode( characteristicsNode, "Textual" );
addAttribute( textualDefNode, "definitionSource", "KICAD" );
addAttribute( textualDefNode, "textualCharacteristicName", prop.first );
addAttribute( textualDefNode, "textualCharacteristicValue", prop.second );
}
}
return bomNode;
}
wxXmlNode* PCB_IO_IPC2581::generateEcadSection()
{
if( m_progressReporter )
m_progressReporter->AdvancePhase( _( "Generating CAD data" ) );
wxXmlNode* ecadNode = appendNode( m_xml_root, "Ecad" );
addAttribute( ecadNode, "name", "Design" );
addCadHeader( ecadNode );
wxXmlNode* cadDataNode = appendNode( ecadNode, "CadData" );
generateCadLayers( cadDataNode );
generateDrillLayers( cadDataNode);
generateStepSection( cadDataNode );
return ecadNode;
}
void PCB_IO_IPC2581::addCadHeader( wxXmlNode* aEcadNode )
{
wxXmlNode* cadHeaderNode = appendNode( aEcadNode, "CadHeader" );
addAttribute( cadHeaderNode, "units", m_units_str );
}
bool PCB_IO_IPC2581::isValidLayerFor2581( PCB_LAYER_ID aLayer )
{
return ( aLayer >= F_Cu && aLayer <= User_9 ) || aLayer == UNDEFINED_LAYER;
}
void PCB_IO_IPC2581::addLayerAttributes( wxXmlNode* aNode, PCB_LAYER_ID aLayer )
{
switch( aLayer )
{
case F_Adhes:
case B_Adhes:
addAttribute( aNode, "layerFunction", "GLUE" );
addAttribute( aNode, "polarity", "POSITIVE" );
addAttribute( aNode, "side", aLayer == F_Adhes ? "TOP" : "BOTTOM" );
break;
case F_Paste:
case B_Paste:
addAttribute( aNode, "layerFunction", "SOLDERPASTE" );
addAttribute( aNode, "polarity", "POSITIVE" );
addAttribute( aNode, "side", aLayer == F_Paste ? "TOP" : "BOTTOM" );
break;
case F_SilkS:
case B_SilkS:
addAttribute( aNode, "layerFunction", "SILKSCREEN" );
addAttribute( aNode, "polarity", "POSITIVE" );
addAttribute( aNode, "side", aLayer == F_SilkS ? "TOP" : "BOTTOM" );
break;
case F_Mask:
case B_Mask:
addAttribute( aNode, "layerFunction", "SOLDERMASK" );
addAttribute( aNode, "polarity", "POSITIVE" );
addAttribute( aNode, "side", aLayer == F_Mask ? "TOP" : "BOTTOM" );
break;
case Edge_Cuts:
addAttribute( aNode, "layerFunction", "BOARD_OUTLINE" );
addAttribute( aNode, "polarity", "POSITIVE" );
addAttribute( aNode, "side", "ALL" );
break;
case B_CrtYd:
case F_CrtYd:
addAttribute( aNode, "layerFunction", "COURTYARD" );
addAttribute( aNode, "polarity", "POSITIVE" );
addAttribute( aNode, "side", aLayer == F_CrtYd ? "TOP" : "BOTTOM" );
break;
case B_Fab:
case F_Fab:
addAttribute( aNode, "layerFunction", "ASSEMBLY" );
addAttribute( aNode, "polarity", "POSITIVE" );
addAttribute( aNode, "side", aLayer == F_Fab ? "TOP" : "BOTTOM" );
break;
case Dwgs_User:
case Cmts_User:
case Eco1_User:
case Eco2_User:
case Margin:
case User_1:
case User_2:
case User_3:
case User_4:
case User_5:
case User_6:
case User_7:
case User_8:
case User_9:
addAttribute( aNode, "layerFunction", "DOCUMENT" );
addAttribute( aNode, "polarity", "POSITIVE" );
addAttribute( aNode, "side", "NONE" );
break;
default:
if( IsCopperLayer( aLayer ) )
{
addAttribute( aNode, "layerFunction", "CONDUCTOR" );
addAttribute( aNode, "polarity", "POSITIVE" );
addAttribute( aNode, "side",
aLayer == F_Cu ? "TOP"
: aLayer == B_Cu ? "BOTTOM"
: "INTERNAL" );
}
break; // Do not handle other layers
}
}
void PCB_IO_IPC2581::generateCadLayers( wxXmlNode* aCadLayerNode )
{
BOARD_DESIGN_SETTINGS& dsnSettings = m_board->GetDesignSettings();
BOARD_STACKUP& stackup = dsnSettings.GetStackupDescriptor();
stackup.SynchronizeWithBoard( &dsnSettings );
std::vector<BOARD_STACKUP_ITEM*> layers = stackup.GetList();
std::set<PCB_LAYER_ID> added_layers;
for( int i = 0; i < stackup.GetCount(); i++ )
{
BOARD_STACKUP_ITEM* stackup_item = layers.at( i );
if( !isValidLayerFor2581( stackup_item->GetBrdLayerId() ) )
continue;
for( int sublayer_id = 0; sublayer_id < stackup_item->GetSublayersCount(); sublayer_id++ )
{
wxXmlNode* cadLayerNode = appendNode( aCadLayerNode, "Layer" );
wxString ly_name = stackup_item->GetLayerName();
if( ly_name.IsEmpty() )
{
if( IsValidLayer( stackup_item->GetBrdLayerId() ) )
ly_name = m_board->GetLayerName( stackup_item->GetBrdLayerId() );
if( ly_name.IsEmpty() && stackup_item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
{
ly_name = wxString::Format( "DIELECTRIC_%d",
stackup_item->GetDielectricLayerId() );
}
}
ly_name = genString( ly_name, "LAYER" );
addAttribute( cadLayerNode, "name", ly_name );
if( stackup_item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
{
if( stackup_item->GetTypeName() == KEY_CORE )
addAttribute( cadLayerNode, "layerFunction", "DIELCORE" );
else
addAttribute( cadLayerNode, "layerFunction", "DIELPREG" );
addAttribute( cadLayerNode, "polarity", "POSITIVE" );
addAttribute( cadLayerNode, "side", "INTERNAL" );
continue;
}
else
{
added_layers.insert( stackup_item->GetBrdLayerId() );
addLayerAttributes( cadLayerNode, stackup_item->GetBrdLayerId() );
m_layer_name_map.emplace( stackup_item->GetBrdLayerId(), ly_name );
}
}
}
LSEQ layer_seq = m_board->GetEnabledLayers().Seq();
for( PCB_LAYER_ID layer : layer_seq )
{
if( added_layers.find( layer ) != added_layers.end() || !isValidLayerFor2581( layer ) )
continue;
wxString ly_name = genLayerString( layer, "LAYER" );
m_layer_name_map.emplace( layer, ly_name );
added_layers.insert( layer );
wxXmlNode* cadLayerNode = appendNode( aCadLayerNode, "Layer" );
addAttribute( cadLayerNode, "name", ly_name );
addLayerAttributes( cadLayerNode, layer );
}
}
void PCB_IO_IPC2581::generateDrillLayers( wxXmlNode* aCadLayerNode )
{
for( BOARD_ITEM* item : m_board->Tracks() )
{
if( item->Type() == PCB_VIA_T )
{
PCB_VIA* via = static_cast<PCB_VIA*>( item );
m_drill_layers[std::make_pair( via->TopLayer(), via->BottomLayer() )].push_back( via );
}
}
for( FOOTPRINT* fp : m_board->Footprints() )
{
for( PAD* pad : fp->Pads() )
{
if( pad->HasDrilledHole() )
m_drill_layers[std::make_pair( F_Cu, B_Cu )].push_back( pad );
else if( pad->HasHole() )
m_slot_holes[std::make_pair( F_Cu, B_Cu )].push_back( pad );
}
}
for( const auto& [layers, vec] : m_drill_layers )
{
wxXmlNode* drillNode = appendNode( aCadLayerNode, "Layer" );
drillNode->AddAttribute( "name", genLayersString( layers.first, layers.second, "DRILL" ) );
addAttribute( drillNode, "layerFunction", "DRILL" );
addAttribute( drillNode, "polarity", "POSITIVE" );
addAttribute( drillNode, "side", "ALL" );
wxXmlNode* spanNode = appendNode( drillNode, "Span" );
addAttribute( spanNode, "fromLayer", genLayerString( layers.first, "LAYER" ) );
addAttribute( spanNode, "toLayer", genLayerString( layers.second, "LAYER" ) );
}
for( const auto& [layers, vec] : m_slot_holes )
{
wxXmlNode* drillNode = appendNode( aCadLayerNode, "Layer" );
drillNode->AddAttribute( "name", genLayersString( layers.first, layers.second, "SLOT" ) );
addAttribute( drillNode, "layerFunction", "ROUT" );
addAttribute( drillNode, "polarity", "POSITIVE" );
addAttribute( drillNode, "side", "ALL" );
wxXmlNode* spanNode = appendNode( drillNode, "Span" );
addAttribute( spanNode, "fromLayer", genLayerString( layers.first, "LAYER" ) );
addAttribute( spanNode, "toLayer", genLayerString( layers.second, "LAYER" ) );
}
}
void PCB_IO_IPC2581::generateStepSection( wxXmlNode* aCadNode )
{
wxXmlNode* stepNode = appendNode( aCadNode, "Step" );
wxFileName fn( m_board->GetFileName() );
addAttribute( stepNode, "name", genString( fn.GetName(), "BOARD" ) );
if( m_version > 'B' )
addAttribute( stepNode, "type", "BOARD" );
wxXmlNode* datumNode = appendNode( stepNode, "Datum" );
addAttribute( datumNode, "x", "0.0" );
addAttribute( datumNode, "y", "0.0" );
generateProfile( stepNode );
generateComponents( stepNode );
m_last_padstack = insertNode( stepNode, "NonstandardAttribute" );
addAttribute( m_last_padstack, "name", "FOOTPRINT_COUNT" );
addAttribute( m_last_padstack, "type", "INTEGER" );
addAttribute( m_last_padstack, "value",
wxString::Format( "%zu", m_board->Footprints().size() ) );
generateLayerFeatures( stepNode );
generateLayerSetDrill( stepNode );
}
void PCB_IO_IPC2581::addPad( wxXmlNode* aContentNode, const PAD* aPad, PCB_LAYER_ID aLayer )
{
wxXmlNode* padNode = appendNode( aContentNode, "Pad" );
FOOTPRINT* fp = aPad->GetParentFootprint();
addPadStack( padNode, aPad );
if( aPad->GetOrientation() != ANGLE_0 )
{
wxXmlNode* xformNode = appendNode( padNode, "Xform" );
xformNode->AddAttribute( "rotation",
floatVal( aPad->GetOrientation().Normalize().AsDegrees() ) );
if( fp && fp->IsFlipped() )
addAttribute( xformNode, "mirror", "true" );
}
addLocationNode( padNode, *aPad, false );
addShape( padNode, *aPad, aLayer );
if( fp )
{
wxXmlNode* pinRefNode = appendNode( padNode, "PinRef" );
addAttribute( pinRefNode, "componentRef", componentName( fp ) );
addAttribute( pinRefNode, "pin", pinName( aPad ) );
}
}
void PCB_IO_IPC2581::addVia( wxXmlNode* aContentNode, const PCB_VIA* aVia, PCB_LAYER_ID aLayer )
{
if( !aVia->FlashLayer( aLayer ) )
return;
wxXmlNode* padNode = appendNode( aContentNode, "Pad" );
addPadStack( padNode, aVia );
addLocationNode( padNode, aVia->GetPosition().x, aVia->GetPosition().y );
PAD dummy( nullptr );
int hole = aVia->GetDrillValue();
dummy.SetDrillSize( VECTOR2I( hole, hole ) );
dummy.SetPosition( aVia->GetStart() );
dummy.SetSize( aLayer, VECTOR2I( aVia->GetWidth( aLayer ), aVia->GetWidth( aLayer ) ) );
addShape( padNode, dummy, aLayer );
}
void PCB_IO_IPC2581::addPadStack( wxXmlNode* aPadNode, const PAD* aPad )
{
size_t hash = hash_fp_item( aPad, 0 );
wxString name = wxString::Format( "PADSTACK_%zu", m_padstack_dict.size() + 1 );
auto [ th_pair, success ] = m_padstack_dict.emplace( hash, name );
addAttribute( aPadNode, "padstackDefRef", th_pair->second );
// If we did not insert a new padstack, then we have already added it to the XML
// and we don't need to add it again.
if( !success )
return;
wxXmlNode* padStackDefNode = new wxXmlNode( wxXML_ELEMENT_NODE, "PadStackDef" );
addAttribute( padStackDefNode, "name", name );
m_padstacks.push_back( padStackDefNode );
// Only handle round holes here because IPC2581 does not support non-round holes
// These will be handled in a slot layer
if( aPad->HasDrilledHole() )
{
wxXmlNode* padStackHoleNode = appendNode( padStackDefNode, "PadstackHoleDef" );
padStackHoleNode->AddAttribute( "name",
wxString::Format( "%s%d_%d",
aPad->GetAttribute() == PAD_ATTRIB::PTH ? "PTH" : "NPTH",
aPad->GetDrillSizeX(), aPad->GetDrillSizeY() ) );
addAttribute( padStackHoleNode, "diameter", floatVal( m_scale * aPad->GetDrillSizeX() ) );
addAttribute( padStackHoleNode, "platingStatus",
aPad->GetAttribute() == PAD_ATTRIB::PTH ? "PLATED" : "NONPLATED" );
addAttribute( padStackHoleNode, "plusTol", "0.0" );
addAttribute( padStackHoleNode, "minusTol", "0.0" );
addXY( padStackHoleNode, aPad->GetOffset( PADSTACK::ALL_LAYERS ) );
}
LSEQ layer_seq = aPad->GetLayerSet().Seq();
for( PCB_LAYER_ID layer : layer_seq )
{
FOOTPRINT* fp = aPad->GetParentFootprint();
if( !m_board->IsLayerEnabled( layer ) )
continue;
wxXmlNode* padStackPadDefNode = appendNode( padStackDefNode, "PadstackPadDef" );
addAttribute( padStackPadDefNode, "layerRef", m_layer_name_map[layer] );
addAttribute( padStackPadDefNode, "padUse", "REGULAR" );
addLocationNode( padStackPadDefNode, aPad->GetOffset( PADSTACK::ALL_LAYERS ).x, aPad->GetOffset( PADSTACK::ALL_LAYERS ).y );
if( aPad->HasHole() || !aPad->FlashLayer( layer ) )
{
PCB_SHAPE shape( nullptr, SHAPE_T::CIRCLE );
shape.SetStart( aPad->GetOffset( PADSTACK::ALL_LAYERS ) );
shape.SetEnd( shape.GetStart() + aPad->GetDrillSize() / 2 );
addShape( padStackPadDefNode, shape );
}
else
{
addShape( padStackPadDefNode, *aPad, layer );
}
}
}
void PCB_IO_IPC2581::addPadStack( wxXmlNode* aContentNode, const PCB_VIA* aVia )
{
size_t hash = hash_fp_item( aVia, 0 );
wxString name = wxString::Format( "PADSTACK_%zu", m_padstack_dict.size() + 1 );
auto [ via_pair, success ] = m_padstack_dict.emplace( hash, name );
addAttribute( aContentNode, "padstackDefRef", via_pair->second );
// If we did not insert a new padstack, then we have already added it to the XML
// and we don't need to add it again.
if( !success )
return;
wxXmlNode* padStackDefNode = new wxXmlNode( wxXML_ELEMENT_NODE, "PadStackDef" );
insertNodeAfter( m_last_padstack, padStackDefNode );
m_last_padstack = padStackDefNode;
addAttribute( padStackDefNode, "name", name );
wxXmlNode* padStackHoleNode = appendNode( padStackDefNode, "PadstackHoleDef" );
addAttribute( padStackHoleNode, "name", wxString::Format( "PH%d", aVia->GetDrillValue() ) );
padStackHoleNode->AddAttribute( "diameter", floatVal( m_scale * aVia->GetDrillValue() ) );
addAttribute( padStackHoleNode, "platingStatus", "VIA" );
addAttribute( padStackHoleNode, "plusTol", "0.0" );
addAttribute( padStackHoleNode, "minusTol", "0.0" );
addAttribute( padStackHoleNode, "x", "0.0" );
addAttribute( padStackHoleNode, "y", "0.0" );
LSEQ layer_seq = aVia->GetLayerSet().Seq();
for( PCB_LAYER_ID layer : layer_seq )
{
if( !aVia->FlashLayer( layer ) || !m_board->IsLayerEnabled( layer ) )
continue;
PCB_SHAPE shape( nullptr, SHAPE_T::CIRCLE );
shape.SetEnd( { KiROUND( aVia->GetWidth( layer ) / 2.0 ), 0 } );
wxXmlNode* padStackPadDefNode = appendNode( padStackDefNode, "PadstackPadDef" );
addAttribute( padStackPadDefNode, "layerRef", m_layer_name_map[layer] );
addAttribute( padStackPadDefNode, "padUse", "REGULAR" );
addLocationNode( padStackPadDefNode, 0.0, 0.0 );
addShape( padStackPadDefNode, shape );
}
}
bool PCB_IO_IPC2581::addPolygonNode( wxXmlNode* aParentNode,
const SHAPE_POLY_SET::POLYGON& aPolygon, FILL_T aFillType,
int aWidth, LINE_STYLE aDashType )
{
wxXmlNode* polygonNode = nullptr;
if( aPolygon.empty() || aPolygon[0].PointCount() < 3 )
return false;
auto make_node =
[&]()
{
polygonNode = appendNode( aParentNode, "Polygon" );
wxXmlNode* polybeginNode = appendNode( polygonNode, "PolyBegin" );
const std::vector<VECTOR2I>& pts = aPolygon[0].CPoints();
addXY( polybeginNode, pts[0] );
for( size_t ii = 1; ii < pts.size(); ++ii )
{
wxXmlNode* polyNode = appendNode( polygonNode, "PolyStepSegment" );
addXY( polyNode, pts[ii] );
}
wxXmlNode* polyendNode = appendNode( polygonNode, "PolyStepSegment" );
addXY( polyendNode, pts[0] );
};
// Allow the case where we don't want line/fill information in the polygon
if( aFillType == FILL_T::NO_FILL )
{
make_node();
// If we specify a line width, we need to add a LineDescRef node and
// since this is only valid for a non-filled polygon, we need to create
// the fillNode as well
if( aWidth > 0 )
addLineDesc( polygonNode, aWidth, aDashType, true );
}
else
{
wxCHECK( aWidth == 0, false );
make_node();
}
addFillDesc( polygonNode, aFillType );
return true;
}
bool PCB_IO_IPC2581::addPolygonCutouts( wxXmlNode* aParentNode,
const SHAPE_POLY_SET::POLYGON& aPolygon )
{
for( size_t ii = 1; ii < aPolygon.size(); ++ii )
{
wxCHECK2( aPolygon[ii].PointCount() >= 3, continue );
wxXmlNode* cutoutNode = appendNode( aParentNode, "Cutout" );
wxXmlNode* polybeginNode = appendNode( cutoutNode, "PolyBegin" );
const std::vector<VECTOR2I>& hole = aPolygon[ii].CPoints();
addXY( polybeginNode, hole[0] );
for( size_t jj = 1; jj < hole.size(); ++jj )
{
wxXmlNode* polyNode = appendNode( cutoutNode, "PolyStepSegment" );
addXY( polyNode, hole[jj] );
}
wxXmlNode* polyendNode = appendNode( cutoutNode, "PolyStepSegment" );
addXY( polyendNode, hole[0] );
}
return true;
}
bool PCB_IO_IPC2581::addOutlineNode( wxXmlNode* aParentNode, const SHAPE_POLY_SET& aPolySet,
int aWidth, LINE_STYLE aDashType )
{
if( aPolySet.OutlineCount() == 0 )
return false;
wxXmlNode* outlineNode = appendNode( aParentNode, "Outline" );
for( int ii = 0; ii < aPolySet.OutlineCount(); ++ii )
{
wxCHECK2( aPolySet.Outline( ii ).PointCount() >= 3, continue );
if( !addPolygonNode( outlineNode, aPolySet.Polygon( ii ) ) )
wxLogTrace( traceIpc2581, wxS( "Failed to add polygon to outline" ) );
}
if( !outlineNode->GetChildren() )
{
aParentNode->RemoveChild( outlineNode );
delete outlineNode;
return false;
}
addLineDesc( outlineNode, aWidth, aDashType );
return true;
}
bool PCB_IO_IPC2581::addContourNode( wxXmlNode* aParentNode, const SHAPE_POLY_SET& aPolySet,
int aOutline, FILL_T aFillType, int aWidth,
LINE_STYLE aDashType )
{
if( aPolySet.OutlineCount() < ( aOutline + 1 ) )
return false;
wxXmlNode* contourNode = appendNode( aParentNode, "Contour" );
if( addPolygonNode( contourNode, aPolySet.Polygon( aOutline ), aFillType, aWidth, aDashType ) )
{
// Do not attempt to add cutouts to shapes that are already hollow
if( aFillType != FILL_T::NO_FILL )
addPolygonCutouts( contourNode, aPolySet.Polygon( aOutline ) );
}
else
{
aParentNode->RemoveChild( contourNode );
delete contourNode;
return false;
}
return true;
}
void PCB_IO_IPC2581::generateProfile( wxXmlNode* aStepNode )
{
SHAPE_POLY_SET board_outline;
if( ! m_board->GetBoardPolygonOutlines( board_outline ) )
{
wxLogError( "Failed to get board outline" );
return;
}
wxXmlNode* profileNode = appendNode( aStepNode, "Profile" );
if( !addPolygonNode( profileNode, board_outline.Polygon( 0 ) ) )
{
wxLogTrace( traceIpc2581, wxS( "Failed to add polygon to profile" ) );
aStepNode->RemoveChild( profileNode );
delete profileNode;
}
}
wxXmlNode* PCB_IO_IPC2581::addPackage( wxXmlNode* aContentNode, FOOTPRINT* aFp )
{
std::unique_ptr<FOOTPRINT> fp( static_cast<FOOTPRINT*>( aFp->Clone() ) );
fp->SetParentGroup( nullptr );
fp->SetPosition( { 0, 0 } );
if( fp->GetLayer() != F_Cu )
fp->Flip( fp->GetPosition(), FLIP_DIRECTION::TOP_BOTTOM );
fp->SetOrientation( ANGLE_0 );
size_t hash = hash_fp_item( fp.get(), HASH_POS | REL_COORD );
wxString name = genString( wxString::Format( "%s_%zu",
fp->GetFPID().GetLibItemName().wx_str(),
m_footprint_dict.size() + 1 ) );
auto [ iter, success ] = m_footprint_dict.emplace( hash, name );
addAttribute( aContentNode, "packageRef", iter->second );
if( !success)
return nullptr;
// Package and Component nodes are at the same level, so we need to find the parent
// which should be the Step node
wxXmlNode* packageNode = new wxXmlNode( wxXML_ELEMENT_NODE, "Package" );
wxXmlNode* otherSideViewNode = nullptr; // Only set this if we have elements on the back side
addAttribute( packageNode, "name", name );
addAttribute( packageNode, "type", "OTHER" ); // TODO: Replace with actual package type once we encode this
// We don't specially identify pin 1 in our footprints, so we need to guess
if( fp->FindPadByNumber( "1" ) )
addAttribute( packageNode, "pinOne", "1" );
else if ( fp->FindPadByNumber( "A1" ) )
addAttribute( packageNode, "pinOne", "A1" );
else if ( fp->FindPadByNumber( "A" ) )
addAttribute( packageNode, "pinOne", "A" );
else if ( fp->FindPadByNumber( "a" ) )
addAttribute( packageNode, "pinOne", "a" );
else if ( fp->FindPadByNumber( "a1" ) )
addAttribute( packageNode, "pinOne", "a1" );
else if ( fp->FindPadByNumber( "Anode" ) )
addAttribute( packageNode, "pinOne", "Anode" );
else if ( fp->FindPadByNumber( "ANODE" ) )
addAttribute( packageNode, "pinOne", "ANODE" );
else
addAttribute( packageNode, "pinOne", "UNKNOWN" );
addAttribute( packageNode, "pinOneOrientation", "OTHER" );
const SHAPE_POLY_SET& courtyard = fp->GetCourtyard( F_CrtYd );
const SHAPE_POLY_SET& courtyard_back = fp->GetCourtyard( B_CrtYd );
if( courtyard.OutlineCount() > 0 )
addOutlineNode( packageNode, courtyard, courtyard.Outline( 0 ).Width(), LINE_STYLE::SOLID );
if( courtyard_back.OutlineCount() > 0 )
{
otherSideViewNode = appendNode( packageNode, "OtherSideView" );
addOutlineNode( otherSideViewNode, courtyard_back, courtyard_back.Outline( 0 ).Width(),
LINE_STYLE::SOLID );
}
if( !courtyard.OutlineCount() && !courtyard_back.OutlineCount() )
{
SHAPE_POLY_SET bbox = fp->GetBoundingHull();
addOutlineNode( packageNode, bbox );
}
wxXmlNode* pickupPointNode = appendNode( packageNode, "PickupPoint" );
addAttribute( pickupPointNode, "x", "0.0" );
addAttribute( pickupPointNode, "y", "0.0" );
std::map<PCB_LAYER_ID, std::map<bool, std::vector<BOARD_ITEM*>>> elements;
for( BOARD_ITEM* item : fp->GraphicalItems() )
{
PCB_LAYER_ID layer = item->GetLayer();
/// IPC2581 only supports the documentation layers for production and post-production
/// All other layers are ignored
/// TODO: Decide if we should place the other layers from footprints on the board
if( layer != F_SilkS && layer != B_SilkS && layer != F_Fab && layer != B_Fab )
continue;
bool is_abs = true;
if( item->Type() == PCB_SHAPE_T )
{
PCB_SHAPE* shape = static_cast<PCB_SHAPE*>( item );
// Circles and Rectanges only have size information so we need to place them in
// a separate node that has a location
if( shape->GetShape() == SHAPE_T::CIRCLE || shape->GetShape() == SHAPE_T::RECTANGLE )
is_abs = false;
}
elements[item->GetLayer()][is_abs].push_back( item );
}
auto add_base_node =
[&]( PCB_LAYER_ID aLayer ) -> wxXmlNode*
{
wxXmlNode* parent = packageNode;
bool is_back = aLayer == B_SilkS || aLayer == B_Fab;
if( is_back )
{
if( !otherSideViewNode )
otherSideViewNode = new wxXmlNode( wxXML_ELEMENT_NODE, "OtherSideView" );
parent = otherSideViewNode;
}
wxString name;
if( aLayer == F_SilkS || aLayer == B_SilkS )
name = "SilkScreen";
else if( aLayer == F_Fab || aLayer == B_Fab )
name = "AssemblyDrawing";
else
wxASSERT( false );
wxXmlNode* new_node = appendNode( parent, name );
return new_node;
};
auto add_marking_node =
[&]( wxXmlNode* aNode ) -> wxXmlNode*
{
wxXmlNode* marking_node = appendNode( aNode, "Marking" );
addAttribute( marking_node, "markingUsage", "NONE" );
return marking_node;
};
std::map<PCB_LAYER_ID, wxXmlNode*> layer_nodes;
std::map<PCB_LAYER_ID, BOX2I> layer_bbox;
for( auto layer : { F_Fab, B_Fab } )
{
if( elements.find( layer ) != elements.end() )
{
if( elements[layer][true].size() > 0 )
layer_bbox[layer] = elements[layer][true][0]->GetBoundingBox();
else if( elements[layer][false].size() > 0 )
layer_bbox[layer] = elements[layer][false][0]->GetBoundingBox();
}
}
for( auto& [layer, map] : elements )
{
wxXmlNode* layer_node = add_base_node( layer );
wxXmlNode* marking_node = add_marking_node( layer_node );
wxXmlNode* group_node = appendNode( marking_node, "UserSpecial" );
bool update_bbox = false;
if( layer == F_Fab || layer == B_Fab )
{
layer_nodes[layer] = layer_node;
update_bbox = true;
}
for( auto& [is_abs, vec] : map )
{
for( BOARD_ITEM* item : vec )
{
wxXmlNode* output_node = nullptr;
if( update_bbox )
layer_bbox[layer].Merge( item->GetBoundingBox() );
if( !is_abs )
output_node = add_marking_node( layer_node );
else
output_node = group_node;
switch( item->Type() )
{
case PCB_TEXT_T:
{
PCB_TEXT* text = static_cast<PCB_TEXT*>( item );
if( text->IsKnockout() )
addKnockoutText( output_node, text );
else
addText( output_node, text, text->GetFontMetrics() );
break;
}
case PCB_TEXTBOX_T:
{
PCB_TEXTBOX* text = static_cast<PCB_TEXTBOX*>( item );
addText( output_node, text, text->GetFontMetrics() );
// We want to force this to be a polygon to get absolute coordinates
if( text->IsBorderEnabled() )
{
SHAPE_POLY_SET poly_set;
text->GetEffectiveShape()->TransformToPolygon( poly_set, 0, ERROR_INSIDE );
addContourNode( output_node, poly_set, 0, FILL_T::NO_FILL,
text->GetBorderWidth() );
}
break;
}
case PCB_SHAPE_T:
{
if( !is_abs )
addLocationNode( output_node, *static_cast<PCB_SHAPE*>( item ) );
addShape( output_node, *static_cast<PCB_SHAPE*>( item ) );
break;
}
default: break;
}
}
}
if( group_node->GetChildren() == nullptr )
{
marking_node->RemoveChild( group_node );
layer_node->RemoveChild( marking_node );
delete group_node;
delete marking_node;
}
}
for( auto&[layer, bbox] : layer_bbox )
{
if( bbox.GetWidth() > 0 )
{
wxXmlNode* outlineNode = insertNode( layer_nodes[layer], "Outline" );
SHAPE_POLY_SET::POLYGON outline( 1 );
std::vector<VECTOR2I> points( 4 );
points[0] = bbox.GetPosition();
points[2] = bbox.GetEnd();
points[1].x = points[0].x;
points[1].y = points[2].y;
points[3].x = points[2].x;
points[3].y = points[0].y;
outline[0].Append( points );
addPolygonNode( outlineNode, outline, FILL_T::NO_FILL, 0 );
addLineDesc( outlineNode, 0, LINE_STYLE::SOLID );
}
}
for( size_t ii = 0; ii < fp->Pads().size(); ++ii )
{
PAD* pad = fp->Pads()[ii];
wxXmlNode* pinNode = appendNode( packageNode, "Pin" );
wxString name = pinName( pad );
addAttribute( pinNode, "number", name );
m_net_pin_dict[pad->GetNetCode()].emplace_back(
genString( fp->GetReference(), "CMP" ), name );
if( pad->GetAttribute() == PAD_ATTRIB::NPTH )
addAttribute( pinNode, "electricalType", "MECHANICAL" );
else if( pad->IsOnCopperLayer() )
addAttribute( pinNode, "electricalType", "ELECTRICAL" );
else
addAttribute( pinNode, "electricalType", "UNDEFINED" );
if( pad->HasHole() )
addAttribute( pinNode, "type", "THRU" );
else
addAttribute( pinNode, "type", "SURFACE" );
if( pad->GetFPRelativeOrientation() != ANGLE_0 )
{
wxXmlNode* xformNode = appendNode( pinNode, "Xform" );
xformNode->AddAttribute(
"rotation",
floatVal( pad->GetFPRelativeOrientation().Normalize().AsDegrees() ) );
}
addLocationNode( pinNode, *pad, true );
addShape( pinNode, *pad, pad->GetLayer() );
// We just need the padstack, we don't need the reference here. The reference will be
// created in the LayerFeature set
wxXmlNode dummy;
addPadStack( &dummy, pad );
}
return packageNode;
}
void PCB_IO_IPC2581::generateComponents( wxXmlNode* aStepNode )
{
std::vector<wxXmlNode*> componentNodes;
std::vector<wxXmlNode*> packageNodes;
std::set<wxString> packageNames;
bool generate_unique = m_OEMRef.empty();
for( FOOTPRINT* fp : m_board->Footprints() )
{
wxXmlNode* componentNode = new wxXmlNode( wxXML_ELEMENT_NODE, "Component" );
addAttribute( componentNode, "refDes", componentName( fp ) );
wxXmlNode* pkg = addPackage( componentNode, fp );
if( pkg )
packageNodes.push_back( pkg );
wxString name;
PCB_FIELD* field = nullptr;
if( !generate_unique )
field = fp->GetFieldByName( m_OEMRef );
if( field && !field->GetText().empty() )
{
name = field->GetShownText( false );
}
else
{
name = wxString::Format( "%s_%s_%s", fp->GetFPID().GetFullLibraryName(),
fp->GetFPID().GetLibItemName().wx_str(),
fp->GetValue() );
}
if( !m_OEMRef_dict.emplace( fp, name ).second )
wxLogError( "Duplicate footprint pointers. Please report this bug." );
addAttribute( componentNode, "part", genString( name, "REF" ) );
addAttribute( componentNode, "layerRef", m_layer_name_map[fp->GetLayer()] );
if( fp->GetAttributes() & FP_THROUGH_HOLE )
addAttribute( componentNode, "mountType", "THMT" );
else if( fp->GetAttributes() & FP_SMD )
addAttribute( componentNode, "mountType", "SMT" );
else
addAttribute( componentNode, "mountType", "OTHER" );
if( fp->GetOrientation() != ANGLE_0 || fp->GetLayer() != F_Cu )
{
wxXmlNode* xformNode = appendNode( componentNode, "Xform" );
if( fp->GetOrientation() != ANGLE_0 )
{
addAttribute( xformNode, "rotation",
floatVal( fp->GetOrientation().Normalize().AsDegrees() ) );
}
if( fp->GetLayer() != F_Cu )
addAttribute( xformNode, "mirror", "true" );
}
addLocationNode( componentNode, fp->GetPosition().x, fp->GetPosition().y );
componentNodes.push_back( componentNode );
}
for( wxXmlNode* padstack : m_padstacks )
{
insertNode( aStepNode, padstack );
m_last_padstack = padstack;
}
for( wxXmlNode* pkg : packageNodes )
aStepNode->AddChild( pkg );
for( wxXmlNode* cmp : componentNodes )
aStepNode->AddChild( cmp );
}
void PCB_IO_IPC2581::generateLogicalNets( wxXmlNode* aStepNode )
{
for( auto& [ net, pin_pair] : m_net_pin_dict )
{
wxXmlNode* netNode = appendNode( aStepNode, "LogicalNet" );
addAttribute( netNode, "name",
genString( m_board->GetNetInfo().GetNetItem( net )->GetNetname(), "NET" ) ) ;
for( auto& [cmp, pin] : pin_pair )
{
wxXmlNode* netPinNode = appendNode( netNode, "PinRef" );
addAttribute( netPinNode, "componentRef", cmp );
addAttribute( netPinNode, "pin", pin );
}
//TODO: Finish
}
}
//TODO: Add PhyNetGroup section
void PCB_IO_IPC2581::generateLayerFeatures( wxXmlNode* aStepNode )
{
LSEQ layers = m_board->GetEnabledLayers().Seq();
const NETINFO_LIST& nets = m_board->GetNetInfo();
std::vector<std::unique_ptr<FOOTPRINT>> footprints;
// To avoid the overhead of repeatedly cycling through the layers and nets,
// we pre-sort the board items into a map of layer -> net -> items
std::map<PCB_LAYER_ID, std::map<int, std::vector<BOARD_ITEM*>>> elements;
std::for_each( m_board->Tracks().begin(), m_board->Tracks().end(),
[&layers, &elements]( PCB_TRACK* aTrack )
{
if( aTrack->Type() == PCB_VIA_T )
{
PCB_VIA* via = static_cast<PCB_VIA*>( aTrack );
for( PCB_LAYER_ID layer : layers )
{
if( via->FlashLayer( layer ) )
elements[layer][via->GetNetCode()].push_back( via );
}
}
else
{
elements[aTrack->GetLayer()][aTrack->GetNetCode()].push_back( aTrack );
}
} );
std::for_each( m_board->Zones().begin(), m_board->Zones().end(),
[ &elements ]( ZONE* zone )
{
LSEQ zone_layers = zone->GetLayerSet().Seq();
for( PCB_LAYER_ID layer : zone_layers )
elements[layer][zone->GetNetCode()].push_back( zone );
} );
for( BOARD_ITEM* item : m_board->Drawings() )
{
if( BOARD_CONNECTED_ITEM* conn_it = dynamic_cast<BOARD_CONNECTED_ITEM*>( item ) )
elements[conn_it->GetLayer()][conn_it->GetNetCode()].push_back( conn_it );
else
elements[item->GetLayer()][0].push_back( item );
}
for( FOOTPRINT* fp : m_board->Footprints() )
{
for( PCB_FIELD* field : fp->GetFields() )
elements[field->GetLayer()][0].push_back( field );
for( BOARD_ITEM* item : fp->GraphicalItems() )
elements[item->GetLayer()][0].push_back( item );
for( PAD* pad : fp->Pads() )
{
LSEQ pad_layers = pad->GetLayerSet().Seq();
for( PCB_LAYER_ID layer : pad_layers )
{
if( pad->FlashLayer( layer ) )
elements[layer][pad->GetNetCode()].push_back( pad );
}
}
}
for( PCB_LAYER_ID layer : layers )
{
if( m_progressReporter )
m_progressReporter->SetMaxProgress( nets.GetNetCount() * layers.size() );
wxXmlNode* layerNode = appendNode( aStepNode, "LayerFeature" );
addAttribute( layerNode, "layerRef", m_layer_name_map[layer] );
auto process_net = [&] ( int net )
{
std::vector<BOARD_ITEM*>& vec = elements[layer][net];
if( vec.empty() )
return;
std::stable_sort( vec.begin(), vec.end(),
[]( BOARD_ITEM* a, BOARD_ITEM* b )
{
if( a->GetParentFootprint() == b->GetParentFootprint() )
return a->Type() < b->Type();
return a->GetParentFootprint() < b->GetParentFootprint();
} );
generateLayerSetNet( layerNode, layer, vec );
};
for( const NETINFO_ITEM* net : nets )
{
if( m_progressReporter )
{
m_progressReporter->Report( wxString::Format( _( "Exporting Layer %s, Net %s" ),
m_board->GetLayerName( layer ),
net->GetNetname() ) );
m_progressReporter->AdvanceProgress();
}
process_net( net->GetNetCode() );
}
if( layerNode->GetChildren() == nullptr )
{
aStepNode->RemoveChild( layerNode );
delete layerNode;
}
}
}
void PCB_IO_IPC2581::generateLayerSetDrill( wxXmlNode* aLayerNode )
{
int hole_count = 1;
for( const auto& [layers, vec] : m_drill_layers )
{
wxXmlNode* layerNode = appendNode( aLayerNode, "LayerFeature" );
layerNode->AddAttribute( "layerRef", genLayersString( layers.first, layers.second, "DRILL" ) );
for( BOARD_ITEM* item : vec )
{
if( item->Type() == PCB_VIA_T )
{
PCB_VIA* via = static_cast<PCB_VIA*>( item );
auto it = m_padstack_dict.find( hash_fp_item( via, 0 ) );
if( it == m_padstack_dict.end() )
{
wxLogError( "Failed to find padstack for via" );
continue;
}
wxXmlNode* padNode = appendNode( layerNode, "Set" );
addAttribute( padNode, "geometry", it->second );
if( via->GetNetCode() > 0 )
addAttribute( padNode, "net", genString( via->GetNetname(), "NET" ) );
wxXmlNode* holeNode = appendNode( padNode, "Hole" );
addAttribute( holeNode, "name", wxString::Format( "H%d", hole_count++ ) );
addAttribute( holeNode, "diameter", floatVal( m_scale * via->GetDrillValue() ) );
addAttribute( holeNode, "platingStatus", "VIA" );
addAttribute( holeNode, "plusTol", "0.0" );
addAttribute( holeNode, "minusTol", "0.0" );
addXY( holeNode, via->GetPosition() );
}
else if( item->Type() == PCB_PAD_T )
{
PAD* pad = static_cast<PAD*>( item );
auto it = m_padstack_dict.find( hash_fp_item( pad, 0 ) );
if( it == m_padstack_dict.end() )
{
wxLogError( "Failed to find padstack for pad" );
continue;
}
wxXmlNode* padNode = appendNode( layerNode, "Set" );
addAttribute( padNode, "geometry", it->second );
if( pad->GetNetCode() > 0 )
addAttribute( padNode, "net", genString( pad->GetNetname(), "NET" ) );
wxXmlNode* holeNode = appendNode( padNode, "Hole" );
addAttribute( holeNode, "name", wxString::Format( "H%d", hole_count++ ) );
addAttribute( holeNode, "diameter", floatVal( m_scale * pad->GetDrillSizeX() ) );
addAttribute( holeNode, "platingStatus",
pad->GetAttribute() == PAD_ATTRIB::PTH ? "PLATED" : "NONPLATED" );
addAttribute( holeNode, "plusTol", "0.0" );
addAttribute( holeNode, "minusTol", "0.0" );
addXY( holeNode, pad->GetPosition() );
}
}
}
hole_count = 1;
for( const auto& [layers, vec] : m_slot_holes )
{
wxXmlNode* layerNode = appendNode( aLayerNode, "LayerFeature" );
layerNode->AddAttribute( "layerRef", genLayersString( layers.first, layers.second, "SLOT" ) );
for( PAD* pad : vec )
{
wxXmlNode* padNode = appendNode( layerNode, "Set" );
if( pad->GetNetCode() > 0 )
addAttribute( padNode, "net", genString( pad->GetNetname(), "NET" ) );
addSlotCavity( padNode, *pad, wxString::Format( "SLOT%d", hole_count++ ) );
}
}
}
void PCB_IO_IPC2581::generateLayerSetNet( wxXmlNode* aLayerNode, PCB_LAYER_ID aLayer,
std::vector<BOARD_ITEM*>& aItems )
{
auto it = aItems.begin();
wxXmlNode* layerSetNode = appendNode( aLayerNode, "Set" );
wxXmlNode* featureSetNode = appendNode( layerSetNode, "Features" );
wxXmlNode* specialNode = appendNode( featureSetNode, "UserSpecial" );
bool has_via = false;
bool has_pad = false;
wxXmlNode* padSetNode = nullptr;
wxXmlNode* viaSetNode = nullptr;
wxXmlNode* teardropLayerSetNode = nullptr;
wxXmlNode* teardropFeatureSetNode = nullptr;
if( BOARD_CONNECTED_ITEM* item = dynamic_cast<BOARD_CONNECTED_ITEM*>( *it );
IsCopperLayer( aLayer ) && item )
{
if( item->GetNetCode() > 0 )
addAttribute( layerSetNode, "net", genString( item->GetNetname(), "NET" ) );
}
auto add_track =
[&]( PCB_TRACK* track )
{
if( track->Type() == PCB_TRACE_T )
{
PCB_SHAPE shape( nullptr, SHAPE_T::SEGMENT );
shape.SetStart( track->GetStart() );
shape.SetEnd( track->GetEnd() );
shape.SetWidth( track->GetWidth() );
addShape( specialNode, shape );
}
else if( track->Type() == PCB_ARC_T )
{
PCB_ARC* arc = static_cast<PCB_ARC*>( track );
PCB_SHAPE shape( nullptr, SHAPE_T::ARC );
shape.SetArcGeometry( arc->GetStart(), arc->GetMid(), arc->GetEnd() );
shape.SetWidth( arc->GetWidth() );
addShape( specialNode, shape );
}
else
{
if( !viaSetNode )
{
if( !has_pad )
{
viaSetNode = layerSetNode;
has_via = true;
}
else
{
viaSetNode = appendNode( layerSetNode, "Set" );
if( track->GetNetCode() > 0 )
addAttribute( viaSetNode, "net", genString( track->GetNetname(), "NET" ) );
}
addAttribute( viaSetNode, "padUsage", "VIA" );
}
addVia( viaSetNode, static_cast<PCB_VIA*>( track ), aLayer );
}
};
auto add_zone =
[&]( ZONE* zone )
{
wxXmlNode* zoneFeatureNode = specialNode;
if( zone->IsTeardropArea() && m_version > 'B' )
{
if( !teardropFeatureSetNode )
{
teardropLayerSetNode = appendNode( aLayerNode, "Set" );
addAttribute( teardropLayerSetNode, "geometryUsage", "TEARDROP" );
if( zone->GetNetCode() > 0 )
{
addAttribute( teardropLayerSetNode, "net",
genString( zone->GetNetname(), "NET" ) );
}
wxXmlNode* new_teardrops = appendNode( teardropLayerSetNode, "Features" );
addLocationNode( new_teardrops, 0.0, 0.0 );
teardropFeatureSetNode = appendNode( new_teardrops, "UserSpecial" );
}
zoneFeatureNode = teardropFeatureSetNode;
}
else
{
if( FOOTPRINT* fp = zone->GetParentFootprint() )
{
wxXmlNode* tempSetNode = appendNode( aLayerNode, "Set" );
wxString refDes = componentName( zone->GetParentFootprint() );
addAttribute( tempSetNode, "componentRef", refDes );
wxXmlNode* newFeatures = appendNode( tempSetNode, "Features" );
addLocationNode( newFeatures, 0.0, 0.0 );
zoneFeatureNode = appendNode( newFeatures, "UserSpecial" );
}
}
SHAPE_POLY_SET& zone_shape = *zone->GetFilledPolysList( aLayer );
for( int ii = 0; ii < zone_shape.OutlineCount(); ++ii )
addContourNode( zoneFeatureNode, zone_shape, ii );
};
auto add_shape =
[&] ( PCB_SHAPE* shape )
{
FOOTPRINT* fp = shape->GetParentFootprint();
if( fp )
{
wxXmlNode* tempSetNode = appendNode( aLayerNode, "Set" );
if( m_version > 'B' )
addAttribute( tempSetNode, "geometryUsage", "GRAPHIC" );
addAttribute( tempSetNode, "componentRef", componentName( fp ) );
wxXmlNode* tempFeature = appendNode( tempSetNode, "Features" );
addLocationNode( tempFeature, *shape );
addShape( tempFeature, *shape );
}
else if( shape->GetShape() == SHAPE_T::CIRCLE
|| shape->GetShape() == SHAPE_T::RECTANGLE
|| shape->GetShape() == SHAPE_T::POLY )
{
wxXmlNode* tempSetNode = appendNode( aLayerNode, "Set" );
if( shape->GetNetCode() > 0 )
addAttribute( tempSetNode, "net", genString( shape->GetNetname(), "NET" ) );
wxXmlNode* tempFeature = appendNode( tempSetNode, "Features" );
addLocationNode( tempFeature, *shape );
addShape( tempFeature, *shape );
}
else
{
addShape( specialNode, *shape );
}
};
auto add_text =
[&] ( BOARD_ITEM* text )
{
EDA_TEXT* text_item;
FOOTPRINT* fp = text->GetParentFootprint();
if( PCB_TEXT* tmp_text = dynamic_cast<PCB_TEXT*>( text ) )
text_item = static_cast<EDA_TEXT*>( tmp_text );
else if( PCB_TEXTBOX* tmp_text = dynamic_cast<PCB_TEXTBOX*>( text ) )
text_item = static_cast<EDA_TEXT*>( tmp_text );
if( !text_item->IsVisible() || text_item->GetShownText( false ).empty() )
return;
wxXmlNode* tempSetNode = appendNode( aLayerNode, "Set" );
if( m_version > 'B' )
addAttribute( tempSetNode, "geometryUsage", "TEXT" );
if( fp )
addAttribute( tempSetNode, "componentRef", componentName( fp ) );
wxXmlNode* nonStandardAttributeNode = appendNode( tempSetNode, "NonstandardAttribute" );
addAttribute( nonStandardAttributeNode, "name", "TEXT" );
addAttribute( nonStandardAttributeNode, "value", text_item->GetShownText( false ) );
addAttribute( nonStandardAttributeNode, "type", "STRING" );
wxXmlNode* tempFeature = appendNode( tempSetNode, "Features" );
addLocationNode( tempFeature, 0.0, 0.0 );
if( text->Type() == PCB_TEXT_T && static_cast<PCB_TEXT*>( text )->IsKnockout() )
addKnockoutText( tempFeature, static_cast<PCB_TEXT*>( text ) );
else
addText( tempFeature, text_item, text->GetFontMetrics() );
if( text->Type() == PCB_TEXTBOX_T )
{
PCB_TEXTBOX* textbox = static_cast<PCB_TEXTBOX*>( text );
if( textbox->IsBorderEnabled() )
addShape( tempFeature, *static_cast<PCB_SHAPE*>( textbox ) );
}
};
auto add_pad =
[&]( PAD* pad )
{
if( !padSetNode )
{
if( !has_via )
{
padSetNode = layerSetNode;
has_pad = true;
}
else
{
padSetNode = appendNode( aLayerNode, "Set" );
if( pad->GetNetCode() > 0 )
addAttribute( padSetNode, "net", genString( pad->GetNetname(), "NET" ) );
}
}
FOOTPRINT* fp = pad->GetParentFootprint();
if( fp && fp->IsFlipped() )
addPad( padSetNode, pad, FlipLayer( aLayer ) );
else
addPad( padSetNode, pad, aLayer );
};
for( BOARD_ITEM* item : aItems )
{
switch( item->Type() )
{
case PCB_TRACE_T:
case PCB_ARC_T:
case PCB_VIA_T:
add_track( static_cast<PCB_TRACK*>( item ) );
break;
case PCB_ZONE_T:
add_zone( static_cast<ZONE*>( item ) );
break;
case PCB_PAD_T:
add_pad( static_cast<PAD*>( item ) );
break;
case PCB_SHAPE_T:
add_shape( static_cast<PCB_SHAPE*>( item ) );
break;
case PCB_TEXT_T:
case PCB_TEXTBOX_T:
case PCB_FIELD_T:
add_text( item );
break;
case PCB_DIMENSION_T:
case PCB_TARGET_T:
case PCB_DIM_ALIGNED_T:
case PCB_DIM_LEADER_T:
case PCB_DIM_CENTER_T:
case PCB_DIM_RADIAL_T:
case PCB_DIM_ORTHOGONAL_T:
//TODO: Add support for dimensions
break;
default:
wxLogTrace( traceIpc2581, wxS( "Unhandled type %s" ),
ENUM_MAP<KICAD_T>::Instance().ToString( item->Type() ) );
}
}
if( specialNode->GetChildren() == nullptr )
{
featureSetNode->RemoveChild( specialNode );
delete specialNode;
}
if( featureSetNode->GetChildren() == nullptr )
{
layerSetNode->RemoveChild( featureSetNode );
delete featureSetNode;
}
if( layerSetNode->GetChildren() == nullptr )
{
aLayerNode->RemoveChild( layerSetNode );
delete layerSetNode;
}
}
wxXmlNode* PCB_IO_IPC2581::generateAvlSection()
{
if( m_progressReporter )
m_progressReporter->AdvancePhase( _( "Generating BOM section" ) );
wxXmlNode* avl = appendNode( m_xml_root, "Avl" );
addAttribute( avl, "name", "Primary_Vendor_List" );
wxXmlNode* header = appendNode( avl, "AvlHeader" );
addAttribute( header, "title", "BOM" );
addAttribute( header, "source", "KiCad" );
addAttribute( header, "author", "OWNER" );
addAttribute( header, "datetime", wxDateTime::Now().FormatISOCombined() );
addAttribute( header, "version", "1" );
std::set<wxString> unique_parts;
std::map<wxString,wxString> unique_vendors;
for( auto& [fp, name] : m_OEMRef_dict )
{
auto [ it, success ] = unique_parts.insert( name );
if( !success )
continue;
wxXmlNode* part = appendNode( avl, "AvlItem" );
addAttribute( part, "OEMDesignNumber", genString( name, "REF" ) );
PCB_FIELD* nums[2] = { fp->GetFieldByName( m_mpn ), fp->GetFieldByName( m_distpn ) };
PCB_FIELD* company[2] = { fp->GetFieldByName( m_mfg ), nullptr };
wxString company_name[2] = { m_mfg, m_dist };
for ( int ii = 0; ii < 2; ++ii )
{
if( nums[ii] )
{
wxString mpn_name = nums[ii]->GetShownText( false );
if( mpn_name.empty() )
continue;
wxXmlNode* vmpn = appendNode( part, "AvlVmpn" );
addAttribute( vmpn, "qualified", "false" );
addAttribute( vmpn, "chosen", "false" );
wxXmlNode* mpn = appendNode( vmpn, "AvlMpn" );
addAttribute( mpn, "name", mpn_name );
wxXmlNode* vendor = appendNode( vmpn, "AvlVendor" );
wxString name = wxT( "UNKNOWN" );
// If the field resolves, then use that field content unless it is empty
if( !ii && company[ii] )
{
wxString tmp = company[ii]->GetShownText( false );
if( !tmp.empty() )
name = tmp;
}
// If it doesn't resolve but there is content from the dialog, use the static content
else if( !ii && !company_name[ii].empty() )
{
name = company_name[ii];
}
else if( ii && !m_dist.empty() )
{
name = m_dist;
}
auto [vendor_id, inserted] = unique_vendors.emplace(
name,
wxString::Format( "VENDOR_%zu", unique_vendors.size() ) );
addAttribute( vendor, "enterpriseRef", vendor_id->second );
if( inserted )
{
wxXmlNode* new_vendor = new wxXmlNode( wxXML_ELEMENT_NODE, "Enterprise" );
addAttribute( new_vendor, "id", vendor_id->second );
addAttribute( new_vendor, "name", name );
addAttribute( new_vendor, "code", "NONE" );
insertNodeAfter( m_enterpriseNode, new_vendor );
m_enterpriseNode = new_vendor;
}
}
}
}
return avl;
}
void PCB_IO_IPC2581::SaveBoard( const wxString& aFileName, BOARD* aBoard,
const std::map<std::string, UTF8>* aProperties )
{
m_board = aBoard;
m_units_str = "MILLIMETER";
m_scale = 1.0 / PCB_IU_PER_MM;
m_sigfig = 4;
if( auto it = aProperties->find( "units" ); it != aProperties->end() )
{
if( it->second == "inch" )
{
m_units_str = "INCH";
m_scale = 25.4 / PCB_IU_PER_MM;
}
}
if( auto it = aProperties->find( "sigfig" ); it != aProperties->end() )
m_sigfig = std::stoi( it->second );
if( auto it = aProperties->find( "version" ); it != aProperties->end() )
m_version = it->second.c_str()[0];
if( auto it = aProperties->find( "OEMRef" ); it != aProperties->end() )
m_OEMRef = it->second.wx_str();
if( auto it = aProperties->find( "mpn" ); it != aProperties->end() )
m_mpn = it->second.wx_str();
if( auto it = aProperties->find( "mfg" ); it != aProperties->end() )
m_mfg = it->second.wx_str();
if( auto it = aProperties->find( "dist" ); it != aProperties->end() )
m_dist = it->second.wx_str();
if( auto it = aProperties->find( "distpn" ); it != aProperties->end() )
m_distpn = it->second.wx_str();
if( m_version == 'B' )
{
for( char c = 'a'; c <= 'z'; ++c )
m_acceptable_chars.insert( c );
for( char c = 'A'; c <= 'Z'; ++c )
m_acceptable_chars.insert( c );
for( char c = '0'; c <= '9'; ++c )
m_acceptable_chars.insert( c );
// Add special characters
std::string specialChars = "_\\-.+><";
for( char c : specialChars )
m_acceptable_chars.insert( c );
}
m_xml_doc = new wxXmlDocument();
m_xml_root = generateXmlHeader();
generateContentSection();
if( m_progressReporter )
{
m_progressReporter->SetNumPhases( 7 );
m_progressReporter->BeginPhase( 1 );
m_progressReporter->Report( _( "Generating logistic section" ) );
}
generateLogisticSection();
generateHistorySection();
wxXmlNode* ecad_node = generateEcadSection();
generateBOMSection( ecad_node );
generateAvlSection();
if( m_progressReporter )
{
m_progressReporter->AdvancePhase( _( "Saving file" ) );
}
wxFileOutputStreamWithProgress out_stream( aFileName );
double written_bytes = 0.0;
double last_yield = 0.0;
// This is a rough estimation of the size of the spaces in the file
// We just need to total to be slightly larger than the value of the
// progress bar, so accurately counting spaces is not terribly important
m_total_bytes += m_total_bytes / 10;
auto update_progress = [&]( size_t aBytes )
{
written_bytes += aBytes;
double percent = written_bytes / static_cast<double>( m_total_bytes );
if( m_progressReporter )
{
// Only update every percent
if( last_yield + 0.01 < percent )
{
last_yield = percent;
m_progressReporter->SetCurrentProgress( percent );
}
}
};
out_stream.SetProgressCallback( update_progress );
if( !m_xml_doc->Save( out_stream ) )
{
wxLogError( _( "Failed to save file to buffer" ) );
return;
}
size_t size = out_stream.GetSize();
}
Reference in New Issue View Git Blame Copy Permalink