footprint.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 1992-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 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
 */
 
#ifndef FOOTPRINT_H
#define FOOTPRINT_H
 
#include <deque>
 
#include <template_fieldnames.h>
 
#include <board_item_container.h>
#include <board_item.h>
#include <collectors.h>
#include <embedded_files.h>
#include <layer_ids.h> // ALL_LAYERS definition.
#include <lset.h>
#include <lib_id.h>
#include <list>
 
#include <zones.h>
#include <convert_shape_list_to_polygon.h>
#include <pcb_item_containers.h>
#include <pcb_text.h>
#include <pcb_field.h>
#include <functional>
#include <math/vector3.h>
 
class LINE_READER;
class EDA_3D_CANVAS;
class PAD;
class BOARD;
class MSG_PANEL_ITEM;
class SHAPE;
class REPORTER;
 
namespace KIGFX {
class VIEW;
}
 
enum INCLUDE_NPTH_T
{
 DO_NOT_INCLUDE_NPTH = false,
 INCLUDE_NPTH = true
};
 
enum FOOTPRINT_ATTR_T
{
 FP_THROUGH_HOLE = 0x0001,
 FP_SMD = 0x0002,
 FP_EXCLUDE_FROM_POS_FILES = 0x0004,
 FP_EXCLUDE_FROM_BOM = 0x0008,
 FP_BOARD_ONLY = 0x0010, // Footprint has no corresponding symbol
 FP_JUST_ADDED = 0x0020, // Footprint just added by netlist update
 FP_ALLOW_SOLDERMASK_BRIDGES = 0x0040,
 FP_ALLOW_MISSING_COURTYARD = 0x0080,
 FP_DNP = 0x0100
};
 
class FP_3DMODEL
{
public:
 FP_3DMODEL() :
 // Initialize with sensible values
 m_Scale { 1, 1, 1 },
 m_Rotation { 0, 0, 0 },
 m_Offset { 0, 0, 0 },
 m_Opacity( 1.0 ),
 m_Show( true )
 {
 }
 
 VECTOR3D m_Scale; 
 VECTOR3D m_Rotation; 
 VECTOR3D m_Offset; 
 double m_Opacity;
 wxString m_Filename; 
 bool m_Show; 
};
 
 
class FOOTPRINT : public BOARD_ITEM_CONTAINER, public EMBEDDED_FILES
{
public:
 FOOTPRINT( BOARD* parent );
 
 FOOTPRINT( const FOOTPRINT& aFootprint );
 
 // Move constructor and operator needed due to std containers inside the footprint
 FOOTPRINT( FOOTPRINT&& aFootprint );
 
 ~FOOTPRINT();
 
 FOOTPRINT& operator=( const FOOTPRINT& aOther );
 FOOTPRINT& operator=( FOOTPRINT&& aOther );
 
 void Serialize( google::protobuf::Any &aContainer ) const override;
 bool Deserialize( const google::protobuf::Any &aContainer ) override;
 
 static inline bool ClassOf( const EDA_ITEM* aItem )
 {
 return aItem && aItem->Type() == PCB_FOOTPRINT_T;
 }
 
 LSET GetPrivateLayers() const { return m_privateLayers; }
 void SetPrivateLayers( LSET aLayers ) { m_privateLayers = aLayers; }
 
 void Add( BOARD_ITEM* aItem, ADD_MODE aMode = ADD_MODE::INSERT,
 bool aSkipConnectivity = false ) override;
 
 void Remove( BOARD_ITEM* aItem, REMOVE_MODE aMode = REMOVE_MODE::NORMAL ) override;
 
 void ClearAllNets();
 
 bool FixUuids();
 
 BOX2I GetFpPadsLocalBbox() const;
 
 SHAPE_POLY_SET GetBoundingHull() const;
 
 bool TextOnly() const;
 
 // Virtual function
 const BOX2I GetBoundingBox() const override;
 const BOX2I GetBoundingBox( bool aIncludeText, bool aIncludeInvisibleText ) const;
 
 const BOX2I GetLayerBoundingBox( LSET aLayers ) const;
 
 VECTOR2I GetCenter() const override
 {
 return GetBoundingBox( false, false ).GetCenter();
 }
 
 PCB_FIELDS& Fields() { return m_fields; }
 const PCB_FIELDS& Fields() const { return m_fields; }
 
 PADS& Pads() { return m_pads; }
 const PADS& Pads() const { return m_pads; }
 
 DRAWINGS& GraphicalItems() { return m_drawings; }
 const DRAWINGS& GraphicalItems() const { return m_drawings; }
 
 ZONES& Zones() { return m_zones; }
 const ZONES& Zones() const { return m_zones; }
 
 GROUPS& Groups() { return m_groups; }
 const GROUPS& Groups() const { return m_groups; }
 
 bool HasThroughHolePads() const;
 
 std::vector<FP_3DMODEL>& Models() { return m_3D_Drawings; }
 const std::vector<FP_3DMODEL>& Models() const { return m_3D_Drawings; }
 
 void SetPosition( const VECTOR2I& aPos ) override;
 VECTOR2I GetPosition() const override { return m_pos; }
 
 void SetOrientation( const EDA_ANGLE& aNewAngle );
 EDA_ANGLE GetOrientation() const { return m_orient; }
 
 void SetLayerAndFlip( PCB_LAYER_ID aLayer );
 
 // to make property magic work
 PCB_LAYER_ID GetLayer() const override { return BOARD_ITEM::GetLayer(); }
 
 // For property system:
 void SetOrientationDegrees( double aOrientation )
 {
 SetOrientation( EDA_ANGLE( aOrientation, DEGREES_T ) );
 }
 double GetOrientationDegrees() const
 {
 return m_orient.AsDegrees();
 }
 
 const LIB_ID& GetFPID() const { return m_fpid; }
 void SetFPID( const LIB_ID& aFPID )
 {
 m_fpid = aFPID;
 }
 
 wxString GetFPIDAsString() const { return m_fpid.Format(); }
 void SetFPIDAsString( const wxString& aFPID ) { m_fpid.Parse( aFPID ); }
 
 wxString GetLibDescription() const { return m_libDescription; }
 void SetLibDescription( const wxString& aDesc ) { m_libDescription = aDesc; }
 
 wxString GetKeywords() const { return m_keywords; }
 void SetKeywords( const wxString& aKeywords ) { m_keywords = aKeywords; }
 
 const KIID_PATH& GetPath() const { return m_path; }
 void SetPath( const KIID_PATH& aPath ) { m_path = aPath; }
 
 wxString GetSheetname() const { return m_sheetname; }
 void SetSheetname( const wxString& aSheetname ) { m_sheetname = aSheetname; }
 
 wxString GetSheetfile() const { return m_sheetfile; }
 void SetSheetfile( const wxString& aSheetfile ) { m_sheetfile = aSheetfile; }
 
 wxString GetFilters() const { return m_filters; }
 void SetFilters( const wxString& aFilters ) { m_filters = aFilters; }
 
 std::optional<int> GetLocalClearance() const { return m_clearance; }
 void SetLocalClearance( std::optional<int> aClearance ) { m_clearance = aClearance; }
 
 std::optional<int> GetLocalSolderMaskMargin() const { return m_solderMaskMargin; }
 void SetLocalSolderMaskMargin( std::optional<int> aMargin ) { m_solderMaskMargin = aMargin; }
 
 std::optional<int> GetLocalSolderPasteMargin() const { return m_solderPasteMargin; }
 void SetLocalSolderPasteMargin( std::optional<int> aMargin ) { m_solderPasteMargin = aMargin; }
 
 std::optional<double> GetLocalSolderPasteMarginRatio() const { return m_solderPasteMarginRatio; }
 void SetLocalSolderPasteMarginRatio( std::optional<double> aRatio ) { m_solderPasteMarginRatio = aRatio; }
 
 void SetLocalZoneConnection( ZONE_CONNECTION aType ) { m_zoneConnection = aType; }
 ZONE_CONNECTION GetLocalZoneConnection() const { return m_zoneConnection; }
 
 int GetAttributes() const { return m_attributes; }
 void SetAttributes( int aAttributes ) { m_attributes = aAttributes; }
 
 void SetFlag( int aFlag ) { m_arflag = aFlag; }
 void IncrementFlag() { m_arflag += 1; }
 int GetFlag() const { return m_arflag; }
 
 bool IsNetTie() const
 {
 for( const wxString& group : m_netTiePadGroups )
 {
 if( !group.IsEmpty() )
 return true;
 }
 
 return false;
 }
 
 std::optional<int> GetLocalClearance( wxString* aSource ) const
 {
 if( m_clearance.has_value() && aSource )
 *aSource = wxString::Format( _( "footprint %s" ), GetReference() );
 
 return m_clearance;
 }
 
 std::optional<int> GetClearanceOverrides( wxString* aSource ) const
 {
 return GetLocalClearance( aSource );
 }
 
 ZONE_CONNECTION GetZoneConnectionOverrides( wxString* aSource ) const
 {
 if( m_zoneConnection != ZONE_CONNECTION::INHERITED && aSource )
 *aSource = wxString::Format( _( "footprint %s" ), GetReference() );
 
 return m_zoneConnection;
 }
 
 const std::vector<wxString>& GetNetTiePadGroups() const { return m_netTiePadGroups; }
 
 void ClearNetTiePadGroups()
 {
 m_netTiePadGroups.clear();
 }
 
 void AddNetTiePadGroup( const wxString& aGroup )
 {
 m_netTiePadGroups.emplace_back( aGroup );
 }
 
 std::map<wxString, int> MapPadNumbersToNetTieGroups() const;
 
 std::vector<PAD*> GetNetTiePads( PAD* aPad ) const;
 
 int GetLikelyAttribute() const;
 
 void Move( const VECTOR2I& aMoveVector ) override;
 
 void Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle ) override;
 
 void Flip( const VECTOR2I& aCentre, bool aFlipLeftRight ) override;
 
 void MoveAnchorPosition( const VECTOR2I& aMoveVector );
 
 bool IsFlipped() const { return GetLayer() == B_Cu; }
 
 PCB_LAYER_ID GetSide() const;
 
 bool IsOnLayer( PCB_LAYER_ID aLayer ) const override;
 
// m_footprintStatus bits:
#define FP_is_LOCKED 0x01 
#define FP_is_PLACED 0x02 
#define FP_to_PLACE 0x04 
#define FP_PADS_are_LOCKED 0x08
 
 
 bool IsLocked() const override
 {
 return ( m_fpStatus & FP_is_LOCKED ) != 0;
 }
 
 void SetLocked( bool isLocked ) override
 {
 if( isLocked )
 m_fpStatus |= FP_is_LOCKED;
 else
 m_fpStatus &= ~FP_is_LOCKED;
 }
 
 bool IsConflicting() const;
 
 bool IsPlaced() const { return m_fpStatus & FP_is_PLACED; }
 void SetIsPlaced( bool isPlaced )
 {
 if( isPlaced )
 m_fpStatus |= FP_is_PLACED;
 else
 m_fpStatus &= ~FP_is_PLACED;
 }
 
 bool NeedsPlaced() const { return m_fpStatus & FP_to_PLACE; }
 void SetNeedsPlaced( bool needsPlaced )
 {
 if( needsPlaced )
 m_fpStatus |= FP_to_PLACE;
 else
 m_fpStatus &= ~FP_to_PLACE;
 }
 
 bool LegacyPadsLocked() const { return m_fpStatus & FP_PADS_are_LOCKED; }
 
 void CheckFootprintAttributes( const std::function<void( const wxString& )>& aErrorHandler );
 
 void CheckPads( UNITS_PROVIDER* aUnitsProvider,
 const std::function<void( const PAD*, int, const wxString& )>& aErrorHandler );
 
 void CheckShortingPads( const std::function<void( const PAD*, const PAD*, int aErrorCode,
 const VECTOR2I& )>& aErrorHandler );
 
 void CheckNetTies( const std::function<void( const BOARD_ITEM* aItem,
 const BOARD_ITEM* bItem,
 const BOARD_ITEM* cItem,
 const VECTOR2I& )>& aErrorHandler );
 
 void CheckNetTiePadGroups( const std::function<void( const wxString& )>& aErrorHandler );
 
 void TransformPadsToPolySet( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer, int aClearance,
 int aMaxError, ERROR_LOC aErrorLoc,
 bool aSkipNPTHPadsWihNoCopper = false,
 bool aSkipPlatedPads = false,
 bool aSkipNonPlatedPads = false ) const;
 
 void TransformFPShapesToPolySet( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer, int aClearance,
 int aError, ERROR_LOC aErrorLoc,
 bool aIncludeText = true,
 bool aIncludeShapes = true,
 bool aIncludePrivateItems = false ) const;
 
 void TransformFPTextToPolySet( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer, int aClearance,
 int aError, ERROR_LOC aErrorLoc ) const
 {
 TransformFPShapesToPolySet( aBuffer, aLayer, aClearance, aError, aErrorLoc, true, false );
 }
 
 void GetContextualTextVars( wxArrayString* aVars ) const;
 
 bool ResolveTextVar( wxString* token, int aDepth = 0 ) const;
 
 void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) override;
 
 bool HitTest( const VECTOR2I& aPosition, int aAccuracy = 0 ) const override;
 
 bool HitTestAccurate( const VECTOR2I& aPosition, int aAccuracy = 0 ) const;
 
 bool HitTest( const BOX2I& aRect, bool aContained, int aAccuracy = 0 ) const override;
 
 bool HitTestOnLayer( const VECTOR2I& aPosition, PCB_LAYER_ID aLayer, int aAccuracy = 0 ) const;
 
 bool HitTestOnLayer( const BOX2I& aRect, bool aContained, PCB_LAYER_ID aLayer, int aAccuracy = 0 ) const;
 
 const wxString& GetReference() const { return Reference().GetText(); }
 
 void SetReference( const wxString& aReference ) { Reference().SetText( aReference ); }
 
 // Property system doesn't like const references
 wxString GetReferenceAsString() const
 {
 return GetReference();
 }
 
 void IncrementReference( int aDelta );
 
 const wxString& GetValue() const { return Value().GetText(); }
 
 void SetValue( const wxString& aValue ) { Value().SetText( aValue ); }
 
 // Property system doesn't like const references
 wxString GetValueAsString() const
 {
 return GetValue();
 }
 
 PCB_FIELD& Value() { return *GetField( VALUE_FIELD ); }
 PCB_FIELD& Reference() { return *GetField( REFERENCE_FIELD ); }
 PCB_FIELD& Footprint() { return *GetField( FOOTPRINT_FIELD ); }
 
 const PCB_FIELD& Value() const { return *GetField( VALUE_FIELD ); }
 const PCB_FIELD& Reference() const { return *GetField( REFERENCE_FIELD ); }
 const PCB_FIELD& Footprint() const { return *GetField( FOOTPRINT_FIELD ); }
 
 //-----<Fields>-----------------------------------------------------------
 
 PCB_FIELD* GetField( MANDATORY_FIELD_T aFieldType );
 const PCB_FIELD* GetField( MANDATORY_FIELD_T aFieldNdx ) const;
 
 PCB_FIELD* GetFieldById( int aFieldId );
 
 PCB_FIELD* GetFieldByName( const wxString& aFieldName );
 
 bool HasFieldByName( const wxString& aFieldName ) const;
 
 wxString GetFieldText( const wxString& aFieldName ) const;
 
 void GetFields( std::vector<PCB_FIELD*>& aVector, bool aVisibleOnly );
 
 PCB_FIELDS GetFields() { return m_fields; }
 const PCB_FIELDS& GetFields() const { return m_fields; }
 
 PCB_FIELD* AddField( const PCB_FIELD& aField );
 
 void RemoveField( const wxString& aFieldName );
 
 int GetFieldCount() const { return (int) m_fields.size(); }
 
 void ApplyDefaultSettings( const BOARD& board, bool aStyleFields, bool aStyleText,
 bool aStyleShapes );
 
 bool IsBoardOnly() const { return m_attributes & FP_BOARD_ONLY; }
 void SetBoardOnly( bool aIsBoardOnly = true )
 {
 if( aIsBoardOnly )
 m_attributes |= FP_BOARD_ONLY;
 else
 m_attributes &= ~FP_BOARD_ONLY;
 }
 
 bool IsExcludedFromPosFiles() const { return m_attributes & FP_EXCLUDE_FROM_POS_FILES; }
 void SetExcludedFromPosFiles( bool aExclude = true )
 {
 if( aExclude )
 m_attributes |= FP_EXCLUDE_FROM_POS_FILES;
 else
 m_attributes &= ~FP_EXCLUDE_FROM_POS_FILES;
 }
 
 bool IsExcludedFromBOM() const { return m_attributes & FP_EXCLUDE_FROM_BOM; }
 void SetExcludedFromBOM( bool aExclude = true )
 {
 if( aExclude )
 m_attributes |= FP_EXCLUDE_FROM_BOM;
 else
 m_attributes &= ~FP_EXCLUDE_FROM_BOM;
 }
 
 bool AllowMissingCourtyard() const { return m_attributes & FP_ALLOW_MISSING_COURTYARD; }
 void SetAllowMissingCourtyard( bool aAllow = true )
 {
 if( aAllow )
 m_attributes |= FP_ALLOW_MISSING_COURTYARD;
 else
 m_attributes &= ~FP_ALLOW_MISSING_COURTYARD;
 }
 
 bool IsDNP() const { return m_attributes & FP_DNP; }
 void SetDNP( bool aDNP = true )
 {
 if( aDNP )
 m_attributes |= FP_DNP;
 else
 m_attributes &= ~FP_DNP;
 }
 
 void SetFileFormatVersionAtLoad( int aVersion ) { m_fileFormatVersionAtLoad = aVersion; }
 int GetFileFormatVersionAtLoad() const { return m_fileFormatVersionAtLoad; }
 
 PAD* FindPadByNumber( const wxString& aPadNumber, PAD* aSearchAfterMe = nullptr ) const;
 
 PAD* GetPad( const VECTOR2I& aPosition, LSET aLayerMask = LSET::AllLayersMask() );
 
 std::vector<const PAD*> GetPads( const wxString& aPadNumber,
 const PAD* aIgnore = nullptr ) const;
 
 unsigned GetPadCount( INCLUDE_NPTH_T aIncludeNPTH = INCLUDE_NPTH_T(INCLUDE_NPTH) ) const;
 
 unsigned GetUniquePadCount( INCLUDE_NPTH_T aIncludeNPTH = INCLUDE_NPTH_T(INCLUDE_NPTH) ) const;
 
 std::set<wxString>
 GetUniquePadNumbers( INCLUDE_NPTH_T aIncludeNPTH = INCLUDE_NPTH_T(INCLUDE_NPTH) ) const;
 
 wxString GetNextPadNumber( const wxString& aLastPadName ) const;
 
 void AutoPositionFields();
 
 wxString GetTypeName() const;
 
 double GetArea( int aPadding = 0 ) const;
 
 KIID GetLink() const { return m_link; }
 void SetLink( const KIID& aLink ) { m_link = aLink; }
 
 BOARD_ITEM* Duplicate() const override;
 
 BOARD_ITEM* DuplicateItem( const BOARD_ITEM* aItem, bool aAddToFootprint = false );
 
 void Add3DModel( FP_3DMODEL* a3DModel );
 
 INSPECT_RESULT Visit( INSPECTOR inspector, void* testData,
 const std::vector<KICAD_T>& aScanTypes ) override;
 
 wxString GetClass() const override
 {
 return wxT( "FOOTPRINT" );
 }
 
 wxString GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const override;
 
 BITMAPS GetMenuImage() const override;
 
 EDA_ITEM* Clone() const override;
 
 void RunOnChildren( const std::function<void (BOARD_ITEM*)>& aFunction ) const override;
 
 void RunOnDescendants( const std::function<void( BOARD_ITEM* )>& aFunction,
 int aDepth = 0 ) const override;
 
 virtual void ViewGetLayers( int aLayers[], int& aCount ) const override;
 
 double ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const override;
 
 virtual const BOX2I ViewBBox() const override;
 
 static bool IsLibNameValid( const wxString& aName );
 
 static const wxChar* StringLibNameInvalidChars( bool aUserReadable );
 
 bool FootprintNeedsUpdate( const FOOTPRINT* aLibFP, int aCompareFlags = 0,
 REPORTER* aReporter = nullptr );
 
 void SetInitialComments( wxArrayString* aInitialComments )
 {
 delete m_initial_comments;
 m_initial_comments = aInitialComments;
 }
 
 double CoverageRatio( const GENERAL_COLLECTOR& aCollector ) const;
 
 static double GetCoverageArea( const BOARD_ITEM* aItem, const GENERAL_COLLECTOR& aCollector );
 
 const wxArrayString* GetInitialComments() const { return m_initial_comments; }
 
 const SHAPE_POLY_SET& GetCourtyard( PCB_LAYER_ID aLayer ) const;
 
 const SHAPE_POLY_SET& GetCachedCourtyard( PCB_LAYER_ID aLayer ) const;
 
 void BuildCourtyardCaches( OUTLINE_ERROR_HANDLER* aErrorHandler = nullptr );
 
 // @copydoc BOARD_ITEM::GetEffectiveShape
 std::shared_ptr<SHAPE> GetEffectiveShape( PCB_LAYER_ID aLayer = UNDEFINED_LAYER,
 FLASHING aFlash = FLASHING::DEFAULT ) const override;
 
 EMBEDDED_FILES* GetEmbeddedFiles() override
 {
 return static_cast<EMBEDDED_FILES*>( this );
 }
 
 const EMBEDDED_FILES* GetEmbeddedFiles() const
 {
 return static_cast<const EMBEDDED_FILES*>( this );
 }
 
 void EmbedFonts() override;
 
 double Similarity( const BOARD_ITEM& aOther ) const override;
 
 bool operator==( const BOARD_ITEM& aOther ) const override;
 bool operator==( const FOOTPRINT& aOther ) const;
 
#if defined(DEBUG)
 virtual void Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
#endif
 
 struct cmp_drawings
 {
 bool operator()( const BOARD_ITEM* itemA, const BOARD_ITEM* itemB ) const;
 };
 
 struct cmp_pads
 {
 bool operator()( const PAD* aFirst, const PAD* aSecond ) const;
 };
 
 struct cmp_padstack
 {
 bool operator()( const PAD* aFirst, const PAD* aSecond ) const;
 };
 
 struct cmp_zones
 {
 bool operator()( const ZONE* aFirst, const ZONE* aSecond ) const;
 };
 
protected:
 virtual void swapData( BOARD_ITEM* aImage ) override;
 
private:
 PCB_FIELDS m_fields;
 DRAWINGS m_drawings; // BOARD_ITEMs for drawings on the board, owned by pointer.
 PADS m_pads; // PAD items, owned by pointer
 ZONES m_zones; // PCB_ZONE items, owned by pointer
 GROUPS m_groups; // PCB_GROUP items, owned by pointer
 
 EDA_ANGLE m_orient; // Orientation
 VECTOR2I m_pos; // Position of footprint on the board in internal units.
 LIB_ID m_fpid; // The #LIB_ID of the FOOTPRINT.
 int m_attributes; // Flag bits (see FOOTPRINT_ATTR_T)
 int m_fpStatus; // For autoplace: flags (LOCKED, FIELDS_AUTOPLACED)
 int m_fileFormatVersionAtLoad;
 
 // Bounding box caching strategy:
 // While we attempt to notice the low-hanging fruit operations and update the bounding boxes
 // accordingly, we rely mostly on a "if anything changed then the caches are stale" approach.
 // We implement this by having PCB_BASE_FRAME's OnModify() method increment an operation
 // counter, and storing that as a timestamp for the various caches.
 // This means caches will get regenerated often -- but still far less often than if we had no
 // caches at all. The principal opitmization would be to change to dirty flag and make sure
 // that any edit that could affect the bounding boxes (including edits to the footprint
 // children) marked the bounding boxes dirty. It would definitely be faster -- but also more
 // fragile.
 mutable BOX2I m_cachedBoundingBox;
 mutable int m_boundingBoxCacheTimeStamp;
 mutable BOX2I m_cachedVisibleBBox;
 mutable int m_visibleBBoxCacheTimeStamp;
 mutable BOX2I m_cachedTextExcludedBBox;
 mutable int m_textExcludedBBoxCacheTimeStamp;
 mutable SHAPE_POLY_SET m_cachedHull;
 mutable int m_hullCacheTimeStamp;
 
 // A list of pad groups, each of which is allowed to short nets within their group.
 // A pad group is a comma-separated list of pad numbers.
 std::vector<wxString> m_netTiePadGroups;
 
 // Optional overrides
 ZONE_CONNECTION m_zoneConnection;
 std::optional<int> m_clearance;
 std::optional<int> m_solderMaskMargin; // Solder mask margin
 std::optional<int> m_solderPasteMargin; // Solder paste margin absolute value
 std::optional<double> m_solderPasteMarginRatio; // Solder mask margin ratio of pad size
 // The final margin is the sum of these 2 values
 
 wxString m_libDescription; // File name and path for documentation file.
 wxString m_keywords; // Search keywords to find footprint in library.
 KIID_PATH m_path; // Path to associated symbol ([sheetUUID, .., symbolUUID]).
 wxString m_sheetname; // Name of the sheet containing the symbol for this footprint
 wxString m_sheetfile; // File of the sheet containing the symbol for this footprint
 wxString m_filters; // Footprint filters from symbol
 timestamp_t m_lastEditTime;
 int m_arflag; // Use to trace ratsnest and auto routing.
 KIID m_link; // Temporary logical link used during editing
 LSET m_privateLayers; // Layers visible only in the footprint editor
 
 std::vector<FP_3DMODEL> m_3D_Drawings; // 3D models.
 wxArrayString* m_initial_comments; // s-expression comments in the footprint,
 // lazily allocated only if needed for speed
 
 SHAPE_POLY_SET m_courtyard_cache_front; // Note that a footprint can have both front and back
 SHAPE_POLY_SET m_courtyard_cache_back; // courtyards populated.
 mutable HASH_128 m_courtyard_cache_front_hash;
 mutable HASH_128 m_courtyard_cache_back_hash;
 mutable std::mutex m_courtyard_cache_mutex;
};
 
#endif // FOOTPRINT_H