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) 2004-2021 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_item.h>
#include <lib_field.h>
#include <vector>
#include <multivector.h>

class EDA_RECT;
class LINE_READER;
class OUTPUTFORMATTER;
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 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;
 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; }

 virtual wxString GetClass() const override
 {
 return wxT( "LIB_SYMBOL" );
 }

 virtual void SetName( const wxString& aName );
 wxString GetName() const override { return m_name; }

 LIB_ID GetLibId() const override { return m_libId; }
 void SetLibId( const LIB_ID& aLibId ) { m_libId = aLibId; }

 wxString GetLibNickname() const override { return GetLibraryName(); }

 void SetDescription( const wxString& aDescription ) { m_description = aDescription; }

 wxString GetDescription() override
 {
 if( m_description.IsEmpty() && IsAlias() )
 {
 if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
 return parent->GetDescription();
 }

 return m_description;
 }

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

 wxString GetSearchText() 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 EDA_RECT GetUnitBoundingBox( int aUnit, int aConvert ) const;

 const EDA_RECT GetBodyBoundingBox( int aUnit, int aConvert, bool aIncludePins ) const;

 const EDA_RECT 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 );

 LIB_FIELD* FindField( const wxString& aFieldName );

 const LIB_FIELD* FindField( const wxString& aFieldName ) const;

 LIB_FIELD* GetFieldById( int aId ) const;

 LIB_FIELD& GetValueField();

 LIB_FIELD& GetReferenceField();

 LIB_FIELD& GetFootprintField();

 LIB_FIELD& GetDatasheetField();

 int UpdateFieldOrdinals();

 int GetNextAvailableFieldId() const;

 void Print( const RENDER_SETTINGS* aSettings, const wxPoint& aOffset,
 int aMulti, int aConvert, const LIB_SYMBOL_OPTIONS& aOpts );

 void Plot( PLOTTER* aPlotter, int aUnit, int aConvert, const wxPoint& aOffset,
 const TRANSFORM& aTransform ) const;

 void PlotLibFields( PLOTTER* aPlotter, int aUnit, int aConvert, const wxPoint& aOffset,
 const TRANSFORM& aTransform );

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

 void RemoveDrawItem( LIB_ITEM* aItem );

 LIB_ITEM* GetNextDrawItem( const LIB_ITEM* aItem = nullptr, KICAD_T aType = TYPE_NOT_INIT );

 size_t GetPinCount() const { return m_drawings.size( LIB_PIN_T ); }

 size_t GetFieldCount() const { return m_drawings.size( LIB_FIELD_T ); }

 LIB_PIN* GetNextPin( LIB_PIN* aItem = nullptr )
 {
 return (LIB_PIN*) GetNextDrawItem( (LIB_ITEM*) aItem, LIB_PIN_T );
 }

 void GetPins( LIB_PINS& aList, int aUnit = 0, int aConvert = 0 ) const;

 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 wxPoint& aOffset );

 void RemoveDuplicateDrawItems();

 bool HasConversion() const;

 void ClearTempFlags();
 void ClearEditFlags();

 LIB_ITEM* LocateDrawItem( int aUnit, int aConvert, KICAD_T aType, const wxPoint& aPoint );

 LIB_ITEM* LocateDrawItem( int aUnit, int aConvert, KICAD_T aType, const wxPoint& aPoint,
 const TRANSFORM& aTransform );

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

 SEARCH_RESULT Visit( INSPECTOR inspector, void* testData, const KICAD_T scanTypes[] ) override;

 void SetUnitCount( int aCount, bool aDuplicateDrawItems = true );
 int GetUnitCount() const override;

 wxString GetUnitReference( int aUnit ) override;

 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 SetIncludeInBom( bool aIncludeInBom ) { m_includeInBom = aIncludeInBom; }
 bool GetIncludeInBom() const { return m_includeInBom; }

 void SetIncludeOnBoard( bool aIncludeOnBoard ) { m_includeOnBoard = aIncludeOnBoard; }
 bool GetIncludeOnBoard() const { return m_includeOnBoard; }

 int Compare( const LIB_SYMBOL& aRhs, int aCompareFlags = 0 ) 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;
 timestamp_t m_lastModDate;

 int m_unitCount; 
 bool m_unitsLocked; 

 int m_pinNameOffset; 
 bool m_showPinNames;
 bool m_showPinNumbers;

 bool m_includeInBom;
 bool m_includeOnBoard;
 LIBRENTRYOPTIONS m_options; 

 LIB_ITEMS_CONTAINER m_drawings;

 SYMBOL_LIB* m_library;
 wxString m_name;
 wxString m_description;
 wxString m_keyWords; 
 wxArrayString m_fpFilters; 

 static int m_subpartIdSeparator; 
 static int m_subpartFirstId; 
};

#endif // CLASS_LIBENTRY_H