2012-01-14 19:50:32 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2018-05-02 08:31:10 +00:00
|
|
|
* Copyright (C) 2018 Jean-Pierre Charras, jp.charras at wanadoo.fr
|
2024-01-10 11:28:29 +00:00
|
|
|
* Copyright (C) 1992-2024 KiCad Developers, see AUTHORS.txt for contributors.
|
2012-01-14 19:50:32 +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
|
|
|
|
*/
|
|
|
|
|
2020-11-12 22:30:02 +00:00
|
|
|
#ifndef PAD_H
|
|
|
|
#define PAD_H
|
2011-08-01 15:29:27 +00:00
|
|
|
|
2020-12-28 21:02:06 +00:00
|
|
|
#include <mutex>
|
2023-02-07 22:32:19 +00:00
|
|
|
#include <array>
|
2020-11-12 22:30:02 +00:00
|
|
|
#include <zones.h>
|
2018-02-02 20:57:12 +00:00
|
|
|
#include <board_connected_item.h>
|
2018-12-12 14:28:59 +00:00
|
|
|
#include <geometry/shape_poly_set.h>
|
2020-07-22 23:05:22 +00:00
|
|
|
#include <geometry/shape_compound.h>
|
2024-04-07 22:01:08 +00:00
|
|
|
#include <padstack.h>
|
2022-01-15 01:12:24 +00:00
|
|
|
#include <geometry/eda_angle.h>
|
2023-12-01 17:24:54 +00:00
|
|
|
#include <geometry/geometry_utils.h>
|
2022-10-18 12:00:37 +00:00
|
|
|
#include <core/arraydim.h>
|
2011-09-17 15:31:21 +00:00
|
|
|
|
2020-10-04 23:34:59 +00:00
|
|
|
class PCB_SHAPE;
|
2020-06-22 19:35:09 +00:00
|
|
|
class SHAPE;
|
|
|
|
class SHAPE_SEGMENT;
|
2017-01-13 17:51:22 +00:00
|
|
|
|
2011-09-23 13:57:12 +00:00
|
|
|
class LINE_READER;
|
2011-09-17 15:31:21 +00:00
|
|
|
class EDA_3D_CANVAS;
|
2020-11-13 15:15:52 +00:00
|
|
|
class FOOTPRINT;
|
2011-09-17 15:31:21 +00:00
|
|
|
|
2016-12-02 17:58:12 +00:00
|
|
|
namespace KIGFX
|
|
|
|
{
|
|
|
|
class VIEW;
|
2017-11-02 20:41:29 +00:00
|
|
|
}
|
2011-09-17 15:31:21 +00:00
|
|
|
|
2020-11-12 22:30:02 +00:00
|
|
|
class PAD : public BOARD_CONNECTED_ITEM
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
|
|
|
public:
|
2020-11-13 15:15:52 +00:00
|
|
|
PAD( FOOTPRINT* parent );
|
2012-01-14 19:50:32 +00:00
|
|
|
|
2020-07-24 16:02:56 +00:00
|
|
|
// Copy constructor & operator= are needed because the list of basic shapes
|
|
|
|
// must be duplicated in copy.
|
2020-11-12 22:30:02 +00:00
|
|
|
PAD( const PAD& aPad );
|
|
|
|
PAD& operator=( const PAD &aOther );
|
2012-01-14 19:50:32 +00:00
|
|
|
|
2024-01-20 23:35:29 +00:00
|
|
|
void Serialize( google::protobuf::Any &aContainer ) const override;
|
|
|
|
bool Deserialize( const google::protobuf::Any &aContainer ) override;
|
|
|
|
|
2020-07-03 15:12:28 +00:00
|
|
|
/*
|
|
|
|
* Default layers used for pads, according to the pad type.
|
2021-01-27 22:15:38 +00:00
|
|
|
*
|
|
|
|
* This is default values only, they can be changed for a given pad.
|
2014-06-24 16:17:18 +00:00
|
|
|
*/
|
2021-01-27 22:15:38 +00:00
|
|
|
static LSET PTHMask(); ///< layer set for a through hole pad
|
2014-07-02 13:08:28 +00:00
|
|
|
static LSET SMDMask(); ///< layer set for a SMD pad on Front layer
|
|
|
|
static LSET ConnSMDMask(); ///< layer set for a SMD pad on Front layer
|
|
|
|
///< used for edge board connectors
|
|
|
|
static LSET UnplatedHoleMask(); ///< layer set for a mechanical unplated through hole pad
|
2018-07-24 13:56:20 +00:00
|
|
|
static LSET ApertureMask(); ///< layer set for an aperture pad
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
static inline bool ClassOf( const EDA_ITEM* aItem )
|
2015-02-17 23:53:57 +00:00
|
|
|
{
|
|
|
|
return aItem && PCB_PAD_T == aItem->Type();
|
|
|
|
}
|
|
|
|
|
2022-08-21 19:54:07 +00:00
|
|
|
bool IsType( const std::vector<KICAD_T>& aScanTypes ) const override
|
2020-05-15 23:25:33 +00:00
|
|
|
{
|
|
|
|
if( BOARD_CONNECTED_ITEM::IsType( aScanTypes ) )
|
|
|
|
return true;
|
|
|
|
|
2022-08-20 09:27:35 +00:00
|
|
|
for( KICAD_T scanType : aScanTypes )
|
2020-05-15 23:25:33 +00:00
|
|
|
{
|
2022-08-20 09:27:35 +00:00
|
|
|
if( HasHole() )
|
2020-05-15 23:25:33 +00:00
|
|
|
{
|
2022-08-20 09:27:35 +00:00
|
|
|
if( scanType == PCB_LOCATE_HOLE_T )
|
2020-05-15 23:25:33 +00:00
|
|
|
return true;
|
2022-08-20 09:27:35 +00:00
|
|
|
else if( scanType == PCB_LOCATE_PTH_T && m_attribute != PAD_ATTRIB::NPTH )
|
2020-05-15 23:25:33 +00:00
|
|
|
return true;
|
2022-08-20 09:27:35 +00:00
|
|
|
else if( scanType == PCB_LOCATE_NPTH_T && m_attribute == PAD_ATTRIB::NPTH )
|
2020-05-15 23:25:33 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-07-15 15:14:11 +00:00
|
|
|
bool HasHole() const override
|
|
|
|
{
|
|
|
|
return GetDrillSizeX() > 0 && GetDrillSizeY() > 0;
|
|
|
|
}
|
|
|
|
|
2024-05-27 12:51:02 +00:00
|
|
|
bool HasDrilledHole() const override
|
|
|
|
{
|
|
|
|
return HasHole() && GetDrillSizeX() == GetDrillSizeY();
|
|
|
|
}
|
|
|
|
|
2020-12-15 22:32:02 +00:00
|
|
|
bool IsLocked() const override;
|
|
|
|
|
2017-02-10 19:44:02 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Import the pad settings from \a aMasterPad.
|
|
|
|
*
|
|
|
|
* The result is "this" has the same settings (sizes, shapes ... ) as \a aMasterPad.
|
|
|
|
*
|
|
|
|
* @param aMasterPad the template pad.
|
2017-02-10 19:44:02 +00:00
|
|
|
*/
|
2020-11-12 22:30:02 +00:00
|
|
|
void ImportSettingsFrom( const PAD& aMasterPad );
|
2017-02-10 19:44:02 +00:00
|
|
|
|
2016-04-06 18:15:49 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* @return true if the pad has a footprint parent flipped on the back/bottom layer.
|
2016-04-06 18:15:49 +00:00
|
|
|
*/
|
2017-01-21 20:19:46 +00:00
|
|
|
bool IsFlipped() const;
|
2016-04-06 18:15:49 +00:00
|
|
|
|
2015-11-13 11:32:42 +00:00
|
|
|
/**
|
2021-08-23 23:10:21 +00:00
|
|
|
* Set the pad number (note that it can be alphanumeric, such as the array reference "AA12").
|
2015-11-13 11:32:42 +00:00
|
|
|
*/
|
2021-08-23 23:10:21 +00:00
|
|
|
void SetNumber( const wxString& aNumber ) { m_number = aNumber; }
|
|
|
|
const wxString& GetNumber() const { return m_number; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Indicates whether or not the pad can have a number. (NPTH and SMD aperture pads can not.)
|
|
|
|
*/
|
|
|
|
bool CanHaveNumber() const;
|
2015-11-13 11:32:42 +00:00
|
|
|
|
2019-11-17 09:11:29 +00:00
|
|
|
/**
|
|
|
|
* Set the pad function (pin name in schematic)
|
|
|
|
*/
|
2020-06-22 19:35:09 +00:00
|
|
|
void SetPinFunction( const wxString& aName ) { m_pinFunction = aName; }
|
|
|
|
const wxString& GetPinFunction() const { return m_pinFunction; }
|
2019-11-17 09:11:29 +00:00
|
|
|
|
2021-01-21 21:46:03 +00:00
|
|
|
/**
|
|
|
|
* Set the pad electrical type
|
|
|
|
*/
|
|
|
|
void SetPinType( const wxString& aType ) { m_pinType = aType; }
|
|
|
|
const wxString& GetPinType() const { return m_pinType; }
|
|
|
|
|
2020-09-29 12:07:55 +00:00
|
|
|
/**
|
|
|
|
* Before we had custom pad shapes it was common to have multiple overlapping pads to
|
|
|
|
* represent a more complex shape.
|
|
|
|
*/
|
2023-01-24 11:32:32 +00:00
|
|
|
bool SameLogicalPadAs( const PAD* aOther ) const
|
2011-12-16 17:03:25 +00:00
|
|
|
{
|
2020-09-29 12:07:55 +00:00
|
|
|
// hide tricks behind sensible API
|
2023-01-24 11:32:32 +00:00
|
|
|
return GetParentFootprint() == aOther->GetParentFootprint()
|
|
|
|
&& !m_number.IsEmpty() && m_number == aOther->m_number;
|
2011-12-16 17:03:25 +00:00
|
|
|
}
|
|
|
|
|
2023-01-24 11:32:32 +00:00
|
|
|
/**
|
2023-03-24 13:02:13 +00:00
|
|
|
* @return true if this and \param aOther represent a net-tie.
|
2023-01-24 11:32:32 +00:00
|
|
|
*/
|
|
|
|
bool SharesNetTieGroup( const PAD* aOther ) const;
|
|
|
|
|
2022-09-05 16:23:19 +00:00
|
|
|
/**
|
|
|
|
* @return true if the pad is associated with an "unconnected" pin (or a no-connect symbol)
|
|
|
|
* and has no net.
|
|
|
|
*/
|
|
|
|
bool IsNoConnectPad() const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return true if the pad is associated with a "free" pin (not-internally-connected) and has
|
|
|
|
* not yet been assigned another net (ie: by being routed to).
|
|
|
|
*/
|
|
|
|
bool IsFreePad() const;
|
|
|
|
|
2008-12-14 19:45:05 +00:00
|
|
|
/**
|
2020-06-25 17:16:03 +00:00
|
|
|
* Set the new shape of this pad.
|
|
|
|
*/
|
2021-05-01 12:22:35 +00:00
|
|
|
void SetShape( PAD_SHAPE aShape )
|
2020-06-25 17:16:03 +00:00
|
|
|
{
|
2024-04-08 13:09:20 +00:00
|
|
|
m_padStack.SetShape( aShape );
|
2021-01-08 00:26:32 +00:00
|
|
|
SetDirty();
|
2020-06-25 17:16:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-12-14 19:45:05 +00:00
|
|
|
* @return the shape of this pad.
|
|
|
|
*/
|
2024-04-08 13:09:20 +00:00
|
|
|
PAD_SHAPE GetShape() const { return m_padStack.Shape(); }
|
2008-12-14 19:45:05 +00:00
|
|
|
|
2022-01-01 06:04:08 +00:00
|
|
|
void SetPosition( const VECTOR2I& aPos ) override
|
2020-06-25 17:16:03 +00:00
|
|
|
{
|
2020-07-31 12:37:22 +00:00
|
|
|
m_pos = aPos;
|
2021-01-08 00:26:32 +00:00
|
|
|
SetDirty();
|
2020-06-25 17:16:03 +00:00
|
|
|
}
|
|
|
|
|
2022-01-01 06:04:08 +00:00
|
|
|
VECTOR2I GetPosition() const override { return m_pos; }
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2017-01-13 17:51:22 +00:00
|
|
|
/**
|
|
|
|
* @return the shape of the anchor pad shape, for custom shaped pads.
|
|
|
|
*/
|
2024-04-08 13:09:20 +00:00
|
|
|
PAD_SHAPE GetAnchorPadShape() const
|
|
|
|
{
|
|
|
|
return m_padStack.AnchorShape();
|
|
|
|
}
|
2017-01-13 17:51:22 +00:00
|
|
|
|
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* @return the option for the custom pad shape to use as clearance area in copper zones.
|
2017-01-13 17:51:22 +00:00
|
|
|
*/
|
2024-04-08 13:09:20 +00:00
|
|
|
PADSTACK::CUSTOM_SHAPE_ZONE_MODE GetCustomShapeInZoneOpt() const
|
2017-01-13 17:51:22 +00:00
|
|
|
{
|
2024-04-08 13:09:20 +00:00
|
|
|
return m_padStack.CustomShapeInZoneMode();
|
2017-01-13 17:51:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Set the option for the custom pad shape to use as clearance area in copper zones.
|
|
|
|
*
|
2017-01-13 17:51:22 +00:00
|
|
|
* @param aOption is the clearance area shape CUST_PAD_SHAPE_IN_ZONE option
|
|
|
|
*/
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetCustomShapeInZoneOpt( PADSTACK::CUSTOM_SHAPE_ZONE_MODE aOption )
|
2017-01-13 17:51:22 +00:00
|
|
|
{
|
2024-04-08 13:09:20 +00:00
|
|
|
m_padStack.SetCustomShapeInZoneMode( aOption );
|
2017-01-13 17:51:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Set the shape of the anchor pad for custom shaped pads.
|
|
|
|
*
|
2023-06-02 09:10:48 +00:00
|
|
|
* @param aShape is the shape of the anchor pad shape( currently, only #PAD_SHAPE::RECTANGLE or
|
2021-05-01 12:22:35 +00:00
|
|
|
* #PAD_SHAPE::CIRCLE.
|
2017-01-13 17:51:22 +00:00
|
|
|
*/
|
2021-05-01 12:22:35 +00:00
|
|
|
void SetAnchorPadShape( PAD_SHAPE aShape )
|
2017-01-13 17:51:22 +00:00
|
|
|
{
|
2024-04-08 13:09:20 +00:00
|
|
|
m_padStack.SetAnchorShape( aShape == PAD_SHAPE::RECTANGLE
|
|
|
|
? PAD_SHAPE::RECTANGLE
|
|
|
|
: PAD_SHAPE::CIRCLE );
|
2021-01-08 00:26:32 +00:00
|
|
|
SetDirty();
|
2017-01-13 17:51:22 +00:00
|
|
|
}
|
|
|
|
|
2019-07-25 11:08:41 +00:00
|
|
|
/**
|
|
|
|
* @return true if the pad is on any copper layer, false otherwise.
|
|
|
|
*/
|
2023-04-08 14:02:48 +00:00
|
|
|
bool IsOnCopperLayer() const override;
|
2019-07-25 11:08:41 +00:00
|
|
|
|
2021-01-08 00:26:32 +00:00
|
|
|
void SetY( int y ) { m_pos.y = y; SetDirty(); }
|
|
|
|
void SetX( int x ) { m_pos.x = x; SetDirty(); }
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetSize( const VECTOR2I& aSize )
|
|
|
|
{
|
|
|
|
m_padStack.Size() = aSize;
|
|
|
|
SetDirty();
|
|
|
|
}
|
|
|
|
const VECTOR2I& GetSize() const { return m_padStack.Size(); }
|
|
|
|
|
|
|
|
void SetSizeX( const int aX ) { if( aX > 0 ) { m_padStack.Size().x = aX; SetDirty(); } }
|
|
|
|
int GetSizeX() const { return m_padStack.Size().x; }
|
|
|
|
void SetSizeY( const int aY ) { if( aY > 0 ) { m_padStack.Size().y = aY; SetDirty(); } }
|
|
|
|
int GetSizeY() const { return m_padStack.Size().y; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetDelta( const VECTOR2I& aSize ) { m_padStack.TrapezoidDeltaSize() = aSize; SetDirty(); }
|
|
|
|
const VECTOR2I& GetDelta() const { return m_padStack.TrapezoidDeltaSize(); }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetDrillSize( const VECTOR2I& aSize ) { m_padStack.Drill().size = aSize; SetDirty(); }
|
|
|
|
const VECTOR2I& GetDrillSize() const { return m_padStack.Drill().size; }
|
|
|
|
void SetDrillSizeX( const int aX ) { m_padStack.Drill().size.x = aX; SetDirty(); }
|
|
|
|
int GetDrillSizeX() const { return m_padStack.Drill().size.x; }
|
|
|
|
void SetDrillSizeY( const int aY ) { m_padStack.Drill().size.y = aY; SetDirty(); }
|
|
|
|
int GetDrillSizeY() const { return m_padStack.Drill().size.y; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetOffset( const VECTOR2I& aOffset ) { m_padStack.Offset() = aOffset; SetDirty(); }
|
|
|
|
const VECTOR2I& GetOffset() const { return m_padStack.Offset(); }
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2022-01-01 06:04:08 +00:00
|
|
|
VECTOR2I GetCenter() const override { return GetPosition(); }
|
2020-10-06 16:38:24 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
const PADSTACK& Padstack() const { return m_padStack; }
|
|
|
|
PADSTACK& Padstack() { return m_padStack; }
|
|
|
|
void SetPadstack( const PADSTACK& aPadstack ) { m_padStack = aPadstack; }
|
|
|
|
|
2017-01-13 17:51:22 +00:00
|
|
|
/**
|
2020-07-03 15:12:28 +00:00
|
|
|
* Has meaning only for custom shape pads.
|
2017-01-13 17:51:22 +00:00
|
|
|
* add a free shape to the shape list.
|
|
|
|
* the shape can be
|
2021-01-27 22:15:38 +00:00
|
|
|
* - a polygon (outline can have a thickness)
|
|
|
|
* - a thick segment
|
|
|
|
* - a filled circle (thickness == 0) or ring
|
|
|
|
* - a filled rect (thickness == 0) or rectangular outline
|
|
|
|
* - a arc
|
|
|
|
* - a bezier curve
|
2017-01-13 17:51:22 +00:00
|
|
|
*/
|
2020-11-14 01:16:02 +00:00
|
|
|
void AddPrimitivePoly( const SHAPE_POLY_SET& aPoly, int aThickness, bool aFilled );
|
2022-01-01 06:04:08 +00:00
|
|
|
void AddPrimitivePoly( const std::vector<VECTOR2I>& aPoly, int aThickness, bool aFilled );
|
2017-10-19 21:16:06 +00:00
|
|
|
|
2017-01-13 17:51:22 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Merge all basic shapes to a #SHAPE_POLY_SET.
|
|
|
|
*
|
|
|
|
* @note The results are relative to the pad position, orientation 0.
|
2021-04-18 16:54:36 +00:00
|
|
|
*
|
|
|
|
* @param aMergedPolygon will store the final polygon
|
|
|
|
* @param aErrorLoc is used when a circle (or arc) is approximated by segments
|
|
|
|
* = ERROR_INSIDE to build a polygon inside the arc/circle (usual shape to raw/plot)
|
|
|
|
* = ERROR_OUIDE to build a polygon outside the arc/circle
|
|
|
|
* (for instance when building a clearance area)
|
2017-01-13 17:51:22 +00:00
|
|
|
*/
|
2021-08-23 11:29:38 +00:00
|
|
|
void MergePrimitivesAsPolygon( SHAPE_POLY_SET* aMergedPolygon,
|
2021-04-18 16:54:36 +00:00
|
|
|
ERROR_LOC aErrorLoc = ERROR_INSIDE ) const;
|
2017-01-13 17:51:22 +00:00
|
|
|
|
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Clear the basic shapes list.
|
2017-01-13 17:51:22 +00:00
|
|
|
*/
|
2017-09-20 08:28:52 +00:00
|
|
|
void DeletePrimitivesList();
|
2017-01-13 17:51:22 +00:00
|
|
|
|
|
|
|
/**
|
2020-09-07 21:20:55 +00:00
|
|
|
* Accessor to the basic shape list for custom-shaped pads.
|
2017-01-13 17:51:22 +00:00
|
|
|
*/
|
2020-10-04 23:34:59 +00:00
|
|
|
const std::vector<std::shared_ptr<PCB_SHAPE>>& GetPrimitives() const
|
2020-06-24 11:12:39 +00:00
|
|
|
{
|
|
|
|
return m_editPrimitives;
|
|
|
|
}
|
2017-01-13 17:51:22 +00:00
|
|
|
|
2022-01-01 06:04:08 +00:00
|
|
|
void Flip( const VECTOR2I& VECTOR2I, bool aFlipLeftRight ) override;
|
2011-12-02 21:56:47 +00:00
|
|
|
|
2017-01-13 17:51:22 +00:00
|
|
|
/**
|
2020-07-25 15:41:36 +00:00
|
|
|
* Flip (mirror) the primitives left to right or top to bottom, around the anchor position
|
2021-01-27 22:15:38 +00:00
|
|
|
* in custom pads.
|
2017-01-13 17:51:22 +00:00
|
|
|
*/
|
2020-07-25 15:41:36 +00:00
|
|
|
void FlipPrimitives( bool aFlipLeftRight );
|
2019-01-17 04:55:40 +00:00
|
|
|
|
2017-01-13 17:51:22 +00:00
|
|
|
/**
|
2020-09-07 21:20:55 +00:00
|
|
|
* Clear the current custom shape primitives list and import a new list. Copies the input,
|
|
|
|
* which is not altered.
|
2017-01-13 17:51:22 +00:00
|
|
|
*/
|
2020-10-04 23:34:59 +00:00
|
|
|
void ReplacePrimitives( const std::vector<std::shared_ptr<PCB_SHAPE>>& aPrimitivesList );
|
2017-01-13 17:51:22 +00:00
|
|
|
|
2018-03-06 13:58:25 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Import a custom shape primitive list (composed of basic shapes) and add items to the
|
2020-09-07 21:20:55 +00:00
|
|
|
* current list. Copies the input, which is not altered.
|
2020-07-24 16:02:56 +00:00
|
|
|
*/
|
2020-10-04 23:34:59 +00:00
|
|
|
void AppendPrimitives( const std::vector<std::shared_ptr<PCB_SHAPE>>& aPrimitivesList );
|
2020-07-24 16:02:56 +00:00
|
|
|
|
|
|
|
/**
|
2020-09-07 21:20:55 +00:00
|
|
|
* Add item to the custom shape primitives list
|
2018-03-06 13:58:25 +00:00
|
|
|
*/
|
2020-10-04 23:34:59 +00:00
|
|
|
void AddPrimitive( PCB_SHAPE* aPrimitive );
|
2016-04-06 18:15:49 +00:00
|
|
|
|
2011-12-02 21:56:47 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Set the rotation angle of the pad.
|
|
|
|
*
|
2022-01-13 13:45:48 +00:00
|
|
|
* If \a aAngle is outside of 0 - 360, then it will be normalized.
|
2011-12-02 21:56:47 +00:00
|
|
|
*/
|
2022-01-13 13:45:48 +00:00
|
|
|
void SetOrientation( const EDA_ANGLE& aAngle );
|
2023-04-03 12:17:52 +00:00
|
|
|
void SetFPRelativeOrientation( const EDA_ANGLE& aAngle );
|
2016-05-02 10:49:14 +00:00
|
|
|
|
2011-12-02 21:56:47 +00:00
|
|
|
/**
|
2022-01-13 13:45:48 +00:00
|
|
|
* Return the rotation angle of the pad.
|
2011-12-02 21:56:47 +00:00
|
|
|
*/
|
2024-06-01 20:31:50 +00:00
|
|
|
EDA_ANGLE GetOrientation() const { return m_padStack.GetOrientation(); }
|
2024-05-05 16:32:07 +00:00
|
|
|
EDA_ANGLE GetFPRelativeOrientation() const;
|
2022-01-13 13:45:48 +00:00
|
|
|
|
|
|
|
// For property system
|
|
|
|
void SetOrientationDegrees( double aOrientation )
|
|
|
|
{
|
|
|
|
SetOrientation( EDA_ANGLE( aOrientation, DEGREES_T ) );
|
|
|
|
}
|
|
|
|
double GetOrientationDegrees() const
|
|
|
|
{
|
2024-06-01 20:31:50 +00:00
|
|
|
return m_padStack.GetOrientation().AsDegrees();
|
2022-01-13 13:45:48 +00:00
|
|
|
}
|
2011-12-02 21:56:47 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetDrillShape( PAD_DRILL_SHAPE aShape )
|
|
|
|
{
|
|
|
|
m_padStack.Drill().shape = aShape;
|
|
|
|
m_shapesDirty = true;
|
|
|
|
}
|
|
|
|
PAD_DRILL_SHAPE GetDrillShape() const { return m_padStack.Drill().shape; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2021-01-08 00:26:32 +00:00
|
|
|
bool IsDirty() const
|
|
|
|
{
|
2023-10-13 11:25:52 +00:00
|
|
|
return m_shapesDirty || m_polyDirty[ERROR_INSIDE] || m_polyDirty[ERROR_OUTSIDE];
|
2021-01-08 00:26:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SetDirty()
|
|
|
|
{
|
|
|
|
m_shapesDirty = true;
|
2023-10-13 11:25:52 +00:00
|
|
|
m_polyDirty[ERROR_INSIDE] = true;
|
|
|
|
m_polyDirty[ERROR_OUTSIDE] = true;
|
2021-01-08 00:26:32 +00:00
|
|
|
}
|
2020-06-28 18:00:40 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetLayerSet( LSET aLayers ) override { m_padStack.SetLayerSet( aLayers ); }
|
|
|
|
LSET GetLayerSet() const override { return m_padStack.LayerSet(); }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2021-05-01 14:46:50 +00:00
|
|
|
void SetAttribute( PAD_ATTRIB aAttribute );
|
|
|
|
PAD_ATTRIB GetAttribute() const { return m_attribute; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2021-05-01 14:58:30 +00:00
|
|
|
void SetProperty( PAD_PROP aProperty );
|
2024-01-10 11:28:29 +00:00
|
|
|
PAD_PROP GetProperty() const { return m_property; }
|
2019-12-11 10:36:45 +00:00
|
|
|
|
2018-07-24 13:56:20 +00:00
|
|
|
// We don't currently have an attribute for APERTURE, and adding one will change the file
|
|
|
|
// format, so for now just infer a copper-less pad to be an APERTURE pad.
|
2021-01-27 22:15:38 +00:00
|
|
|
bool IsAperturePad() const
|
|
|
|
{
|
2024-04-08 13:09:20 +00:00
|
|
|
return ( m_padStack.LayerSet() & LSET::AllCuMask() ).none();
|
2021-01-27 22:15:38 +00:00
|
|
|
}
|
2018-07-24 13:56:20 +00:00
|
|
|
|
2020-07-31 12:37:22 +00:00
|
|
|
void SetPadToDieLength( int aLength ) { m_lengthPadToDie = aLength; }
|
|
|
|
int GetPadToDieLength() const { return m_lengthPadToDie; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
std::optional<int> GetLocalClearance() const override { return m_padStack.Clearance(); }
|
|
|
|
void SetLocalClearance( std::optional<int> aClearance ) { m_padStack.Clearance() = aClearance; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
std::optional<int> GetLocalSolderMaskMargin() const { return m_padStack.SolderMaskMargin(); }
|
|
|
|
void SetLocalSolderMaskMargin( std::optional<int> aMargin )
|
|
|
|
{
|
|
|
|
m_padStack.SolderMaskMargin() = aMargin;
|
|
|
|
}
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
std::optional<int> GetLocalSolderPasteMargin() const { return m_padStack.SolderPasteMargin(); }
|
|
|
|
void SetLocalSolderPasteMargin( std::optional<int> aMargin )
|
|
|
|
{
|
|
|
|
m_padStack.SolderPasteMargin() = aMargin;
|
|
|
|
}
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
std::optional<double> GetLocalSolderPasteMarginRatio() const
|
|
|
|
{
|
|
|
|
return m_padStack.SolderPasteMarginRatio();
|
|
|
|
}
|
|
|
|
void SetLocalSolderPasteMarginRatio( std::optional<double> aRatio )
|
|
|
|
{
|
|
|
|
m_padStack.SolderPasteMarginRatio() = aRatio;
|
|
|
|
}
|
2011-12-01 06:04:23 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetLocalZoneConnection( ZONE_CONNECTION aType ) { m_padStack.ZoneConnection() = aType; }
|
|
|
|
ZONE_CONNECTION GetLocalZoneConnection() const
|
|
|
|
{
|
|
|
|
return m_padStack.ZoneConnection().value_or( ZONE_CONNECTION::INHERITED );
|
|
|
|
}
|
2024-01-10 11:28:29 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the pad's "own" clearance in internal units.
|
|
|
|
*
|
|
|
|
* @param aLayer the layer in question.
|
|
|
|
* @param aSource [out] optionally reports the source as a user-readable string.
|
|
|
|
* @return the clearance in internal units.
|
|
|
|
*/
|
2022-04-03 22:51:03 +00:00
|
|
|
int GetOwnClearance( PCB_LAYER_ID aLayer, wxString* aSource = nullptr ) const override;
|
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
2020-06-22 19:35:09 +00:00
|
|
|
* Convert the pad shape to a closed polygon. Circles and arcs are approximated by segments.
|
2021-01-27 22:15:38 +00:00
|
|
|
*
|
2022-10-21 12:48:45 +00:00
|
|
|
* @param aBuffer a buffer to store the polygon.
|
|
|
|
* @param aClearance the clearance around the pad.
|
2021-01-27 22:15:38 +00:00
|
|
|
* @param aMaxError maximum error from true when converting arcs.
|
|
|
|
* @param aErrorLoc should the approximation error be placed outside or inside the polygon?
|
|
|
|
* @param ignoreLineWidth used for edge cuts where the line width is only for visualization.
|
2018-11-14 23:34:32 +00:00
|
|
|
*/
|
2022-10-21 12:48:45 +00:00
|
|
|
void TransformShapeToPolygon( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer, int aClearance,
|
2023-12-01 17:24:54 +00:00
|
|
|
int aMaxError, ERROR_LOC aErrorLoc = ERROR_INSIDE,
|
2022-10-21 12:48:45 +00:00
|
|
|
bool ignoreLineWidth = false ) const override;
|
2020-06-22 19:35:09 +00:00
|
|
|
|
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Build the corner list of the polygonal drill shape in the board coordinate system.
|
|
|
|
*
|
2022-10-21 12:48:45 +00:00
|
|
|
* @param aBuffer a buffer to fill.
|
|
|
|
* @param aClearance the clearance or margin value.
|
2021-01-27 22:15:38 +00:00
|
|
|
* @param aError maximum deviation of an arc from the polygon approximation.
|
2020-10-13 10:55:24 +00:00
|
|
|
* @param aErrorLoc = should the approximation error be placed outside or inside the polygon?
|
2021-01-27 22:15:38 +00:00
|
|
|
* @return false if the pad has no hole, true otherwise.
|
2020-06-22 19:35:09 +00:00
|
|
|
*/
|
2022-10-21 12:48:45 +00:00
|
|
|
bool TransformHoleToPolygon( SHAPE_POLY_SET& aBuffer, int aClearance, int aError,
|
2023-12-01 17:24:54 +00:00
|
|
|
ERROR_LOC aErrorLoc = ERROR_INSIDE ) const;
|
2020-06-22 19:35:09 +00:00
|
|
|
|
2022-10-13 11:22:57 +00:00
|
|
|
/**
|
|
|
|
* Some pad shapes can be complex (rounded/chamfered rectangle), even without considering
|
|
|
|
* custom shapes. This routine returns a COMPOUND shape (set of simple shapes which make
|
|
|
|
* up the pad for use with routing, collision determination, etc).
|
|
|
|
*
|
|
|
|
* @note This list can contain a SHAPE_SIMPLE (a simple single-outline non-intersecting
|
|
|
|
* polygon), but should never contain a SHAPE_POLY_SET (a complex polygon consisting of
|
|
|
|
* multiple outlines and/or holes).
|
|
|
|
*
|
|
|
|
* @param aLayer optional parameter allowing a caller to specify a particular layer (default
|
|
|
|
* is to return the pad's "natural" shape).
|
|
|
|
* @param aFlash optional parameter allowing a caller to force the pad to be flashed (or not
|
|
|
|
* flashed) on the current layer (default is to honour the pad's setting and
|
|
|
|
* the current connections for the given layer).
|
|
|
|
*/
|
2022-08-29 11:33:31 +00:00
|
|
|
virtual std::shared_ptr<SHAPE>
|
|
|
|
GetEffectiveShape( PCB_LAYER_ID aLayer = UNDEFINED_LAYER,
|
|
|
|
FLASHING flashPTHPads = FLASHING::DEFAULT ) const override;
|
2020-06-22 19:35:09 +00:00
|
|
|
|
2023-12-01 17:24:54 +00:00
|
|
|
const std::shared_ptr<SHAPE_POLY_SET>& GetEffectivePolygon( ERROR_LOC aErrorLoc = ERROR_INSIDE ) const;
|
2020-07-25 11:58:17 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
/**
|
2022-07-22 22:05:25 +00:00
|
|
|
* Return a SHAPE_SEGMENT object representing the pad's hole.
|
2020-06-22 19:35:09 +00:00
|
|
|
*/
|
2022-07-22 22:05:25 +00:00
|
|
|
std::shared_ptr<SHAPE_SEGMENT> GetEffectiveHoleShape() const override;
|
2020-06-22 19:35:09 +00:00
|
|
|
|
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Return the radius of a minimum sized circle which fully encloses this pad.
|
|
|
|
*
|
2020-06-22 19:35:09 +00:00
|
|
|
* The center is the pad position NOT THE SHAPE POS!
|
|
|
|
*/
|
|
|
|
int GetBoundingRadius() const;
|
2009-03-23 19:54:15 +00:00
|
|
|
|
2018-11-14 23:34:32 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Return any local clearance overrides set in the "classic" (ie: pre-rule) system.
|
|
|
|
*
|
|
|
|
* @param aSource [out] optionally reports the source as a user-readable string.
|
|
|
|
* @return the clearance in internal units.
|
2009-11-05 20:59:42 +00:00
|
|
|
*/
|
2024-01-10 11:28:29 +00:00
|
|
|
std::optional<int> GetLocalClearance( wxString* aSource ) const override;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return any clearance overrides set in the "classic" (ie: pre-rule) system.
|
|
|
|
*
|
|
|
|
* @param aSource [out] optionally reports the source as a user-readable string.
|
|
|
|
* @return the clearance in internal units.
|
|
|
|
*/
|
|
|
|
std::optional<int> GetClearanceOverrides( wxString* aSource ) const override;
|
2009-11-05 20:59:42 +00:00
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
2021-08-22 22:05:47 +00:00
|
|
|
* @return the expansion for the solder mask layer
|
2021-01-27 22:15:38 +00:00
|
|
|
*
|
|
|
|
* Usually > 0 (mask shape bigger than pad). For pads **not** on copper layers, the value
|
|
|
|
* is the local value because there is no default shape to build. For pads also on copper
|
|
|
|
* layers, the value (used to build a default shape) is:
|
|
|
|
* 1 the local value
|
|
|
|
* 2 if 0, the parent footprint value
|
|
|
|
* 3 if 0, the global value
|
2009-11-04 19:08:08 +00:00
|
|
|
*/
|
2021-08-22 22:05:47 +00:00
|
|
|
int GetSolderMaskExpansion() const;
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Usually < 0 (mask shape smaller than pad)because the margin can be dependent on the pad
|
|
|
|
* size, the margin has a x and a y value. For pads **not** on copper layers, the value is
|
|
|
|
* the local value because there is no default shape to build. For pads also on copper
|
|
|
|
* layers, the value (used to build a default shape) is:
|
|
|
|
* 1 the local value
|
|
|
|
* 2 if 0, the parent footprint value
|
|
|
|
* 3 if 0, the global value
|
2018-05-02 08:31:10 +00:00
|
|
|
*
|
2021-01-27 22:15:38 +00:00
|
|
|
* @return the margin for the solder mask layer.
|
2018-05-02 08:31:10 +00:00
|
|
|
*/
|
2022-01-05 01:42:27 +00:00
|
|
|
VECTOR2I GetSolderPasteMargin() const;
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2024-01-10 11:28:29 +00:00
|
|
|
ZONE_CONNECTION GetZoneConnectionOverrides( wxString* aSource = nullptr ) const;
|
2012-02-24 23:23:46 +00:00
|
|
|
|
2020-07-03 15:12:28 +00:00
|
|
|
/**
|
|
|
|
* Set the width of the thermal spokes connecting the pad to a zone. If != 0 this will
|
|
|
|
* override similar settings in the parent footprint and zone.
|
|
|
|
*/
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetThermalSpokeWidth( int aWidth ) { m_padStack.ThermalSpokeWidth() = aWidth; }
|
|
|
|
int GetThermalSpokeWidth() const { return m_padStack.ThermalSpokeWidth().value_or( 0 ); }
|
2021-08-08 13:37:14 +00:00
|
|
|
|
|
|
|
int GetLocalSpokeWidthOverride( wxString* aSource = nullptr ) const;
|
2020-09-10 18:35:11 +00:00
|
|
|
|
|
|
|
/**
|
2022-01-13 13:45:48 +00:00
|
|
|
* The orientation of the thermal spokes. 45° will produce an X (the default for circular
|
|
|
|
* pads and circular-anchored custom shaped pads), while 90° will produce a + (the default
|
|
|
|
* for all other shapes).
|
2020-09-10 18:35:11 +00:00
|
|
|
*/
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetThermalSpokeAngle( const EDA_ANGLE& aAngle )
|
|
|
|
{
|
|
|
|
m_padStack.SetThermalSpokeAngle( aAngle );
|
|
|
|
}
|
|
|
|
EDA_ANGLE GetThermalSpokeAngle() const
|
|
|
|
{
|
|
|
|
return m_padStack.ThermalSpokeAngle();
|
|
|
|
}
|
2022-01-13 13:45:48 +00:00
|
|
|
|
|
|
|
// For property system
|
|
|
|
void SetThermalSpokeAngleDegrees( double aAngle )
|
|
|
|
{
|
2024-05-15 03:13:31 +00:00
|
|
|
m_padStack.SetThermalSpokeAngle( EDA_ANGLE( aAngle, DEGREES_T ) );
|
2022-01-13 13:45:48 +00:00
|
|
|
}
|
|
|
|
double GetThermalSpokeAngleDegrees() const
|
|
|
|
{
|
2024-04-08 13:09:20 +00:00
|
|
|
return m_padStack.ThermalSpokeAngle().AsDegrees();
|
2022-01-13 13:45:48 +00:00
|
|
|
}
|
2012-03-08 20:44:03 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetThermalGap( int aGap ) { m_padStack.ThermalGap() = aGap; }
|
|
|
|
int GetThermalGap() const { return m_padStack.ThermalGap().value_or( 0 ); }
|
2020-09-10 18:35:11 +00:00
|
|
|
|
2021-08-08 13:37:14 +00:00
|
|
|
int GetLocalThermalGapOverride( wxString* aSource = nullptr ) const;
|
2012-03-08 20:44:03 +00:00
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Has meaning only for rounded rectangle pads.
|
|
|
|
*
|
2016-04-06 18:15:49 +00:00
|
|
|
* @return The radius of the rounded corners for this pad.
|
|
|
|
*/
|
2018-09-09 19:19:21 +00:00
|
|
|
void SetRoundRectCornerRadius( double aRadius );
|
2020-06-22 19:35:09 +00:00
|
|
|
int GetRoundRectCornerRadius() const;
|
2010-12-10 19:47:44 +00:00
|
|
|
|
2022-01-01 06:04:08 +00:00
|
|
|
VECTOR2I ShapePos() const;
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2016-04-06 18:15:49 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Has meaning only for rounded rectangle pads.
|
|
|
|
*
|
2020-07-03 15:12:28 +00:00
|
|
|
* Set the ratio between the smaller X or Y size and the rounded corner radius.
|
|
|
|
* Cannot be > 0.5; the normalized IPC-7351C value is 0.25
|
2016-04-06 18:15:49 +00:00
|
|
|
*/
|
2020-06-22 19:35:09 +00:00
|
|
|
void SetRoundRectRadiusRatio( double aRadiusScale );
|
2024-04-08 13:09:20 +00:00
|
|
|
double GetRoundRectRadiusRatio() const { return m_padStack.RoundRectRadiusRatio(); }
|
2018-08-29 07:13:07 +00:00
|
|
|
|
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Has meaning only for chamfered rectangular pads.
|
|
|
|
*
|
2020-07-03 15:12:28 +00:00
|
|
|
* Set the ratio between the smaller X or Y size and chamfered corner size.
|
|
|
|
* Cannot be < 0.5.
|
2018-08-29 07:13:07 +00:00
|
|
|
*/
|
2020-06-22 19:35:09 +00:00
|
|
|
void SetChamferRectRatio( double aChamferScale );
|
2024-04-08 13:09:20 +00:00
|
|
|
double GetChamferRectRatio() const { return m_padStack.ChamferRatio(); }
|
2018-08-29 07:13:07 +00:00
|
|
|
|
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Has meaning only for chamfered rectangular pads.
|
|
|
|
*
|
|
|
|
* Set the position of the chamfers for orientation 0.
|
|
|
|
*
|
|
|
|
* @param aPositions a bit-set of #RECT_CHAMFER_POSITIONS.
|
2018-08-29 07:13:07 +00:00
|
|
|
*/
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetChamferPositions( int aPositions ) { m_padStack.SetChamferPositions( aPositions ); }
|
|
|
|
int GetChamferPositions() const { return m_padStack.ChamferPositions(); }
|
2018-08-29 07:13:07 +00:00
|
|
|
|
2007-10-13 06:18:44 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* @return the netcode.
|
2007-10-13 06:18:44 +00:00
|
|
|
*/
|
2020-07-31 12:37:22 +00:00
|
|
|
int GetSubRatsnest() const { return m_subRatsnest; }
|
|
|
|
void SetSubRatsnest( int aSubRatsnest ) { m_subRatsnest = aSubRatsnest; }
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2020-07-27 19:41:50 +00:00
|
|
|
/**
|
2024-04-08 13:09:20 +00:00
|
|
|
* @deprecated - use Padstack().SetUnconnectedLayerMode()
|
|
|
|
* Sets the unconnected removal property. If true, the copper is removed on zone fill
|
|
|
|
* or when specifically requested when the via is not connected on a layer.
|
2020-07-27 19:41:50 +00:00
|
|
|
*/
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetRemoveUnconnected( bool aSet )
|
|
|
|
{
|
|
|
|
m_padStack.SetUnconnectedLayerMode( aSet
|
|
|
|
? PADSTACK::UNCONNECTED_LAYER_MODE::REMOVE_ALL
|
|
|
|
: PADSTACK::UNCONNECTED_LAYER_MODE::KEEP_ALL );
|
|
|
|
}
|
|
|
|
|
|
|
|
bool GetRemoveUnconnected() const
|
|
|
|
{
|
|
|
|
return m_padStack.UnconnectedLayerMode() != PADSTACK::UNCONNECTED_LAYER_MODE::KEEP_ALL;
|
|
|
|
}
|
2020-07-27 19:41:50 +00:00
|
|
|
|
|
|
|
/**
|
2024-04-08 13:09:20 +00:00
|
|
|
* @deprecated - use Padstack().SetUnconnectedLayerMode()
|
|
|
|
* Sets whether we keep the start and end annular rings even if they are not connected
|
2020-07-27 19:41:50 +00:00
|
|
|
*/
|
2024-04-08 13:09:20 +00:00
|
|
|
void SetKeepTopBottom( bool aSet )
|
|
|
|
{
|
|
|
|
m_padStack.SetUnconnectedLayerMode( aSet
|
|
|
|
? PADSTACK::UNCONNECTED_LAYER_MODE::REMOVE_EXCEPT_START_AND_END
|
|
|
|
: PADSTACK::UNCONNECTED_LAYER_MODE::REMOVE_ALL );
|
|
|
|
}
|
|
|
|
|
|
|
|
bool GetKeepTopBottom() const
|
|
|
|
{
|
|
|
|
return m_padStack.UnconnectedLayerMode()
|
|
|
|
== PADSTACK::UNCONNECTED_LAYER_MODE::REMOVE_EXCEPT_START_AND_END;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetUnconnectedLayerMode( PADSTACK::UNCONNECTED_LAYER_MODE aMode )
|
|
|
|
{
|
|
|
|
m_padStack.SetUnconnectedLayerMode( aMode );
|
|
|
|
}
|
|
|
|
|
|
|
|
PADSTACK::UNCONNECTED_LAYER_MODE GetUnconnectedLayerMode() const
|
|
|
|
{
|
|
|
|
return m_padStack.UnconnectedLayerMode();
|
|
|
|
}
|
2020-07-27 19:41:50 +00:00
|
|
|
|
2022-11-22 18:18:07 +00:00
|
|
|
bool ConditionallyFlashed( PCB_LAYER_ID aLayer ) const
|
|
|
|
{
|
2024-04-08 13:09:20 +00:00
|
|
|
switch( m_padStack.UnconnectedLayerMode() )
|
|
|
|
{
|
|
|
|
case PADSTACK::UNCONNECTED_LAYER_MODE::KEEP_ALL:
|
2022-11-22 18:18:07 +00:00
|
|
|
return false;
|
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
case PADSTACK::UNCONNECTED_LAYER_MODE::REMOVE_ALL:
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case PADSTACK::UNCONNECTED_LAYER_MODE::REMOVE_EXCEPT_START_AND_END:
|
|
|
|
{
|
|
|
|
if( aLayer == m_padStack.Drill().start || aLayer == m_padStack.Drill().end )
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2022-11-22 18:18:07 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-04-24 13:36:10 +00:00
|
|
|
void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) override;
|
2007-08-30 08:15:05 +00:00
|
|
|
|
2023-08-01 17:37:19 +00:00
|
|
|
bool IsOnLayer( PCB_LAYER_ID aLayer ) const override
|
2014-06-24 16:17:18 +00:00
|
|
|
{
|
2024-04-08 13:09:20 +00:00
|
|
|
return m_padStack.LayerSet().test( aLayer );
|
2014-06-24 16:17:18 +00:00
|
|
|
}
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2020-12-31 01:36:44 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Check to see whether the pad should be flashed on the specific layer.
|
|
|
|
*
|
2020-12-31 01:36:44 +00:00
|
|
|
* @param aLayer Layer to check for connectivity
|
2023-01-07 15:20:12 +00:00
|
|
|
* @param aOnlyCheckIfPermitted indicates that the routine should just return whether or not
|
|
|
|
* a flashed connection is permitted on this layer (without checking for a connection)
|
2020-12-31 01:36:44 +00:00
|
|
|
* @return true if connected by pad or track (or optionally zone)
|
|
|
|
*/
|
2023-01-07 15:20:12 +00:00
|
|
|
bool FlashLayer( int aLayer, bool aOnlyCheckIfPermitted = false ) const;
|
|
|
|
|
|
|
|
bool CanFlashLayer( int aLayer )
|
|
|
|
{
|
|
|
|
return FlashLayer( aLayer, true );
|
|
|
|
}
|
2020-12-31 01:36:44 +00:00
|
|
|
|
2022-02-18 10:12:11 +00:00
|
|
|
PCB_LAYER_ID GetLayer() const override;
|
|
|
|
|
2022-02-18 14:19:13 +00:00
|
|
|
/**
|
|
|
|
* @return the principal copper layer for SMD and CONN pads.
|
|
|
|
*/
|
|
|
|
PCB_LAYER_ID GetPrincipalLayer() const;
|
|
|
|
|
2020-12-31 01:36:44 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Check to see if the pad should be flashed to any of the layers in the set.
|
|
|
|
*
|
2020-12-31 01:36:44 +00:00
|
|
|
* @param aLayers set of layers to check the via against
|
2021-01-27 22:15:38 +00:00
|
|
|
* @return true if connected by pad or track (or optionally zone) on any of the associated
|
|
|
|
* layers
|
2020-12-31 01:36:44 +00:00
|
|
|
*/
|
2021-01-28 21:21:22 +00:00
|
|
|
bool FlashLayer( LSET aLayers ) const;
|
2020-07-27 19:41:50 +00:00
|
|
|
|
2022-01-01 06:04:08 +00:00
|
|
|
bool HitTest( const VECTOR2I& aPosition, int aAccuracy = 0 ) const override;
|
2022-08-31 09:33:46 +00:00
|
|
|
bool HitTest( const BOX2I& aRect, bool aContained, int aAccuracy = 0 ) const override;
|
2017-04-22 06:49:15 +00:00
|
|
|
|
2016-09-24 18:53:15 +00:00
|
|
|
wxString GetClass() const override
|
2007-08-07 06:21:19 +00:00
|
|
|
{
|
|
|
|
return wxT( "PAD" );
|
|
|
|
}
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2020-07-03 15:12:28 +00:00
|
|
|
/**
|
|
|
|
* The bounding box is cached, so this will be efficient most of the time.
|
|
|
|
*/
|
2022-08-31 09:15:42 +00:00
|
|
|
const BOX2I GetBoundingBox() const override;
|
2008-04-18 13:28:56 +00:00
|
|
|
|
2008-01-24 21:50:12 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Compare two pads and return 0 if they are equal.
|
|
|
|
*
|
|
|
|
* @return less than 0 if left less than right, 0 if equal, or greater than 0 if left
|
|
|
|
* greater than right.
|
2008-01-24 21:50:12 +00:00
|
|
|
*/
|
2021-11-24 17:52:17 +00:00
|
|
|
static int Compare( const PAD* aPadRef, const PAD* aPadCmp );
|
2008-01-24 21:50:12 +00:00
|
|
|
|
2022-01-01 06:04:08 +00:00
|
|
|
void Move( const VECTOR2I& aMoveVector ) override
|
2009-08-01 19:26:05 +00:00
|
|
|
{
|
2020-07-31 12:37:22 +00:00
|
|
|
m_pos += aMoveVector;
|
2021-01-08 00:26:32 +00:00
|
|
|
SetDirty();
|
2009-08-01 19:26:05 +00:00
|
|
|
}
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2022-01-13 19:32:00 +00:00
|
|
|
void Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle ) override;
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2023-01-12 03:27:44 +00:00
|
|
|
wxString GetItemDescription( UNITS_PROVIDER* aUnitsProvider ) const override;
|
2011-07-14 15:42:44 +00:00
|
|
|
|
2021-03-08 02:59:07 +00:00
|
|
|
BITMAPS GetMenuImage() const override;
|
2011-08-01 15:29:27 +00:00
|
|
|
|
2011-07-14 19:41:20 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* @return the GUI-appropriate name of the shape.
|
2011-07-14 19:41:20 +00:00
|
|
|
*/
|
|
|
|
wxString ShowPadShape() const;
|
|
|
|
|
|
|
|
/**
|
2020-07-03 15:12:28 +00:00
|
|
|
* @return the GUI-appropriate description of the pad type (attribute) : Std, SMD ...
|
2011-07-14 19:41:20 +00:00
|
|
|
*/
|
|
|
|
wxString ShowPadAttr() const;
|
|
|
|
|
2016-09-24 18:53:15 +00:00
|
|
|
EDA_ITEM* Clone() const override;
|
2012-03-17 14:39:27 +00:00
|
|
|
|
2014-07-02 13:08:28 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Same as Clone, but returns a PAD item.
|
|
|
|
*
|
2020-02-20 12:11:04 +00:00
|
|
|
* Useful mainly for python scripts, because Clone returns an EDA_ITEM.
|
2014-07-02 13:08:28 +00:00
|
|
|
*/
|
2020-11-12 22:30:02 +00:00
|
|
|
PAD* ClonePad() const
|
2014-07-02 13:08:28 +00:00
|
|
|
{
|
2020-11-12 22:30:02 +00:00
|
|
|
return (PAD*) Clone();
|
2014-07-02 13:08:28 +00:00
|
|
|
}
|
|
|
|
|
2020-06-28 18:00:40 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Rebuild the effective shape cache (and bounding box and radius) for the pad and clears
|
2020-07-03 15:12:28 +00:00
|
|
|
* the dirty bit.
|
2020-06-28 18:00:40 +00:00
|
|
|
*/
|
2020-08-12 21:18:13 +00:00
|
|
|
void BuildEffectiveShapes( PCB_LAYER_ID aLayer ) const;
|
2023-12-01 17:24:54 +00:00
|
|
|
void BuildEffectivePolygon( ERROR_LOC aErrorLoc = ERROR_INSIDE ) const;
|
2020-06-28 18:00:40 +00:00
|
|
|
|
2016-09-24 18:53:15 +00:00
|
|
|
virtual void ViewGetLayers( int aLayers[], int& aCount ) const override;
|
Introduction of Graphics Abstraction Layer based rendering for pcbnew.
New classes:
- VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.)
- VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes).
- EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL).
- GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries.
- WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc.
- PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods.
- STROKE_FONT - Implements stroke font drawing using GAL methods.
Most important changes to Kicad original code:
* EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects.
* EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime.
* There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew)
* Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom.
* Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime.
* Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods.
* Removed tools/class_painter.h, as now it is extended and included in source code.
Build changes:
* GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL.
* When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required.
* GAL-related code is compiled into a static library (common/libgal).
* Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad
Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS).
More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
|
|
|
|
2020-09-21 15:03:08 +00:00
|
|
|
double ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const override;
|
2013-07-08 09:30:50 +00:00
|
|
|
|
2016-09-24 18:53:15 +00:00
|
|
|
virtual const BOX2I ViewBBox() const override;
|
2013-07-26 16:15:11 +00:00
|
|
|
|
2023-02-05 13:07:30 +00:00
|
|
|
void ClearZoneLayerOverrides()
|
2022-10-18 12:00:37 +00:00
|
|
|
{
|
2023-02-07 22:32:19 +00:00
|
|
|
m_zoneLayerOverrides.fill( ZLO_NONE );
|
2022-10-18 12:00:37 +00:00
|
|
|
}
|
|
|
|
|
2023-02-05 13:07:30 +00:00
|
|
|
const ZONE_LAYER_OVERRIDE& GetZoneLayerOverride( PCB_LAYER_ID aLayer ) const
|
2022-10-18 12:00:37 +00:00
|
|
|
{
|
2023-05-03 14:06:17 +00:00
|
|
|
return m_zoneLayerOverrides.at( aLayer );
|
2022-10-18 12:00:37 +00:00
|
|
|
}
|
|
|
|
|
2023-02-05 13:07:30 +00:00
|
|
|
void SetZoneLayerOverride( PCB_LAYER_ID aLayer, ZONE_LAYER_OVERRIDE aOverride )
|
2023-01-15 15:46:32 +00:00
|
|
|
{
|
2023-02-05 13:07:30 +00:00
|
|
|
std::unique_lock<std::mutex> cacheLock( m_zoneLayerOverridesMutex );
|
2023-05-03 14:06:17 +00:00
|
|
|
m_zoneLayerOverrides.at( aLayer ) = aOverride;
|
2023-01-15 15:46:32 +00:00
|
|
|
}
|
|
|
|
|
2024-05-29 14:23:46 +00:00
|
|
|
void CheckPad( UNITS_PROVIDER* aUnitsProvider,
|
|
|
|
const std::function<void( int aErrorCode,
|
|
|
|
const wxString& aMsg )>& aErrorHandler ) const;
|
|
|
|
|
2023-09-14 21:39:42 +00:00
|
|
|
double Similarity( const BOARD_ITEM& aOther ) const override;
|
|
|
|
|
|
|
|
bool operator==( const BOARD_ITEM& aOther ) const override;
|
2024-06-01 00:38:45 +00:00
|
|
|
bool operator!=( const BOARD_ITEM& aOther ) const { return !operator==( aOther ); }
|
2023-09-14 21:39:42 +00:00
|
|
|
|
2009-03-23 19:54:15 +00:00
|
|
|
#if defined(DEBUG)
|
2016-09-24 18:53:15 +00:00
|
|
|
virtual void Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
|
2007-08-07 06:21:19 +00:00
|
|
|
#endif
|
2012-01-14 19:50:32 +00:00
|
|
|
|
2022-11-11 17:09:25 +00:00
|
|
|
protected:
|
|
|
|
virtual void swapData( BOARD_ITEM* aImage ) override;
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2012-01-14 19:50:32 +00:00
|
|
|
private:
|
2021-08-23 11:29:38 +00:00
|
|
|
void addPadPrimitivesToPolygon( SHAPE_POLY_SET* aMergedPolygon, int aError,
|
|
|
|
ERROR_LOC aErrorLoc ) const;
|
2017-10-19 21:16:06 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
private:
|
2021-08-23 23:10:21 +00:00
|
|
|
wxString m_number; // Pad name (pin number in schematic)
|
2021-01-21 21:46:03 +00:00
|
|
|
wxString m_pinFunction; // Pin name in schematic
|
|
|
|
wxString m_pinType; // Pin electrical type in schematic
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2022-01-01 06:04:08 +00:00
|
|
|
VECTOR2I m_pos; // Pad Position on board
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2024-04-08 13:09:20 +00:00
|
|
|
PADSTACK m_padStack;
|
2020-07-03 15:12:28 +00:00
|
|
|
/*
|
|
|
|
* Editing definitions of primitives for custom pad shapes. In local coordinates relative
|
|
|
|
* to m_Pos (NOT shapePos) at orient 0.
|
|
|
|
*/
|
2022-09-14 10:34:10 +00:00
|
|
|
std::vector<std::shared_ptr<PCB_SHAPE>> m_editPrimitives;
|
2020-06-24 11:12:39 +00:00
|
|
|
|
2020-09-21 12:43:26 +00:00
|
|
|
// Must be set to true to force rebuild shapes to draw (after geometry change for instance)
|
2020-09-17 16:32:42 +00:00
|
|
|
mutable bool m_shapesDirty;
|
2020-12-28 19:47:47 +00:00
|
|
|
mutable std::mutex m_shapesBuildingLock;
|
2022-08-31 09:15:42 +00:00
|
|
|
mutable BOX2I m_effectiveBoundingBox;
|
2020-09-17 16:32:42 +00:00
|
|
|
mutable std::shared_ptr<SHAPE_COMPOUND> m_effectiveShape;
|
|
|
|
mutable std::shared_ptr<SHAPE_SEGMENT> m_effectiveHoleShape;
|
2021-01-08 00:26:32 +00:00
|
|
|
|
2023-10-13 11:25:52 +00:00
|
|
|
mutable bool m_polyDirty[2];
|
2021-01-08 00:26:32 +00:00
|
|
|
mutable std::mutex m_polyBuildingLock;
|
2023-10-13 11:25:52 +00:00
|
|
|
mutable std::shared_ptr<SHAPE_POLY_SET> m_effectivePolygon[2];
|
2021-01-08 00:26:32 +00:00
|
|
|
mutable int m_effectiveBoundingRadius;
|
2020-06-22 19:35:09 +00:00
|
|
|
|
2020-07-31 12:37:22 +00:00
|
|
|
int m_subRatsnest; // Variable used to handle subnet (block) number in
|
2020-07-03 15:12:28 +00:00
|
|
|
// ratsnest computations
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2024-05-01 17:15:50 +00:00
|
|
|
PAD_ATTRIB m_attribute = PAD_ATTRIB::PTH;
|
|
|
|
|
2021-08-23 11:29:38 +00:00
|
|
|
PAD_PROP m_property; // Property in fab files (BGA, FIDUCIAL, TESTPOINT, etc.)
|
2019-12-11 10:36:45 +00:00
|
|
|
|
2020-07-31 12:37:22 +00:00
|
|
|
int m_lengthPadToDie; // Length net from pad to die, inside the package
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2023-02-07 22:32:19 +00:00
|
|
|
std::mutex m_zoneLayerOverridesMutex;
|
|
|
|
std::array<ZONE_LAYER_OVERRIDE, MAX_CU_LAYERS> m_zoneLayerOverrides;
|
2012-02-19 04:02:19 +00:00
|
|
|
};
|
2011-08-01 15:29:27 +00:00
|
|
|
|
2020-11-12 22:30:02 +00:00
|
|
|
#endif // PAD_H
|