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 (C) 2004-2023 KiCad Developers, see change_log.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 CLASS_LIBENTRY_H
#define CLASS_LIBENTRY_H
 
#include <general.h>
#include <lib_tree_item.h>
#include <lib_field.h>
#include <vector>
#include <core/multivector.h>
 
class LINE_READER;
class OUTPUTFORMATTER;
class REPORTER;
class SYMBOL_LIB;
class LIB_SYMBOL;
class LIB_FIELD;
class TEST_LIB_SYMBOL_FIXTURE;
 
 
typedef std::shared_ptr<LIB_SYMBOL> LIB_SYMBOL_SPTR; 
typedef std::weak_ptr<LIB_SYMBOL> LIB_SYMBOL_REF; 
typedef MULTIVECTOR<LIB_ITEM, LIB_SHAPE_T, LIB_FIELD_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_POWER // Libentry is a power symbol
};
 
 
extern bool operator<( const LIB_SYMBOL& aItem1, const LIB_SYMBOL& aItem2 );
 
 
struct LIB_SYMBOL_OPTIONS
{
 TRANSFORM transform; // Coordinate adjustment settings
 bool force_draw_pin_text; // Whether or not to force the drawing of pin names and numbers
 bool draw_visible_fields; // Whether to draw "visible" fields
 bool draw_hidden_fields; // Whether to draw "hidden" fields
 bool show_elec_type; // Whether to show the pin electrical type
 bool show_connect_point; // Whether to show the pin connect point marker (small circle)
 // useful in dialog pin properties
 
 LIB_SYMBOL_OPTIONS()
 {
 transform = DefaultTransform;
 force_draw_pin_text = false;
 draw_visible_fields = true;
 draw_hidden_fields = true;
 show_elec_type = false;
 show_connect_point = false;
 }
};
 
 
struct LIB_SYMBOL_UNIT
{
 int m_unit; 
 int m_convert; 
 std::vector<LIB_ITEM*> m_items; 
};
 
 
class LIB_SYMBOL : public EDA_ITEM, public LIB_TREE_ITEM
{
public:
 LIB_SYMBOL( const wxString& aName, LIB_SYMBOL* aParent = nullptr,
 SYMBOL_LIB* aLibrary = nullptr );
 
 LIB_SYMBOL( const LIB_SYMBOL& aSymbol, SYMBOL_LIB* aLibrary = nullptr );
 
 virtual ~LIB_SYMBOL()
 {}
 
 LIB_SYMBOL_SPTR 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( LIB_ITEM& item : dupe->m_drawings )
 const_cast<KIID&>( item.m_Uuid ) = KIID();
 
 return dupe;
 }
 
 void SetParent( LIB_SYMBOL* aParent = nullptr );
 LIB_SYMBOL_REF& GetParent() { return m_parent; }
 const LIB_SYMBOL_REF& GetParent() const { return m_parent; }
 
 unsigned GetInheritanceDepth() const;
 
 LIB_SYMBOL_REF GetRootSymbol() const;
 
 void ClearCaches();
 
 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& LibId() { return m_libId; }
 LIB_ID GetLibId() const override { return m_libId; }
 void SetLibId( const LIB_ID& aLibId ) { m_libId = 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 )
 {
 GetDescriptionField().SetText( aDescription );
 }
 
 wxString GetDescription() override
 {
 if( GetDescriptionField().GetText().IsEmpty() && IsAlias() )
 {
 if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
 return parent->GetDescription();
 }
 
 return GetDescriptionField().GetText();
 }
 
 void SetKeyWords( const wxString& aKeyWords ) { m_keyWords = aKeyWords; }
 
 wxString GetKeyWords() const
 {
 if( m_keyWords.IsEmpty() && IsAlias() )
 {
 if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
 return parent->GetKeyWords();
 }
 
 return m_keyWords;
 }
 
 std::vector<SEARCH_TERM> GetSearchTerms() override;
 
 wxString GetFootprint() override
 {
 return GetFootprintField().GetText();
 }
 
 void GetChooserFields( std::map<wxString , wxString>& aColumnMap ) override;
 
 bool IsRoot() const override { return m_parent.use_count() == 0; }
 bool IsAlias() const { return !m_parent.expired() && m_parent.use_count() > 0; }
 
 const wxString GetLibraryName() const;
 
 SYMBOL_LIB* GetLib() const { return m_library; }
 void SetLib( SYMBOL_LIB* aLibrary ) { m_library = aLibrary; }
 
 timestamp_t GetLastModDate() const { return m_lastModDate; }
 
 void SetFPFilters( const wxArrayString& aFilters ) { m_fpFilters = aFilters; }
 
 wxArrayString GetFPFilters() const
 {
 if( m_fpFilters.IsEmpty() && IsAlias() )
 {
 if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
 return parent->GetFPFilters();
 }
 
 return m_fpFilters;
 }
 
 void ViewGetLayers( int aLayers[], int& aCount ) const override;
 
 const BOX2I GetUnitBoundingBox( int aUnit, int aConvert, bool aIgnoreHiddenFields = true ) const;
 
 const BOX2I GetBodyBoundingBox( int aUnit, int aConvert, bool aIncludePins,
 bool aIncludePrivateItems ) const;
 
 const BOX2I GetBoundingBox() const override
 {
 return GetUnitBoundingBox( 0, 0 );
 }
 
 bool IsPower() const;
 bool IsNormal() const;
 
 void SetPower();
 void SetNormal();
 
 void LockUnits( bool aLockUnits ) { m_unitsLocked = aLockUnits; }
 
 bool UnitsLocked() const { return m_unitsLocked; }
 
 void SetFields( const std::vector<LIB_FIELD>& aFieldsList );
 
 void GetFields( std::vector<LIB_FIELD*>& aList );
 void GetFields( std::vector<LIB_FIELD>& aList );
 
 void AddField( LIB_FIELD* aField );
 
 void AddField( LIB_FIELD& aField ) { AddField( new LIB_FIELD( aField ) ); }
 
 LIB_FIELD* FindField( const wxString& aFieldName, bool aCaseInsensitive = false );
 
 const LIB_FIELD* FindField( const wxString& aFieldName,
 const bool aCaseInsensitive = false ) const;
 
 LIB_FIELD* GetFieldById( int aId ) const;
 
 LIB_FIELD& GetValueField();
 
 LIB_FIELD& GetReferenceField();
 
 LIB_FIELD& GetFootprintField();
 
 LIB_FIELD& GetDatasheetField();
 
 LIB_FIELD& GetDescriptionField();
 
 wxString GetPrefix();
 
 void RunOnChildren( const std::function<void( LIB_ITEM* )>& aFunction );
 
 int UpdateFieldOrdinals();
 
 int GetNextAvailableFieldId() const;
 
 void Print( const RENDER_SETTINGS* aSettings, const VECTOR2I& aOffset, int aMulti, int aConvert,
 const LIB_SYMBOL_OPTIONS& aOpts, bool aDimmed );
 
 void PrintBackground( const RENDER_SETTINGS *aSettings, const VECTOR2I &aOffset, int aMulti,
 int aConvert, const LIB_SYMBOL_OPTIONS &aOpts, bool aDimmed );
 
 void Plot( PLOTTER* aPlotter, int aUnit, int aConvert, bool aBackground,
 const VECTOR2I& aOffset, const TRANSFORM& aTransform, bool aDimmed ) const;
 
 void PlotLibFields( PLOTTER* aPlotter, int aUnit, int aConvert, bool aBackground,
 const VECTOR2I& aOffset, const TRANSFORM& aTransform, bool aDimmed,
 bool aPlotHidden = true );
 
 void AddDrawItem( LIB_ITEM* aItem, bool aSort = true );
 
 void RemoveDrawItem( LIB_ITEM* aItem );
 
 void RemoveField( LIB_FIELD* aField ) { RemoveDrawItem( aField ); }
 
 size_t GetPinCount() const { return m_drawings.size( LIB_PIN_T ); }
 
 size_t GetFieldCount() const { return m_drawings.size( LIB_FIELD_T ); }
 
 void GetPins( LIB_PINS& aList, int aUnit = 0, int aConvert = 0 ) const;
 
 std::vector<LIB_PIN*> GetAllLibPins() const;
 
 int GetPinCount() override { return GetAllLibPins().size(); }
 
 LIB_PIN* GetPin( const wxString& aNumber, int aUnit = 0, int aConvert = 0 ) const;
 
 bool PinsConflictWith( const LIB_SYMBOL& aOtherSymbol, bool aTestNums, bool aTestNames,
 bool aTestType, bool aTestOrientation, bool aTestLength ) const;
 
 void SetOffset( const VECTOR2I& aOffset );
 
 void RemoveDuplicateDrawItems();
 
 bool HasConversion() const;
 
 int GetMaxPinNumber() const;
 
 void ClearTempFlags();
 void ClearEditFlags();
 
 LIB_ITEM* LocateDrawItem( int aUnit, int aConvert, KICAD_T aType, const VECTOR2I& aPoint );
 
 LIB_ITEM* LocateDrawItem( int aUnit, int aConvert, 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 = true );
 int GetUnitCount() const override;
 
 wxString GetUnitReference( int aUnit ) override;
 
 bool HasUnitDisplayName( int aUnit ) override;
 
 wxString GetUnitDisplayName( int aUnit ) override;
 
 void CopyUnitDisplayNames( std::map<int, wxString>& aTarget ) const;
 
 void SetUnitDisplayName( int aUnit, const wxString& aName );
 
 bool IsMulti() const { return m_unitCount > 1; }
 
 static wxString SubReference( int aUnit, bool aAddSeparator = true );
 
 // Accessors to sub ref parameters
 static int GetSubpartIdSeparator() { return m_subpartIdSeparator; }
 
 static int* SubpartIdSeparatorPtr() { return &m_subpartIdSeparator; }
 static int GetSubpartFirstId() { return m_subpartFirstId; }
 
 static int* SubpartFirstIdPtr() { return &m_subpartFirstId; }
 
 static void SetSubpartIdNotation( int aSep, int aFirstId );
 
 void SetConversion( bool aSetConvert, bool aDuplicatePins = true );
 
 void SetPinNameOffset( int aOffset ) { m_pinNameOffset = aOffset; }
 int GetPinNameOffset() const { return m_pinNameOffset; }
 
 void SetShowPinNames( bool aShow ) { m_showPinNames = aShow; }
 bool ShowPinNames() const { return m_showPinNames; }
 
 void SetShowPinNumbers( bool aShow ) { m_showPinNumbers = aShow; }
 bool ShowPinNumbers() const { return m_showPinNumbers; }
 
 void SetExcludedFromSim( bool aExcludeFromSim ) { m_excludedFromSim = aExcludeFromSim; }
 bool GetExcludedFromSim() const { return m_excludedFromSim; }
 
 void SetExcludedFromBOM( bool aExcludeFromBOM ) { m_excludedFromBOM = aExcludeFromBOM; }
 bool GetExcludedFromBOM() const { return m_excludedFromBOM; }
 
 void SetExcludedFromBoard( bool aExcludeFromBoard ) { m_excludedFromBoard = aExcludeFromBoard; }
 bool GetExcludedFromBoard() const { return m_excludedFromBoard; }
 
 int Compare( const LIB_SYMBOL& aRhs, int aCompareFlags = 0,
 REPORTER* aReporter = nullptr ) const;
 
 bool operator==( const LIB_SYMBOL* aSymbol ) const { return this == aSymbol; }
 bool operator==( const LIB_SYMBOL& aSymbol ) const
 {
 return Compare( aSymbol, LIB_ITEM::COMPARE_FLAGS::EQUALITY ) == 0;
 }
 
 bool operator!=( const LIB_SYMBOL& aSymbol ) const
 {
 return Compare( aSymbol, LIB_ITEM::COMPARE_FLAGS::EQUALITY ) != 0;
 }
 
 const LIB_SYMBOL& operator=( const LIB_SYMBOL& aSymbol );
 
 std::unique_ptr< LIB_SYMBOL > Flatten() const;
 
 std::vector<struct LIB_SYMBOL_UNIT> GetUnitDrawItems();
 
 std::vector<struct LIB_SYMBOL_UNIT> GetUniqueUnits();
 
 std::vector<LIB_ITEM*> GetUnitDrawItems( int aUnit, int aConvert );
 
#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;
 
 void deleteAllFields();
 
private:
 LIB_SYMBOL_SPTR m_me;
 LIB_SYMBOL_REF m_parent; 
 LIB_ID m_libId;
 LIB_ID m_sourceLibId; 
 timestamp_t m_lastModDate;
 
 int m_unitCount; 
 bool m_unitsLocked; 
 
 int m_pinNameOffset; 
 bool m_showPinNames;
 bool m_showPinNumbers;
 
 bool m_excludedFromSim;
 bool m_excludedFromBOM;
 bool m_excludedFromBoard;
 LIBRENTRYOPTIONS m_options; 
 
 LIB_ITEMS_CONTAINER m_drawings;
 
 SYMBOL_LIB* m_library;
 wxString m_name;
 wxString m_keyWords; 
 wxArrayString m_fpFilters; 
 
 static int m_subpartIdSeparator; 
 static int m_subpartFirstId; 
 std::map<int, wxString> m_unitDisplayNames;
};
 
#endif // CLASS_LIBENTRY_H