kicad/pcbnew/board.cpp

2306 lines
62 KiB
C++
Raw Normal View History

/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2018 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
2021-06-04 13:04:30 +00:00
* Copyright (C) 2011 Wayne Stambaugh <stambaughw@gmail.com>
*
2022-01-30 10:52:52 +00:00
* Copyright (C) 1992-2022 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 2
* 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, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <iterator>
#include <thread>
#include <drc/drc_rtree.h>
2018-01-29 15:39:40 +00:00
#include <pcb_base_frame.h>
#include <board_design_settings.h>
#include <reporter.h>
#include <board_commit.h>
#include <board.h>
#include <footprint.h>
2021-06-11 21:07:02 +00:00
#include <pcb_track.h>
#include <zone.h>
2020-11-14 18:11:28 +00:00
#include <pcb_marker.h>
#include <pcb_group.h>
#include <pcb_target.h>
#include <pcb_shape.h>
#include <pcb_text.h>
2022-01-30 10:52:52 +00:00
#include <pcb_textbox.h>
#include <core/arraydim.h>
#include <core/kicad_algo.h>
#include <connectivity/connectivity_data.h>
#include <string_utils.h>
#include <pgm_base.h>
#include <pcbnew_settings.h>
#include <project.h>
#include <project/net_settings.h>
#include <project/project_file.h>
#include <project/project_local_settings.h>
#include <ratsnest/ratsnest_data.h>
#include <tool/selection_conditions.h>
#include <convert_shape_list_to_polygon.h>
2021-06-03 12:11:15 +00:00
#include <wx/log.h>
#include <progress_reporter.h>
2007-12-01 05:37:44 +00:00
2020-11-14 18:11:28 +00:00
// This is an odd place for this, but CvPcb won't link if it's in board_item.cpp like I first
// tried it.
2022-01-01 18:57:44 +00:00
VECTOR2I BOARD_ITEM::ZeroOffset( 0, 0 );
2008-04-01 05:21:50 +00:00
++PCBNew * Removed Pcb_Frame argument from BOARD() constructor, since it precludes having a BOARD being edited by more than one editor, it was a bad design. And this meant removing m_PcbFrame from BOARD. * removed BOARD::SetWindowFrame(), and BOARD::m_PcbFrame * Removed the global BOARD_DESIGN_SETTINGS which was in class_board.cpp * added BOARD_DESIGN_SETTINGS to the BOARD class, a full instance * a couple dialogs now only change BOARD_DESIGN_SETTINGS when OK is pressed, such as dialog_mask_clearance, dialog_drc, etc. * Removed common/pcbcommon.cpp's int g_CurrentVersionPCB = 1 and replaced it with build_version.h's #define BOARD_FILE_VERSION, although there may be a better place for this constant. * Made the public functions in PARAM_CFG_ARRAY be type const. void SaveParam(..) const and void ReadParam(..) const * PARAM_CFG_BASE now has virtual destructor since we have various way of destroying the derived class and boost::ptr_vector must be told about this. * Pass const PARAM_CFG_ARRAY& instead of PARAM_CFG_ARRAY so that we can use an automatic PARAM_CFG_ARRAY which is on the stack.\ * PCB_EDIT_FRAME::GetProjectFileParameters() may no longer cache the array, since it has to access the current BOARD and the BOARD can change. Remember BOARD_DESIGN_SETTINGS are now in the BOARD. * Made the m_BoundingBox member private, this was a brutally hard task, and indicative of the lack of commitment to accessors and object oriented design on the part of KiCad developers. We must do better. Added BOARD::GetBoundingBox, SetBoundingBox(), ComputeBoundingBox(). * Added PCB_BASE_FRAME::GetBoardBoundingBox() which calls BOARD::ComputeBoundingBox()
2011-12-05 06:15:33 +00:00
BOARD::BOARD() :
BOARD_ITEM_CONTAINER( (BOARD_ITEM*) nullptr, PCB_T ),
2021-06-04 13:04:30 +00:00
m_LegacyDesignSettingsLoaded( false ),
m_LegacyCopperEdgeClearanceLoaded( false ),
m_LegacyNetclassesLoaded( false ),
m_boardUse( BOARD_USE::NORMAL ),
m_timeStamp( 1 ),
m_paper( PAGE_INFO::A4 ),
m_project( nullptr ),
m_designSettings( new BOARD_DESIGN_SETTINGS( nullptr, "board.design_settings" ) ),
2021-06-04 13:04:30 +00:00
m_NetInfo( this )
{
++PCBNew * Removed Pcb_Frame argument from BOARD() constructor, since it precludes having a BOARD being edited by more than one editor, it was a bad design. And this meant removing m_PcbFrame from BOARD. * removed BOARD::SetWindowFrame(), and BOARD::m_PcbFrame * Removed the global BOARD_DESIGN_SETTINGS which was in class_board.cpp * added BOARD_DESIGN_SETTINGS to the BOARD class, a full instance * a couple dialogs now only change BOARD_DESIGN_SETTINGS when OK is pressed, such as dialog_mask_clearance, dialog_drc, etc. * Removed common/pcbcommon.cpp's int g_CurrentVersionPCB = 1 and replaced it with build_version.h's #define BOARD_FILE_VERSION, although there may be a better place for this constant. * Made the public functions in PARAM_CFG_ARRAY be type const. void SaveParam(..) const and void ReadParam(..) const * PARAM_CFG_BASE now has virtual destructor since we have various way of destroying the derived class and boost::ptr_vector must be told about this. * Pass const PARAM_CFG_ARRAY& instead of PARAM_CFG_ARRAY so that we can use an automatic PARAM_CFG_ARRAY which is on the stack.\ * PCB_EDIT_FRAME::GetProjectFileParameters() may no longer cache the array, since it has to access the current BOARD and the BOARD can change. Remember BOARD_DESIGN_SETTINGS are now in the BOARD. * Made the m_BoundingBox member private, this was a brutally hard task, and indicative of the lack of commitment to accessors and object oriented design on the part of KiCad developers. We must do better. Added BOARD::GetBoundingBox, SetBoundingBox(), ComputeBoundingBox(). * Added PCB_BASE_FRAME::GetBoardBoundingBox() which calls BOARD::ComputeBoundingBox()
2011-12-05 06:15:33 +00:00
// we have not loaded a board yet, assume latest until then.
m_fileFormatVersionAtLoad = LEGACY_BOARD_FILE_VERSION;
++PCBNew * Removed Pcb_Frame argument from BOARD() constructor, since it precludes having a BOARD being edited by more than one editor, it was a bad design. And this meant removing m_PcbFrame from BOARD. * removed BOARD::SetWindowFrame(), and BOARD::m_PcbFrame * Removed the global BOARD_DESIGN_SETTINGS which was in class_board.cpp * added BOARD_DESIGN_SETTINGS to the BOARD class, a full instance * a couple dialogs now only change BOARD_DESIGN_SETTINGS when OK is pressed, such as dialog_mask_clearance, dialog_drc, etc. * Removed common/pcbcommon.cpp's int g_CurrentVersionPCB = 1 and replaced it with build_version.h's #define BOARD_FILE_VERSION, although there may be a better place for this constant. * Made the public functions in PARAM_CFG_ARRAY be type const. void SaveParam(..) const and void ReadParam(..) const * PARAM_CFG_BASE now has virtual destructor since we have various way of destroying the derived class and boost::ptr_vector must be told about this. * Pass const PARAM_CFG_ARRAY& instead of PARAM_CFG_ARRAY so that we can use an automatic PARAM_CFG_ARRAY which is on the stack.\ * PCB_EDIT_FRAME::GetProjectFileParameters() may no longer cache the array, since it has to access the current BOARD and the BOARD can change. Remember BOARD_DESIGN_SETTINGS are now in the BOARD. * Made the m_BoundingBox member private, this was a brutally hard task, and indicative of the lack of commitment to accessors and object oriented design on the part of KiCad developers. We must do better. Added BOARD::GetBoundingBox, SetBoundingBox(), ComputeBoundingBox(). * Added PCB_BASE_FRAME::GetBoardBoundingBox() which calls BOARD::ComputeBoundingBox()
2011-12-05 06:15:33 +00:00
2021-07-21 23:14:56 +00:00
for( int layer = 0; layer < PCB_LAYER_ID_COUNT; ++layer )
2008-03-04 04:22:27 +00:00
{
2020-11-14 14:29:11 +00:00
m_layers[layer].m_name = GetStandardLayerName( ToLAYER_ID( layer ) );
if( IsCopperLayer( layer ) )
2020-11-14 14:29:11 +00:00
m_layers[layer].m_type = LT_SIGNAL;
else
2020-11-14 14:29:11 +00:00
m_layers[layer].m_type = LT_UNDEFINED;
2008-03-04 04:22:27 +00:00
}
2009-09-10 15:22:26 +00:00
m_SolderMask = new ZONE( this );
m_SolderMask->SetLayerSet( LSET().set( F_Mask ).set( B_Mask ) );
m_SolderMask->SetOutline( new SHAPE_POLY_SET() );
int infinity = ( std::numeric_limits<int>::max() / 2 ) - Millimeter2iu( 1 );
m_SolderMask->Outline()->NewOutline();
m_SolderMask->Outline()->Append( VECTOR2I( -infinity, -infinity ) );
m_SolderMask->Outline()->Append( VECTOR2I( -infinity, +infinity ) );
m_SolderMask->Outline()->Append( VECTOR2I( +infinity, +infinity ) );
m_SolderMask->Outline()->Append( VECTOR2I( +infinity, -infinity ) );
m_SolderMask->SetMinThickness( 0 );
BOARD_DESIGN_SETTINGS& bds = GetDesignSettings();
// Initialize default netclass.
NETCLASS* defaultClass = bds.GetDefault();
defaultClass->SetDescription( _( "This is the default net class." ) );
2013-11-25 15:50:03 +00:00
bds.UseCustomTrackViaSize( false );
2014-03-03 16:15:41 +00:00
// Initialize ratsnest
2017-03-22 13:43:10 +00:00
m_connectivity.reset( new CONNECTIVITY_DATA() );
// Set flag bits on these that will only be cleared if these are loaded from a legacy file
m_LegacyVisibleLayers.reset().set( Rescue );
m_LegacyVisibleItems.reset().set( GAL_LAYER_INDEX( GAL_LAYER_ID_BITMASK_END ) );
}
2007-08-30 22:20:52 +00:00
BOARD::~BOARD()
{
// Clean up the owned elements
2007-11-27 22:49:35 +00:00
DeleteMARKERs();
2008-02-12 01:02:53 +00:00
for( ZONE* zone : m_zones )
delete zone;
m_zones.clear();
delete m_SolderMask;
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : m_footprints )
2020-11-12 23:50:33 +00:00
delete footprint;
2020-11-12 23:50:33 +00:00
m_footprints.clear();
2021-06-11 21:07:02 +00:00
for( PCB_TRACK* t : m_tracks )
delete t;
m_tracks.clear();
for( BOARD_ITEM* d : m_drawings )
delete d;
m_drawings.clear();
for( PCB_GROUP* g : m_groups )
delete g;
m_groups.clear();
}
void BOARD::BuildConnectivity( PROGRESS_REPORTER* aReporter )
{
GetConnectivity()->Build( this, aReporter );
}
void BOARD::SetProject( PROJECT* aProject )
{
if( m_project )
ClearProject();
m_project = aProject;
if( aProject )
{
PROJECT_FILE& project = aProject->GetProjectFile();
// Link the design settings object to the project file
project.m_BoardSettings = &GetDesignSettings();
// Set parent, which also will load the values from JSON stored in the project if we don't
// have legacy design settings loaded already
project.m_BoardSettings->SetParent( &project, !m_LegacyDesignSettingsLoaded );
// The DesignSettings' netclasses pointer will be pointing to its internal netclasses
// list at this point. If we loaded anything into it from a legacy board file then we
// want to transfer it over to the project netclasses list.
if( m_LegacyNetclassesLoaded )
project.NetSettings().m_NetClasses = GetDesignSettings().GetNetClasses();
// Now update the DesignSettings' netclass pointer to point into the project.
GetDesignSettings().SetNetClasses( &project.NetSettings().m_NetClasses );
}
}
void BOARD::ClearProject()
{
if( !m_project )
return;
PROJECT_FILE& project = m_project->GetProjectFile();
// Owned by the BOARD
if( project.m_BoardSettings )
{
project.ReleaseNestedSettings( project.m_BoardSettings );
project.m_BoardSettings = nullptr;
}
GetDesignSettings().SetParent( nullptr );
m_project = nullptr;
}
void BOARD::IncrementTimeStamp()
{
m_timeStamp++;
{
std::unique_lock<std::mutex> cacheLock( m_CachesMutex );
m_InsideAreaCache.clear();
m_InsideCourtyardCache.clear();
m_InsideFCourtyardCache.clear();
m_InsideBCourtyardCache.clear();
m_LayerExpressionCache.clear();
}
m_CopperZoneRTrees.clear();
}
2020-11-14 18:11:28 +00:00
std::vector<PCB_MARKER*> BOARD::ResolveDRCExclusions()
{
std::shared_ptr<CONNECTIVITY_DATA> conn = GetConnectivity();
auto setExcluded =
[&conn]( PCB_MARKER* aMarker )
{
if( aMarker->GetMarkerType() == MARKER_BASE::MARKER_RATSNEST )
{
const std::shared_ptr<RC_ITEM>& rcItem = aMarker->GetRCItem();
conn->AddExclusion( rcItem->GetMainItemID(), rcItem->GetAuxItemID() );
}
aMarker->SetExcluded( true );
};
2020-11-14 18:11:28 +00:00
for( PCB_MARKER* marker : GetBoard()->Markers() )
{
auto i = m_designSettings->m_DrcExclusions.find( marker->Serialize() );
if( i != m_designSettings->m_DrcExclusions.end() )
{
setExcluded( marker );
m_designSettings->m_DrcExclusions.erase( i );
}
}
2020-11-14 18:11:28 +00:00
std::vector<PCB_MARKER*> newMarkers;
for( const wxString& exclusionData : m_designSettings->m_DrcExclusions )
{
2020-11-14 18:11:28 +00:00
PCB_MARKER* marker = PCB_MARKER::Deserialize( exclusionData );
if( marker )
{
setExcluded( marker );
newMarkers.push_back( marker );
}
}
m_designSettings->m_DrcExclusions.clear();
return newMarkers;
}
bool BOARD::ResolveTextVar( wxString* token, int aDepth ) const
{
if( GetTitleBlock().TextVarResolver( token, m_project ) )
{
return true;
}
else if( m_properties.count( *token ) )
{
*token = m_properties.at( *token );
return true;
}
return false;
}
VECTOR2I BOARD::GetPosition() const
{
return ZeroOffset;
}
2017-12-17 17:43:43 +00:00
void BOARD::SetPosition( const VECTOR2I& aPos )
{
wxLogWarning( wxT( "This should not be called on the BOARD object") );
}
void BOARD::Move( const VECTOR2I& aMoveVector ) // overload
{
// @todo : anything like this elsewhere? maybe put into GENERAL_COLLECTOR class.
static const KICAD_T top_level_board_stuff[] = {
PCB_MARKER_T,
PCB_TEXT_T,
2022-01-30 10:52:52 +00:00
PCB_TEXTBOX_T,
PCB_SHAPE_T,
PCB_DIM_ALIGNED_T,
PCB_DIM_ORTHOGONAL_T,
PCB_DIM_CENTER_T,
PCB_DIM_RADIAL_T,
PCB_DIM_LEADER_T,
PCB_TARGET_T,
PCB_VIA_T,
PCB_TRACE_T,
PCB_ARC_T,
2020-11-13 12:21:02 +00:00
PCB_FOOTPRINT_T,
PCB_ZONE_T,
EOT
};
INSPECTOR_FUNC inspector = [&] ( EDA_ITEM* item, void* testData )
{
BOARD_ITEM* brd_item = (BOARD_ITEM*) item;
// aMoveVector was snapshotted, don't need "data".
brd_item->Move( aMoveVector );
2019-12-28 00:55:11 +00:00
return SEARCH_RESULT::CONTINUE;
};
Visit( inspector, nullptr, top_level_board_stuff );
}
TRACKS BOARD::TracksInNet( int aNetCode )
{
TRACKS ret;
INSPECTOR_FUNC inspector = [aNetCode, &ret]( EDA_ITEM* item, void* testData )
{
2021-06-11 21:07:02 +00:00
PCB_TRACK* t = static_cast<PCB_TRACK*>( item );
if( t->GetNetCode() == aNetCode )
ret.push_back( t );
return SEARCH_RESULT::CONTINUE;
};
2021-06-11 21:07:02 +00:00
// visit this BOARD's PCB_TRACKs and PCB_VIAs with above TRACK INSPECTOR which
// appends all in aNetCode to ret.
Visit( inspector, nullptr, GENERAL_COLLECTOR::Tracks );
return ret;
}
bool BOARD::SetLayerDescr( PCB_LAYER_ID aIndex, const LAYER& aLayer )
{
2020-11-14 14:29:11 +00:00
if( unsigned( aIndex ) < arrayDim( m_layers ) )
{
2020-11-14 14:29:11 +00:00
m_layers[ aIndex ] = aLayer;
return true;
}
return false;
}
const PCB_LAYER_ID BOARD::GetLayerID( const wxString& aLayerName ) const
{
// Check the BOARD physical layer names.
2021-07-21 23:14:56 +00:00
for( int layer = 0; layer < PCB_LAYER_ID_COUNT; ++layer )
{
2021-07-21 23:14:56 +00:00
if ( m_layers[ layer ].m_name == aLayerName || m_layers[ layer ].m_userName == aLayerName )
return ToLAYER_ID( layer );
}
// Otherwise fall back to the system standard layer names for virtual layers.
2021-07-21 23:14:56 +00:00
for( int layer = 0; layer < PCB_LAYER_ID_COUNT; ++layer )
{
2015-06-04 12:54:07 +00:00
if( GetStandardLayerName( ToLAYER_ID( layer ) ) == aLayerName )
return ToLAYER_ID( layer );
}
return UNDEFINED_LAYER;
}
const wxString BOARD::GetLayerName( PCB_LAYER_ID aLayer ) const
2008-01-23 01:50:16 +00:00
{
// All layer names are stored in the BOARD.
if( IsLayerEnabled( aLayer ) )
2008-03-04 04:22:27 +00:00
{
// Standard names were set in BOARD::BOARD() but they may be over-ridden by
// BOARD::SetLayerName(). For copper layers, return the user defined layer name,
// if it was set. Otherwise return the Standard English layer name.
2020-11-14 14:29:11 +00:00
if( !m_layers[aLayer].m_userName.IsEmpty() )
return m_layers[aLayer].m_userName;
2008-03-04 04:22:27 +00:00
}
return GetStandardLayerName( aLayer );
}
bool BOARD::SetLayerName( PCB_LAYER_ID aLayer, const wxString& aLayerName )
2008-03-01 13:15:41 +00:00
{
wxCHECK( !aLayerName.IsEmpty(), false );
// no quote chars in the name allowed
if( aLayerName.Find( wxChar( '"' ) ) != wxNOT_FOUND )
return false;
2008-03-04 04:22:27 +00:00
if( IsLayerEnabled( aLayer ) )
{
2020-11-14 14:29:11 +00:00
m_layers[aLayer].m_userName = aLayerName;
2008-03-04 04:22:27 +00:00
return true;
}
return false;
2008-03-01 13:15:41 +00:00
}
LAYER_T BOARD::GetLayerType( PCB_LAYER_ID aLayer ) const
2008-03-01 13:15:41 +00:00
{
if( !IsCopperLayer( aLayer ) )
return LT_SIGNAL;
if( IsLayerEnabled( aLayer ) )
2020-11-14 14:29:11 +00:00
return m_layers[aLayer].m_type;
2008-03-01 13:15:41 +00:00
return LT_SIGNAL;
}
bool BOARD::SetLayerType( PCB_LAYER_ID aLayer, LAYER_T aLayerType )
2008-03-01 13:15:41 +00:00
{
if( !IsCopperLayer( aLayer ) )
return false;
if( IsLayerEnabled( aLayer ) )
2008-03-04 04:22:27 +00:00
{
2020-11-14 14:29:11 +00:00
m_layers[aLayer].m_type = aLayerType;
2008-03-04 04:22:27 +00:00
return true;
}
2008-03-04 04:22:27 +00:00
return false;
}
const char* LAYER::ShowType( LAYER_T aType )
{
switch( aType )
{
default:
case LT_SIGNAL: return "signal";
case LT_POWER: return "power";
case LT_MIXED: return "mixed";
case LT_JUMPER: return "jumper";
2008-03-04 04:22:27 +00:00
}
}
LAYER_T LAYER::ParseType( const char* aType )
{
if( strcmp( aType, "signal" ) == 0 )
return LT_SIGNAL;
else if( strcmp( aType, "power" ) == 0 )
return LT_POWER;
else if( strcmp( aType, "mixed" ) == 0 )
return LT_MIXED;
else if( strcmp( aType, "jumper" ) == 0 )
return LT_JUMPER;
else
return LT_UNDEFINED;
2008-03-01 13:15:41 +00:00
}
2008-01-23 01:50:16 +00:00
int BOARD::GetCopperLayerCount() const
{
return GetDesignSettings().GetCopperLayerCount();
2008-01-23 01:50:16 +00:00
}
2010-01-21 07:41:30 +00:00
void BOARD::SetCopperLayerCount( int aCount )
{
GetDesignSettings().SetCopperLayerCount( aCount );
2010-01-21 07:41:30 +00:00
}
2008-01-23 01:50:16 +00:00
LSET BOARD::GetEnabledLayers() const
{
return GetDesignSettings().GetEnabledLayers();
}
bool BOARD::IsLayerVisible( PCB_LAYER_ID aLayer ) const
{
// If there is no project, assume layer is visible always
return GetDesignSettings().IsLayerEnabled( aLayer )
&& ( !m_project || m_project->GetLocalSettings().m_VisibleLayers[aLayer] );
}
LSET BOARD::GetVisibleLayers() const
{
return m_project ? m_project->GetLocalSettings().m_VisibleLayers : LSET::AllLayersMask();
}
void BOARD::SetEnabledLayers( LSET aLayerSet )
{
GetDesignSettings().SetEnabledLayers( aLayerSet );
}
bool BOARD::IsLayerEnabled( PCB_LAYER_ID aLayer ) const
{
return GetDesignSettings().IsLayerEnabled( aLayer );
}
void BOARD::SetVisibleLayers( LSET aLayerSet )
{
if( m_project )
m_project->GetLocalSettings().m_VisibleLayers = aLayerSet;
}
void BOARD::SetVisibleElements( const GAL_SET& aSet )
{
// Call SetElementVisibility for each item
// to ensure specific calculations that can be needed by some items,
// just changing the visibility flags could be not sufficient.
for( size_t i = 0; i < aSet.size(); i++ )
SetElementVisibility( GAL_LAYER_ID_START + static_cast<int>( i ), aSet[i] );
}
2012-02-06 05:44:19 +00:00
void BOARD::SetVisibleAlls()
{
SetVisibleLayers( LSET().set() );
2012-02-06 05:44:19 +00:00
// Call SetElementVisibility for each item,
// to ensure specific calculations that can be needed by some items
for( GAL_LAYER_ID ii = GAL_LAYER_ID_START; ii < GAL_LAYER_ID_BITMASK_END; ++ii )
SetElementVisibility( ii, true );
}
GAL_SET BOARD::GetVisibleElements() const
{
return m_project ? m_project->GetLocalSettings().m_VisibleItems : GAL_SET().set();
}
2010-01-21 20:53:01 +00:00
bool BOARD::IsElementVisible( GAL_LAYER_ID aLayer ) const
2010-01-25 06:45:34 +00:00
{
return !m_project || m_project->GetLocalSettings().m_VisibleItems[aLayer - GAL_LAYER_ID_START];
2010-01-25 06:45:34 +00:00
}
void BOARD::SetElementVisibility( GAL_LAYER_ID aLayer, bool isEnabled )
2010-01-25 06:45:34 +00:00
{
if( m_project )
m_project->GetLocalSettings().m_VisibleItems.set( aLayer - GAL_LAYER_ID_START, isEnabled );
2012-02-06 05:44:19 +00:00
switch( aLayer )
2010-01-25 06:45:34 +00:00
{
case LAYER_RATSNEST:
2017-06-23 17:22:44 +00:00
{
2020-10-14 23:37:26 +00:00
// because we have a tool to show/hide ratsnest relative to a pad or a footprint
// so the hide/show option is a per item selection
2017-04-24 20:26:11 +00:00
2021-06-11 21:07:02 +00:00
for( PCB_TRACK* track : Tracks() )
2017-04-24 20:26:11 +00:00
track->SetLocalRatsnestVisible( isEnabled );
2017-06-23 17:22:44 +00:00
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : Footprints() )
2017-06-23 17:22:44 +00:00
{
2020-11-12 22:30:02 +00:00
for( PAD* pad : footprint->Pads() )
2017-04-24 20:26:11 +00:00
pad->SetLocalRatsnestVisible( isEnabled );
2017-06-23 17:22:44 +00:00
}
for( ZONE* zone : Zones() )
2017-04-24 20:26:11 +00:00
zone->SetLocalRatsnestVisible( isEnabled );
2017-04-24 20:26:11 +00:00
break;
2017-06-23 17:22:44 +00:00
}
2010-01-25 06:45:34 +00:00
default:
2012-02-06 05:44:19 +00:00
;
2010-01-25 06:45:34 +00:00
}
}
bool BOARD::IsFootprintLayerVisible( PCB_LAYER_ID aLayer ) const
{
switch( aLayer )
{
2021-07-21 23:14:56 +00:00
case F_Cu: return IsElementVisible( LAYER_MOD_FR );
case B_Cu: return IsElementVisible( LAYER_MOD_BK );
default: wxFAIL_MSG( wxT( "BOARD::IsModuleLayerVisible(): bad layer" ) ); return true;
}
}
BOARD_DESIGN_SETTINGS& BOARD::GetDesignSettings() const
{
return *m_designSettings;
}
const ZONE_SETTINGS& BOARD::GetZoneSettings() const
{
return GetDesignSettings().GetDefaultZoneSettings();
}
void BOARD::SetZoneSettings( const ZONE_SETTINGS& aSettings )
{
GetDesignSettings().SetDefaultZoneSettings( aSettings );
}
void BOARD::CacheTriangulation( PROGRESS_REPORTER* aReporter, const std::vector<ZONE*>& aZones )
{
std::vector<ZONE*> zones = aZones;
if( zones.empty() )
zones = m_zones;
if( zones.empty() )
return;
if( aReporter )
aReporter->Report( _( "Tessellating copper zones..." ) );
std::atomic<size_t> next( 0 );
std::atomic<size_t> zones_done( 0 );
std::atomic<size_t> threads_done( 0 );
size_t parallelThreadCount = std::max<size_t>( std::thread::hardware_concurrency(), 2 );
for( size_t ii = 0; ii < parallelThreadCount; ++ii )
{
std::thread t = std::thread(
[ &zones, &zones_done, &threads_done, &next ]( )
{
for( size_t i = next.fetch_add( 1 ); i < zones.size(); i = next.fetch_add( 1 ) )
{
zones[i]->CacheTriangulation();
zones_done.fetch_add( 1 );
}
threads_done.fetch_add( 1 );
} );
t.detach();
}
// Finalize the triangulation threads
while( threads_done < parallelThreadCount )
{
if( aReporter )
{
aReporter->SetCurrentProgress( (double) zones_done / (double) zones.size() );
aReporter->KeepRefreshing();
}
std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) );
}
}
void BOARD::Add( BOARD_ITEM* aBoardItem, ADD_MODE aMode, bool aSkipConnectivity )
2007-11-27 22:49:35 +00:00
{
if( aBoardItem == nullptr )
2008-02-12 01:02:53 +00:00
{
wxFAIL_MSG( wxT( "BOARD::Add() param error: aBoardItem nullptr" ) );
2008-02-12 01:02:53 +00:00
return;
}
2007-11-27 22:49:35 +00:00
switch( aBoardItem->Type() )
{
case PCB_NETINFO_T:
m_NetInfo.AppendNet( (NETINFO_ITEM*) aBoardItem );
2016-09-05 10:19:30 +00:00
break;
2007-11-27 22:49:35 +00:00
// this one uses a vector
case PCB_MARKER_T:
2020-11-14 18:11:28 +00:00
m_markers.push_back( (PCB_MARKER*) aBoardItem );
2007-11-27 22:49:35 +00:00
break;
2008-02-12 01:02:53 +00:00
// this one uses a vector
case PCB_GROUP_T:
m_groups.push_back( (PCB_GROUP*) aBoardItem );
break;
2008-01-06 17:19:36 +00:00
// this one uses a vector
case PCB_ZONE_T:
m_zones.push_back( (ZONE*) aBoardItem );
2008-01-06 17:19:36 +00:00
break;
2008-02-12 01:02:53 +00:00
case PCB_TRACE_T:
case PCB_VIA_T:
case PCB_ARC_T:
// N.B. This inserts a small memory leak as we lose the
if( !IsCopperLayer( aBoardItem->GetLayer() ) )
{
wxFAIL_MSG( wxT( "BOARD::Add() Cannot place Track on non-copper layer" ) );
return;
}
if( aMode == ADD_MODE::APPEND || aMode == ADD_MODE::BULK_APPEND )
2021-06-11 21:07:02 +00:00
m_tracks.push_back( static_cast<PCB_TRACK*>( aBoardItem ) );
else
2021-06-11 21:07:02 +00:00
m_tracks.push_front( static_cast<PCB_TRACK*>( aBoardItem ) );
2011-08-09 14:13:01 +00:00
break;
2008-02-12 01:02:53 +00:00
2020-11-13 12:21:02 +00:00
case PCB_FOOTPRINT_T:
if( aMode == ADD_MODE::APPEND || aMode == ADD_MODE::BULK_APPEND )
2020-11-13 15:15:52 +00:00
m_footprints.push_back( static_cast<FOOTPRINT*>( aBoardItem ) );
else
2020-11-13 15:15:52 +00:00
m_footprints.push_front( static_cast<FOOTPRINT*>( aBoardItem ) );
break;
case PCB_DIM_ALIGNED_T:
2020-09-17 00:54:58 +00:00
case PCB_DIM_CENTER_T:
case PCB_DIM_RADIAL_T:
2020-09-17 00:54:58 +00:00
case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T:
case PCB_SHAPE_T:
case PCB_TEXT_T:
2022-01-30 10:52:52 +00:00
case PCB_TEXTBOX_T:
case PCB_TARGET_T:
if( aMode == ADD_MODE::APPEND || aMode == ADD_MODE::BULK_APPEND )
m_drawings.push_back( aBoardItem );
else
m_drawings.push_front( aBoardItem );
break;
// other types may use linked list
2007-11-27 22:49:35 +00:00
default:
2011-08-09 14:13:01 +00:00
{
wxString msg;
msg.Printf( wxT( "BOARD::Add() needs work: BOARD_ITEM type (%d) not handled" ),
aBoardItem->Type() );
2011-08-09 14:13:01 +00:00
wxFAIL_MSG( msg );
return;
2011-08-09 14:13:01 +00:00
}
break;
2007-11-27 22:49:35 +00:00
}
aBoardItem->SetParent( this );
aBoardItem->ClearEditFlags();
2020-04-12 19:29:16 +00:00
if( !aSkipConnectivity )
m_connectivity->Add( aBoardItem );
if( aMode != ADD_MODE::BULK_INSERT && aMode != ADD_MODE::BULK_APPEND )
{
InvokeListeners( &BOARD_LISTENER::OnBoardItemAdded, *this, aBoardItem );
}
2007-11-27 22:49:35 +00:00
}
void BOARD::FinalizeBulkAdd( std::vector<BOARD_ITEM*>& aNewItems )
{
InvokeListeners( &BOARD_LISTENER::OnBoardItemsAdded, *this, aNewItems );
}
void BOARD::FinalizeBulkRemove( std::vector<BOARD_ITEM*>& aRemovedItems )
{
InvokeListeners( &BOARD_LISTENER::OnBoardItemsRemoved, *this, aRemovedItems );
}
void BOARD::Remove( BOARD_ITEM* aBoardItem, REMOVE_MODE aRemoveMode )
2007-11-27 22:49:35 +00:00
{
// find these calls and fix them! Don't send me no stinking' nullptr.
wxASSERT( aBoardItem );
2007-11-27 22:49:35 +00:00
switch( aBoardItem->Type() )
{
case PCB_NETINFO_T:
{
NETINFO_ITEM* item = static_cast<NETINFO_ITEM*>( aBoardItem );
NETINFO_ITEM* unconnected = m_NetInfo.GetNetItem( NETINFO_LIST::UNCONNECTED );
for( FOOTPRINT* fp : m_footprints )
{
for( PAD* pad : fp->Pads() )
{
if( pad->GetNet() == item )
pad->SetNet( unconnected );
}
}
for( ZONE* zone : m_zones )
{
if( zone->GetNet() == item )
zone->SetNet( unconnected );
}
2021-06-11 21:07:02 +00:00
for( PCB_TRACK* track : m_tracks )
{
if( track->GetNet() == item )
track->SetNet( unconnected );
}
m_NetInfo.RemoveNet( item );
break;
}
2016-05-13 15:31:54 +00:00
case PCB_MARKER_T:
alg::delete_matching( m_markers, aBoardItem );
2007-11-27 22:49:35 +00:00
break;
case PCB_GROUP_T:
alg::delete_matching( m_groups, aBoardItem );
break;
case PCB_ZONE_T:
alg::delete_matching( m_zones, aBoardItem );
break;
2008-02-12 01:02:53 +00:00
2020-11-13 12:21:02 +00:00
case PCB_FOOTPRINT_T:
alg::delete_matching( m_footprints, aBoardItem );
2008-12-06 08:21:54 +00:00
break;
case PCB_TRACE_T:
case PCB_ARC_T:
case PCB_VIA_T:
alg::delete_matching( m_tracks, aBoardItem );
2008-12-06 08:21:54 +00:00
break;
case PCB_DIM_ALIGNED_T:
2020-09-17 00:54:58 +00:00
case PCB_DIM_CENTER_T:
case PCB_DIM_RADIAL_T:
2020-09-17 00:54:58 +00:00
case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T:
case PCB_SHAPE_T:
case PCB_TEXT_T:
2022-01-30 10:52:52 +00:00
case PCB_TEXTBOX_T:
case PCB_TARGET_T:
alg::delete_matching( m_drawings, aBoardItem );
2008-12-06 08:21:54 +00:00
break;
2007-11-27 22:49:35 +00:00
// other types may use linked list
default:
wxFAIL_MSG( wxT( "BOARD::Remove() needs more ::Type() support" ) );
2007-11-27 22:49:35 +00:00
}
aBoardItem->SetFlags( STRUCT_DELETED );
PCB_GROUP* parentGroup = aBoardItem->GetParentGroup();
if( parentGroup && !( parentGroup->GetFlags() & STRUCT_DELETED ) )
parentGroup->RemoveItem( aBoardItem );
2017-03-22 13:43:10 +00:00
m_connectivity->Remove( aBoardItem );
2020-04-12 19:29:16 +00:00
if( aRemoveMode != REMOVE_MODE::BULK )
InvokeListeners( &BOARD_LISTENER::OnBoardItemRemoved, *this, aBoardItem );
2007-12-03 05:14:51 +00:00
}
2019-12-20 14:11:39 +00:00
wxString BOARD::GetSelectMenuText( EDA_UNITS aUnits ) const
{
return wxString::Format( _( "PCB" ) );
}
2007-11-27 22:49:35 +00:00
void BOARD::DeleteMARKERs()
{
2020-11-14 18:11:28 +00:00
// the vector does not know how to delete the PCB_MARKER, it holds pointers
for( PCB_MARKER* marker : m_markers )
delete marker;
2008-02-12 01:02:53 +00:00
2007-11-27 22:49:35 +00:00
m_markers.clear();
}
void BOARD::DeleteMARKERs( bool aWarningsAndErrors, bool aExclusions )
{
// Deleting lots of items from a vector can be very slow. Copy remaining items instead.
MARKERS remaining;
2020-11-14 18:11:28 +00:00
for( PCB_MARKER* marker : m_markers )
{
if( ( marker->GetSeverity() == RPT_SEVERITY_EXCLUSION && aExclusions )
|| ( marker->GetSeverity() != RPT_SEVERITY_EXCLUSION && aWarningsAndErrors ) )
{
delete marker;
}
else
{
remaining.push_back( marker );
}
}
m_markers = remaining;
}
void BOARD::DeleteAllFootprints()
{
for( FOOTPRINT* footprint : m_footprints )
delete footprint;
m_footprints.clear();
}
BOARD_ITEM* BOARD::GetItem( const KIID& aID ) const
{
2020-02-24 17:23:53 +00:00
if( aID == niluuid )
return nullptr;
2021-06-11 21:07:02 +00:00
for( PCB_TRACK* track : Tracks() )
{
2020-02-24 17:23:53 +00:00
if( track->m_Uuid == aID )
return track;
}
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : Footprints() )
{
2020-10-14 23:37:26 +00:00
if( footprint->m_Uuid == aID )
return footprint;
2020-11-12 22:30:02 +00:00
for( PAD* pad : footprint->Pads() )
{
2020-02-24 17:23:53 +00:00
if( pad->m_Uuid == aID )
return pad;
}
2020-10-14 23:37:26 +00:00
if( footprint->Reference().m_Uuid == aID )
return &footprint->Reference();
2020-10-14 23:37:26 +00:00
if( footprint->Value().m_Uuid == aID )
return &footprint->Value();
2020-10-14 23:37:26 +00:00
for( BOARD_ITEM* drawing : footprint->GraphicalItems() )
{
2020-02-24 17:23:53 +00:00
if( drawing->m_Uuid == aID )
return drawing;
}
2020-10-14 23:37:26 +00:00
for( BOARD_ITEM* zone : footprint->Zones() )
{
if( zone->m_Uuid == aID )
return zone;
}
2020-10-14 23:37:26 +00:00
for( PCB_GROUP* group : footprint->Groups() )
{
if( group->m_Uuid == aID )
return group;
}
}
for( ZONE* zone : Zones() )
{
2020-02-24 17:23:53 +00:00
if( zone->m_Uuid == aID )
return zone;
}
for( BOARD_ITEM* drawing : Drawings() )
{
2020-02-24 17:23:53 +00:00
if( drawing->m_Uuid == aID )
return drawing;
}
2020-11-14 18:11:28 +00:00
for( PCB_MARKER* marker : m_markers )
{
2020-02-24 17:23:53 +00:00
if( marker->m_Uuid == aID )
return marker;
}
2020-02-24 17:23:53 +00:00
for( PCB_GROUP* group : m_groups )
{
if( group->m_Uuid == aID )
return group;
}
2020-05-18 00:20:16 +00:00
if( m_Uuid == aID )
return const_cast<BOARD*>( this );
2020-05-18 00:20:16 +00:00
// Not found; weak reference has been deleted.
return DELETED_BOARD_ITEM::GetInstance();
}
void BOARD::FillItemMap( std::map<KIID, EDA_ITEM*>& aMap )
{
// the board itself
aMap[ m_Uuid ] = this;
2021-06-11 21:07:02 +00:00
for( PCB_TRACK* track : Tracks() )
aMap[ track->m_Uuid ] = track;
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : Footprints() )
{
2020-10-14 23:37:26 +00:00
aMap[ footprint->m_Uuid ] = footprint;
2020-11-12 22:30:02 +00:00
for( PAD* pad : footprint->Pads() )
aMap[ pad->m_Uuid ] = pad;
2020-10-14 23:37:26 +00:00
aMap[ footprint->Reference().m_Uuid ] = &footprint->Reference();
aMap[ footprint->Value().m_Uuid ] = &footprint->Value();
2020-10-14 23:37:26 +00:00
for( BOARD_ITEM* drawing : footprint->GraphicalItems() )
aMap[ drawing->m_Uuid ] = drawing;
}
for( ZONE* zone : Zones() )
aMap[ zone->m_Uuid ] = zone;
for( BOARD_ITEM* drawing : Drawings() )
aMap[ drawing->m_Uuid ] = drawing;
2020-11-14 18:11:28 +00:00
for( PCB_MARKER* marker : m_markers )
aMap[ marker->m_Uuid ] = marker;
for( PCB_GROUP* group : m_groups )
aMap[ group->m_Uuid ] = group;
}
wxString BOARD::ConvertCrossReferencesToKIIDs( const wxString& aSource ) const
{
wxString newbuf;
size_t sourceLen = aSource.length();
for( size_t i = 0; i < sourceLen; ++i )
{
if( aSource[i] == '$' && i + 1 < sourceLen && aSource[i+1] == '{' )
{
wxString token;
bool isCrossRef = false;
for( i = i + 2; i < sourceLen; ++i )
{
if( aSource[i] == '}' )
break;
if( aSource[i] == ':' )
isCrossRef = true;
token.append( aSource[i] );
}
if( isCrossRef )
{
wxString remainder;
wxString ref = token.BeforeFirst( ':', &remainder );
for( const FOOTPRINT* footprint : Footprints() )
{
2020-10-14 23:37:26 +00:00
if( footprint->GetReference().CmpNoCase( ref ) == 0 )
{
wxString test( remainder );
2020-10-14 23:37:26 +00:00
if( footprint->ResolveTextVar( &test ) )
2022-02-04 22:44:59 +00:00
token = footprint->m_Uuid.AsString() + wxT( ":" ) + remainder;
break;
}
}
}
2022-02-04 22:44:59 +00:00
newbuf.append( wxT( "${" ) + token + wxT( "}" ) );
}
else
{
newbuf.append( aSource[i] );
}
}
return newbuf;
}
wxString BOARD::ConvertKIIDsToCrossReferences( const wxString& aSource ) const
{
wxString newbuf;
size_t sourceLen = aSource.length();
for( size_t i = 0; i < sourceLen; ++i )
{
if( aSource[i] == '$' && i + 1 < sourceLen && aSource[i+1] == '{' )
{
wxString token;
bool isCrossRef = false;
for( i = i + 2; i < sourceLen; ++i )
{
if( aSource[i] == '}' )
break;
if( aSource[i] == ':' )
isCrossRef = true;
token.append( aSource[i] );
}
if( isCrossRef )
{
wxString remainder;
wxString ref = token.BeforeFirst( ':', &remainder );
BOARD_ITEM* refItem = GetItem( KIID( ref ) );
2020-11-13 12:21:02 +00:00
if( refItem && refItem->Type() == PCB_FOOTPRINT_T )
2022-02-04 22:44:59 +00:00
{
token = static_cast<FOOTPRINT*>( refItem )->GetReference() + wxT( ":" )
+ remainder;
}
}
2022-02-04 22:44:59 +00:00
newbuf.append( wxT( "${" ) + token + wxT( "}" ) );
}
else
{
newbuf.append( aSource[i] );
}
}
return newbuf;
}
2020-10-27 11:03:35 +00:00
unsigned BOARD::GetNodesCount( int aNet ) const
{
unsigned retval = 0;
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : Footprints() )
{
2020-11-12 22:30:02 +00:00
for( PAD* pad : footprint->Pads() )
{
if( ( aNet == -1 && pad->GetNetCode() > 0 ) || aNet == pad->GetNetCode() )
retval++;
}
}
return retval;
}
unsigned BOARD::GetUnconnectedNetCount() const
{
return m_connectivity->GetUnconnectedCount();
}
EDA_RECT BOARD::ComputeBoundingBox( bool aBoardEdgesOnly ) const
{
EDA_RECT area;
LSET visible = GetVisibleLayers();
bool showInvisibleText = IsElementVisible( LAYER_MOD_TEXT_INVISIBLE )
&& PgmOrNull() && !PgmOrNull()->m_Printing;
if( aBoardEdgesOnly )
visible.set( Edge_Cuts );
// Check shapes, dimensions, texts, and fiducials
for( BOARD_ITEM* item : m_drawings )
{
if( aBoardEdgesOnly && ( item->GetLayer() != Edge_Cuts || item->Type() != PCB_SHAPE_T ) )
continue;
if( ( item->GetLayerSet() & visible ).any() )
area.Merge( item->GetBoundingBox() );
}
2020-10-14 23:37:26 +00:00
// Check footprints
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : m_footprints )
{
2020-10-14 23:37:26 +00:00
if( !( footprint->GetLayerSet() & visible ).any() )
continue;
if( aBoardEdgesOnly )
{
2020-10-14 23:37:26 +00:00
for( const BOARD_ITEM* edge : footprint->GraphicalItems() )
{
if( edge->GetLayer() == Edge_Cuts && edge->Type() == PCB_FP_SHAPE_T )
area.Merge( edge->GetBoundingBox() );
}
}
else
{
area.Merge( footprint->GetBoundingBox( true, showInvisibleText ) );
}
}
if( !aBoardEdgesOnly )
{
// Check tracks
2021-06-11 21:07:02 +00:00
for( PCB_TRACK* track : m_tracks )
{
if( ( track->GetLayerSet() & visible ).any() )
area.Merge( track->GetBoundingBox() );
}
// Check zones
for( ZONE* aZone : m_zones )
{
if( ( aZone->GetLayerSet() & visible ).any() )
area.Merge( aZone->GetBoundingBox() );
}
}
++PCBNew * Removed Pcb_Frame argument from BOARD() constructor, since it precludes having a BOARD being edited by more than one editor, it was a bad design. And this meant removing m_PcbFrame from BOARD. * removed BOARD::SetWindowFrame(), and BOARD::m_PcbFrame * Removed the global BOARD_DESIGN_SETTINGS which was in class_board.cpp * added BOARD_DESIGN_SETTINGS to the BOARD class, a full instance * a couple dialogs now only change BOARD_DESIGN_SETTINGS when OK is pressed, such as dialog_mask_clearance, dialog_drc, etc. * Removed common/pcbcommon.cpp's int g_CurrentVersionPCB = 1 and replaced it with build_version.h's #define BOARD_FILE_VERSION, although there may be a better place for this constant. * Made the public functions in PARAM_CFG_ARRAY be type const. void SaveParam(..) const and void ReadParam(..) const * PARAM_CFG_BASE now has virtual destructor since we have various way of destroying the derived class and boost::ptr_vector must be told about this. * Pass const PARAM_CFG_ARRAY& instead of PARAM_CFG_ARRAY so that we can use an automatic PARAM_CFG_ARRAY which is on the stack.\ * PCB_EDIT_FRAME::GetProjectFileParameters() may no longer cache the array, since it has to access the current BOARD and the BOARD can change. Remember BOARD_DESIGN_SETTINGS are now in the BOARD. * Made the m_BoundingBox member private, this was a brutally hard task, and indicative of the lack of commitment to accessors and object oriented design on the part of KiCad developers. We must do better. Added BOARD::GetBoundingBox, SetBoundingBox(), ComputeBoundingBox(). * Added PCB_BASE_FRAME::GetBoardBoundingBox() which calls BOARD::ComputeBoundingBox()
2011-12-05 06:15:33 +00:00
return area;
}
void BOARD::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
{
int padCount = 0;
int viaCount = 0;
int trackSegmentCount = 0;
std::set<int> netCodes;
int unconnected = GetConnectivity()->GetUnconnectedCount();
2021-06-11 21:07:02 +00:00
for( PCB_TRACK* item : m_tracks )
{
if( item->Type() == PCB_VIA_T )
viaCount++;
else
trackSegmentCount++;
if( item->GetNetCode() > 0 )
netCodes.insert( item->GetNetCode() );
}
for( FOOTPRINT* footprint : Footprints() )
{
for( PAD* pad : footprint->Pads() )
{
padCount++;
if( pad->GetNetCode() > 0 )
netCodes.insert( pad->GetNetCode() );
}
}
2022-02-04 22:44:59 +00:00
aList.emplace_back( _( "Pads" ), wxString::Format( wxT( "%d" ), padCount ) );
aList.emplace_back( _( "Vias" ), wxString::Format( wxT( "%d" ), viaCount ) );
aList.emplace_back( _( "Track Segments" ), wxString::Format( wxT( "%d" ), trackSegmentCount ) );
aList.emplace_back( _( "Nets" ), wxString::Format( wxT( "%d" ), (int) netCodes.size() ) );
aList.emplace_back( _( "Unrouted" ), wxString::Format( wxT( "%d" ), unconnected ) );
}
SEARCH_RESULT BOARD::Visit( INSPECTOR inspector, void* testData, const KICAD_T scanTypes[] )
{
KICAD_T stype;
2019-12-28 00:55:11 +00:00
SEARCH_RESULT result = SEARCH_RESULT::CONTINUE;
const KICAD_T* p = scanTypes;
bool done = false;
2007-08-30 22:20:52 +00:00
#if 0 && defined(DEBUG)
std::cout << GetClass().mb_str() << ' ';
2008-02-12 01:02:53 +00:00
#endif
while( !done )
{
stype = *p;
switch( stype )
{
case PCB_T:
result = inspector( this, testData ); // inspect me
// skip over any types handled in the above call.
++p;
break;
2020-11-13 11:17:15 +00:00
/*
* Instances of the requested KICAD_T live in a list, either one that I manage, or one
* that my footprints manage. If it's a type managed by class FOOTPRINT, then simply
* pass it on to each footprint's Visit() function via IterateForward( m_footprints, ... ).
*/
2008-02-12 01:02:53 +00:00
2020-11-13 12:21:02 +00:00
case PCB_FOOTPRINT_T:
case PCB_PAD_T:
case PCB_FP_TEXT_T:
2022-01-30 10:52:52 +00:00
case PCB_FP_TEXTBOX_T:
case PCB_FP_SHAPE_T:
case PCB_FP_DIM_ALIGNED_T:
case PCB_FP_DIM_LEADER_T:
case PCB_FP_DIM_CENTER_T:
case PCB_FP_DIM_RADIAL_T:
case PCB_FP_DIM_ORTHOGONAL_T:
case PCB_FP_ZONE_T:
2020-11-13 11:17:15 +00:00
// this calls FOOTPRINT::Visit() on each footprint.
2020-11-13 15:15:52 +00:00
result = IterateForward<FOOTPRINT*>( m_footprints, inspector, testData, p );
// skip over any types handled in the above call.
for( ; ; )
{
switch( stype = *++p )
{
2020-11-13 12:21:02 +00:00
case PCB_FOOTPRINT_T:
case PCB_PAD_T:
case PCB_FP_TEXT_T:
2022-01-30 10:52:52 +00:00
case PCB_FP_TEXTBOX_T:
case PCB_FP_SHAPE_T:
case PCB_FP_DIM_ALIGNED_T:
case PCB_FP_DIM_LEADER_T:
case PCB_FP_DIM_CENTER_T:
case PCB_FP_DIM_RADIAL_T:
case PCB_FP_DIM_ORTHOGONAL_T:
case PCB_FP_ZONE_T:
continue;
default:
;
}
break;
}
break;
case PCB_SHAPE_T:
case PCB_TEXT_T:
2022-01-30 10:52:52 +00:00
case PCB_TEXTBOX_T:
case PCB_DIM_ALIGNED_T:
2020-09-17 00:54:58 +00:00
case PCB_DIM_CENTER_T:
case PCB_DIM_RADIAL_T:
2020-09-17 00:54:58 +00:00
case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T:
case PCB_TARGET_T:
result = IterateForward<BOARD_ITEM*>( m_drawings, inspector, testData, p );
// skip over any types handled in the above call.
for( ; ; )
{
switch( stype = *++p )
{
case PCB_SHAPE_T:
case PCB_TEXT_T:
2022-01-30 10:52:52 +00:00
case PCB_TEXTBOX_T:
case PCB_DIM_ALIGNED_T:
2020-09-17 00:54:58 +00:00
case PCB_DIM_CENTER_T:
case PCB_DIM_RADIAL_T:
2020-09-17 00:54:58 +00:00
case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T:
case PCB_TARGET_T:
continue;
default:
;
}
break;
}
break;
2007-08-30 22:20:52 +00:00
case PCB_VIA_T:
2021-06-11 21:07:02 +00:00
result = IterateForward<PCB_TRACK*>( m_tracks, inspector, testData, p );
2007-08-30 22:20:52 +00:00
++p;
break;
2008-02-12 01:02:53 +00:00
case PCB_TRACE_T:
case PCB_ARC_T:
2021-06-11 21:07:02 +00:00
result = IterateForward<PCB_TRACK*>( m_tracks, inspector, testData, p );
2007-08-30 22:20:52 +00:00
++p;
break;
2007-11-27 22:49:35 +00:00
case PCB_MARKER_T:
2020-11-14 18:11:28 +00:00
for( PCB_MARKER* marker : m_markers )
2007-11-27 22:49:35 +00:00
{
result = marker->Visit( inspector, testData, p );
2019-12-28 00:55:11 +00:00
if( result == SEARCH_RESULT::QUIT )
2007-11-27 22:49:35 +00:00
break;
}
2007-11-27 22:49:35 +00:00
++p;
break;
case PCB_ZONE_T:
for( ZONE* zone : m_zones)
{
result = zone->Visit( inspector, testData, p );
2019-12-28 00:55:11 +00:00
if( result == SEARCH_RESULT::QUIT )
break;
}
++p;
break;
case PCB_GROUP_T:
result = IterateForward<PCB_GROUP*>( m_groups, inspector, testData, p );
++p;
break;
default: // catch EOT or ANY OTHER type here and return.
done = true;
break;
}
2008-02-12 01:02:53 +00:00
2019-12-28 00:55:11 +00:00
if( result == SEARCH_RESULT::QUIT )
break;
}
2008-02-12 01:02:53 +00:00
return result;
}
2010-12-29 17:47:32 +00:00
NETINFO_ITEM* BOARD::FindNet( int aNetcode ) const
{
// the first valid netcode is 1 and the last is m_NetInfo.GetCount()-1.
// zero is reserved for "no connection" and is not actually a net.
// nullptr is returned for non valid netcodes
wxASSERT( m_NetInfo.GetNetCount() > 0 );
if( aNetcode == NETINFO_LIST::UNCONNECTED && m_NetInfo.GetNetCount() == 0 )
return NETINFO_LIST::OrphanedItem();
else
return m_NetInfo.GetNetItem( aNetcode );
}
NETINFO_ITEM* BOARD::FindNet( const wxString& aNetname ) const
2008-01-06 20:58:27 +00:00
{
Changed the way of looking up NETINFO_ITEM using net names (using boost::unordered_map). Added a hash function (wxString) for that. Introduced NETINFO_ITEM::GetNetItem( wxString ). BOARD::FindNet() uses the map. Net codes are updated upon net list update. (BOARD::ReplaceNetlist()) Added in some places (mostly class_board.cpp) pad->SetNet() calls to synchronize net codes. On creation of NETINFO_LIST, the first NETINFO_ITEM is added (the unconnected items net). Removed COMPONENT_NET::m_netNumber, as it was not used anywhere. Added an assert to D_PAD::GetNetname(), checking if net code and net name is consistent for unconnected pads. Added an assert for NETINFO_LIST::AppendNet() to assure that appended nets are unique. It seems that at this point: - Updating net lists works fine. The only difference between the file ouput is that after changes it contains empty nets as well. - Nets are not saved in the lexical order. Still, net names and net codes are properly assigned to all items in the .kicad_pcb file. It is going to be addressed in the next commit. I believe it should not create any problems, as pads are sorted by their net names anyway (NETINFO_LIST::buildPadsFullList()) Performed tests: - Created a blank PCB, saved as pic_programmer.kicad_pcb (from demos folder). Updated net lists. .kicad_pcb file (comparing to the results from master branch) differ with net order (as mentioned before), net codes and timestamps. - Removed some of components from the above .kicad_pcb file and updated net lists. Modules reappeared. .kicad_pcb file differs in the same way as described above. - Trying to change a pad net name (via properties dialog) results in assert being fired. It is done on purpose (as there is a call to GetNetname() and net name and net code do not match). This will not happen after the next commit. - Prepared a simple project (starting with schematics). Imported net list, changed schematic, reimported net list - changes are applied. - Eagle & KiCad legacy boards seem to load without any problem.
2014-01-10 17:04:07 +00:00
return m_NetInfo.GetNetItem( aNetname );
2008-01-06 20:58:27 +00:00
}
2020-11-13 15:15:52 +00:00
FOOTPRINT* BOARD::FindFootprintByReference( const wxString& aReference ) const
2008-02-07 17:10:12 +00:00
{
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : m_footprints )
{
2020-10-14 23:37:26 +00:00
if( aReference == footprint->GetReference() )
return footprint;
}
2008-02-12 01:02:53 +00:00
return nullptr;
2008-02-07 17:10:12 +00:00
}
2008-01-06 20:58:27 +00:00
2020-11-13 15:15:52 +00:00
FOOTPRINT* BOARD::FindFootprintByPath( const KIID_PATH& aPath ) const
{
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : m_footprints )
{
2020-10-14 23:37:26 +00:00
if( footprint->GetPath() == aPath )
return footprint;
}
2020-02-20 12:11:04 +00:00
return nullptr;
}
std::vector<wxString> BOARD::GetNetClassAssignmentCandidates() const
{
std::vector<wxString> names;
for( const NETINFO_ITEM* net : m_NetInfo )
{
if( !net->GetNetname().IsEmpty() )
names.emplace_back( net->GetNetname() );
}
return names;
}
void BOARD::SynchronizeProperties()
{
if( m_project )
SetProperties( m_project->GetTextVars() );
}
void BOARD::SynchronizeNetsAndNetClasses()
{
if( !m_project )
return;
NET_SETTINGS* netSettings = m_project->GetProjectFile().m_NetSettings.get();
NETCLASSES& netClasses = netSettings->m_NetClasses;
NETCLASSPTR defaultNetClass = netClasses.GetDefault();
for( NETINFO_ITEM* net : m_NetInfo )
{
const wxString& netname = net->GetNetname();
const wxString& netclassName = netSettings->GetNetclassName( netname );
2020-12-08 13:02:08 +00:00
net->SetNetClass( netClasses.Find( netclassName ) );
}
BOARD_DESIGN_SETTINGS& bds = GetDesignSettings();
// Set initial values for custom track width & via size to match the default
// netclass settings
bds.UseCustomTrackViaSize( false );
bds.SetCustomTrackWidth( defaultNetClass->GetTrackWidth() );
bds.SetCustomViaSize( defaultNetClass->GetViaDiameter() );
bds.SetCustomViaDrill( defaultNetClass->GetViaDrill() );
bds.SetCustomDiffPairWidth( defaultNetClass->GetDiffPairWidth() );
bds.SetCustomDiffPairGap( defaultNetClass->GetDiffPairGap() );
bds.SetCustomDiffPairViaGap( defaultNetClass->GetDiffPairViaGap() );
InvokeListeners( &BOARD_LISTENER::OnBoardNetSettingsChanged, *this );
}
int BOARD::SetAreasNetCodesFromNetNames()
{
int error_count = 0;
for( ZONE* zone : Zones() )
{
if( !zone->IsOnCopperLayer() )
{
zone->SetNetCode( NETINFO_LIST::UNCONNECTED );
continue;
}
if( zone->GetNetCode() != 0 ) // i.e. if this zone is connected to a net
{
const NETINFO_ITEM* net = zone->GetNet();
if( net )
{
2020-12-08 13:02:08 +00:00
zone->SetNetCode( net->GetNetCode() );
}
else
{
error_count++;
// keep Net Name and set m_NetCode to -1 : error flag.
zone->SetNetCode( -1 );
}
}
}
return error_count;
}
2007-10-30 21:30:58 +00:00
PAD* BOARD::GetPad( const VECTOR2I& aPosition, LSET aLayerSet ) const
{
if( !aLayerSet.any() )
aLayerSet = LSET::AllCuMask();
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : m_footprints )
{
PAD* pad = nullptr;
2020-10-14 23:37:26 +00:00
if( footprint->HitTest( aPosition ) )
pad = footprint->GetPad( aPosition, aLayerSet );
if( pad )
return pad;
}
return nullptr;
}
2021-06-11 21:07:02 +00:00
PAD* BOARD::GetPad( const PCB_TRACK* aTrace, ENDPOINT_T aEndPoint ) const
{
const VECTOR2I& aPosition = aTrace->GetEndPoint( aEndPoint );
LSET lset( aTrace->GetLayer() );
return GetPad( aPosition, lset );
}
2017-09-18 09:25:32 +00:00
PAD* BOARD::GetPadFast( const VECTOR2I& aPosition, LSET aLayerSet ) const
{
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : Footprints() )
{
2020-11-12 22:30:02 +00:00
for( PAD* pad : footprint->Pads() )
{
2012-02-19 04:02:19 +00:00
if( pad->GetPosition() != aPosition )
continue;
// Pad found, it must be on the correct layer
if( ( pad->GetLayerSet() & aLayerSet ).any() )
return pad;
}
}
return nullptr;
}
PAD* BOARD::GetPad( std::vector<PAD*>& aPadList, const VECTOR2I& aPosition, LSET aLayerSet ) const
{
// Search aPadList for aPosition
// aPadList is sorted by X then Y values, and a fast binary search is used
int idxmax = aPadList.size() - 1;
int delta = aPadList.size();
int idx = 0; // Starting index is the beginning of list
while( delta )
{
// Calculate half size of remaining interval to test.
// Ensure the computed value is not truncated (too small)
if( (delta & 1) && ( delta > 1 ) )
delta++;
delta /= 2;
2020-11-12 22:30:02 +00:00
PAD* pad = aPadList[idx];
2012-02-19 04:02:19 +00:00
if( pad->GetPosition() == aPosition ) // candidate found
{
// The pad must match the layer mask:
if( ( aLayerSet & pad->GetLayerSet() ).any() )
return pad;
// More than one pad can be at aPosition
// search for a pad at aPosition that matched this mask
// search next
for( int ii = idx+1; ii <= idxmax; ii++ )
{
pad = aPadList[ii];
2012-02-19 04:02:19 +00:00
if( pad->GetPosition() != aPosition )
break;
if( ( aLayerSet & pad->GetLayerSet() ).any() )
return pad;
}
// search previous
for( int ii = idx - 1 ;ii >=0; ii-- )
{
pad = aPadList[ii];
2012-02-19 04:02:19 +00:00
if( pad->GetPosition() != aPosition )
break;
if( ( aLayerSet & pad->GetLayerSet() ).any() )
return pad;
}
// Not found:
return nullptr;
}
if( pad->GetPosition().x == aPosition.x ) // Must search considering Y coordinate
{
if( pad->GetPosition().y < aPosition.y ) // Must search after this item
{
idx += delta;
if( idx > idxmax )
idx = idxmax;
}
else // Must search before this item
{
idx -= delta;
if( idx < 0 )
idx = 0;
}
}
2012-02-19 04:02:19 +00:00
else if( pad->GetPosition().x < aPosition.x ) // Must search after this item
{
idx += delta;
if( idx > idxmax )
idx = idxmax;
}
else // Must search before this item
{
idx -= delta;
if( idx < 0 )
idx = 0;
}
}
return nullptr;
}
/**
* Used by #GetSortedPadListByXCoord to sort a pad list by X coordinate value.
*
* This function is used to build ordered pads lists
*/
2021-01-19 23:50:18 +00:00
bool sortPadsByXthenYCoord( PAD* const & aLH, PAD* const & aRH )
{
2021-01-19 23:50:18 +00:00
if( aLH->GetPosition().x == aRH->GetPosition().x )
return aLH->GetPosition().y < aRH->GetPosition().y;
return aLH->GetPosition().x < aRH->GetPosition().x;
}
void BOARD::GetSortedPadListByXthenYCoord( std::vector<PAD*>& aVector, int aNetCode ) const
{
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : Footprints() )
{
2020-11-12 22:30:02 +00:00
for( PAD* pad : footprint->Pads( ) )
{
if( aNetCode < 0 || pad->GetNetCode() == aNetCode )
aVector.push_back( pad );
}
}
std::sort( aVector.begin(), aVector.end(), sortPadsByXthenYCoord );
}
2020-11-12 22:30:02 +00:00
void BOARD::PadDelete( PAD* aPad )
{
GetConnectivity()->Remove( aPad );
2020-04-12 19:29:16 +00:00
InvokeListeners( &BOARD_LISTENER::OnBoardItemRemoved, *this, aPad );
aPad->DeleteStructure();
}
2021-06-11 21:07:02 +00:00
std::tuple<int, double, double> BOARD::GetTrackLength( const PCB_TRACK& aTrack ) const
{
2019-05-31 02:30:28 +00:00
int count = 0;
double length = 0.0;
double package_length = 0.0;
constexpr KICAD_T types[] = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T, PCB_PAD_T, EOT };
2019-05-31 02:30:28 +00:00
auto connectivity = GetBoard()->GetConnectivity();
BOARD_STACKUP& stackup = GetDesignSettings().GetStackupDescriptor();
bool useHeight = GetDesignSettings().m_UseHeightForLengthCalcs;
2020-10-14 23:37:26 +00:00
for( BOARD_CONNECTED_ITEM* item : connectivity->GetConnectedItems(
2019-05-31 02:30:28 +00:00
static_cast<const BOARD_CONNECTED_ITEM*>( &aTrack ), types ) )
{
2019-05-31 02:30:28 +00:00
count++;
2021-06-11 21:07:02 +00:00
if( PCB_TRACK* track = dynamic_cast<PCB_TRACK*>( item ) )
{
if( track->Type() == PCB_VIA_T && useHeight )
{
2021-06-11 21:07:02 +00:00
PCB_VIA* via = static_cast<PCB_VIA*>( track );
length += stackup.GetLayerDistance( via->TopLayer(), via->BottomLayer() );
continue;
}
else if( track->Type() == PCB_ARC_T )
{
// Note: we don't apply the clip-to-pad optimization if an arc ends in a pad
// Room for future improvement.
length += track->GetLength();
continue;
}
bool inPad = false;
SEG trackSeg( track->GetStart(), track->GetEnd() );
double segLen = trackSeg.Length();
double segInPadLen = 0;
2019-05-31 02:30:28 +00:00
for( auto pad_it : connectivity->GetConnectedPads( item ) )
{
2020-11-12 22:30:02 +00:00
PAD* pad = static_cast<PAD*>( pad_it );
bool hitStart = pad->HitTest( track->GetStart(), track->GetWidth() / 2 );
bool hitEnd = pad->HitTest( track->GetEnd(), track->GetWidth() / 2 );
if( hitStart && hitEnd )
2019-05-31 02:30:28 +00:00
{
inPad = true;
break;
}
else if( hitStart || hitEnd )
{
VECTOR2I loc;
// We may not collide even if we passed the bounding-box hit test
if( pad->GetEffectivePolygon()->Collide( trackSeg, 0, nullptr, &loc ) )
{
// Part 1: length of the seg to the intersection with the pad poly
if( hitStart )
trackSeg.A = loc;
else
trackSeg.B = loc;
segLen = trackSeg.Length();
// Part 2: length from the intersection to the pad anchor
segInPadLen += ( loc - pad->GetPosition() ).EuclideanNorm();
}
}
}
2019-05-31 02:30:28 +00:00
if( !inPad )
length += segLen + segInPadLen;
}
2020-11-12 22:30:02 +00:00
else if( PAD* pad = dyn_cast<PAD*>( item ) )
2020-10-14 23:37:26 +00:00
{
2019-05-31 02:30:28 +00:00
package_length += pad->GetPadToDieLength();
2020-10-14 23:37:26 +00:00
}
}
2019-05-31 02:30:28 +00:00
return std::make_tuple( count, length, package_length );
}
2022-01-01 18:57:44 +00:00
FOOTPRINT* BOARD::GetFootprint( const VECTOR2I& aPosition, PCB_LAYER_ID aActiveLayer,
bool aVisibleOnly, bool aIgnoreLocked ) const
{
FOOTPRINT* footprint = nullptr;
FOOTPRINT* alt_footprint = nullptr;
2020-11-13 15:15:52 +00:00
int min_dim = 0x7FFFFFFF;
int alt_min_dim = 0x7FFFFFFF;
bool current_layer_back = IsBackLayer( aActiveLayer );
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* candidate : m_footprints )
{
2020-10-14 23:37:26 +00:00
// is the ref point within the footprint's bounds?
if( !candidate->HitTest( aPosition ) )
continue;
2020-10-14 23:37:26 +00:00
// if caller wants to ignore locked footprints, and this one is locked, skip it.
if( aIgnoreLocked && candidate->IsLocked() )
continue;
2020-10-14 23:37:26 +00:00
PCB_LAYER_ID layer = candidate->GetLayer();
2020-10-14 23:37:26 +00:00
// Filter non visible footprints if requested
2020-11-13 11:17:15 +00:00
if( !aVisibleOnly || IsFootprintLayerVisible( layer ) )
{
EDA_RECT bb = candidate->GetBoundingBox( false, false );
int offx = bb.GetX() + bb.GetWidth() / 2;
int offy = bb.GetY() + bb.GetHeight() / 2;
// off x & offy point to the middle of the box.
int dist = ( aPosition.x - offx ) * ( aPosition.x - offx ) +
( aPosition.y - offy ) * ( aPosition.y - offy );
if( current_layer_back == IsBackLayer( layer ) )
{
if( dist <= min_dim )
{
// better footprint shown on the active side
footprint = candidate;
min_dim = dist;
}
}
2020-11-13 11:17:15 +00:00
else if( aVisibleOnly && IsFootprintLayerVisible( layer ) )
{
if( dist <= alt_min_dim )
{
// better footprint shown on the other side
alt_footprint = candidate;
alt_min_dim = dist;
}
}
}
}
2020-10-14 23:37:26 +00:00
if( footprint )
return footprint;
2020-10-14 23:37:26 +00:00
if( alt_footprint)
return alt_footprint;
return nullptr;
}
2019-12-20 14:11:39 +00:00
std::list<ZONE*> BOARD::GetZoneList( bool aIncludeZonesInFootprints ) const
{
std::list<ZONE*> zones;
for( ZONE* zone : Zones() )
zones.push_back( zone );
if( aIncludeZonesInFootprints )
{
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : m_footprints )
{
for( FP_ZONE* zone : footprint->Zones() )
zones.push_back( zone );
}
}
return zones;
}
ZONE* BOARD::AddArea( PICKED_ITEMS_LIST* aNewZonesList, int aNetcode, PCB_LAYER_ID aLayer,
2022-01-01 18:57:44 +00:00
VECTOR2I aStartPointPosition, ZONE_BORDER_DISPLAY_STYLE aHatch )
{
ZONE* new_area = new ZONE( this );
new_area->SetNetCode( aNetcode );
new_area->SetLayer( aLayer );
m_zones.push_back( new_area );
new_area->SetHatchStyle( (ZONE_BORDER_DISPLAY_STYLE) aHatch );
// Add the first corner to the new zone
new_area->AppendCorner( aStartPointPosition, -1 );
if( aNewZonesList )
{
2020-08-26 18:04:32 +00:00
ITEM_PICKER picker( nullptr, new_area, UNDO_REDO::NEWITEM );
aNewZonesList->PushItem( picker );
}
return new_area;
}
bool BOARD::GetBoardPolygonOutlines( SHAPE_POLY_SET& aOutlines,
OUTLINE_ERROR_HANDLER* aErrorHandler )
{
int chainingEpsilon = Millimeter2iu( 0.02 ); // max dist from one endPt to next startPt
bool success = BuildBoardPolygonOutlines( this, aOutlines, GetDesignSettings().m_MaxError,
chainingEpsilon, aErrorHandler );
// Make polygon strictly simple to avoid issues (especially in 3D viewer)
aOutlines.Simplify( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
return success;
}
2017-03-22 13:43:10 +00:00
2020-11-12 22:30:02 +00:00
const std::vector<PAD*> BOARD::GetPads() const
{
2020-11-12 22:30:02 +00:00
std::vector<PAD*> allPads;
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : Footprints() )
{
2020-11-12 22:30:02 +00:00
for( PAD* pad : footprint->Pads() )
allPads.push_back( pad );
}
return allPads;
}
2017-06-30 11:40:20 +00:00
const std::vector<BOARD_CONNECTED_ITEM*> BOARD::AllConnectedItems()
{
std::vector<BOARD_CONNECTED_ITEM*> items;
2021-06-11 21:07:02 +00:00
for( PCB_TRACK* track : Tracks() )
items.push_back( track );
2020-11-13 15:15:52 +00:00
for( FOOTPRINT* footprint : Footprints() )
{
2020-11-12 22:30:02 +00:00
for( PAD* pad : footprint->Pads() )
items.push_back( pad );
}
for( ZONE* zone : Zones() )
items.push_back( zone );
return items;
}
void BOARD::ClearAllNetCodes()
{
for( BOARD_CONNECTED_ITEM* item : AllConnectedItems() )
item->SetNetCode( 0 );
}
void BOARD::MapNets( const BOARD* aDestBoard )
{
for( BOARD_CONNECTED_ITEM* item : AllConnectedItems() )
{
NETINFO_ITEM* netInfo = aDestBoard->FindNet( item->GetNetname() );
if( netInfo )
item->SetNet( netInfo );
else
item->SetNetCode( 0 );
}
}
void BOARD::SanitizeNetcodes()
{
for ( BOARD_CONNECTED_ITEM* item : AllConnectedItems() )
{
if( FindNet( item->GetNetCode() ) == nullptr )
item->SetNetCode( NETINFO_LIST::ORPHANED );
}
}
2020-04-12 19:29:16 +00:00
2020-04-21 06:31:44 +00:00
2020-04-12 19:29:16 +00:00
void BOARD::AddListener( BOARD_LISTENER* aListener )
{
2020-09-26 13:42:40 +00:00
if( !alg::contains( m_listeners, aListener ) )
2020-04-12 19:29:16 +00:00
m_listeners.push_back( aListener );
}
2020-04-21 06:31:44 +00:00
2020-04-12 19:29:16 +00:00
void BOARD::RemoveListener( BOARD_LISTENER* aListener )
{
auto i = std::find( m_listeners.begin(), m_listeners.end(), aListener );
if( i != m_listeners.end() )
{
std::iter_swap( i, m_listeners.end() - 1 );
m_listeners.pop_back();
}
}
2020-04-21 06:31:44 +00:00
2020-04-12 19:29:16 +00:00
void BOARD::OnItemChanged( BOARD_ITEM* aItem )
{
InvokeListeners( &BOARD_LISTENER::OnBoardItemChanged, *this, aItem );
}
void BOARD::OnItemsChanged( std::vector<BOARD_ITEM*>& aItems )
{
InvokeListeners( &BOARD_LISTENER::OnBoardItemsChanged, *this, aItems );
}
2020-04-12 19:29:16 +00:00
void BOARD::ResetNetHighLight()
{
m_highLight.Clear();
m_highLightPrevious.Clear();
InvokeListeners( &BOARD_LISTENER::OnBoardHighlightNetChanged, *this );
}
void BOARD::SetHighLightNet( int aNetCode, bool aMulti )
2020-04-12 19:29:16 +00:00
{
if( !m_highLight.m_netCodes.count( aNetCode ) )
2020-04-12 19:29:16 +00:00
{
if( !aMulti )
m_highLight.m_netCodes.clear();
m_highLight.m_netCodes.insert( aNetCode );
2020-04-12 19:29:16 +00:00
InvokeListeners( &BOARD_LISTENER::OnBoardHighlightNetChanged, *this );
}
}
void BOARD::HighLightON( bool aValue )
{
if( m_highLight.m_highLightOn != aValue )
{
m_highLight.m_highLightOn = aValue;
InvokeListeners( &BOARD_LISTENER::OnBoardHighlightNetChanged, *this );
}
}
wxString BOARD::GroupsSanityCheck( bool repair )
{
if( repair )
{
while( GroupsSanityCheckInternal( repair ) != wxEmptyString )
{};
return wxEmptyString;
}
return GroupsSanityCheckInternal( repair );
}
wxString BOARD::GroupsSanityCheckInternal( bool repair )
{
// Cycle detection
//
// Each group has at most one parent group.
// So we start at group 0 and traverse the parent chain, marking groups seen along the way.
// If we ever see a group that we've already marked, that's a cycle.
// If we reach the end of the chain, we know all groups in that chain are not part of any cycle.
//
// Algorithm below is linear in the # of groups because each group is visited only once.
// There may be extra time taken due to the container access calls and iterators.
//
// Groups we know are cycle free
std::unordered_set<PCB_GROUP*> knownCycleFreeGroups;
// Groups in the current chain we're exploring.
std::unordered_set<PCB_GROUP*> currentChainGroups;
// Groups we haven't checked yet.
std::unordered_set<PCB_GROUP*> toCheckGroups;
// Initialize set of groups to check that could participate in a cycle.
for( PCB_GROUP* group : Groups() )
toCheckGroups.insert( group);
while( !toCheckGroups.empty() )
{
currentChainGroups.clear();
PCB_GROUP* group = *toCheckGroups.begin();
while( true )
{
if( currentChainGroups.find( group ) != currentChainGroups.end() )
{
if( repair )
Remove( group );
return "Cycle detected in group membership";
}
else if( knownCycleFreeGroups.find( group ) != knownCycleFreeGroups.end() )
{
// Parent is a group we know does not lead to a cycle
break;
}
currentChainGroups.insert( group );
// We haven't visited currIdx yet, so it must be in toCheckGroups
toCheckGroups.erase( group );
group = group->GetParentGroup();
if( !group )
{
// end of chain and no cycles found in this chain
break;
}
}
// No cycles found in chain, so add it to set of groups we know don't participate
// in a cycle.
knownCycleFreeGroups.insert( currentChainGroups.begin(), currentChainGroups.end() );
}
// Success
return "";
}
BOARD::GroupLegalOpsField BOARD::GroupLegalOps( const PCB_SELECTION& selection ) const
{
bool hasGroup = false;
bool hasMember = false;
for( EDA_ITEM* item : selection )
{
if( item->Type() == PCB_GROUP_T )
hasGroup = true;
if( static_cast<BOARD_ITEM*>( item )->GetParentGroup() )
hasMember = true;
}
GroupLegalOpsField legalOps;
legalOps.create = true;
legalOps.removeItems = hasMember;
legalOps.ungroup = hasGroup;
legalOps.enter = hasGroup && selection.Size() == 1;
return legalOps;
}
bool BOARD::cmp_items::operator() ( const BOARD_ITEM* a, const BOARD_ITEM* b ) const
{
if( a->Type() != b->Type() )
return a->Type() < b->Type();
if( a->GetLayer() != b->GetLayer() )
return a->GetLayer() < b->GetLayer();
if( a->GetPosition().x != b->GetPosition().x )
return a->GetPosition().x < b->GetPosition().x;
if( a->GetPosition().y != b->GetPosition().y )
return a->GetPosition().y < b->GetPosition().y;
if( a->m_Uuid != b->m_Uuid ) // shopuld be always the case foer valid boards
return a->m_Uuid < b->m_Uuid;
return a < b;
}
bool BOARD::cmp_drawings::operator()( const BOARD_ITEM* aFirst,
const BOARD_ITEM* aSecond ) const
{
if( aFirst->Type() != aSecond->Type() )
return aFirst->Type() < aSecond->Type();
if( aFirst->GetLayer() != aSecond->GetLayer() )
return aFirst->GetLayer() < aSecond->GetLayer();
if( aFirst->Type() == PCB_SHAPE_T )
{
const PCB_SHAPE* shape = static_cast<const PCB_SHAPE*>( aFirst );
const PCB_SHAPE* other = static_cast<const PCB_SHAPE*>( aSecond );
return shape->Compare( other );
}
else if( aFirst->Type() == PCB_TEXT_T )
{
const PCB_TEXT* text = static_cast<const PCB_TEXT*>( aFirst );
const PCB_TEXT* other = static_cast<const PCB_TEXT*>( aSecond );
return text->Compare( other );
}
2022-01-30 10:52:52 +00:00
else if( aFirst->Type() == PCB_TEXTBOX_T )
{
const PCB_TEXTBOX* textbox = static_cast<const PCB_TEXTBOX*>( aFirst );
const PCB_TEXTBOX* other = static_cast<const PCB_TEXTBOX*>( aSecond );
return textbox->PCB_SHAPE::Compare( other ) && textbox->EDA_TEXT::Compare( other );
}
return aFirst->m_Uuid < aSecond->m_Uuid;
}
void BOARD::ConvertBrdLayerToPolygonalContours( PCB_LAYER_ID aLayer,
SHAPE_POLY_SET& aOutlines ) const
{
int maxError = GetDesignSettings().m_MaxError;
// convert tracks and vias:
for( const PCB_TRACK* track : m_tracks )
{
if( !track->IsOnLayer( aLayer ) )
continue;
track->TransformShapeWithClearanceToPolygon( aOutlines, aLayer, 0, maxError,
ERROR_INSIDE );
}
// convert pads and other copper items in footprints
for( const FOOTPRINT* footprint : m_footprints )
{
footprint->TransformPadsWithClearanceToPolygon( aOutlines, aLayer, 0, maxError,
ERROR_INSIDE );
// Micro-wave footprints may have items on copper layers
footprint->TransformFPShapesWithClearanceToPolygon( aOutlines, aLayer, 0, maxError,
ERROR_INSIDE,
true, /* include text */
true /* include shapes */ );
for( const ZONE* zone : footprint->Zones() )
{
if( zone->GetLayerSet().test( aLayer ) )
zone->TransformSolidAreasShapesToPolygon( aLayer, aOutlines );
}
}
// convert copper zones
for( const ZONE* zone : Zones() )
{
if( zone->GetLayerSet().test( aLayer ) )
zone->TransformSolidAreasShapesToPolygon( aLayer, aOutlines );
}
// convert graphic items on copper layers (texts)
for( const BOARD_ITEM* item : m_drawings )
{
if( !item->IsOnLayer( aLayer ) )
continue;
switch( item->Type() )
{
case PCB_SHAPE_T:
{
const PCB_SHAPE* shape = static_cast<const PCB_SHAPE*>( item );
shape->TransformShapeWithClearanceToPolygon( aOutlines, aLayer, 0, maxError,
ERROR_INSIDE );
break;
}
case PCB_TEXT_T:
{
const PCB_TEXT* text = static_cast<const PCB_TEXT*>( item );
text->TransformTextShapeWithClearanceToPolygon( aOutlines, aLayer, 0, maxError,
ERROR_INSIDE );
break;
}
2022-01-30 10:52:52 +00:00
case PCB_TEXTBOX_T:
{
const PCB_TEXTBOX* textbox = static_cast<const PCB_TEXTBOX*>( item );
textbox->TransformTextShapeWithClearanceToPolygon( aOutlines, aLayer, 0, maxError,
ERROR_INSIDE );
break;
}
default:
break;
}
}
}