2011-10-17 20:01:27 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2017-07-01 13:16:51 +00:00
|
|
|
* Copyright (C) 2017 Jean-Pierre Charras, jp.charras at wanadoo.fr
|
2012-06-08 09:56:42 +00:00
|
|
|
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
|
2020-08-05 20:15:27 +00:00
|
|
|
* Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
|
2011-10-17 20:01:27 +00:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2019-05-14 12:39:34 +00:00
|
|
|
#include <bitmaps.h>
|
|
|
|
#include <fctsys.h>
|
|
|
|
#include <geometry/geometry_utils.h>
|
2020-08-26 22:04:16 +00:00
|
|
|
#include <geometry/shape_null.h>
|
|
|
|
|
2019-05-14 12:39:34 +00:00
|
|
|
#include <pcb_base_frame.h>
|
|
|
|
#include <pcb_screen.h>
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <class_board.h>
|
|
|
|
#include <class_zone.h>
|
2020-06-24 02:19:08 +00:00
|
|
|
#include <pcb_edit_frame.h> // current layer for msgpanel
|
2012-07-30 07:40:25 +00:00
|
|
|
#include <math_for_graphics.h>
|
2020-01-13 01:44:19 +00:00
|
|
|
#include <settings/color_settings.h>
|
|
|
|
#include <settings/settings_manager.h>
|
2009-08-01 19:26:05 +00:00
|
|
|
|
2007-12-09 12:59:06 +00:00
|
|
|
|
2019-10-26 15:49:29 +00:00
|
|
|
ZONE_CONTAINER::ZONE_CONTAINER( BOARD_ITEM_CONTAINER* aParent, bool aInModule )
|
2020-02-05 09:43:52 +00:00
|
|
|
: BOARD_CONNECTED_ITEM( aParent, aInModule ? PCB_MODULE_ZONE_AREA_T : PCB_ZONE_AREA_T ),
|
|
|
|
m_area( 0.0 )
|
2007-12-09 12:59:06 +00:00
|
|
|
{
|
2017-03-07 12:06:00 +00:00
|
|
|
m_CornerSelection = nullptr; // no corner is selected
|
2011-01-20 18:40:33 +00:00
|
|
|
m_IsFilled = false; // fill status : true when the zone is filled
|
2019-12-20 14:11:39 +00:00
|
|
|
m_FillMode = ZONE_FILL_MODE::POLYGONS;
|
2020-08-07 14:04:34 +00:00
|
|
|
m_borderStyle = ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE;
|
|
|
|
m_borderHatchPitch = GetDefaultHatchPitch();
|
2018-03-19 09:02:05 +00:00
|
|
|
m_hv45 = false;
|
2020-08-07 14:04:34 +00:00
|
|
|
m_hatchThickness = 0;
|
|
|
|
m_hatchGap = 0;
|
|
|
|
m_hatchOrientation = 0.0;
|
|
|
|
m_hatchSmoothingLevel = 0; // Grid pattern smoothing type. 0 = no smoothing
|
|
|
|
m_hatchSmoothingValue = 0.1; // Grid pattern chamfer value relative to the gap value
|
|
|
|
// used only if m_hatchSmoothingLevel > 0
|
|
|
|
m_hatchHoleMinArea = 0.3; // Min size before holes are dropped (ratio of hole size)
|
|
|
|
m_hatchBorderAlgorithm = 1; // 0 = use zone min thickness; 1 = use hatch width
|
2012-01-29 19:29:19 +00:00
|
|
|
m_priority = 0;
|
2012-07-13 18:55:29 +00:00
|
|
|
m_cornerSmoothingType = ZONE_SETTINGS::SMOOTHING_NONE;
|
2019-10-29 10:09:54 +00:00
|
|
|
SetIsKeepout( aInModule ? true : false ); // Zones living in modules have the keepout option.
|
2012-07-14 16:27:25 +00:00
|
|
|
SetDoNotAllowCopperPour( false ); // has meaning only if m_isKeepout == true
|
|
|
|
SetDoNotAllowVias( true ); // has meaning only if m_isKeepout == true
|
|
|
|
SetDoNotAllowTracks( true ); // has meaning only if m_isKeepout == true
|
2020-05-07 00:30:46 +00:00
|
|
|
SetDoNotAllowPads( true ); // has meaning only if m_isKeepout == true
|
|
|
|
SetDoNotAllowFootprints( false ); // has meaning only if m_isKeepout == true
|
2012-07-13 18:55:29 +00:00
|
|
|
m_cornerRadius = 0;
|
2013-03-26 09:58:40 +00:00
|
|
|
SetLocalFlags( 0 ); // flags tempoarry used in zone calculations
|
2017-03-07 12:06:00 +00:00
|
|
|
m_Poly = new SHAPE_POLY_SET(); // Outlines
|
2019-06-04 07:23:12 +00:00
|
|
|
m_FilledPolysUseThickness = true; // set the "old" way to build filled polygon areas (before 6.0.x)
|
2020-06-26 02:19:51 +00:00
|
|
|
m_islandRemovalMode = ISLAND_REMOVAL_MODE::ALWAYS;
|
2019-10-28 09:15:03 +00:00
|
|
|
aParent->GetZoneSettings().ExportSetting( *this );
|
2019-03-14 13:35:55 +00:00
|
|
|
|
|
|
|
m_needRefill = false; // True only after some edition.
|
2007-12-09 12:59:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-10-28 09:15:03 +00:00
|
|
|
ZONE_CONTAINER::ZONE_CONTAINER( const ZONE_CONTAINER& aZone )
|
2020-09-06 15:33:03 +00:00
|
|
|
: BOARD_CONNECTED_ITEM( aZone ),
|
2020-07-20 10:26:48 +00:00
|
|
|
m_Poly( nullptr ),
|
|
|
|
m_CornerSelection( nullptr )
|
2012-01-14 19:50:32 +00:00
|
|
|
{
|
2020-07-27 17:56:15 +00:00
|
|
|
InitDataFromSrcInCopyCtor( aZone );
|
2012-01-14 19:50:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-05-31 08:27:52 +00:00
|
|
|
ZONE_CONTAINER& ZONE_CONTAINER::operator=( const ZONE_CONTAINER& aOther )
|
|
|
|
{
|
|
|
|
BOARD_CONNECTED_ITEM::operator=( aOther );
|
|
|
|
|
2020-07-27 17:56:15 +00:00
|
|
|
InitDataFromSrcInCopyCtor( aOther );
|
2019-09-05 14:36:23 +00:00
|
|
|
|
2016-05-31 08:27:52 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-01-04 12:27:16 +00:00
|
|
|
ZONE_CONTAINER::~ZONE_CONTAINER()
|
2007-12-09 12:59:06 +00:00
|
|
|
{
|
2008-01-31 20:53:44 +00:00
|
|
|
delete m_Poly;
|
2017-03-07 12:06:00 +00:00
|
|
|
delete m_CornerSelection;
|
2007-12-09 12:59:06 +00:00
|
|
|
}
|
|
|
|
|
2011-10-17 20:01:27 +00:00
|
|
|
|
2020-07-27 17:56:15 +00:00
|
|
|
void ZONE_CONTAINER::InitDataFromSrcInCopyCtor( const ZONE_CONTAINER& aZone )
|
2019-10-26 15:49:29 +00:00
|
|
|
{
|
2019-10-29 10:09:54 +00:00
|
|
|
// members are expected non initialize in this.
|
2020-07-27 17:56:15 +00:00
|
|
|
// InitDataFromSrcInCopyCtor() is expected to be called
|
2019-10-29 10:09:54 +00:00
|
|
|
// only from a copy constructor.
|
2020-03-15 08:39:42 +00:00
|
|
|
|
|
|
|
// Copy only useful EDA_ITEM flags:
|
2020-08-18 13:26:22 +00:00
|
|
|
m_Flags = aZone.m_Flags;
|
|
|
|
m_forceVisible = aZone.m_forceVisible;
|
2020-03-15 08:39:42 +00:00
|
|
|
|
2020-07-18 22:55:06 +00:00
|
|
|
// Replace the outlines for aZone outlines.
|
|
|
|
delete m_Poly;
|
|
|
|
m_Poly = new SHAPE_POLY_SET( *aZone.m_Poly );
|
2019-10-29 10:09:54 +00:00
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
m_cornerSmoothingType = aZone.m_cornerSmoothingType;
|
|
|
|
m_cornerRadius = aZone.m_cornerRadius;
|
|
|
|
m_zoneName = aZone.m_zoneName;
|
2020-07-18 22:55:06 +00:00
|
|
|
SetLayerSet( aZone.GetLayerSet() );
|
2020-08-18 13:26:22 +00:00
|
|
|
m_priority = aZone.m_priority;
|
|
|
|
m_isKeepout = aZone.m_isKeepout;
|
2020-07-01 02:21:59 +00:00
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
m_doNotAllowCopperPour = aZone.m_doNotAllowCopperPour;
|
|
|
|
m_doNotAllowVias = aZone.m_doNotAllowVias;
|
|
|
|
m_doNotAllowTracks = aZone.m_doNotAllowTracks;
|
|
|
|
m_doNotAllowPads = aZone.m_doNotAllowPads;
|
|
|
|
m_doNotAllowFootprints = aZone.m_doNotAllowFootprints;
|
2019-10-26 15:49:29 +00:00
|
|
|
|
2020-07-18 22:55:06 +00:00
|
|
|
m_PadConnection = aZone.m_PadConnection;
|
|
|
|
m_ZoneClearance = aZone.m_ZoneClearance; // clearance value
|
|
|
|
m_ZoneMinThickness = aZone.m_ZoneMinThickness;
|
2019-10-26 15:49:29 +00:00
|
|
|
m_FilledPolysUseThickness = aZone.m_FilledPolysUseThickness;
|
2020-07-18 22:55:06 +00:00
|
|
|
m_islandRemovalMode = aZone.m_islandRemovalMode;
|
|
|
|
m_minIslandArea = aZone.m_minIslandArea;
|
|
|
|
|
|
|
|
m_IsFilled = aZone.m_IsFilled;
|
|
|
|
m_needRefill = aZone.m_needRefill;
|
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
m_ThermalReliefGap = aZone.m_ThermalReliefGap;
|
2019-10-26 15:49:29 +00:00
|
|
|
m_ThermalReliefCopperBridge = aZone.m_ThermalReliefCopperBridge;
|
2020-07-01 02:21:59 +00:00
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
m_FillMode = aZone.m_FillMode; // solid vs. hatched
|
|
|
|
m_hatchThickness = aZone.m_hatchThickness;
|
|
|
|
m_hatchGap = aZone.m_hatchGap;
|
|
|
|
m_hatchOrientation = aZone.m_hatchOrientation;
|
|
|
|
m_hatchSmoothingLevel = aZone.m_hatchSmoothingLevel;
|
|
|
|
m_hatchSmoothingValue = aZone.m_hatchSmoothingValue;
|
|
|
|
m_hatchBorderAlgorithm = aZone.m_hatchBorderAlgorithm;
|
|
|
|
m_hatchHoleMinArea = aZone.m_hatchHoleMinArea;
|
2020-07-18 22:55:06 +00:00
|
|
|
|
|
|
|
// For corner moving, corner index to drag, or nullptr if no selection
|
2020-07-20 10:26:48 +00:00
|
|
|
delete m_CornerSelection;
|
2020-08-18 13:26:22 +00:00
|
|
|
m_CornerSelection = nullptr;
|
2020-07-18 22:55:06 +00:00
|
|
|
|
2020-07-01 02:21:59 +00:00
|
|
|
for( PCB_LAYER_ID layer : aZone.GetLayerSet().Seq() )
|
|
|
|
{
|
|
|
|
m_FilledPolysList[layer] = aZone.m_FilledPolysList.at( layer );
|
|
|
|
m_RawPolysList[layer] = aZone.m_RawPolysList.at( layer );
|
|
|
|
m_filledPolysHash[layer] = aZone.m_filledPolysHash.at( layer );
|
|
|
|
m_FillSegmList[layer] = aZone.m_FillSegmList.at( layer ); // vector <> copy
|
|
|
|
m_insulatedIslands[layer] = aZone.m_insulatedIslands.at( layer );
|
|
|
|
}
|
2019-10-26 15:49:29 +00:00
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
m_borderStyle = aZone.m_borderStyle;
|
|
|
|
m_borderHatchPitch = aZone.m_borderHatchPitch;
|
|
|
|
m_borderHatchLines = aZone.m_borderHatchLines;
|
2019-10-26 15:49:29 +00:00
|
|
|
|
|
|
|
SetLocalFlags( aZone.GetLocalFlags() );
|
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
m_netinfo = aZone.m_netinfo;
|
2020-03-29 16:42:24 +00:00
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
m_hv45 = aZone.m_hv45;
|
|
|
|
m_area = aZone.m_area;
|
2019-10-26 15:49:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-17 14:39:27 +00:00
|
|
|
EDA_ITEM* ZONE_CONTAINER::Clone() const
|
2012-01-14 19:50:32 +00:00
|
|
|
{
|
|
|
|
return new ZONE_CONTAINER( *this );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-16 16:04:49 +00:00
|
|
|
bool ZONE_CONTAINER::UnFill()
|
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
bool change = false;
|
|
|
|
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, SHAPE_POLY_SET>& pair : m_FilledPolysList )
|
2020-06-24 02:19:08 +00:00
|
|
|
{
|
|
|
|
change |= !pair.second.IsEmpty();
|
|
|
|
pair.second.RemoveAllContours();
|
|
|
|
}
|
|
|
|
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, ZONE_SEGMENT_FILL>& pair : m_FillSegmList )
|
2020-06-24 02:19:08 +00:00
|
|
|
{
|
|
|
|
change |= !pair.second.empty();
|
|
|
|
pair.second.clear();
|
|
|
|
}
|
2011-07-16 16:04:49 +00:00
|
|
|
|
|
|
|
m_IsFilled = false;
|
|
|
|
|
|
|
|
return change;
|
|
|
|
}
|
2007-12-09 12:59:06 +00:00
|
|
|
|
2011-10-17 20:01:27 +00:00
|
|
|
|
2020-02-02 17:52:19 +00:00
|
|
|
wxPoint ZONE_CONTAINER::GetPosition() const
|
2008-10-29 15:26:53 +00:00
|
|
|
{
|
2017-12-18 17:24:25 +00:00
|
|
|
return (wxPoint) GetCornerPosition( 0 );
|
2011-11-29 17:25:30 +00:00
|
|
|
}
|
2011-01-20 18:40:33 +00:00
|
|
|
|
2011-11-24 17:32:51 +00:00
|
|
|
|
2017-10-30 17:21:07 +00:00
|
|
|
PCB_LAYER_ID ZONE_CONTAINER::GetLayer() const
|
|
|
|
{
|
|
|
|
return BOARD_ITEM::GetLayer();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool ZONE_CONTAINER::IsOnCopperLayer() const
|
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
return ( m_layerSet & LSET::AllCuMask() ).count() > 0;
|
2017-10-30 17:21:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool ZONE_CONTAINER::CommonLayerExists( const LSET aLayerSet ) const
|
|
|
|
{
|
|
|
|
LSET common = GetLayerSet() & aLayerSet;
|
|
|
|
|
|
|
|
return common.count() > 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ZONE_CONTAINER::SetLayer( PCB_LAYER_ID aLayer )
|
|
|
|
{
|
|
|
|
SetLayerSet( LSET( aLayer ) );
|
|
|
|
|
|
|
|
m_Layer = aLayer;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ZONE_CONTAINER::SetLayerSet( LSET aLayerSet )
|
|
|
|
{
|
|
|
|
if( GetIsKeepout() )
|
|
|
|
{
|
|
|
|
// Keepouts can only exist on copper layers
|
|
|
|
aLayerSet &= LSET::AllCuMask();
|
|
|
|
}
|
|
|
|
|
2017-09-29 16:49:09 +00:00
|
|
|
if( aLayerSet.count() == 0 )
|
|
|
|
return;
|
|
|
|
|
2019-03-14 13:35:55 +00:00
|
|
|
if( m_layerSet != aLayerSet )
|
2020-06-24 02:19:08 +00:00
|
|
|
{
|
2019-03-14 13:35:55 +00:00
|
|
|
SetNeedRefill( true );
|
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
UnFill();
|
|
|
|
|
2020-07-01 02:21:59 +00:00
|
|
|
m_FillSegmList.clear();
|
|
|
|
m_FilledPolysList.clear();
|
|
|
|
m_RawPolysList.clear();
|
|
|
|
m_filledPolysHash.clear();
|
|
|
|
m_insulatedIslands.clear();
|
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
for( PCB_LAYER_ID layer : aLayerSet.Seq() )
|
|
|
|
{
|
2020-06-26 02:19:51 +00:00
|
|
|
m_FillSegmList[layer] = {};
|
|
|
|
m_FilledPolysList[layer] = {};
|
|
|
|
m_RawPolysList[layer] = {};
|
|
|
|
m_filledPolysHash[layer] = {};
|
|
|
|
m_insulatedIslands[layer] = {};
|
2020-06-24 02:19:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-30 17:21:07 +00:00
|
|
|
m_layerSet = aLayerSet;
|
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
// Set the single layer parameter. For zones that can be on many layers, this parameter
|
|
|
|
// is arbitrary at best, but some code still uses it.
|
2019-10-28 09:15:03 +00:00
|
|
|
// Priority is F_Cu then B_Cu then to the first selected layer
|
2017-10-30 17:21:07 +00:00
|
|
|
m_Layer = aLayerSet.Seq()[0];
|
2019-10-28 09:15:03 +00:00
|
|
|
|
|
|
|
if( m_Layer != F_Cu && aLayerSet[B_Cu] )
|
|
|
|
m_Layer = B_Cu;
|
2017-10-30 17:21:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
LSET ZONE_CONTAINER::GetLayerSet() const
|
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
return m_layerSet;
|
2017-10-30 17:21:07 +00:00
|
|
|
}
|
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
|
2017-10-30 17:21:07 +00:00
|
|
|
void ZONE_CONTAINER::ViewGetLayers( int aLayers[], int& aCount ) const
|
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
LSEQ layers = m_layerSet.Seq();
|
2017-10-30 17:21:07 +00:00
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
for( unsigned int idx = 0; idx < layers.size(); idx++ )
|
2020-07-11 17:42:00 +00:00
|
|
|
aLayers[idx] = LAYER_ZONE_START + layers[idx];
|
2017-10-30 17:21:07 +00:00
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
aCount = layers.size();
|
2017-10-30 17:21:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-07-11 17:42:00 +00:00
|
|
|
unsigned int ZONE_CONTAINER::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
|
|
|
|
{
|
|
|
|
constexpr unsigned int HIDE = std::numeric_limits<unsigned int>::max();
|
|
|
|
|
|
|
|
return aView->IsLayerVisible( LAYER_ZONES ) ? 0 : HIDE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-10-30 17:21:07 +00:00
|
|
|
bool ZONE_CONTAINER::IsOnLayer( PCB_LAYER_ID aLayer ) const
|
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
return m_layerSet.test( aLayer );
|
2017-10-30 17:21:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-24 17:48:14 +00:00
|
|
|
const EDA_RECT ZONE_CONTAINER::GetBoundingBox() const
|
2008-05-02 05:16:35 +00:00
|
|
|
{
|
2020-04-13 14:55:26 +00:00
|
|
|
auto bb = m_Poly->BBox();
|
2008-05-02 05:16:35 +00:00
|
|
|
|
2020-04-13 14:55:26 +00:00
|
|
|
EDA_RECT ret( (wxPoint) bb.GetOrigin(), wxSize( bb.GetWidth(), bb.GetHeight() ) );
|
2008-05-02 05:16:35 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-08 20:44:03 +00:00
|
|
|
int ZONE_CONTAINER::GetThermalReliefGap( D_PAD* aPad ) const
|
|
|
|
{
|
|
|
|
if( aPad == NULL || aPad->GetThermalGap() == 0 )
|
|
|
|
return m_ThermalReliefGap;
|
|
|
|
else
|
|
|
|
return aPad->GetThermalGap();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int ZONE_CONTAINER::GetThermalReliefCopperBridge( D_PAD* aPad ) const
|
|
|
|
{
|
|
|
|
if( aPad == NULL || aPad->GetThermalWidth() == 0 )
|
|
|
|
return m_ThermalReliefCopperBridge;
|
|
|
|
else
|
|
|
|
return aPad->GetThermalWidth();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
int ZONE_CONTAINER::GetKeepouts( PCB_LAYER_ID aLayer, std::map<int, wxString>* aSources ) const
|
2020-05-25 17:46:06 +00:00
|
|
|
{
|
|
|
|
wxString source;
|
|
|
|
int keepouts = 0;
|
|
|
|
|
|
|
|
auto setFlag = [&]( int aFlag )
|
|
|
|
{
|
|
|
|
keepouts |= aFlag;
|
|
|
|
|
|
|
|
if( aSources )
|
|
|
|
(*aSources)[ aFlag ] = source;
|
|
|
|
};
|
|
|
|
|
|
|
|
if( m_isKeepout )
|
|
|
|
{
|
|
|
|
if( aSources )
|
|
|
|
source = _( "zone properties" );
|
|
|
|
|
|
|
|
if( m_doNotAllowTracks )
|
|
|
|
setFlag( DISALLOW_TRACKS );
|
|
|
|
|
|
|
|
if( m_doNotAllowVias )
|
|
|
|
setFlag( DISALLOW_VIAS );
|
|
|
|
|
|
|
|
if( m_doNotAllowPads )
|
|
|
|
setFlag( DISALLOW_PADS );
|
|
|
|
|
|
|
|
if( m_doNotAllowFootprints )
|
|
|
|
setFlag( DISALLOW_FOOTPRINTS );
|
|
|
|
|
|
|
|
if( m_doNotAllowCopperPour )
|
|
|
|
setFlag( DISALLOW_ZONES );
|
|
|
|
}
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
const DRC_CONSTRAINT* constraint = GetConstraint( this, nullptr, DRC_RULE_ID_DISALLOW, aLayer,
|
|
|
|
&source );
|
2020-05-25 17:46:06 +00:00
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( constraint )
|
2020-05-25 17:46:06 +00:00
|
|
|
{
|
|
|
|
if( aSources )
|
2020-08-07 20:18:33 +00:00
|
|
|
source = wxString::Format( _( "'%s' rule" ), source );
|
2020-05-25 17:46:06 +00:00
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_VIAS ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_VIAS );
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_MICRO_VIAS ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_MICRO_VIAS );
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_BB_VIAS ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_BB_VIAS );
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_TRACKS ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_TRACKS );
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_PADS ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_PADS );
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_ZONES ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_ZONES );
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_TEXTS ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_TEXTS );
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_GRAPHICS ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_GRAPHICS );
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_HOLES ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_HOLES );
|
|
|
|
|
2020-08-07 20:18:33 +00:00
|
|
|
if( ( constraint->m_DisallowFlags & DISALLOW_FOOTPRINTS ) > 0 )
|
2020-05-25 17:46:06 +00:00
|
|
|
setFlag( DISALLOW_FOOTPRINTS );
|
|
|
|
}
|
|
|
|
|
|
|
|
return keepouts;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-15 12:49:11 +00:00
|
|
|
void ZONE_CONTAINER::SetCornerRadius( unsigned int aRadius )
|
|
|
|
{
|
2019-03-14 13:35:55 +00:00
|
|
|
if( m_cornerRadius != aRadius )
|
|
|
|
SetNeedRefill( true );
|
|
|
|
|
2015-05-15 12:49:11 +00:00
|
|
|
m_cornerRadius = aRadius;
|
2017-11-02 20:41:29 +00:00
|
|
|
}
|
2015-05-15 12:49:11 +00:00
|
|
|
|
|
|
|
|
2019-05-05 10:33:34 +00:00
|
|
|
bool ZONE_CONTAINER::HitTest( const wxPoint& aPosition, int aAccuracy ) const
|
2007-12-29 19:15:58 +00:00
|
|
|
{
|
2018-11-17 00:34:12 +00:00
|
|
|
// Normally accuracy is zoom-relative, but for the generic HitTest we just use
|
|
|
|
// a fixed (small) value.
|
2019-05-05 10:33:34 +00:00
|
|
|
int accuracy = std::max( aAccuracy, Millimeter2iu( 0.1 ) );
|
2018-11-17 00:34:12 +00:00
|
|
|
|
|
|
|
return HitTestForCorner( aPosition, accuracy * 2 ) || HitTestForEdge( aPosition, accuracy );
|
2007-12-29 19:15:58 +00:00
|
|
|
}
|
|
|
|
|
2017-03-07 12:06:00 +00:00
|
|
|
|
2018-11-17 00:34:12 +00:00
|
|
|
void ZONE_CONTAINER::SetSelectedCorner( const wxPoint& aPosition, int aAccuracy )
|
2014-05-04 17:08:36 +00:00
|
|
|
{
|
2017-03-07 12:06:00 +00:00
|
|
|
SHAPE_POLY_SET::VERTEX_INDEX corner;
|
2014-05-04 17:08:36 +00:00
|
|
|
|
2017-03-07 12:06:00 +00:00
|
|
|
// If there is some corner to be selected, assign it to m_CornerSelection
|
2018-11-17 00:34:12 +00:00
|
|
|
if( HitTestForCorner( aPosition, aAccuracy * 2, corner )
|
|
|
|
|| HitTestForEdge( aPosition, aAccuracy, corner ) )
|
2017-03-07 12:06:00 +00:00
|
|
|
{
|
|
|
|
if( m_CornerSelection == nullptr )
|
|
|
|
m_CornerSelection = new SHAPE_POLY_SET::VERTEX_INDEX;
|
2014-05-04 17:08:36 +00:00
|
|
|
|
2017-03-07 12:06:00 +00:00
|
|
|
*m_CornerSelection = corner;
|
|
|
|
}
|
|
|
|
}
|
2014-05-04 17:08:36 +00:00
|
|
|
|
2018-11-17 00:34:12 +00:00
|
|
|
bool ZONE_CONTAINER::HitTestForCorner( const wxPoint& refPos, int aAccuracy,
|
2017-03-07 12:06:00 +00:00
|
|
|
SHAPE_POLY_SET::VERTEX_INDEX& aCornerHit ) const
|
2007-12-29 19:15:58 +00:00
|
|
|
{
|
2018-11-17 00:34:12 +00:00
|
|
|
return m_Poly->CollideVertex( VECTOR2I( refPos ), aCornerHit, aAccuracy );
|
2007-12-29 19:15:58 +00:00
|
|
|
}
|
|
|
|
|
2008-01-31 20:53:44 +00:00
|
|
|
|
2018-11-17 00:34:12 +00:00
|
|
|
bool ZONE_CONTAINER::HitTestForCorner( const wxPoint& refPos, int aAccuracy ) const
|
2017-03-07 12:06:00 +00:00
|
|
|
{
|
|
|
|
SHAPE_POLY_SET::VERTEX_INDEX dummy;
|
2018-11-17 00:34:12 +00:00
|
|
|
return HitTestForCorner( refPos, aAccuracy, dummy );
|
2017-03-07 12:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-11-17 00:34:12 +00:00
|
|
|
bool ZONE_CONTAINER::HitTestForEdge( const wxPoint& refPos, int aAccuracy,
|
2017-03-07 12:06:00 +00:00
|
|
|
SHAPE_POLY_SET::VERTEX_INDEX& aCornerHit ) const
|
2007-12-29 19:15:58 +00:00
|
|
|
{
|
2018-11-17 00:34:12 +00:00
|
|
|
return m_Poly->CollideEdge( VECTOR2I( refPos ), aCornerHit, aAccuracy );
|
2017-03-07 12:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-11-17 00:34:12 +00:00
|
|
|
bool ZONE_CONTAINER::HitTestForEdge( const wxPoint& refPos, int aAccuracy ) const
|
2017-03-07 12:06:00 +00:00
|
|
|
{
|
|
|
|
SHAPE_POLY_SET::VERTEX_INDEX dummy;
|
2018-11-17 00:34:12 +00:00
|
|
|
return HitTestForEdge( refPos, aAccuracy, dummy );
|
2007-12-29 19:15:58 +00:00
|
|
|
}
|
|
|
|
|
2008-01-31 20:53:44 +00:00
|
|
|
|
2013-09-21 18:09:41 +00:00
|
|
|
bool ZONE_CONTAINER::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
|
2008-01-06 12:43:57 +00:00
|
|
|
{
|
2017-05-01 12:10:24 +00:00
|
|
|
// Calculate bounding box for zone
|
|
|
|
EDA_RECT bbox = GetBoundingBox();
|
2014-11-08 12:25:29 +00:00
|
|
|
bbox.Normalize();
|
2013-09-21 18:09:41 +00:00
|
|
|
|
2017-05-01 12:10:24 +00:00
|
|
|
EDA_RECT arect = aRect;
|
|
|
|
arect.Normalize();
|
|
|
|
arect.Inflate( aAccuracy );
|
|
|
|
|
2013-09-21 18:09:41 +00:00
|
|
|
if( aContained )
|
2017-05-01 12:10:24 +00:00
|
|
|
{
|
|
|
|
return arect.Contains( bbox );
|
|
|
|
}
|
2020-08-18 13:26:22 +00:00
|
|
|
else
|
2013-09-21 18:09:41 +00:00
|
|
|
{
|
2019-07-12 21:02:10 +00:00
|
|
|
// Fast test: if aBox is outside the polygon bounding box, rectangles cannot intersect
|
2017-05-01 12:10:24 +00:00
|
|
|
if( !arect.Intersects( bbox ) )
|
2013-09-21 18:09:41 +00:00
|
|
|
return false;
|
|
|
|
|
2017-03-07 12:06:00 +00:00
|
|
|
int count = m_Poly->TotalVertices();
|
2019-07-12 21:02:10 +00:00
|
|
|
|
|
|
|
for( int ii = 0; ii < count; ii++ )
|
2013-09-21 18:09:41 +00:00
|
|
|
{
|
2019-03-23 18:26:44 +00:00
|
|
|
auto vertex = m_Poly->CVertex( ii );
|
|
|
|
auto vertexNext = m_Poly->CVertex( ( ii + 1 ) % count );
|
2017-05-01 12:10:24 +00:00
|
|
|
|
|
|
|
// Test if the point is within the rect
|
|
|
|
if( arect.Contains( ( wxPoint ) vertex ) )
|
2013-09-21 18:09:41 +00:00
|
|
|
return true;
|
2017-05-01 12:10:24 +00:00
|
|
|
|
|
|
|
// Test if this edge intersects the rect
|
|
|
|
if( arect.Intersects( ( wxPoint ) vertex, ( wxPoint ) vertexNext ) )
|
|
|
|
return true;
|
2013-09-21 18:09:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2008-01-06 12:43:57 +00:00
|
|
|
}
|
2007-12-29 19:15:58 +00:00
|
|
|
|
2011-01-20 18:40:33 +00:00
|
|
|
|
2020-05-29 12:36:45 +00:00
|
|
|
int ZONE_CONTAINER::GetLocalClearance( wxString* aSource ) const
|
2011-08-09 03:41:20 +00:00
|
|
|
{
|
2020-05-15 23:25:33 +00:00
|
|
|
if( m_isKeepout )
|
|
|
|
return 0;
|
|
|
|
|
2020-05-23 21:48:24 +00:00
|
|
|
if( aSource )
|
2020-05-29 12:36:45 +00:00
|
|
|
*aSource = _( "zone" );
|
2020-05-18 16:11:57 +00:00
|
|
|
|
2020-05-29 12:36:45 +00:00
|
|
|
return m_ZoneClearance;
|
2011-08-09 03:41:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-08-05 20:15:27 +00:00
|
|
|
bool ZONE_CONTAINER::HitTestFilledArea( PCB_LAYER_ID aLayer, const wxPoint &aRefPos,
|
|
|
|
int aAccuracy ) const
|
2008-11-27 10:12:46 +00:00
|
|
|
{
|
2020-06-30 00:37:57 +00:00
|
|
|
// Keepouts have no filled area, but it's generally nice to treat their interior as if it were
|
|
|
|
// filled so that people don't have to select keepouts by their outline (which is min-width)
|
|
|
|
if( GetIsKeepout() )
|
2020-08-05 20:15:27 +00:00
|
|
|
return m_Poly->Contains( VECTOR2I( aRefPos.x, aRefPos.y ), -1, aAccuracy );
|
2020-06-30 00:37:57 +00:00
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
if( !m_FilledPolysList.count( aLayer ) )
|
|
|
|
return false;
|
|
|
|
|
2020-08-05 20:15:27 +00:00
|
|
|
return m_FilledPolysList.at( aLayer ).Contains( VECTOR2I( aRefPos.x, aRefPos.y ), -1,
|
2020-08-18 13:26:22 +00:00
|
|
|
aAccuracy );
|
2008-11-27 10:12:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-04-14 16:57:18 +00:00
|
|
|
bool ZONE_CONTAINER::HitTestCutout( const VECTOR2I& aRefPos, int* aOutlineIdx, int* aHoleIdx ) const
|
|
|
|
{
|
|
|
|
// Iterate over each outline polygon in the zone and then iterate over
|
|
|
|
// each hole it has to see if the point is in it.
|
|
|
|
for( int i = 0; i < m_Poly->OutlineCount(); i++ )
|
|
|
|
{
|
|
|
|
for( int j = 0; j < m_Poly->HoleCount( i ); j++ )
|
|
|
|
{
|
|
|
|
if( m_Poly->Hole( i, j ).PointInside( aRefPos ) )
|
|
|
|
{
|
|
|
|
if( aOutlineIdx )
|
|
|
|
*aOutlineIdx = i;
|
|
|
|
|
|
|
|
if( aHoleIdx )
|
|
|
|
*aHoleIdx = j;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-04-24 13:36:10 +00:00
|
|
|
void ZONE_CONTAINER::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
|
2007-12-29 19:15:58 +00:00
|
|
|
{
|
2020-05-21 17:42:42 +00:00
|
|
|
EDA_UNITS units = aFrame->GetUserUnits();
|
|
|
|
wxString msg, msg2;
|
2008-01-31 20:53:44 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
if( GetIsKeepout() )
|
|
|
|
msg = _( "Keepout Area" );
|
|
|
|
else if( IsOnCopperLayer() )
|
|
|
|
msg = _( "Copper Zone" );
|
|
|
|
else
|
|
|
|
msg = _( "Non-copper Zone" );
|
2007-12-29 19:15:58 +00:00
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
// Display Cutout instead of Outline for holes inside a zone (i.e. when num contour !=0).
|
2017-03-07 12:06:00 +00:00
|
|
|
// Check whether the selected corner is in a hole; i.e., in any contour but the first one.
|
|
|
|
if( m_CornerSelection != nullptr && m_CornerSelection->m_contour > 0 )
|
2020-05-21 17:42:42 +00:00
|
|
|
msg << wxT( " " ) << _( "Cutout" );
|
2008-01-05 13:37:51 +00:00
|
|
|
|
2020-05-22 10:31:14 +00:00
|
|
|
aList.emplace_back( _( "Type" ), msg, DARKCYAN );
|
2007-12-29 19:15:58 +00:00
|
|
|
|
2012-11-23 09:10:37 +00:00
|
|
|
if( GetIsKeepout() )
|
|
|
|
{
|
|
|
|
msg.Empty();
|
2013-01-12 17:32:24 +00:00
|
|
|
|
2012-11-23 09:10:37 +00:00
|
|
|
if( GetDoNotAllowVias() )
|
2020-05-07 00:30:46 +00:00
|
|
|
AccumulateDescription( msg, _( "No vias" ) );
|
2013-01-12 17:32:24 +00:00
|
|
|
|
2012-11-23 09:10:37 +00:00
|
|
|
if( GetDoNotAllowTracks() )
|
2020-05-10 14:55:15 +00:00
|
|
|
AccumulateDescription( msg, _( "No tracks" ) );
|
2020-05-07 00:30:46 +00:00
|
|
|
|
|
|
|
if( GetDoNotAllowPads() )
|
2020-05-10 14:55:15 +00:00
|
|
|
AccumulateDescription( msg, _( "No pads" ) );
|
2013-01-12 17:32:24 +00:00
|
|
|
|
2012-11-23 09:10:37 +00:00
|
|
|
if( GetDoNotAllowCopperPour() )
|
2020-05-10 14:55:15 +00:00
|
|
|
AccumulateDescription( msg, _( "No copper zones" ) );
|
2020-05-07 00:30:46 +00:00
|
|
|
|
|
|
|
if( GetDoNotAllowFootprints() )
|
2020-05-10 14:55:15 +00:00
|
|
|
AccumulateDescription( msg, _( "No footprints" ) );
|
2012-11-23 09:10:37 +00:00
|
|
|
|
2019-07-12 21:02:10 +00:00
|
|
|
aList.emplace_back( MSG_PANEL_ITEM( _( "Keepout" ), msg, RED ) );
|
2012-11-23 09:10:37 +00:00
|
|
|
}
|
|
|
|
else if( IsOnCopperLayer() )
|
2008-01-31 20:53:44 +00:00
|
|
|
{
|
2014-02-25 10:40:34 +00:00
|
|
|
if( GetNetCode() >= 0 )
|
2008-09-26 19:51:36 +00:00
|
|
|
{
|
2015-01-22 12:06:34 +00:00
|
|
|
NETINFO_ITEM* net = GetNet();
|
2020-05-21 17:42:42 +00:00
|
|
|
NETCLASS* netclass = nullptr;
|
2008-01-31 20:53:44 +00:00
|
|
|
|
2015-01-22 12:06:34 +00:00
|
|
|
if( net )
|
2020-05-21 17:42:42 +00:00
|
|
|
{
|
|
|
|
if( net->GetNet() )
|
|
|
|
netclass = GetNetClass();
|
|
|
|
else
|
|
|
|
netclass = GetBoard()->GetDesignSettings().GetDefault();
|
|
|
|
|
2018-10-19 11:28:34 +00:00
|
|
|
msg = UnescapeString( net->GetNetname() );
|
2020-05-21 17:42:42 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
msg = wxT( "<no name>" );
|
|
|
|
}
|
2008-01-31 20:53:44 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
aList.emplace_back( _( "Net" ), msg, RED );
|
2013-01-12 17:32:24 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
if( netclass )
|
|
|
|
aList.emplace_back( _( "NetClass" ), netclass->GetName(), DARKMAGENTA );
|
|
|
|
}
|
2012-01-29 19:29:19 +00:00
|
|
|
|
|
|
|
// Display priority level
|
|
|
|
msg.Printf( wxT( "%d" ), GetPriority() );
|
2020-06-24 01:09:15 +00:00
|
|
|
aList.emplace_back( _( "Priority" ), msg, BLUE );
|
2008-09-26 19:51:36 +00:00
|
|
|
}
|
2007-12-29 19:15:58 +00:00
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
wxString layerDesc;
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
for( PCB_LAYER_ID layer : m_layerSet.Seq() )
|
|
|
|
{
|
|
|
|
if( count == 0 )
|
|
|
|
layerDesc = GetBoard()->GetLayerName( layer );
|
|
|
|
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( count > 1 )
|
|
|
|
layerDesc.Printf( _( "%s and %d more" ), layerDesc, count - 1 );
|
|
|
|
|
|
|
|
aList.emplace_back( _( "Layer" ), layerDesc, DARKGREEN );
|
2007-12-29 19:15:58 +00:00
|
|
|
|
2020-06-24 01:09:15 +00:00
|
|
|
if( !m_zoneName.empty() )
|
|
|
|
aList.emplace_back( _( "Name" ), m_zoneName, DARKMAGENTA );
|
|
|
|
|
2018-02-18 09:09:13 +00:00
|
|
|
switch( m_FillMode )
|
|
|
|
{
|
2020-05-21 17:42:42 +00:00
|
|
|
case ZONE_FILL_MODE::POLYGONS: msg = _( "Solid" ); break;
|
|
|
|
case ZONE_FILL_MODE::HATCH_PATTERN: msg = _( "Hatched" ); break;
|
|
|
|
default: msg = _( "Unknown" ); break;
|
2018-02-18 09:09:13 +00:00
|
|
|
}
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
aList.emplace_back( _( "Fill Mode" ), msg, BROWN );
|
2008-10-07 09:32:56 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
msg = MessageTextFromValue( units, m_area, false, EDA_DATA_TYPE::AREA );
|
|
|
|
aList.emplace_back( _( "Filled Area" ), msg, BLUE );
|
2020-02-05 09:43:52 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
wxString source;
|
2020-08-07 20:18:33 +00:00
|
|
|
int clearance = GetClearance( GetLayer(), nullptr, &source );
|
2008-10-08 12:36:27 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
msg.Printf( _( "Min Clearance: %s" ), MessageTextFromValue( units, clearance, true ) );
|
2020-05-22 10:31:14 +00:00
|
|
|
msg2.Printf( _( "(from %s)" ), source );
|
2020-05-21 17:42:42 +00:00
|
|
|
aList.emplace_back( msg, msg2, BLACK );
|
2020-06-10 18:46:38 +00:00
|
|
|
|
|
|
|
// Useful for statistics, especially when zones are complex the number of hatches
|
|
|
|
// and filled polygons can explain the display and DRC calculation time:
|
2020-08-07 14:04:34 +00:00
|
|
|
msg.Printf( wxT( "%d" ), (int) m_borderHatchLines.size() );
|
|
|
|
aList.emplace_back( MSG_PANEL_ITEM( _( "HatchBorder Lines" ), msg, BLUE ) );
|
2020-06-10 18:46:38 +00:00
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
PCB_LAYER_ID layer = m_Layer;
|
|
|
|
|
|
|
|
// NOTE: This brings in dependence on PCB_EDIT_FRAME to the qa tests, which isn't ideal.
|
|
|
|
// TODO: Figure out a way for items to know the active layer without the whole edit frame?
|
|
|
|
#if 0
|
|
|
|
if( PCB_EDIT_FRAME* pcbframe = dynamic_cast<PCB_EDIT_FRAME*>( aFrame ) )
|
|
|
|
if( m_FilledPolysList.count( pcbframe->GetActiveLayer() ) )
|
|
|
|
layer = pcbframe->GetActiveLayer();
|
|
|
|
#endif
|
2020-09-06 15:33:03 +00:00
|
|
|
auto layer_it = m_FilledPolysList.find( layer );
|
2020-06-24 02:19:08 +00:00
|
|
|
|
2020-09-06 15:33:03 +00:00
|
|
|
if( layer_it == m_FilledPolysList.end() )
|
|
|
|
layer_it = m_FilledPolysList.begin();
|
|
|
|
|
|
|
|
if( layer_it != m_FilledPolysList.end() )
|
2020-06-10 18:46:38 +00:00
|
|
|
{
|
2020-09-06 15:33:03 +00:00
|
|
|
msg.Printf( wxT( "%d" ), layer_it->second.TotalVertices() );
|
2020-06-10 18:46:38 +00:00
|
|
|
aList.emplace_back( MSG_PANEL_ITEM( _( "Corner Count" ), msg, BLUE ) );
|
|
|
|
}
|
2007-12-29 19:15:58 +00:00
|
|
|
}
|
2008-01-06 12:43:57 +00:00
|
|
|
|
|
|
|
|
2008-02-01 21:30:45 +00:00
|
|
|
/* Geometric transforms: */
|
2008-01-31 20:53:44 +00:00
|
|
|
|
|
|
|
void ZONE_CONTAINER::Move( const wxPoint& offset )
|
2008-01-06 12:43:57 +00:00
|
|
|
{
|
2008-12-03 10:32:53 +00:00
|
|
|
/* move outlines */
|
2019-07-12 21:02:10 +00:00
|
|
|
m_Poly->Move( offset );
|
2008-01-31 20:53:44 +00:00
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
HatchBorder();
|
2008-12-03 10:32:53 +00:00
|
|
|
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, SHAPE_POLY_SET>& pair : m_FilledPolysList )
|
2020-06-24 02:19:08 +00:00
|
|
|
pair.second.Move( offset );
|
2011-01-20 18:40:33 +00:00
|
|
|
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, ZONE_SEGMENT_FILL>& pair : m_FillSegmList )
|
2009-08-06 18:30:46 +00:00
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
for( SEG& seg : pair.second )
|
|
|
|
{
|
|
|
|
seg.A += VECTOR2I( offset );
|
|
|
|
seg.B += VECTOR2I( offset );
|
|
|
|
}
|
2009-08-06 18:30:46 +00:00
|
|
|
}
|
2008-01-06 12:43:57 +00:00
|
|
|
}
|
|
|
|
|
2008-09-26 19:51:36 +00:00
|
|
|
|
2014-05-04 17:08:36 +00:00
|
|
|
void ZONE_CONTAINER::MoveEdge( const wxPoint& offset, int aEdge )
|
2008-02-01 21:30:45 +00:00
|
|
|
{
|
2017-04-16 16:32:47 +00:00
|
|
|
int next_corner;
|
2008-02-01 21:30:45 +00:00
|
|
|
|
2017-04-16 16:32:47 +00:00
|
|
|
if( m_Poly->GetNeighbourIndexes( aEdge, nullptr, &next_corner ) )
|
|
|
|
{
|
2019-03-23 18:26:44 +00:00
|
|
|
m_Poly->SetVertex( aEdge, m_Poly->CVertex( aEdge ) + VECTOR2I( offset ) );
|
|
|
|
m_Poly->SetVertex( next_corner, m_Poly->CVertex( next_corner ) + VECTOR2I( offset ) );
|
2020-08-07 14:04:34 +00:00
|
|
|
HatchBorder();
|
2019-03-14 13:35:55 +00:00
|
|
|
|
|
|
|
SetNeedRefill( true );
|
2017-04-16 16:32:47 +00:00
|
|
|
}
|
2008-02-01 21:30:45 +00:00
|
|
|
}
|
|
|
|
|
2008-01-31 20:53:44 +00:00
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
void ZONE_CONTAINER::Rotate( const wxPoint& aCentre, double aAngle )
|
2008-01-06 12:43:57 +00:00
|
|
|
{
|
2020-08-18 13:26:22 +00:00
|
|
|
aAngle = -DECIDEG2RAD( aAngle );
|
2008-01-31 20:53:44 +00:00
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
m_Poly->Rotate( aAngle, VECTOR2I( aCentre ) );
|
2020-08-07 14:04:34 +00:00
|
|
|
HatchBorder();
|
2009-08-01 19:58:01 +00:00
|
|
|
|
|
|
|
/* rotate filled areas: */
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, SHAPE_POLY_SET>& pair : m_FilledPolysList )
|
2020-08-18 13:26:22 +00:00
|
|
|
pair.second.Rotate( aAngle, VECTOR2I( aCentre ) );
|
2011-01-20 18:40:33 +00:00
|
|
|
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, ZONE_SEGMENT_FILL>& pair : m_FillSegmList )
|
2009-08-06 18:30:46 +00:00
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
for( SEG& seg : pair.second )
|
|
|
|
{
|
|
|
|
wxPoint a( seg.A );
|
2020-08-18 13:26:22 +00:00
|
|
|
RotatePoint( &a, aCentre, aAngle );
|
2020-06-24 02:19:08 +00:00
|
|
|
seg.A = a;
|
|
|
|
wxPoint b( seg.B );
|
2020-08-18 13:26:22 +00:00
|
|
|
RotatePoint( &b, aCentre, aAngle );
|
2020-06-24 02:19:08 +00:00
|
|
|
seg.B = a;
|
|
|
|
}
|
2009-08-06 18:30:46 +00:00
|
|
|
}
|
2008-01-06 12:43:57 +00:00
|
|
|
}
|
|
|
|
|
2011-01-20 18:40:33 +00:00
|
|
|
|
2019-07-12 21:02:10 +00:00
|
|
|
void ZONE_CONTAINER::Flip( const wxPoint& aCentre, bool aFlipLeftRight )
|
2009-08-01 19:26:05 +00:00
|
|
|
{
|
2019-07-12 21:02:10 +00:00
|
|
|
Mirror( aCentre, aFlipLeftRight );
|
2015-12-27 15:51:13 +00:00
|
|
|
int copperLayerCount = GetBoard()->GetCopperLayerCount();
|
2017-10-30 17:21:07 +00:00
|
|
|
|
|
|
|
if( GetIsKeepout() )
|
|
|
|
SetLayerSet( FlipLayerMask( GetLayerSet(), copperLayerCount ) );
|
|
|
|
else
|
|
|
|
SetLayer( FlipLayer( GetLayer(), copperLayerCount ) );
|
2009-08-01 19:26:05 +00:00
|
|
|
}
|
2008-01-06 12:43:57 +00:00
|
|
|
|
2011-01-20 18:40:33 +00:00
|
|
|
|
2019-07-12 21:02:10 +00:00
|
|
|
void ZONE_CONTAINER::Mirror( const wxPoint& aMirrorRef, bool aMirrorLeftRight )
|
2008-01-06 12:43:57 +00:00
|
|
|
{
|
2019-03-23 18:26:44 +00:00
|
|
|
// ZONE_CONTAINERs mirror about the x-axis (why?!?)
|
|
|
|
m_Poly->Mirror( aMirrorLeftRight, !aMirrorLeftRight, VECTOR2I( aMirrorRef ) );
|
2008-01-31 20:53:44 +00:00
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
HatchBorder();
|
2009-08-01 19:58:01 +00:00
|
|
|
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, SHAPE_POLY_SET>& pair : m_FilledPolysList )
|
2020-06-24 02:19:08 +00:00
|
|
|
pair.second.Mirror( aMirrorLeftRight, !aMirrorLeftRight, VECTOR2I( aMirrorRef ) );
|
2011-01-20 18:40:33 +00:00
|
|
|
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, ZONE_SEGMENT_FILL>& pair : m_FillSegmList )
|
2009-08-06 18:30:46 +00:00
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
for( SEG& seg : pair.second )
|
2019-07-12 21:02:10 +00:00
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
if( aMirrorLeftRight )
|
|
|
|
{
|
|
|
|
MIRROR( seg.A.x, aMirrorRef.x );
|
|
|
|
MIRROR( seg.B.x, aMirrorRef.x );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
MIRROR( seg.A.y, aMirrorRef.y );
|
|
|
|
MIRROR( seg.B.y, aMirrorRef.y );
|
|
|
|
}
|
2019-07-12 21:02:10 +00:00
|
|
|
}
|
2009-08-06 18:30:46 +00:00
|
|
|
}
|
2008-01-06 12:43:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
ZONE_CONNECTION ZONE_CONTAINER::GetPadConnection( D_PAD* aPad ) const
|
2012-02-24 23:23:46 +00:00
|
|
|
{
|
2020-06-22 19:35:09 +00:00
|
|
|
if( aPad == NULL || aPad->GetEffectiveZoneConnection() == ZONE_CONNECTION::INHERITED )
|
2012-02-24 23:23:46 +00:00
|
|
|
return m_PadConnection;
|
|
|
|
else
|
2020-06-22 19:35:09 +00:00
|
|
|
return aPad->GetEffectiveZoneConnection();
|
2012-02-24 23:23:46 +00:00
|
|
|
}
|
2020-04-14 16:57:18 +00:00
|
|
|
|
|
|
|
|
|
|
|
void ZONE_CONTAINER::RemoveCutout( int aOutlineIdx, int aHoleIdx )
|
|
|
|
{
|
|
|
|
// Ensure the requested cutout is valid
|
|
|
|
if( m_Poly->OutlineCount() < aOutlineIdx || m_Poly->HoleCount( aOutlineIdx ) < aHoleIdx )
|
|
|
|
return;
|
|
|
|
|
|
|
|
SHAPE_POLY_SET cutPoly( m_Poly->Hole( aOutlineIdx, aHoleIdx ) );
|
|
|
|
|
|
|
|
// Add the cutout back to the zone
|
|
|
|
m_Poly->BooleanAdd( cutPoly, SHAPE_POLY_SET::PM_FAST );
|
|
|
|
|
|
|
|
SetNeedRefill( true );
|
|
|
|
}
|
2012-02-24 23:23:46 +00:00
|
|
|
|
|
|
|
|
2019-05-21 02:31:40 +00:00
|
|
|
void ZONE_CONTAINER::AddPolygon( const SHAPE_LINE_CHAIN& aPolygon )
|
|
|
|
{
|
|
|
|
wxASSERT( aPolygon.IsClosed() );
|
|
|
|
|
|
|
|
// Add the outline as a new polygon in the polygon set
|
|
|
|
if( m_Poly->OutlineCount() == 0 )
|
|
|
|
m_Poly->AddOutline( aPolygon );
|
|
|
|
else
|
|
|
|
m_Poly->AddHole( aPolygon );
|
|
|
|
|
|
|
|
SetNeedRefill( true );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-06-09 17:00:13 +00:00
|
|
|
void ZONE_CONTAINER::AddPolygon( std::vector< wxPoint >& aPolygon )
|
|
|
|
{
|
|
|
|
if( aPolygon.empty() )
|
|
|
|
return;
|
|
|
|
|
2017-03-07 12:06:00 +00:00
|
|
|
SHAPE_LINE_CHAIN outline;
|
|
|
|
|
|
|
|
// Create an outline and populate it with the points of aPolygon
|
2020-05-21 17:42:42 +00:00
|
|
|
for( const wxPoint& pt : aPolygon)
|
|
|
|
outline.Append( pt );
|
2012-06-09 17:00:13 +00:00
|
|
|
|
2017-03-07 12:06:00 +00:00
|
|
|
outline.SetClosed( true );
|
2012-06-09 17:00:13 +00:00
|
|
|
|
2020-04-14 17:00:09 +00:00
|
|
|
AddPolygon( outline );
|
2017-03-07 12:06:00 +00:00
|
|
|
}
|
2012-06-09 17:00:13 +00:00
|
|
|
|
2017-04-07 06:02:26 +00:00
|
|
|
|
2017-06-19 11:29:57 +00:00
|
|
|
bool ZONE_CONTAINER::AppendCorner( wxPoint aPosition, int aHoleIdx, bool aAllowDuplication )
|
|
|
|
{
|
|
|
|
// Ensure the main outline exists:
|
|
|
|
if( m_Poly->OutlineCount() == 0 )
|
|
|
|
m_Poly->NewOutline();
|
|
|
|
|
|
|
|
// If aHoleIdx >= 0, the corner musty be added to the hole, index aHoleIdx.
|
|
|
|
// (remember: the index of the first hole is 0)
|
|
|
|
// Return error if if does dot exist.
|
|
|
|
if( aHoleIdx >= m_Poly->HoleCount( 0 ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
m_Poly->Append( aPosition.x, aPosition.y, -1, aHoleIdx, aAllowDuplication );
|
|
|
|
|
2019-03-14 13:35:55 +00:00
|
|
|
SetNeedRefill( true );
|
|
|
|
|
2017-06-19 11:29:57 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-20 14:11:39 +00:00
|
|
|
wxString ZONE_CONTAINER::GetSelectMenuText( EDA_UNITS aUnits ) const
|
2011-07-14 15:42:44 +00:00
|
|
|
{
|
|
|
|
wxString text;
|
|
|
|
|
2017-03-07 12:06:00 +00:00
|
|
|
// Check whether the selected contour is a hole (contour index > 0)
|
|
|
|
if( m_CornerSelection != nullptr && m_CornerSelection->m_contour > 0 )
|
2018-01-31 09:08:57 +00:00
|
|
|
text << wxT( " " ) << _( "(Cutout)" );
|
2011-07-14 15:42:44 +00:00
|
|
|
|
2013-02-07 17:56:41 +00:00
|
|
|
if( GetIsKeepout() )
|
|
|
|
text << wxT( " " ) << _( "(Keepout)" );
|
2018-01-31 09:08:57 +00:00
|
|
|
else
|
|
|
|
text << GetNetnameMsg();
|
2011-07-14 15:42:44 +00:00
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
wxString layerDesc;
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
for( PCB_LAYER_ID layer : m_layerSet.Seq() )
|
|
|
|
{
|
|
|
|
if( count == 0 )
|
|
|
|
layerDesc = GetBoard()->GetLayerName( layer );
|
|
|
|
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( count > 1 )
|
|
|
|
layerDesc.Printf( _( "%s and %d more" ), layerDesc, count - 1 );
|
|
|
|
|
|
|
|
return wxString::Format( _( "Zone Outline %s on %s" ), text, layerDesc );
|
2015-12-27 15:51:13 +00:00
|
|
|
}
|
2017-02-20 12:20:39 +00:00
|
|
|
|
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
int ZONE_CONTAINER::GetBorderHatchPitch() const
|
2017-03-07 12:06:00 +00:00
|
|
|
{
|
2020-08-07 14:04:34 +00:00
|
|
|
return m_borderHatchPitch;
|
2017-03-07 12:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
void ZONE_CONTAINER::SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE aHatchStyle, int aHatchPitch,
|
|
|
|
bool aRebuildHatch )
|
2017-03-07 12:06:00 +00:00
|
|
|
{
|
|
|
|
SetHatchPitch( aHatchPitch );
|
2020-08-07 14:04:34 +00:00
|
|
|
m_borderStyle = aHatchStyle;
|
2017-03-07 12:06:00 +00:00
|
|
|
|
|
|
|
if( aRebuildHatch )
|
2020-08-07 14:04:34 +00:00
|
|
|
HatchBorder();
|
2017-03-07 12:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ZONE_CONTAINER::SetHatchPitch( int aPitch )
|
|
|
|
{
|
2020-08-07 14:04:34 +00:00
|
|
|
m_borderHatchPitch = aPitch;
|
2017-03-07 12:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
void ZONE_CONTAINER::UnHatchBorder()
|
2017-03-07 12:06:00 +00:00
|
|
|
{
|
2020-08-07 14:04:34 +00:00
|
|
|
m_borderHatchLines.clear();
|
2017-03-07 12:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Creates hatch lines inside the outline of the complex polygon
|
2020-08-07 14:04:34 +00:00
|
|
|
// sort function used in ::HatchBorder to sort points by descending wxPoint.x values
|
2017-03-07 12:06:00 +00:00
|
|
|
bool sortEndsByDescendingX( const VECTOR2I& ref, const VECTOR2I& tst )
|
|
|
|
{
|
|
|
|
return tst.x < ref.x;
|
|
|
|
}
|
|
|
|
|
2017-07-01 13:16:51 +00:00
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
void ZONE_CONTAINER::HatchBorder()
|
2017-03-07 12:06:00 +00:00
|
|
|
{
|
2020-08-07 14:04:34 +00:00
|
|
|
UnHatchBorder();
|
2017-03-07 12:06:00 +00:00
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
if( m_borderStyle == ZONE_BORDER_DISPLAY_STYLE::NO_HATCH
|
|
|
|
|| m_borderHatchPitch == 0
|
|
|
|
|| m_Poly->IsEmpty() )
|
|
|
|
{
|
2017-03-07 12:06:00 +00:00
|
|
|
return;
|
2020-08-07 14:04:34 +00:00
|
|
|
}
|
2017-03-07 12:06:00 +00:00
|
|
|
|
|
|
|
// define range for hatch lines
|
2019-03-23 18:26:44 +00:00
|
|
|
int min_x = m_Poly->CVertex( 0 ).x;
|
|
|
|
int max_x = m_Poly->CVertex( 0 ).x;
|
|
|
|
int min_y = m_Poly->CVertex( 0 ).y;
|
|
|
|
int max_y = m_Poly->CVertex( 0 ).y;
|
2017-03-07 12:06:00 +00:00
|
|
|
|
|
|
|
for( auto iterator = m_Poly->IterateWithHoles(); iterator; iterator++ )
|
|
|
|
{
|
|
|
|
if( iterator->x < min_x )
|
|
|
|
min_x = iterator->x;
|
|
|
|
|
|
|
|
if( iterator->x > max_x )
|
|
|
|
max_x = iterator->x;
|
|
|
|
|
|
|
|
if( iterator->y < min_y )
|
|
|
|
min_y = iterator->y;
|
|
|
|
|
|
|
|
if( iterator->y > max_y )
|
|
|
|
max_y = iterator->y;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Calculate spacing between 2 hatch lines
|
|
|
|
int spacing;
|
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
if( m_borderStyle == ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE )
|
|
|
|
spacing = m_borderHatchPitch;
|
2017-03-07 12:06:00 +00:00
|
|
|
else
|
2020-08-07 14:04:34 +00:00
|
|
|
spacing = m_borderHatchPitch * 2;
|
2017-03-07 12:06:00 +00:00
|
|
|
|
|
|
|
// set the "length" of hatch lines (the length on horizontal axis)
|
2020-08-07 14:04:34 +00:00
|
|
|
int hatch_line_len = m_borderHatchPitch;
|
2017-03-07 12:06:00 +00:00
|
|
|
|
|
|
|
// To have a better look, give a slope depending on the layer
|
|
|
|
LAYER_NUM layer = GetLayer();
|
|
|
|
int slope_flag = (layer & 1) ? 1 : -1; // 1 or -1
|
|
|
|
double slope = 0.707106 * slope_flag; // 45 degrees slope
|
|
|
|
int max_a, min_a;
|
|
|
|
|
|
|
|
if( slope_flag == 1 )
|
|
|
|
{
|
|
|
|
max_a = KiROUND( max_y - slope * min_x );
|
|
|
|
min_a = KiROUND( min_y - slope * max_x );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
max_a = KiROUND( max_y - slope * max_x );
|
|
|
|
min_a = KiROUND( min_y - slope * min_x );
|
|
|
|
}
|
|
|
|
|
|
|
|
min_a = (min_a / spacing) * spacing;
|
|
|
|
|
|
|
|
// calculate an offset depending on layer number,
|
|
|
|
// for a better look of hatches on a multilayer board
|
|
|
|
int offset = (layer * 7) / 8;
|
|
|
|
min_a += offset;
|
|
|
|
|
|
|
|
// loop through hatch lines
|
|
|
|
#define MAXPTS 200 // Usually we store only few values per one hatch line
|
|
|
|
// depending on the complexity of the zone outline
|
|
|
|
|
|
|
|
static std::vector<VECTOR2I> pointbuffer;
|
|
|
|
pointbuffer.clear();
|
|
|
|
pointbuffer.reserve( MAXPTS + 2 );
|
|
|
|
|
|
|
|
for( int a = min_a; a < max_a; a += spacing )
|
|
|
|
{
|
|
|
|
// get intersection points for this hatch line
|
|
|
|
|
|
|
|
// Note: because we should have an even number of intersections with the
|
|
|
|
// current hatch line and the zone outline (a closed polygon,
|
|
|
|
// or a set of closed polygons), if an odd count is found
|
|
|
|
// we skip this line (should not occur)
|
|
|
|
pointbuffer.clear();
|
|
|
|
|
|
|
|
// Iterate through all vertices
|
|
|
|
for( auto iterator = m_Poly->IterateSegmentsWithHoles(); iterator; iterator++ )
|
|
|
|
{
|
|
|
|
double x, y, x2, y2;
|
|
|
|
int ok;
|
|
|
|
|
|
|
|
SEG segment = *iterator;
|
|
|
|
|
|
|
|
ok = FindLineSegmentIntersection( a, slope,
|
|
|
|
segment.A.x, segment.A.y,
|
|
|
|
segment.B.x, segment.B.y,
|
|
|
|
&x, &y, &x2, &y2 );
|
|
|
|
|
|
|
|
if( ok )
|
|
|
|
{
|
|
|
|
VECTOR2I point( KiROUND( x ), KiROUND( y ) );
|
|
|
|
pointbuffer.push_back( point );
|
|
|
|
}
|
|
|
|
|
|
|
|
if( ok == 2 )
|
|
|
|
{
|
|
|
|
VECTOR2I point( KiROUND( x2 ), KiROUND( y2 ) );
|
|
|
|
pointbuffer.push_back( point );
|
|
|
|
}
|
|
|
|
|
|
|
|
if( pointbuffer.size() >= MAXPTS ) // overflow
|
|
|
|
{
|
|
|
|
wxASSERT( 0 );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ensure we have found an even intersection points count
|
|
|
|
// because intersections are the ends of segments
|
|
|
|
// inside the polygon(s) and a segment has 2 ends.
|
|
|
|
// if not, this is a strange case (a bug ?) so skip this hatch
|
|
|
|
if( pointbuffer.size() % 2 != 0 )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// sort points in order of descending x (if more than 2) to
|
|
|
|
// ensure the starting point and the ending point of the same segment
|
|
|
|
// are stored one just after the other.
|
|
|
|
if( pointbuffer.size() > 2 )
|
|
|
|
sort( pointbuffer.begin(), pointbuffer.end(), sortEndsByDescendingX );
|
|
|
|
|
|
|
|
// creates lines or short segments inside the complex polygon
|
|
|
|
for( unsigned ip = 0; ip < pointbuffer.size(); ip += 2 )
|
|
|
|
{
|
|
|
|
int dx = pointbuffer[ip + 1].x - pointbuffer[ip].x;
|
|
|
|
|
|
|
|
// Push only one line for diagonal hatch,
|
|
|
|
// or for small lines < twice the line length
|
|
|
|
// else push 2 small lines
|
2020-08-07 14:04:34 +00:00
|
|
|
if( m_borderStyle == ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_FULL
|
|
|
|
|| std::abs( dx ) < 2 * hatch_line_len )
|
2017-03-07 12:06:00 +00:00
|
|
|
{
|
2020-08-07 14:04:34 +00:00
|
|
|
m_borderHatchLines.emplace_back( SEG( pointbuffer[ip], pointbuffer[ ip + 1] ) );
|
2017-03-07 12:06:00 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
double dy = pointbuffer[ip + 1].y - pointbuffer[ip].y;
|
|
|
|
slope = dy / dx;
|
|
|
|
|
|
|
|
if( dx > 0 )
|
|
|
|
dx = hatch_line_len;
|
|
|
|
else
|
|
|
|
dx = -hatch_line_len;
|
|
|
|
|
|
|
|
int x1 = KiROUND( pointbuffer[ip].x + dx );
|
|
|
|
int x2 = KiROUND( pointbuffer[ip + 1].x - dx );
|
|
|
|
int y1 = KiROUND( pointbuffer[ip].y + dx * slope );
|
|
|
|
int y2 = KiROUND( pointbuffer[ip + 1].y - dx * slope );
|
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
m_borderHatchLines.emplace_back( SEG( pointbuffer[ip].x, pointbuffer[ip].y, x1, y1 ) );
|
2017-03-07 12:06:00 +00:00
|
|
|
|
2020-08-07 14:04:34 +00:00
|
|
|
m_borderHatchLines.emplace_back( SEG( pointbuffer[ip+1].x, pointbuffer[ip+1].y, x2, y2 ) );
|
2017-03-07 12:06:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-07-01 13:16:51 +00:00
|
|
|
int ZONE_CONTAINER::GetDefaultHatchPitch()
|
|
|
|
{
|
|
|
|
return Mils2iu( 20 );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-02-20 12:20:39 +00:00
|
|
|
BITMAP_DEF ZONE_CONTAINER::GetMenuImage() const
|
|
|
|
{
|
|
|
|
return add_zone_xpm;
|
|
|
|
}
|
2017-10-31 13:59:03 +00:00
|
|
|
|
2018-06-22 23:35:07 +00:00
|
|
|
|
2017-10-31 13:59:03 +00:00
|
|
|
void ZONE_CONTAINER::SwapData( BOARD_ITEM* aImage )
|
|
|
|
{
|
|
|
|
assert( aImage->Type() == PCB_ZONE_AREA_T );
|
|
|
|
|
|
|
|
std::swap( *((ZONE_CONTAINER*) this), *((ZONE_CONTAINER*) aImage) );
|
|
|
|
}
|
2017-11-23 16:20:27 +00:00
|
|
|
|
2018-06-22 23:35:07 +00:00
|
|
|
|
2017-11-23 16:20:27 +00:00
|
|
|
void ZONE_CONTAINER::CacheTriangulation()
|
|
|
|
{
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, SHAPE_POLY_SET>& pair : m_FilledPolysList )
|
2020-06-24 02:19:08 +00:00
|
|
|
pair.second.CacheTriangulation();
|
2017-11-23 16:20:27 +00:00
|
|
|
}
|
2017-12-04 18:06:47 +00:00
|
|
|
|
2018-06-22 23:35:07 +00:00
|
|
|
|
2020-06-26 02:19:51 +00:00
|
|
|
bool ZONE_CONTAINER::IsIsland( PCB_LAYER_ID aLayer, int aPolyIdx )
|
|
|
|
{
|
|
|
|
if( GetNetCode() < 1 )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if( !m_insulatedIslands.count( aLayer ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return m_insulatedIslands.at( aLayer ).count( aPolyIdx );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-08-12 18:42:40 +00:00
|
|
|
void ZONE_CONTAINER::GetInteractingZones( PCB_LAYER_ID aLayer,
|
|
|
|
std::vector<ZONE_CONTAINER*>* aZones ) const
|
2019-07-13 22:34:09 +00:00
|
|
|
{
|
|
|
|
int epsilon = Millimeter2iu( 0.001 );
|
|
|
|
|
2020-08-12 18:42:40 +00:00
|
|
|
for( ZONE_CONTAINER* candidate : GetBoard()->Zones() )
|
2019-07-13 22:34:09 +00:00
|
|
|
{
|
2019-07-28 16:31:26 +00:00
|
|
|
if( candidate == this )
|
|
|
|
continue;
|
|
|
|
|
2020-08-12 18:42:40 +00:00
|
|
|
if( !candidate->GetLayerSet().test( aLayer ) )
|
2019-07-28 16:31:26 +00:00
|
|
|
continue;
|
|
|
|
|
2020-08-12 18:42:40 +00:00
|
|
|
if( candidate->GetIsKeepout() )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if( candidate->GetNetCode() != GetNetCode() )
|
2019-07-28 16:31:26 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
for( auto iter = m_Poly->CIterate(); iter; iter++ )
|
2019-07-13 22:34:09 +00:00
|
|
|
{
|
2019-07-28 16:31:26 +00:00
|
|
|
if( candidate->m_Poly->Collide( iter.Get(), epsilon ) )
|
2019-07-13 22:34:09 +00:00
|
|
|
{
|
2020-08-12 18:42:40 +00:00
|
|
|
aZones->push_back( candidate );
|
|
|
|
break;
|
2019-07-13 22:34:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-08-12 18:42:40 +00:00
|
|
|
bool ZONE_CONTAINER::BuildSmoothedPoly( SHAPE_POLY_SET& aSmoothedPoly, PCB_LAYER_ID aLayer ) const
|
2017-12-04 18:06:47 +00:00
|
|
|
{
|
2020-08-30 14:18:35 +00:00
|
|
|
if( GetNumCorners() <= 2 ) // malformed zone. polygon calculations will not like it ...
|
2017-12-04 18:06:47 +00:00
|
|
|
return false;
|
|
|
|
|
2020-08-30 14:18:35 +00:00
|
|
|
BOARD* board = GetBoard();
|
|
|
|
int maxError = ARC_HIGH_DEF;
|
|
|
|
bool keepExternalFillets = false;
|
2020-08-12 18:42:40 +00:00
|
|
|
|
2020-08-30 14:18:35 +00:00
|
|
|
if( board )
|
|
|
|
{
|
|
|
|
maxError = board->GetDesignSettings().m_MaxError;
|
|
|
|
keepExternalFillets = board->GetDesignSettings().m_ZoneKeepExternalFillets;
|
|
|
|
}
|
2020-08-12 18:42:40 +00:00
|
|
|
|
2020-08-30 14:18:35 +00:00
|
|
|
auto smooth = [&]( SHAPE_POLY_SET& aPoly )
|
|
|
|
{
|
|
|
|
switch( m_cornerSmoothingType )
|
|
|
|
{
|
|
|
|
case ZONE_SETTINGS::SMOOTHING_CHAMFER:
|
|
|
|
aPoly = aPoly.Chamfer( (int) m_cornerRadius );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ZONE_SETTINGS::SMOOTHING_FILLET:
|
|
|
|
{
|
|
|
|
aPoly = aPoly.Fillet( (int) m_cornerRadius, maxError );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
};
|
2020-08-12 18:42:40 +00:00
|
|
|
|
2020-08-30 14:18:35 +00:00
|
|
|
std::vector<ZONE_CONTAINER*> interactingZones;
|
|
|
|
GetInteractingZones( aLayer, &interactingZones );
|
2017-12-04 18:06:47 +00:00
|
|
|
|
2020-08-30 14:18:35 +00:00
|
|
|
SHAPE_POLY_SET* maxExtents = m_Poly;
|
|
|
|
SHAPE_POLY_SET withFillets;
|
2017-12-04 18:06:47 +00:00
|
|
|
|
2020-08-30 14:18:35 +00:00
|
|
|
aSmoothedPoly = *m_Poly;
|
2019-05-22 14:47:38 +00:00
|
|
|
|
2020-08-30 14:18:35 +00:00
|
|
|
// Should external fillets (that is, those applied to concave corners) be kept? While it
|
|
|
|
// seems safer to never have copper extend outside the zone outline, 5.1.x and prior did
|
|
|
|
// indeed fill them so we leave the mode available.
|
|
|
|
if( keepExternalFillets )
|
|
|
|
{
|
|
|
|
withFillets = *m_Poly;
|
|
|
|
smooth( withFillets );
|
|
|
|
withFillets.BooleanAdd( *m_Poly, SHAPE_POLY_SET::PM_FAST );
|
|
|
|
maxExtents = &withFillets;
|
2019-05-22 14:47:38 +00:00
|
|
|
}
|
2020-08-25 18:03:21 +00:00
|
|
|
|
2020-08-30 14:18:35 +00:00
|
|
|
for( ZONE_CONTAINER* zone : interactingZones )
|
|
|
|
aSmoothedPoly.BooleanAdd( *zone->Outline(), SHAPE_POLY_SET::PM_FAST );
|
|
|
|
|
|
|
|
smooth( aSmoothedPoly );
|
2017-12-04 18:06:47 +00:00
|
|
|
|
2020-08-12 18:42:40 +00:00
|
|
|
if( interactingZones.size() )
|
2020-08-30 14:18:35 +00:00
|
|
|
aSmoothedPoly.BooleanIntersection( *maxExtents, SHAPE_POLY_SET::PM_FAST );
|
2020-08-12 18:42:40 +00:00
|
|
|
|
2017-12-04 18:06:47 +00:00
|
|
|
return true;
|
2020-08-30 14:18:35 +00:00
|
|
|
}
|
2017-12-13 23:33:20 +00:00
|
|
|
|
2020-02-05 09:43:52 +00:00
|
|
|
|
|
|
|
double ZONE_CONTAINER::CalculateFilledArea()
|
|
|
|
{
|
|
|
|
m_area = 0.0;
|
|
|
|
|
|
|
|
// Iterate over each outline polygon in the zone and then iterate over
|
|
|
|
// each hole it has to compute the total area.
|
2020-06-30 17:32:48 +00:00
|
|
|
for( std::pair<const PCB_LAYER_ID, SHAPE_POLY_SET>& pair : m_FilledPolysList )
|
2020-02-05 09:43:52 +00:00
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
SHAPE_POLY_SET& poly = pair.second;
|
2020-02-05 09:43:52 +00:00
|
|
|
|
2020-06-24 02:19:08 +00:00
|
|
|
for( int i = 0; i < poly.OutlineCount(); i++ )
|
2020-02-05 09:43:52 +00:00
|
|
|
{
|
2020-06-24 02:19:08 +00:00
|
|
|
m_area += poly.Outline( i ).Area();
|
|
|
|
|
|
|
|
for( int j = 0; j < poly.HoleCount( i ); j++ )
|
|
|
|
m_area -= poly.Hole( i, j ).Area();
|
2020-02-05 09:43:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_area;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
/**
|
|
|
|
* Function TransformOutlinesShapeWithClearanceToPolygon
|
|
|
|
* Convert the filled areas to polygons (optionally inflated by \a aClearance) and copy them
|
|
|
|
* into \a aCornerBuffer.
|
2017-12-13 23:33:20 +00:00
|
|
|
*/
|
2019-07-13 22:34:09 +00:00
|
|
|
void ZONE_CONTAINER::TransformOutlinesShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
|
2020-08-12 18:42:40 +00:00
|
|
|
int aClearance ) const
|
2017-12-13 23:33:20 +00:00
|
|
|
{
|
|
|
|
// Creates the zone outline polygon (with holes if any)
|
|
|
|
SHAPE_POLY_SET polybuffer;
|
2020-08-12 18:42:40 +00:00
|
|
|
BuildSmoothedPoly( polybuffer, GetLayer() );
|
2017-12-13 23:33:20 +00:00
|
|
|
|
|
|
|
// Calculate the polygon with clearance
|
|
|
|
// holes are linked to the main outline, so only one polygon is created.
|
2020-05-18 16:11:57 +00:00
|
|
|
if( aClearance )
|
2019-05-14 12:39:34 +00:00
|
|
|
{
|
2019-07-13 16:35:57 +00:00
|
|
|
BOARD* board = GetBoard();
|
2019-05-22 14:47:38 +00:00
|
|
|
int maxError = ARC_HIGH_DEF;
|
|
|
|
|
|
|
|
if( board )
|
|
|
|
maxError = board->GetDesignSettings().m_MaxError;
|
|
|
|
|
2020-05-18 16:11:57 +00:00
|
|
|
int segCount = std::max( GetArcToSegmentCount( aClearance, maxError, 360.0 ), 3 );
|
|
|
|
polybuffer.Inflate( aClearance, segCount );
|
2019-05-14 12:39:34 +00:00
|
|
|
}
|
2019-07-13 16:35:57 +00:00
|
|
|
|
2017-12-13 23:33:20 +00:00
|
|
|
polybuffer.Fracture( SHAPE_POLY_SET::PM_FAST );
|
|
|
|
aCornerBuffer.Append( polybuffer );
|
|
|
|
}
|
2019-10-26 15:49:29 +00:00
|
|
|
|
2020-08-18 13:26:22 +00:00
|
|
|
|
2019-10-29 10:09:54 +00:00
|
|
|
//
|
|
|
|
/********* MODULE_ZONE_CONTAINER **************/
|
|
|
|
//
|
|
|
|
MODULE_ZONE_CONTAINER::MODULE_ZONE_CONTAINER( BOARD_ITEM_CONTAINER* aParent ) :
|
|
|
|
ZONE_CONTAINER( aParent, true )
|
|
|
|
{
|
|
|
|
// in a footprint, net classes are not managed.
|
|
|
|
// so set the net to NETINFO_LIST::ORPHANED_ITEM
|
|
|
|
SetNetCode( -1, true );
|
|
|
|
}
|
|
|
|
|
2019-10-26 15:49:29 +00:00
|
|
|
|
|
|
|
MODULE_ZONE_CONTAINER::MODULE_ZONE_CONTAINER( const MODULE_ZONE_CONTAINER& aZone )
|
|
|
|
: ZONE_CONTAINER( aZone.GetParent(), true )
|
|
|
|
{
|
2020-07-27 17:56:15 +00:00
|
|
|
InitDataFromSrcInCopyCtor( aZone );
|
2019-10-26 15:49:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
MODULE_ZONE_CONTAINER& MODULE_ZONE_CONTAINER::operator=( const MODULE_ZONE_CONTAINER& aOther )
|
|
|
|
{
|
|
|
|
ZONE_CONTAINER::operator=( aOther );
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
EDA_ITEM* MODULE_ZONE_CONTAINER::Clone() const
|
|
|
|
{
|
|
|
|
return new MODULE_ZONE_CONTAINER( *this );
|
|
|
|
}
|
2019-10-28 09:15:03 +00:00
|
|
|
|
|
|
|
|
|
|
|
unsigned int MODULE_ZONE_CONTAINER::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
|
|
|
|
{
|
|
|
|
const int HIDE = std::numeric_limits<unsigned int>::max();
|
|
|
|
|
|
|
|
if( !aView )
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bool flipped = GetParent() && GetParent()->GetLayer() == B_Cu;
|
|
|
|
|
|
|
|
// Handle Render tab switches
|
|
|
|
if( !flipped && !aView->IsLayerVisible( LAYER_MOD_FR ) )
|
|
|
|
return HIDE;
|
|
|
|
|
|
|
|
if( flipped && !aView->IsLayerVisible( LAYER_MOD_BK ) )
|
|
|
|
return HIDE;
|
|
|
|
|
|
|
|
// Other layers are shown without any conditions
|
|
|
|
return 0;
|
|
|
|
}
|
2020-02-02 18:40:14 +00:00
|
|
|
|
|
|
|
|
2020-08-26 22:04:16 +00:00
|
|
|
std::shared_ptr<SHAPE> ZONE_CONTAINER::GetEffectiveShape( PCB_LAYER_ID aLayer ) const
|
|
|
|
{
|
|
|
|
std::shared_ptr<SHAPE> shape;
|
|
|
|
|
|
|
|
if( m_FilledPolysList.find( aLayer ) == m_FilledPolysList.end() )
|
|
|
|
{
|
|
|
|
shape.reset( new SHAPE_NULL );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
shape.reset( m_FilledPolysList.at( aLayer ).Clone() );
|
|
|
|
}
|
|
|
|
|
|
|
|
return shape;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-02-02 18:40:14 +00:00
|
|
|
static struct ZONE_CONTAINER_DESC
|
|
|
|
{
|
|
|
|
ZONE_CONTAINER_DESC()
|
|
|
|
{
|
2020-09-05 16:00:29 +00:00
|
|
|
ENUM_MAP<ZONE_CONNECTION>::Instance()
|
|
|
|
.Map( ZONE_CONNECTION::INHERITED, _( "Inherited" ) )
|
|
|
|
.Map( ZONE_CONNECTION::NONE, _( "None" ) )
|
|
|
|
.Map( ZONE_CONNECTION::THERMAL, _( "Thermal reliefs" ) )
|
|
|
|
.Map( ZONE_CONNECTION::FULL, _( "Solid" ) )
|
|
|
|
.Map( ZONE_CONNECTION::THT_THERMAL, _( "Reliefs for PTH" ) );
|
|
|
|
|
2020-02-02 18:40:14 +00:00
|
|
|
PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
|
|
|
|
REGISTER_TYPE( ZONE_CONTAINER );
|
|
|
|
propMgr.InheritsAfter( TYPE_HASH( ZONE_CONTAINER ), TYPE_HASH( BOARD_CONNECTED_ITEM ) );
|
|
|
|
propMgr.AddProperty( new PROPERTY<ZONE_CONTAINER, unsigned>( _( "Priority" ),
|
|
|
|
&ZONE_CONTAINER::SetPriority, &ZONE_CONTAINER::GetPriority ) );
|
|
|
|
//propMgr.AddProperty( new PROPERTY<ZONE_CONTAINER, bool>( "Filled",
|
|
|
|
//&ZONE_CONTAINER::SetIsFilled, &ZONE_CONTAINER::IsFilled ) );
|
2020-08-07 20:18:33 +00:00
|
|
|
propMgr.AddProperty( new PROPERTY<ZONE_CONTAINER, wxString>( _( "Name" ),
|
|
|
|
&ZONE_CONTAINER::SetZoneName, &ZONE_CONTAINER::GetZoneName ) );
|
2020-09-05 16:00:29 +00:00
|
|
|
propMgr.AddProperty( new PROPERTY<ZONE_CONTAINER, int>( _( "Clearance" ),
|
|
|
|
&ZONE_CONTAINER::SetLocalClearance, &ZONE_CONTAINER::GetLocalClearance,
|
|
|
|
PROPERTY_DISPLAY::DISTANCE ) );
|
|
|
|
propMgr.AddProperty( new PROPERTY<ZONE_CONTAINER, int>( _( "Min Width" ),
|
|
|
|
&ZONE_CONTAINER::SetMinThickness, &ZONE_CONTAINER::GetMinThickness,
|
|
|
|
PROPERTY_DISPLAY::DISTANCE ) );
|
|
|
|
propMgr.AddProperty( new PROPERTY_ENUM<ZONE_CONTAINER, ZONE_CONNECTION>( _( "Pad Connections" ),
|
|
|
|
&ZONE_CONTAINER::SetPadConnection, &ZONE_CONTAINER::GetPadConnection ) );
|
|
|
|
propMgr.AddProperty( new PROPERTY<ZONE_CONTAINER, int>( _( "Thermal Clearance" ),
|
|
|
|
&ZONE_CONTAINER::SetThermalReliefGap, &ZONE_CONTAINER::GetThermalReliefGap,
|
|
|
|
PROPERTY_DISPLAY::DISTANCE ) );
|
|
|
|
propMgr.AddProperty( new PROPERTY<ZONE_CONTAINER, int>( _( "Thermal Spoke Width" ),
|
|
|
|
&ZONE_CONTAINER::SetThermalReliefCopperBridge, &ZONE_CONTAINER::GetThermalReliefCopperBridge,
|
|
|
|
PROPERTY_DISPLAY::DISTANCE ) );
|
2020-02-02 18:40:14 +00:00
|
|
|
}
|
|
|
|
} _ZONE_CONTAINER_DESC;
|
2020-09-05 16:00:29 +00:00
|
|
|
|
|
|
|
ENUM_TO_WXANY( ZONE_CONNECTION );
|