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-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
 */
 
#pragma once
 
 
#include <core/mirror.h>
#include <eda_item.h>
#include <geometry/approximation.h>
#include <layer_ids.h>
#include <lseq.h>
#include <lset.h>
#include <stroke_params.h>
#include <geometry/eda_angle.h>
 
class BOARD;
class BOARD_DESIGN_SETTINGS;
class BOARD_ITEM_CONTAINER;
class SHAPE_POLY_SET;
class SHAPE_SEGMENT;
class PCB_BASE_FRAME;
class SHAPE;
class PCB_GROUP;
class FOOTPRINT;
 
namespace KIFONT
{
class METRICS;
}
 
 
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, false, true ), 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 double Similarity( const BOARD_ITEM& aItem ) const = 0;
    virtual bool operator==( const BOARD_ITEM& aItem ) const = 0;
 
    virtual bool IsOnCopperLayer() const
    {
        return IsCopperLayer( GetLayer() );
    }
 
    virtual bool HasHole() const
    {
        return false;
    }
 
    virtual bool HasDrilledHole() const
    {
        return false;
    }
 
    virtual bool IsTented( PCB_LAYER_ID aLayer ) 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;
 
    virtual void RunOnChildren( const std::function<void ( BOARD_ITEM* )>& aFunction ) const { }
 
    virtual void RunOnDescendants( const std::function<void ( BOARD_ITEM* )>& aFunction,
                                   int aDepth = 0 ) 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 );
 
    const KIFONT::METRICS& GetFontMetrics() const;
 
    virtual PCB_LAYER_ID GetLayer() const { return m_layer; }
 
    virtual int BoardLayerCount() const;
 
    virtual int BoardCopperLayerCount() const;
 
    virtual LSET BoardLayerSet() const;
 
    virtual LSET GetLayerSet() const
    {
        if( m_layer == UNDEFINED_LAYER )
            return LSET();
        else
            return LSET( { m_layer } );
    }
 
    virtual void SetLayerSet( const 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
    }
 
    bool IsSideSpecific() const;
 
    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  ) 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; }
 
    virtual void StyleFromSettings( const BOARD_DESIGN_SETTINGS& settings ) { }
 
    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, FLIP_DIRECTION aFlipDirection );
 
    virtual void Mirror( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection );
 
    virtual void Normalize() {}
 
    virtual void NormalizeForCompare() { Normalize(); }
 
    virtual const BOARD* GetBoard() const;
    virtual BOARD* GetBoard();
 
    wxString GetParentAsString() const;
 
    wxString GetLayerName() const;
 
    virtual std::vector<int> ViewGetLayers() const override;
 
    virtual void TransformShapeToPolygon( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer,
                                          int aClearance, int aError, ERROR_LOC aErrorLoc,
                                          bool ignoreLineWidth = false ) const;
 
    enum COMPARE_FLAGS : int
    {
        DRC = 0x01
    };
 
    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, bool aFull ) 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;
    }
 
    double Similarity( const BOARD_ITEM& aItem ) const override
    {
        return ( this == &aItem ) ? 1.0 : 0.0;
    }
 
    bool operator==( const BOARD_ITEM& aBoardItem ) const override
    {
        return ( this == &aBoardItem );
    }
 
    bool operator==( const DELETED_BOARD_ITEM& aOther ) const
    {
        return ( this == &aOther );
    }
 
#if defined(DEBUG)
    void Show( int , std::ostream& ) const override {}
#endif
};