pcb_constraint.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * 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/>.
 */
 
#ifndef PCB_CONSTRAINT_H_
#define PCB_CONSTRAINT_H_
 
#include <optional>
#include <vector>
 
#include <board_item.h>
 

enum class PCB_CONSTRAINT_TYPE
{
    UNDEFINED = 0,
    COINCIDENT,        
    HORIZONTAL,        
    VERTICAL,          
    PARALLEL,          
    PERPENDICULAR,     
    COLLINEAR,         
    SYMMETRIC,         
    EQUAL_LENGTH,      
    EQUAL_RADIUS,      
    POINT_ON_LINE,     
    MIDPOINT,          
    FIXED_POSITION,    
    FIXED_LENGTH,      
    CONCENTRIC,        
    FIXED_RADIUS,      
    ANGULAR_DIMENSION, 
    TANGENT,           
    ARC_ANGLE,         
};
 

enum class CONSTRAINT_ANCHOR
{
    WHOLE = 0,  
    START,      
    END,        
    MID,        
    CENTER,     
    RADIUS,     
    VERTEX,     
};
 

struct CONSTRAINT_MEMBER
{
    KIID              m_item;        
    CONSTRAINT_ANCHOR m_anchor;      
    int               m_index = -1;  
 
    CONSTRAINT_MEMBER() :
            m_item( niluuid ),
            m_anchor( CONSTRAINT_ANCHOR::WHOLE )
    {
    }
 
    CONSTRAINT_MEMBER( const KIID& aItem, CONSTRAINT_ANCHOR aAnchor, int aIndex = -1 ) :
            m_item( aItem ),
            m_anchor( aAnchor ),
            m_index( aIndex )
    {
    }
 
    bool operator==( const CONSTRAINT_MEMBER& aOther ) const = default;
};
 

const char* ConstraintTypeToken( PCB_CONSTRAINT_TYPE aType );

PCB_CONSTRAINT_TYPE ConstraintTypeFromToken( const wxString& aToken );

const char* ConstraintAnchorToken( CONSTRAINT_ANCHOR aAnchor );

CONSTRAINT_ANCHOR ConstraintAnchorFromToken( const wxString& aToken );

wxString ConstraintAnchorLabel( CONSTRAINT_ANCHOR aAnchor );

bool ConstraintValueIsLength( PCB_CONSTRAINT_TYPE aType );

wxString ConstraintTypeLabel( PCB_CONSTRAINT_TYPE aType );

wxString ConstraintTypeGlyph( PCB_CONSTRAINT_TYPE aType );
 
enum class BITMAPS : unsigned int;

BITMAPS ConstraintTypeBitmap( PCB_CONSTRAINT_TYPE aType );
 
enum class EDA_UNITS : int;
 

class PCB_CONSTRAINT : public BOARD_ITEM
{
public:
    PCB_CONSTRAINT( BOARD_ITEM* aParent = nullptr );
    PCB_CONSTRAINT( BOARD_ITEM* aParent, PCB_CONSTRAINT_TYPE aType );
 
    static inline bool ClassOf( const EDA_ITEM* aItem )
    {
        return aItem && PCB_CONSTRAINT_T == aItem->Type();
    }
 
    wxString GetClass() const override { return wxT( "PCB_CONSTRAINT" ); }
 
    PCB_CONSTRAINT_TYPE GetConstraintType() const { return m_type; }
    void                SetConstraintType( PCB_CONSTRAINT_TYPE aType ) { m_type = aType; }
 
    const std::vector<CONSTRAINT_MEMBER>& GetMembers() const { return m_members; }
    std::vector<CONSTRAINT_MEMBER>&       Members() { return m_members; }
 
    void AddMember( const KIID& aItem, CONSTRAINT_ANCHOR aAnchor = CONSTRAINT_ANCHOR::WHOLE,
                    int aIndex = -1 )
    {
        m_members.emplace_back( aItem, aAnchor, aIndex );
    }
 
    bool                  HasValue() const { return m_value.has_value(); }
    std::optional<double> GetValue() const { return m_value; }
    void                  SetValue( std::optional<double> aValue ) { m_value = aValue; }

    bool IsDriving() const { return m_driving; }
    void SetDriving( bool aDriving ) { m_driving = aDriving; }
 
    void Serialize( google::protobuf::Any& aContainer ) const override;
    bool Deserialize( const google::protobuf::Any& aContainer ) override;
 
    EDA_ITEM* Clone() const override;
 
    double Similarity( const BOARD_ITEM& aOther ) const override;
    bool   operator==( const PCB_CONSTRAINT& aOther ) const;
    bool   operator==( const BOARD_ITEM& aOther ) const override;
 
    // A constraint occupies no space and is never on a layer.
    VECTOR2I GetPosition() const override { return VECTOR2I(); }
    void     SetPosition( const VECTOR2I& ) override {}

    bool IsLayerAgnostic() const override { return true; }
 
    const BOX2I GetBoundingBox() const override { return BOX2I(); }
 
    bool HitTest( const VECTOR2I& aPosition, int aAccuracy = 0 ) const override { return false; }
    bool HitTest( const BOX2I& aRect, bool aContained, int aAccuracy = 0 ) const override
    {
        return false;
    }
 
    std::vector<int> ViewGetLayers() const override { return {}; }
 
    // A constraint has no geometry, so the spatial transforms are no-ops (the base
    // implementations wxFAIL_MSG).  Its members move with their own host items.
    void Move( const VECTOR2I& aMoveVector ) override {}
    void Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle ) override {}
    void Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection ) override {}
    void Mirror( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection ) override {}

    std::shared_ptr<SHAPE> GetEffectiveShape( PCB_LAYER_ID aLayer = UNDEFINED_LAYER,
                                              FLASHING aFlash = FLASHING::DEFAULT ) const override;
 
    wxString GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const override;
    BITMAPS  GetMenuImage() const override;
 
    void RemapKIIDs( const std::map<KIID, KIID>& aIdMap ) override;
 
#if defined( DEBUG )
    void Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
#endif
 
protected:
    void swapData( BOARD_ITEM* aImage ) override;
 
private:
    PCB_CONSTRAINT_TYPE            m_type;
    std::vector<CONSTRAINT_MEMBER> m_members;
    std::optional<double>          m_value;
    bool                           m_driving;
};
 

wxString ConstraintDisplayLabel( const PCB_CONSTRAINT& aConstraint, EDA_UNITS aUnits );
 

wxString ConstraintMemberLabel( BOARD_ITEM* aItem, const CONSTRAINT_MEMBER& aMember,
                                UNITS_PROVIDER* aUnitsProvider );
 

bool ConstraintsAreDuplicate( const PCB_CONSTRAINT& aA, const PCB_CONSTRAINT& aB );
 
#endif // PCB_CONSTRAINT_H_