padstack.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2024 Jon Evans <[email protected]>
 * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef KICAD_PADSTACK_H
#define KICAD_PADSTACK_H
 
#include <memory>
#include <optional>
#include <wx/string.h>
 
#include <api/serializable.h>
#include <geometry/eda_angle.h>
#include <layer_ids.h>
#include <lset.h>
#include <math/vector2d.h>
#include <properties/property.h>
#include <zones.h>
 
class BOARD_ITEM;
class PCB_SHAPE;
 
 
enum class PAD_SHAPE : int
{
 CIRCLE,
 RECTANGLE, // do not use just RECT: it collides in a header on MSYS2
 OVAL,
 TRAPEZOID,
 ROUNDRECT,
 
 // Rectangle with a chamfered corner ( and with rounded other corners).
 CHAMFERED_RECT,
 CUSTOM // A shape defined by user, using a set of basic shapes
 // (thick segments, circles, arcs, polygons).
};
 
enum class PAD_DRILL_SHAPE
{
 CIRCLE,
 OBLONG,
};
 
enum class PAD_ATTRIB
{
 PTH, 
 SMD, 
 CONN, 
 NPTH, 
};
 
 
enum class PAD_PROP
{
 NONE, 
 BGA, 
 FIDUCIAL_GLBL, 
 FIDUCIAL_LOCAL, 
 TESTPOINT, 
 HEATSINK, 
 CASTELLATED, 
 MECHANICAL, 
};
 
 
class PADSTACK : public SERIALIZABLE
{
public:
 enum class TYPE
 {
 NORMAL, 
 VIA, 
 MOUNTING 
 };
 
 enum class MODE
 {
 NORMAL, 
 TOP_INNER_BOTTOM, 
 CUSTOM 
 };
 
 enum class UNCONNECTED_LAYER_MODE
 {
 KEEP_ALL,
 REMOVE_ALL,
 REMOVE_EXCEPT_START_AND_END
 };
 
 enum class CUSTOM_SHAPE_ZONE_MODE
 {
 OUTLINE,
 CONVEXHULL
 };
 
 struct SHAPE_PROPS
 {
 PAD_SHAPE shape; 
 PAD_SHAPE anchor_shape; 
 VECTOR2I size; 
 
 /*
 * Most of the time the hole is the center of the shape (m_Offset = 0). But some designers
 * use oblong/rect pads with a hole moved to one of the oblong/rect pad shape ends.
 * In all cases the hole is at the pad position. This offset is from the hole to the center
 * of the pad shape (ie: the copper area around the hole).
 * ShapePos() returns the board shape position according to the offset and the pad rotation.
 */
 VECTOR2I offset; 
 
 double round_rect_corner_radius;
 double round_rect_radius_ratio;
 double chamfered_rect_ratio; 
 int chamfered_rect_positions; 
 
 VECTOR2I trapezoid_delta_size;
 
 SHAPE_PROPS();
 bool operator==( const SHAPE_PROPS& aOther ) const;
 };
 
 struct COPPER_LAYER_PROPS
 {
 SHAPE_PROPS shape;
 std::optional<ZONE_CONNECTION> zone_connection;
 std::optional<int> thermal_spoke_width;
 std::optional<EDA_ANGLE> thermal_spoke_angle;
 std::optional<int> thermal_gap;
 std::optional<int> clearance;
 
 /*
 * Editing definitions of primitives for custom pad shapes. In local coordinates relative
 * to m_Pos (NOT shapePos) at orient 0.
 */
 std::vector<std::shared_ptr<PCB_SHAPE>> custom_shapes;
 
 bool operator==( const COPPER_LAYER_PROPS& aOther ) const;
 };
 
 struct MASK_LAYER_PROPS
 {
 std::optional<int> solder_mask_margin;
 std::optional<int> solder_paste_margin;
 std::optional<double> solder_paste_margin_ratio;
 std::optional<bool> has_solder_mask; 
 std::optional<bool> has_solder_paste; 
 
 bool operator==( const MASK_LAYER_PROPS& aOther ) const;
 };
 
 struct DRILL_PROPS
 {
 VECTOR2I size; 
 PAD_DRILL_SHAPE shape;
 PCB_LAYER_ID start;
 PCB_LAYER_ID end;
 
 bool operator==( const DRILL_PROPS& aOther ) const;
 };
 
public:
 PADSTACK( BOARD_ITEM* aParent );
 virtual ~PADSTACK() = default;
 PADSTACK( const PADSTACK& aOther );
 PADSTACK& operator=( const PADSTACK &aOther );
 
 bool operator==( const PADSTACK& aOther ) const;
 bool operator!=( const PADSTACK& aOther ) const { return !operator==( aOther ); }
 
 void Serialize( google::protobuf::Any &aContainer ) const override;
 bool Deserialize( const google::protobuf::Any &aContainer ) override;
 
 const LSET& LayerSet() const { return m_layerSet; }
 LSET& LayerSet() { return m_layerSet; }
 void SetLayerSet( const LSET& aSet ) { m_layerSet = aSet; }
 
 PCB_LAYER_ID StartLayer() const;
 PCB_LAYER_ID EndLayer() const;
 
 MODE Mode() const { return m_mode; }
 void SetMode( MODE aMode ) { m_mode = aMode; }
 
 wxString Name() const;
 
 EDA_ANGLE GetOrientation() const { return m_orientation; }
 void SetOrientation( EDA_ANGLE aAngle )
 {
 m_orientation = aAngle;
 m_orientation.Normalize();
 }
 
 DRILL_PROPS& Drill() { return m_drill; }
 const DRILL_PROPS& Drill() const { return m_drill; }
 
 DRILL_PROPS& SecondaryDrill() { return m_secondaryDrill; }
 const DRILL_PROPS& SecondaryDrill() const { return m_secondaryDrill; }
 
 UNCONNECTED_LAYER_MODE UnconnectedLayerMode() const { return m_unconnectedLayerMode; }
 void SetUnconnectedLayerMode( UNCONNECTED_LAYER_MODE aMode ) { m_unconnectedLayerMode = aMode; }
 
 COPPER_LAYER_PROPS& CopperLayerDefaults() { return m_defaultCopperProps; }
 const COPPER_LAYER_PROPS& CopperLayerDefaults() const { return m_defaultCopperProps; }
 
 MASK_LAYER_PROPS& FrontOuterLayers() { return m_frontMaskProps; }
 const MASK_LAYER_PROPS& FrontOuterLayers() const { return m_frontMaskProps; }
 
 MASK_LAYER_PROPS& BackOuterLayers() { return m_backMaskProps; }
 const MASK_LAYER_PROPS& BackOuterLayers() const { return m_backMaskProps; }
 
 std::optional<bool> IsTented( PCB_LAYER_ID aSide ) const;
 
 CUSTOM_SHAPE_ZONE_MODE CustomShapeInZoneMode() const { return m_customShapeInZoneMode; }
 void SetCustomShapeInZoneMode( CUSTOM_SHAPE_ZONE_MODE aM ) { m_customShapeInZoneMode = aM; }
 
 // The following section has convenience getters for the padstack properties on a given layer.
 
 PAD_SHAPE Shape( PCB_LAYER_ID aLayer = F_Cu ) const;
 void SetShape( PAD_SHAPE aShape, PCB_LAYER_ID aLayer = F_Cu );
 
 VECTOR2I& Size( PCB_LAYER_ID aLayer = F_Cu );
 const VECTOR2I& Size( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 PAD_DRILL_SHAPE DrillShape( PCB_LAYER_ID aLayer = F_Cu ) const;
 void SetDrillShape( PAD_DRILL_SHAPE aShape, PCB_LAYER_ID aLayer = F_Cu );
 
 VECTOR2I& Offset( PCB_LAYER_ID aLayer = F_Cu );
 const VECTOR2I& Offset( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 PAD_SHAPE AnchorShape( PCB_LAYER_ID aLayer = F_Cu ) const;
 void SetAnchorShape( PAD_SHAPE aShape, PCB_LAYER_ID aLayer = F_Cu );
 
 VECTOR2I& TrapezoidDeltaSize( PCB_LAYER_ID aLayer = F_Cu );
 const VECTOR2I& TrapezoidDeltaSize( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 double RoundRectRadiusRatio( PCB_LAYER_ID aLayer = F_Cu ) const;
 void SetRoundRectRadiusRatio( double aRatio, PCB_LAYER_ID aLayer = F_Cu );
 
 int RoundRectRadius( PCB_LAYER_ID aLayer = F_Cu ) const;
 void SetRoundRectRadius( double aRadius, PCB_LAYER_ID aLayer = F_Cu );
 
 double ChamferRatio( PCB_LAYER_ID aLayer = F_Cu ) const;
 void SetChamferRatio( double aRatio, PCB_LAYER_ID aLayer = F_Cu );
 
 int& ChamferPositions( PCB_LAYER_ID aLayer = F_Cu );
 const int& ChamferPositions( PCB_LAYER_ID aLayer = F_Cu ) const;
 void SetChamferPositions( int aPositions, PCB_LAYER_ID aLayer = F_Cu );
 
 std::optional<int>& Clearance( PCB_LAYER_ID aLayer = F_Cu );
 const std::optional<int>& Clearance( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 std::optional<int>& SolderMaskMargin( PCB_LAYER_ID aLayer = F_Cu );
 const std::optional<int>& SolderMaskMargin( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 std::optional<int>& SolderPasteMargin( PCB_LAYER_ID aLayer = F_Cu );
 const std::optional<int>& SolderPasteMargin( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 std::optional<double>& SolderPasteMarginRatio( PCB_LAYER_ID aLayer = F_Cu );
 const std::optional<double>& SolderPasteMarginRatio( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 std::optional<ZONE_CONNECTION>& ZoneConnection( PCB_LAYER_ID aLayer = F_Cu );
 const std::optional<ZONE_CONNECTION>& ZoneConnection( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 std::optional<int>& ThermalSpokeWidth( PCB_LAYER_ID aLayer = F_Cu );
 const std::optional<int>& ThermalSpokeWidth( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 std::optional<int>& ThermalGap( PCB_LAYER_ID aLayer = F_Cu );
 const std::optional<int>& ThermalGap( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 EDA_ANGLE DefaultThermalSpokeAngleForShape( PCB_LAYER_ID aLayer = F_Cu ) const;
 EDA_ANGLE ThermalSpokeAngle( PCB_LAYER_ID aLayer = F_Cu ) const;
 void SetThermalSpokeAngle( EDA_ANGLE aAngle, PCB_LAYER_ID aLayer = F_Cu );
 
 std::vector<std::shared_ptr<PCB_SHAPE>>& Primitives( PCB_LAYER_ID aLayer = F_Cu );
 const std::vector<std::shared_ptr<PCB_SHAPE>>& Primitives( PCB_LAYER_ID aLayer = F_Cu ) const;
 
 void AddPrimitive( PCB_SHAPE* aShape, PCB_LAYER_ID aLayer = F_Cu );
 
 void AppendPrimitives( const std::vector<std::shared_ptr<PCB_SHAPE>>& aPrimitivesList,
 PCB_LAYER_ID aLayer = F_Cu );
 
 void ReplacePrimitives( const std::vector<std::shared_ptr<PCB_SHAPE>>& aPrimitivesList,
 PCB_LAYER_ID aLayer = F_Cu );
 
 void ClearPrimitives( PCB_LAYER_ID aLayer = F_Cu );
 
private:
 BOARD_ITEM* m_parent;
 
 MODE m_mode;
 
 LSET m_layerSet;
 
 wxString m_customName;
 
 EDA_ANGLE m_orientation;
 
 COPPER_LAYER_PROPS m_defaultCopperProps;
 
 MASK_LAYER_PROPS m_frontMaskProps;
 
 MASK_LAYER_PROPS m_backMaskProps;
 
 UNCONNECTED_LAYER_MODE m_unconnectedLayerMode;
 
 CUSTOM_SHAPE_ZONE_MODE m_customShapeInZoneMode;
 
 std::unordered_map<PCB_LAYER_ID, COPPER_LAYER_PROPS> m_copperOverrides;
 
 DRILL_PROPS m_drill;
 
 DRILL_PROPS m_secondaryDrill;
};
 
#ifndef SWIG
DECLARE_ENUM_TO_WXANY( PADSTACK::UNCONNECTED_LAYER_MODE );
#endif
 
 
#endif //KICAD_PADSTACK_H