board_item.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2018 Jean-Pierre Charras, jp.charras at wandadoo.fr
 * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef BOARD_ITEM_STRUCT_H
#define BOARD_ITEM_STRUCT_H
 
 
#include <eda_item.h>
#include <layer_ids.h>
#include <geometry/geometry_utils.h>
#include <stroke_params.h>
#include <geometry/eda_angle.h>
 
class BOARD;
class BOARD_ITEM_CONTAINER;
class SHAPE_POLY_SET;
class SHAPE_SEGMENT;
class PCB_BASE_FRAME;
class SHAPE;
class PCB_GROUP;
class FOOTPRINT;
 
 
enum ZONE_LAYER_OVERRIDE
{
 ZLO_NONE,
 ZLO_FORCE_FLASHED,
 ZLO_FORCE_NO_ZONE_CONNECTION
};
 
 
class BOARD_ITEM : public EDA_ITEM
{
public:
 BOARD_ITEM( BOARD_ITEM* aParent, KICAD_T idtype, PCB_LAYER_ID aLayer = F_Cu ) :
 EDA_ITEM( aParent, idtype ),
 m_layer( aLayer ),
 m_isKnockout( false ),
 m_isLocked( false ),
 m_group( nullptr )
 {
 }
 
 ~BOARD_ITEM();
 
 void SetParentGroup( PCB_GROUP* aGroup ) { m_group = aGroup; }
 PCB_GROUP* GetParentGroup() const { return m_group; }
 
 // Do not create a copy constructor & operator=.
 // The ones generated by the compiler are adequate.
 int GetX() const
 {
 VECTOR2I p = GetPosition();
 return p.x;
 }
 
 int GetY() const
 {
 VECTOR2I p = GetPosition();
 return p.y;
 }
 
 virtual VECTOR2I GetCenter() const
 {
 return GetBoundingBox().GetCenter();
 }
 
 void SetX( int aX )
 {
 VECTOR2I p( aX, GetY() );
 SetPosition( p );
 }
 
 void SetY( int aY )
 {
 VECTOR2I p( GetX(), aY );
 SetPosition( p );
 }
 
 virtual bool IsConnected() const
 {
 return false;
 }
 
 virtual bool IsOnCopperLayer() const
 {
 return IsCopperLayer( GetLayer() );
 }
 
 virtual bool HasHole() const
 {
 return false;
 }
 
 virtual bool IsTented() const
 {
 return false;
 }
 
 static VECTOR2I ZeroOffset;
 
 virtual std::shared_ptr<SHAPE> GetEffectiveShape( PCB_LAYER_ID aLayer = UNDEFINED_LAYER,
 FLASHING aFlash = FLASHING::DEFAULT ) const;
 
 virtual std::shared_ptr<SHAPE_SEGMENT> GetEffectiveHoleShape() const;
 
 BOARD_ITEM_CONTAINER* GetParent() const { return (BOARD_ITEM_CONTAINER*) m_parent; }
 
 FOOTPRINT* GetParentFootprint() const;
 
 VECTOR2I GetFPRelativePosition() const;
 void SetFPRelativePosition( const VECTOR2I& aPos );
 
 virtual bool HasLineStroke() const { return false; }
 
 virtual STROKE_PARAMS GetStroke() const;
 virtual void SetStroke( const STROKE_PARAMS& aStroke );
 
 virtual PCB_LAYER_ID GetLayer() const { return m_layer; }
 
 virtual LSET GetLayerSet() const
 {
 if( m_layer == UNDEFINED_LAYER )
 return LSET();
 else
 return LSET( m_layer );
 }
 
 virtual void SetLayerSet( LSET aLayers )
 {
 if( aLayers.count() == 1 )
 {
 SetLayer( aLayers.Seq()[0] );
 return;
 }
 
 wxFAIL_MSG( wxT( "Attempted to SetLayerSet() on a single-layer object." ) );
 
 // Derived classes which support multiple layers must implement this
 }
 
 virtual void SetLayer( PCB_LAYER_ID aLayer )
 {
 m_layer = aLayer;
 }
 
 virtual BOARD_ITEM* Duplicate() const;
 
 void SwapItemData( BOARD_ITEM* aImage );
 
 virtual bool IsOnLayer( PCB_LAYER_ID aLayer, bool aIncludeCourtyards = false ) const
 {
 return m_layer == aLayer;
 }
 
 virtual bool IsKnockout() const { return m_isKnockout; }
 virtual void SetIsKnockout( bool aKnockout ) { m_isKnockout = aKnockout; }
 
 virtual bool IsLocked() const;
 virtual void SetLocked( bool aLocked ) { m_isLocked = aLocked; }
 
 void DeleteStructure();
 
 virtual void Move( const VECTOR2I& aMoveVector )
 {
 wxFAIL_MSG( wxT( "virtual BOARD_ITEM::Move called for " ) + GetClass() );
 }
 
 virtual void Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle );
 
 virtual void Flip( const VECTOR2I& aCentre, bool aFlipLeftRight );
 
 virtual const BOARD* GetBoard() const;
 virtual BOARD* GetBoard();
 
 wxString GetLayerName() const;
 
 virtual void ViewGetLayers( int aLayers[], int& aCount ) const override;
 
 virtual void TransformShapeToPolygon( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer,
 int aClearance, int aError, ERROR_LOC aErrorLoc,
 bool ignoreLineWidth = false ) const;
 
 struct ptr_cmp
 {
 bool operator() ( const BOARD_ITEM* a, const BOARD_ITEM* b ) const;
 };
 
protected:
 virtual wxString layerMaskDescribe() const;
 
 virtual void swapData( BOARD_ITEM* aImage );
 
protected:
 PCB_LAYER_ID m_layer;
 bool m_isKnockout;
 
 bool m_isLocked;
 
 PCB_GROUP* m_group;
};
 
#ifndef SWIG
DECLARE_ENUM_TO_WXANY( PCB_LAYER_ID );
#endif
 
 
class DELETED_BOARD_ITEM : public BOARD_ITEM
{
public:
 DELETED_BOARD_ITEM() :
 BOARD_ITEM( nullptr, NOT_USED )
 {}
 
 wxString GetItemDescription( UNITS_PROVIDER* aUnitsProvider ) const override
 {
 return _( "(Deleted Item)" );
 }
 
 wxString GetClass() const override
 {
 return wxT( "DELETED_BOARD_ITEM" );
 }
 
 // pure virtuals:
 void SetPosition( const VECTOR2I& ) override {}
 VECTOR2I GetPosition() const override { return VECTOR2I( 0, 0 ); }
 
 static DELETED_BOARD_ITEM* GetInstance()
 {
 static DELETED_BOARD_ITEM* item = nullptr;
 
 if( !item )
 item = new DELETED_BOARD_ITEM();
 
 return item;
 }
 
#if defined(DEBUG)
 void Show( int , std::ostream& ) const override {}
#endif
};
 
 
#endif /* BOARD_ITEM_STRUCT_H */