lib_symbol.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2004-2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2008 Wayne Stambaugh <[email protected]>
 * Copyright (C) 2022 CERN
 * 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 <base_units.h>
#include <embedded_files.h>
#include <symbol.h>
#include <sch_field.h>
#include <sch_pin.h>
#include <lib_tree_item.h>
#include <pin_map.h>
#include <set>
#include <vector>
#include <core/multivector.h>
#include <default_values.h>
 
class LINE_READER;
class OUTPUTFORMATTER;
class REPORTER;
class LEGACY_SYMBOL_LIB;
class LIB_SYMBOL;
class TEST_LIB_SYMBOL_FIXTURE;
 
namespace KIFONT
{
    class OUTLINE_FONT;
}
 
 
typedef MULTIVECTOR<SCH_ITEM, SCH_SHAPE_T, SCH_PIN_T> LIB_ITEMS_CONTAINER;
typedef LIB_ITEMS_CONTAINER::ITEM_PTR_VECTOR LIB_ITEMS;
 
 
/* values for member .m_options */
enum LIBRENTRYOPTIONS
{
    ENTRY_NORMAL,     // Libentry is a standard symbol (real or alias)
    ENTRY_GLOBAL_POWER,      // Libentry is a power symbol
    ENTRY_LOCAL_POWER // Libentry is a local power symbol
};
 
 
extern bool operator<( const LIB_SYMBOL& aItem1, const LIB_SYMBOL& aItem2 );
 
 
struct LIB_SYMBOL_UNIT
{
    int m_unit;                       
    int m_bodyStyle;                  
    std::vector<SCH_ITEM*> m_items;   
};
 

struct LIB_FIELD_SYNC_OPTIONS
{
    bool m_updateAllFields = true;

    std::set<wxString> m_updateFields;

    bool m_removeExtraFields = false;

    bool m_resetVisibility = false;

    bool m_resetEffects = false;

    bool m_resetPositions = false;

    bool m_resetText = false;

    bool m_resetEmptyText = false;
};
 

class LIB_SYMBOL : public SYMBOL, public LIB_TREE_ITEM, public EMBEDDED_FILES
{
public:
    LIB_SYMBOL( const wxString& aName, LIB_SYMBOL* aParent = nullptr, LEGACY_SYMBOL_LIB* aLibrary = nullptr );
 
    LIB_SYMBOL( const LIB_SYMBOL& aSymbol, LEGACY_SYMBOL_LIB* aLibrary = nullptr, bool aCopyEmbeddedFiles = true );
 
    virtual ~LIB_SYMBOL() = default;

    std::shared_ptr<LIB_SYMBOL> SharedPtr() const { return m_me; }

    virtual LIB_SYMBOL* Duplicate() const
    {
        LIB_SYMBOL* dupe = new LIB_SYMBOL( *this, m_library );
        const_cast<KIID&>( dupe->m_Uuid ) = KIID();
 
        for( SCH_ITEM& item : dupe->m_drawings )
            const_cast<KIID&>( item.m_Uuid ) = KIID();
 
        return dupe;
    }

    static LIB_SYMBOL* GetDummy();
 
    void SetParent( LIB_SYMBOL* aParent = nullptr );
    std::weak_ptr<LIB_SYMBOL>& GetParent() { return m_parent; }
    const std::weak_ptr<LIB_SYMBOL>& GetParent() const { return m_parent; }

    unsigned GetInheritanceDepth() const;

    std::shared_ptr<LIB_SYMBOL> GetRootSymbol() const;
 
    virtual wxString GetClass() const override
    {
        return wxT( "LIB_SYMBOL" );
    }
 
    static inline bool ClassOf( const EDA_ITEM* aItem )
    {
        return aItem && aItem->Type() == LIB_SYMBOL_T;
    }
 
    virtual void SetName( const wxString& aName );
    wxString GetName() const override { return m_name; }
 
    LIB_ID GetLIB_ID() const override { return m_libId; }
    wxString GetDesc() override { return GetShownDescription(); }
    wxString GetFootprint() override;
    int GetSubUnitCount() const override { return GetUnitCount(); }
 
    const LIB_ID& GetLibId() const override { return m_libId; }
    void SetLibId( const LIB_ID& aLibId );
 
    LIB_ID GetSourceLibId() const { return m_sourceLibId; }
    void SetSourceLibId( const LIB_ID& aLibId ) { m_sourceLibId = aLibId; }
 
    wxString GetLibNickname() const override { return GetLibraryName(); }

    void SetDescription( const wxString& aDescription );

    wxString GetDescription() const override
    {
        if( GetDescriptionField().GetText().IsEmpty() && IsDerived() )
        {
            if( std::shared_ptr<LIB_SYMBOL> parent = m_parent.lock() )
                return parent->GetDescription();
        }
 
        return GetDescriptionField().GetText();
    }
 
    wxString GetShownDescription( int aDepth = 0 ) const override;
 
    void SetKeyWords( const wxString& aKeyWords );
 
    wxString GetKeyWords() const override
    {
        if( m_keyWords.IsEmpty() && IsDerived() )
        {
            if( std::shared_ptr<LIB_SYMBOL> parent = m_parent.lock() )
                return parent->GetKeyWords();
        }
 
        return m_keyWords;
    }
 
    wxString GetShownKeyWords( int aDepth = 0 ) const override;
 
    std::vector<SEARCH_TERM>& GetSearchTerms() override { return m_searchTermsCache; }
 
    void GetChooserFields( std::map<wxString , wxString>& aColumnMap ) override;

    bool IsRoot() const override { return m_parent.use_count() == 0; }
    bool IsDerived() const { return !m_parent.expired() && m_parent.use_count() > 0; }
 
    const wxString GetLibraryName() const;
 
    LEGACY_SYMBOL_LIB* GetLib() const          { return m_library; }
    void SetLib( LEGACY_SYMBOL_LIB* aLibrary );
 
    timestamp_t GetLastModDate() const { return m_lastModDate; }
 
    void SetFPFilters( const wxArrayString& aFilters ) { m_fpFilters = aFilters; }
 
    wxArrayString GetFPFilters() const
    {
        if( m_fpFilters.IsEmpty() && IsDerived() )
        {
            if( std::shared_ptr<LIB_SYMBOL> parent = m_parent.lock() )
                return parent->GetFPFilters();
        }
 
        return m_fpFilters;
    }

 
    const PIN_MAP_SET& GetPinMaps() const { return m_pinMaps; }
    PIN_MAP_SET&       PinMaps() { return m_pinMaps; }
    void               SetPinMaps( const PIN_MAP_SET& aPinMaps ) { m_pinMaps = aPinMaps; }
 
    const std::vector<ASSOCIATED_FOOTPRINT>& GetAssociatedFootprints() const { return m_associatedFootprints; }
 
    void SetAssociatedFootprints( std::vector<ASSOCIATED_FOOTPRINT> aList )
    {
        m_associatedFootprints = std::move( aList );
    }

    const PIN_MAP_SET& GetEffectivePinMaps() const
    {
        if( !definesOwnPinMapBundle() && IsDerived() )
        {
            if( std::shared_ptr<LIB_SYMBOL> parent = m_parent.lock() )
                return parent->GetEffectivePinMaps();
        }
 
        return m_pinMaps;
    }

    const std::vector<ASSOCIATED_FOOTPRINT>& GetEffectiveAssociatedFootprints() const
    {
        if( !definesOwnPinMapBundle() && IsDerived() )
        {
            if( std::shared_ptr<LIB_SYMBOL> parent = m_parent.lock() )
                return parent->GetEffectiveAssociatedFootprints();
        }
 
        return m_associatedFootprints;
    }

    const BOX2I GetUnitBoundingBox( int aUnit, int aBodyStyle, bool aIgnoreHiddenFields = true,
                                    bool aIgnoreLabelsOnInvisiblePins = true ) const;
 
    const BOX2I GetBoundingBox() const override
    {
        return GetUnitBoundingBox( 0, 0 );
    }

    const BOX2I GetBodyBoundingBox( int aUnit, int aBodyStyle, bool aIncludePins,
                                    bool aIncludePrivateItems ) const;
 
    BOX2I GetBodyBoundingBox() const override
    {
        return GetBodyBoundingBox( m_previewUnit, m_previewBodyStyle, false, false );
    }
 
    BOX2I GetBodyAndPinsBoundingBox() const override
    {
        return GetBodyBoundingBox( m_previewUnit, m_previewBodyStyle, true, false );
    }
 
    bool IsGlobalPower() const override;
    bool IsLocalPower() const override;
    bool IsPower() const override;
    bool IsNormal() const override;
 
    // LIB_TREE_ITEM interface
    bool IsPowerSymbol() const override { return IsPower(); }
 
    void SetGlobalPower();
    void SetLocalPower();
    void SetNormal();

    void LockUnits( bool aLockUnits ) { m_unitsLocked = aLockUnits; }

    bool UnitsLocked() const { return m_unitsLocked; }

    void SetFields( const std::vector<SCH_FIELD>& aFieldsList );

    void GetFields( std::vector<SCH_FIELD*>& aList, bool aVisibleOnly = false ) const override;

    void CopyFields( std::vector<SCH_FIELD>& aList );

    void SyncFieldsFromParent( const LIB_FIELD_SYNC_OPTIONS& aOptions );

    bool CanUpdateFieldsFromParent() const { return IsDerived(); }

    void AddField( SCH_FIELD* aField );
 
    void AddField( SCH_FIELD& aField ) { AddField( new SCH_FIELD( aField ) ); }

    int GetNextFieldOrdinal() const;

    SCH_FIELD* GetField( const wxString& aFieldName );
    const SCH_FIELD* GetField( const wxString& aFieldName ) const;
 
    SCH_FIELD*       FindFieldCaseInsensitive( const wxString& aFieldName );
    const SCH_FIELD* FindFieldCaseInsensitive( const wxString& aFieldName ) const;
 
    const SCH_FIELD* GetField( FIELD_T aFieldType ) const;
    SCH_FIELD* GetField( FIELD_T aFieldType );

    SCH_FIELD& GetValueField() { return *GetField( FIELD_T::VALUE ); }
    const SCH_FIELD& GetValueField() const;

    SCH_FIELD& GetReferenceField() { return *GetField( FIELD_T::REFERENCE ); }
    const SCH_FIELD& GetReferenceField() const;

    SCH_FIELD& GetFootprintField() { return *GetField( FIELD_T::FOOTPRINT ); }
    const SCH_FIELD& GetFootprintField() const;

    SCH_FIELD& GetDatasheetField() { return *GetField( FIELD_T::DATASHEET ); }
    const SCH_FIELD& GetDatasheetField() const;

    SCH_FIELD& GetDescriptionField() {return *GetField( FIELD_T::DESCRIPTION ); }
    const SCH_FIELD& GetDescriptionField() const;
 
    wxString GetPrefix();
 
    const wxString GetRef( const SCH_SHEET_PATH* aSheet, bool aIncludeUnit = false ) const override
    {
        return GetReferenceField().GetText();
    }
 
    const wxString GetValue( bool aResolve, const SCH_SHEET_PATH* aPath, bool aAllowExtraText,
                             const wxString& aVariantName = wxEmptyString ) const override
    {
        return GetValueField().GetText();
    }
 
    /*
     * Field access for property manager
     */
    wxString GetRefProp() const
    {
        return GetReferenceField().GetText();
    }
 
    void SetRefProp( const wxString& aRef )
    {
        GetReferenceField().SetText( aRef );
    }
 
    wxString GetValueProp() const
    {
        return GetValueField().GetText();
    }
 
    void SetValueProp( const wxString& aValue )
    {
        GetValueField().SetText( aValue );
    }
 
    wxString GetFootprintProp() const
    {
        return GetFootprintField().GetText();
    }
 
    void SetFootprintProp( const wxString& aFootprint )
    {
        GetFootprintField().SetText( aFootprint );
    }
 
    wxString GetDatasheetProp() const
    {
        return GetDatasheetField().GetText();
    }
 
    void SetDatasheetProp( const wxString& aDatasheet )
    {
        GetDatasheetField().SetText( aDatasheet );
    }
 
    wxString GetKeywordsProp() const
    {
        return GetKeyWords();
    }
 
    void SetKeywordsProp( const wxString& aKeywords )
    {
        SetKeyWords( aKeywords );
    }
 
    bool GetPowerSymbolProp() const
    {
        return IsPower();
    }
 
    void SetPowerSymbolProp( bool aIsPower )
    {
        if( aIsPower )
            SetGlobalPower();
        else
            SetNormal();
    }
 
    bool GetLocalPowerSymbolProp() const
    {
        return IsLocalPower();
    }
 
    void SetLocalPowerSymbolProp( bool aIsLocalPower )
    {
        if( aIsLocalPower )
            SetLocalPower();
        else if( IsPower() )
            SetGlobalPower();
        else
            SetNormal();
    }
 
    bool GetPinNamesInsideProp() const
    {
        return GetPinNameOffset() != 0;
    }
 
    void SetPinNamesInsideProp( bool aInside )
    {
        if( aInside && GetPinNameOffset() == 0 )
            SetPinNameOffset( schIUScale.MilsToIU( DEFAULT_PIN_NAME_OFFSET ) );
        else if( !aInside )
            SetPinNameOffset( 0 );
    }
 
    int GetUnitProp() const
    {
        return GetUnitCount();
    }
 
    void SetUnitProp( int aUnits )
    {
        SetUnitCount( aUnits, true );
    }
 
    bool GetUnitsInterchangeableProp() const
    {
        return !UnitsLocked();
    }
 
    void SetUnitsInterchangeableProp( bool aInterchangeable )
    {
        LockUnits( !aInterchangeable );
    }
 
    wxString GetBodyStyleProp() const override
    {
        return GetBodyStyleDescription( 1, false );
    }
 
    void SetBodyStyleProp( const wxString& aBodyStyle ) override
    {
        // Body style setting is more complex for LIB_SYMBOL
        // For now, this is primarily for display purposes
    }
 
    bool GetExcludedFromSimProp() const
    {
        return GetExcludedFromSim();
    }
 
    void SetExcludedFromSimProp( bool aExclude )
    {
        SetExcludedFromSim( aExclude );
    }
 
    bool GetExcludedFromBOMProp() const
    {
        return GetExcludedFromBOM();
    }
 
    void SetExcludedFromBOMProp( bool aExclude )
    {
        SetExcludedFromBOM( aExclude );
    }
 
    bool GetExcludedFromBoardProp() const
    {
        return GetExcludedFromBoard();
    }
 
    void SetExcludedFromBoardProp( bool aExclude )
    {
        SetExcludedFromBoard( aExclude );
    }
 
    bool GetExcludedFromPosFilesProp() const { return GetExcludedFromPosFiles(); }
    void SetExcludedFromPosFilesProp( bool aExclude ) { SetExcludedFromPosFiles( aExclude ); }
 
    std::set<KIFONT::OUTLINE_FONT*> GetFonts() const override;
 
    EMBEDDED_FILES* GetEmbeddedFiles() override;
    const EMBEDDED_FILES* GetEmbeddedFiles() const;
    void AppendParentEmbeddedFiles( std::vector<EMBEDDED_FILES*>& aStack ) const;
 
    void EmbedFonts() override;

    void AutoplaceFields( SCH_SCREEN* aScreen, AUTOPLACE_ALGO aAlgo ) override;
 
    void RunOnChildren( const std::function<void( SCH_ITEM* )>& aFunction, RECURSE_MODE aMode ) override;

    bool ResolveTextVar( wxString* token, int aDepth = 0 ) const;
 
    void Plot( PLOTTER* aPlotter, bool aBackground, const SCH_PLOT_OPTS& aPlotOpts,
               int aUnit, int aBodyStyle, const VECTOR2I& aOffset, bool aDimmed ) override;

    void PlotFields( PLOTTER* aPlotter, bool aBackground, const SCH_PLOT_OPTS& aPlotOpts,
                     int aUnit, int aBodyStyle, const VECTOR2I& aOffset, bool aDimmed );

    void AddDrawItem( SCH_ITEM* aItem, bool aSort = true );

    void RemoveDrawItem( SCH_ITEM* aItem );
 
    void RemoveField( SCH_FIELD* aField ) { RemoveDrawItem( aField ); }

    std::vector<const SCH_PIN*> GetGraphicalPins( int aUnit = 0, int aBodyStyle = 0 ) const;
    std::vector<SCH_PIN*> GetGraphicalPins( int aUnit = 0, int aBodyStyle = 0 );

    struct LOGICAL_PIN
    {
        const SCH_PIN* pin;        
        wxString       number;     
    };

    std::vector<LOGICAL_PIN> GetLogicalPins( int aUnit, int aBodyStyle ) const;
 
    struct UNIT_PIN_INFO
    {
        wxString              m_unitName;
        std::vector<wxString> m_pinNumbers;
    };

    std::vector<UNIT_PIN_INFO> GetUnitPinInfo() const;
 
 
    // Deprecated: use GetGraphicalPins(). This override remains to satisfy SYMBOL's pure virtual.
    std::vector<SCH_PIN*> GetPins() const override;

    int GetPinCount() override;

    const SCH_PIN* GetPin( const wxString& aNumber, int aUnit = 0, int aBodyStyle = 0 ) const;

    std::vector<SCH_PIN*> GetPinsByNumber( const wxString& aNumber, int aUnit = 0, int aBodyStyle = 0 );

    bool PinsConflictWith( const LIB_SYMBOL& aOtherSymbol, bool aTestNums, bool aTestNames,
                           bool aTestType, bool aTestOrientation, bool aTestLength ) const;

    void Move( const VECTOR2I& aOffset ) override;

    bool HasLegacyAlternateBodyStyle() const;

    int GetMaxPinNumber() const;

    void ClearTempFlags() override;
    void ClearEditFlags() override;

    SCH_ITEM* LocateDrawItem( int aUnit, int aBodyStyle, KICAD_T aType, const VECTOR2I& aPoint );

    SCH_ITEM* LocateDrawItem( int aUnit, int aBodyStyle, KICAD_T aType, const VECTOR2I& aPoint,
                              const TRANSFORM& aTransform );

    LIB_ITEMS_CONTAINER& GetDrawItems() { return m_drawings; }
    const LIB_ITEMS_CONTAINER& GetDrawItems() const { return m_drawings; }

    void FixupDrawItems();
 
    INSPECT_RESULT Visit( INSPECTOR inspector, void* testData,
                          const std::vector<KICAD_T>& aScanTypes ) override;

    void SetUnitCount( int aCount, bool aDuplicateDrawItems );
    int GetUnitCount() const override;
 
    wxString GetUnitName( int aUnit ) const override
    {
        return GetUnitDisplayName( aUnit, true );
    }

    wxString GetUnitDisplayName( int aUnit, bool aLabel ) const override;
 
    wxString GetBodyStyleDescription( int aBodyStyle, bool aLabel ) const override;
 
    std::map<int, wxString>& GetUnitDisplayNames() { return m_unitDisplayNames; }
    const std::map<int, wxString>& GetUnitDisplayNames() const { return m_unitDisplayNames; }
 
    bool GetDuplicatePinNumbersAreJumpers() const { return m_duplicatePinNumbersAreJumpers; }
    void SetDuplicatePinNumbersAreJumpers( bool aEnabled ) { m_duplicatePinNumbersAreJumpers = aEnabled; }

    std::vector<std::set<wxString>>& JumperPinGroups() { return m_jumperPinGroups; }
    const std::vector<std::set<wxString>>& JumperPinGroups() const { return m_jumperPinGroups; }

    std::optional<const std::set<wxString>> GetJumperPinGroup( const wxString& aPinNumber ) const;

    bool IsMultiUnit() const override { return m_unitCount > 1; }
 
    static wxString LetterSubReference( int aUnit, wxChar aInitialLetter );
 
    bool IsMultiBodyStyle() const override { return GetBodyStyleCount() > 1; }
 
    int GetBodyStyleCount() const override
    {
        if( m_demorgan )
            return 2;
        else
            return std::max( 1, (int) m_bodyStyleNames.size() );
    }
 
    bool HasDeMorganBodyStyles() const override { return m_demorgan; }
    void SetHasDeMorganBodyStyles( bool aFlag ) { m_demorgan = aFlag; }
 
    const std::vector<wxString>& GetBodyStyleNames() const { return m_bodyStyleNames; }
    void SetBodyStyleNames( const std::vector<wxString>& aBodyStyleNames ) { m_bodyStyleNames = aBodyStyleNames; }

    void SetBodyStyleCount( int aCount, bool aDuplicateDrawItems, bool aDuplicatePins );

    int Compare( const LIB_SYMBOL& aRhs, int aCompareFlags = 0, REPORTER* aReporter = nullptr ) const;
 
    const LIB_SYMBOL& operator=( const LIB_SYMBOL& aSymbol );

    std::unique_ptr< LIB_SYMBOL > Flatten() const;

    std::vector<struct LIB_SYMBOL_UNIT> GetUnitDrawItems();

    std::vector<SCH_ITEM*> GetUnitDrawItems( int aUnit, int aBodyStyle );

    double Similarity( const SCH_ITEM& aSymbol ) const override;
 
    void RefreshLibraryTreeCaches();
 
    void SetParentName( const wxString& aParentName ) { m_parentName = aParentName; }
    const wxString& GetParentName() const { return m_parentName; }
 
#if defined(DEBUG)
    void Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
#endif
 
private:
    // We create a different set parent function for this class, so we hide the inherited one.
    using EDA_ITEM::SetParent;

    int compare( const SCH_ITEM& aOther, int aCompareFlags = SCH_ITEM::COMPARE_FLAGS::EQUALITY ) const override;
 
    void deleteAllFields();

    bool definesOwnPinMapBundle() const { return !m_pinMaps.IsEmpty() || !m_associatedFootprints.empty(); }
 
    void cacheSearchTerms();
    void cachePinCount();
    void cacheShownDescription();
    void cacheChooserFields();
 
private:
    std::shared_ptr<LIB_SYMBOL> m_me;
    std::weak_ptr<LIB_SYMBOL>   m_parent;   
 
    wxString            m_parentName;       
 
    LIB_ID              m_libId;
    LIB_ID              m_sourceLibId;      
    timestamp_t         m_lastModDate;
 
    int                 m_unitCount;        
    bool                m_unitsLocked;      
 
    bool                m_demorgan;         
 
    LIBRENTRYOPTIONS    m_options;          
 
    LIB_ITEMS_CONTAINER m_drawings;
 
    LEGACY_SYMBOL_LIB*  m_library;
    wxString            m_name;
    wxString            m_keyWords;         
    wxArrayString       m_fpFilters;        

    PIN_MAP_SET m_pinMaps;

    std::vector<ASSOCIATED_FOOTPRINT> m_associatedFootprints;

    std::vector<std::set<wxString> > m_jumperPinGroups;

    bool m_duplicatePinNumbersAreJumpers;
 
    std::map<int, wxString> m_unitDisplayNames;
    std::vector<wxString>   m_bodyStyleNames;
 
    // Caches for things that are expensive to compute but required every time
    // the symbol chooser or other library list is created
 
    std::vector<SEARCH_TERM> m_searchTermsCache;
    int m_pinCountCache;
    wxString m_shownDescriptionCache;
    std::map<wxString, wxString> m_chooserFieldsCache;
};