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 The 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, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
 
#include <map>
 
#include <core/mirror.h>
#include <eda_item.h>
#include <geometry/approximation.h>
#include <layer_ids.h>
#include <properties/property.h>
#include <lseq.h>
#include <lset.h>
#include <stroke_params.h>
#include <geometry/eda_angle.h>
#include "macros.h"
#include "drc/drc_rule.h"
 
class BOARD;
class BOARD_DESIGN_SETTINGS;
class BOARD_ITEM_CONTAINER;
class BOARD_COMMIT;
class SHAPE_POLY_SET;
class SHAPE_SEGMENT;
class PCB_BASE_FRAME;
class SHAPE;
class PCB_GROUP;
class FOOTPRINT;
namespace KIGFX
{
    class RENDER_SETTINGS;
};
 
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 )
    {
    }
 
    BOARD_ITEM( const BOARD_ITEM& aOther ) :
            EDA_ITEM( aOther ),
            m_layer( aOther.m_layer ),
            m_isKnockout( aOther.m_isKnockout ),
            m_isLocked( aOther.m_isLocked )
    {
        // Cache membership is owned by BOARD: clones start detached from any board index
    }
 
    BOARD_ITEM& operator=( const BOARD_ITEM& aOther )
    {
        if( this == &aOther )
            return *this;
 
        EDA_ITEM::operator=( aOther );
        m_layer = aOther.m_layer;
        m_isKnockout = aOther.m_isKnockout;
        m_isLocked = aOther.m_isLocked;
        // Owner stays with the target, do not copy it
        return *this;
    }
 
    // A default move would copy the owner. Do not move it.
    BOARD_ITEM( BOARD_ITEM&& aOther ) :
            BOARD_ITEM( static_cast<const BOARD_ITEM&>( aOther ) )
    {
    }
 
    BOARD_ITEM& operator=( BOARD_ITEM&& aOther )
    {
        return operator=( static_cast<const BOARD_ITEM&>( aOther ) );
    }
 
    ~BOARD_ITEM() override;
 
    virtual void CopyFrom( const BOARD_ITEM* aOther );
 
    bool IsGroupableType() const;
 
    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
    {
        if( IsSingleLayerType( Type() ) )
        {
            return IsCopperLayer( GetLayer() );
        }
        else
        {
            for( PCB_LAYER_ID layer : GetLayerSet() )
            {
                if( IsCopperLayer( layer ) )
                    return true;
            }
 
            return false;
        }
    }
 
    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,
                                                      DRC_CONSTRAINT_T aUsage = NULL_CONSTRAINT ) const;
 
    virtual std::shared_ptr<SHAPE_SEGMENT> GetEffectiveHoleShape( PCB_LAYER_ID aLayer = UNDEFINED_LAYER,
                                                                  DRC_CONSTRAINT_T aUsage = NULL_CONSTRAINT ) const;

    virtual void RunOnChildren( const std::function<void( BOARD_ITEM* )>& aFunction, RECURSE_MODE aMode ) const {}
 
    BOARD_ITEM_CONTAINER* GetParent() const { return (BOARD_ITEM_CONTAINER*) m_parent; }
 
    FOOTPRINT* GetParentFootprint() const;

    void SetUuidDirect( const KIID& aUuid );
 
    void ResetUuidDirect() { SetUuidDirect( KIID() ); }
 
    void SetUuid( const KIID& aUuid );
    void ResetUuid() { SetUuid( KIID() ); }

    virtual void RemapKIIDs( const std::map<KIID, KIID>& aIdMap ) {}
 
    VECTOR2I GetFPRelativePosition() const;
    void SetFPRelativePosition( const VECTOR2I& aPos );

    virtual bool HasLineStroke() const { return false; }

    virtual bool IsLayerAgnostic() const { return false; }

    virtual bool FitsEnabledLayers( const LSET& aEnabledLayers, int aCopperLayerCount ) const;
 
    virtual STROKE_PARAMS GetStroke() const;
    virtual void SetStroke( const STROKE_PARAMS& aStroke );
 
    const KIFONT::METRICS& GetFontMetrics() const;

    virtual PCB_LAYER_ID GetLayer() const;

    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;
        }
 
        UNIMPLEMENTED_FOR( GetClass() );
 
        // 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( bool addToParentGroup, BOARD_COMMIT* aCommit = nullptr ) 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; }
 
    bool IsLocked() const override;
    void SetLocked( bool aLocked ) override { m_isLocked = aLocked; }
 
    bool IsIndexedInBoard() const { return m_boardCacheOwner != nullptr; }
 
    int GetMaxError() const;
 
    virtual void StyleFromSettings( const BOARD_DESIGN_SETTINGS& settings, bool aCheckSide ) { }

    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 OnFootprintRescaled( double aRatioX, double aRatioY, double aLinearFactor, const VECTOR2I& aAnchor,
                                      const EDA_ANGLE& aParentRotate )
    {}

    virtual void OnFootprintTransformed() {}

    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;

    virtual void TransformShapeToPolySet( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer,
                                          int aClearance, int aError, ERROR_LOC aErrorLoc,
                                          KIGFX::RENDER_SETTINGS* aRenderSettings = nullptr ) const
    {
        TransformShapeToPolygon( aBuffer, aLayer, aClearance, aError, aErrorLoc );
    }
 
    const std::vector<wxString>* GetEmbeddedFonts() override;

    virtual wxString LayerMaskDescribe() const;
 
    enum COMPARE_FLAGS : int
    {
        DRC                  = 0x01,
        INSTANCE_TO_INSTANCE = 0x02
    };
 
    struct ptr_cmp
    {
        bool operator() ( const BOARD_ITEM* a, const BOARD_ITEM* b ) const;
    };
 
protected:
    virtual void swapData( BOARD_ITEM* aImage );
 
protected:
    PCB_LAYER_ID    m_layer;
    bool            m_isKnockout;
    bool            m_isLocked;
 
    // Board that indexed this item, or nullptr. Set only by BOARD. Clones start detached.
    mutable BOARD*  m_boardCacheOwner = nullptr;
 
    friend class BOARD;
};
 
DECLARE_ENUM_TO_WXANY( PCB_LAYER_ID );

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
};