kicad/eeschema/sch_component.cpp

1859 lines
51 KiB
C++
Raw Normal View History

/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 1992-2020 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, 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
*/
2018-01-30 10:49:51 +00:00
#include <sch_edit_frame.h>
#include <widgets/msgpanel.h>
#include <bitmaps.h>
#include <core/mirror.h>
#include <lib_rectangle.h>
#include <lib_pin.h>
#include <lib_text.h>
#include <sch_component.h>
#include <sch_sheet_path.h>
#include <schematic.h>
#include <trace_helpers.h>
2020-10-14 03:37:48 +00:00
#include <trigo.h>
/**
* Convert a wxString to UTF8 and replace any control characters with a ~,
* where a control character is one of the first ASCII values up to ' ' 32d.
*/
std::string toUTFTildaText( const wxString& txt )
{
std::string ret = TO_UTF8( txt );
for( std::string::iterator it = ret.begin(); it!=ret.end(); ++it )
{
if( (unsigned char) *it <= ' ' )
*it = '~';
}
return ret;
}
/**
2019-07-02 20:09:23 +00:00
* Used to draw a dummy shape when a LIB_PART is not found in library
*
* This component is a 400 mils square with the text ??
* DEF DUMMY U 0 40 Y Y 1 0 N
* F0 "U" 0 -350 60 H V
* F1 "DUMMY" 0 350 60 H V
* DRAW
* T 0 0 0 150 0 0 0 ??
* S -200 200 200 -200 0 1 0
* ENDDRAW
* ENDDEF
*/
static LIB_PART* dummy()
{
static LIB_PART* part;
if( !part )
{
part = new LIB_PART( wxEmptyString );
LIB_RECTANGLE* square = new LIB_RECTANGLE( part );
square->MoveTo( wxPoint( Mils2iu( -200 ), Mils2iu( 200 ) ) );
square->SetEndPosition( wxPoint( Mils2iu( 200 ), Mils2iu( -200 ) ) );
LIB_TEXT* text = new LIB_TEXT( part );
text->SetTextSize( wxSize( Mils2iu( 150 ), Mils2iu( 150 ) ) );
text->SetText( wxString( wxT( "??" ) ) );
part->AddDrawItem( square );
part->AddDrawItem( text );
}
return part;
}
SCH_COMPONENT::SCH_COMPONENT( const wxPoint& aPos, SCH_ITEM* aParent ) :
SCH_ITEM( aParent, SCH_COMPONENT_T )
{
Init( aPos );
}
SCH_COMPONENT::SCH_COMPONENT( LIB_PART& aPart, LIB_ID aLibId, SCH_SHEET_PATH* sheet,
int unit, int convert, const wxPoint& pos ) :
SCH_ITEM( NULL, SCH_COMPONENT_T )
{
Init( pos );
2016-02-15 20:15:51 +00:00
m_unit = unit;
m_convert = convert;
m_lib_id = aLibId;
std::unique_ptr< LIB_PART > part;
part = aPart.Flatten();
part->SetParent();
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
SetLibSymbol( part.release() );
// Copy fields from the library component
UpdateFields( true, true );
// Update the reference -- just the prefix for now.
if( sheet )
SetRef( sheet, m_part->GetReferenceField().GetText() + wxT( "?" ) );
else
m_prefix = m_part->GetReferenceField().GetText() + wxT( "?" );
// Inherit the include in bill of materials and board netlist settings from library symbol.
m_inBom = aPart.GetIncludeInBom();
m_onBoard = aPart.GetIncludeOnBoard();
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
2020-11-07 14:31:50 +00:00
SCH_COMPONENT::SCH_COMPONENT( LIB_PART& aPart, SCH_SHEET_PATH* aSheet, PICKED_SYMBOL& aSel,
const wxPoint& pos ) :
SCH_COMPONENT( aPart, aSel.LibId, aSheet, aSel.Unit, aSel.Convert, pos )
{
// Set any fields that were modified as part of the component selection
for( auto const& i : aSel.Fields )
{
auto field = this->GetField( i.first );
if( field )
field->SetText( i.second );
}
}
SCH_COMPONENT::SCH_COMPONENT( const SCH_COMPONENT& aComponent ) :
SCH_ITEM( aComponent )
{
2020-11-14 18:11:28 +00:00
m_parent = aComponent.m_parent;
2020-11-16 13:15:54 +00:00
m_pos = aComponent.m_pos;
m_unit = aComponent.m_unit;
m_convert = aComponent.m_convert;
m_lib_id = aComponent.m_lib_id;
m_isInNetlist = aComponent.m_isInNetlist;
m_inBom = aComponent.m_inBom;
m_onBoard = aComponent.m_onBoard;
if( aComponent.m_part )
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
SetLibSymbol( new LIB_PART( *aComponent.m_part.get() ) );
2020-02-21 22:20:42 +00:00
const_cast<KIID&>( m_Uuid ) = aComponent.m_Uuid;
m_transform = aComponent.m_transform;
m_prefix = aComponent.m_prefix;
m_instanceReferences = aComponent.m_instanceReferences;
2020-11-16 13:15:54 +00:00
m_fields = aComponent.m_fields;
// Re-parent the fields, which before this had aComponent as parent
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : m_fields )
field.SetParent( this );
m_fieldsAutoplaced = aComponent.m_fieldsAutoplaced;
}
void SCH_COMPONENT::Init( const wxPoint& pos )
{
2020-11-16 13:15:54 +00:00
m_pos = pos;
m_unit = 1; // In multi unit chip - which unit to draw.
m_convert = LIB_ITEM::LIB_CONVERT::BASE; // De Morgan Handling
// The rotation/mirror transformation matrix. pos normal
m_transform = TRANSFORM();
// construct only the mandatory fields, which are the first 4 only.
for( int i = 0; i < MANDATORY_FIELDS; ++i )
{
2020-11-16 13:15:54 +00:00
m_fields.emplace_back( pos, i, this, TEMPLATE_FIELDNAME::GetDefaultFieldName( i ) );
2020-11-12 21:31:41 +00:00
if( i == REFERENCE_FIELD )
2020-11-16 13:15:54 +00:00
m_fields.back().SetLayer( LAYER_REFERENCEPART );
2020-11-12 21:31:41 +00:00
else if( i == VALUE_FIELD )
2020-11-16 13:15:54 +00:00
m_fields.back().SetLayer( LAYER_VALUEPART );
else
2020-11-16 13:15:54 +00:00
m_fields.back().SetLayer( LAYER_FIELDS );
}
m_prefix = wxString( wxT( "U" ) );
2019-04-09 01:54:41 +00:00
m_isInNetlist = true;
m_inBom = true;
m_onBoard = true;
}
EDA_ITEM* SCH_COMPONENT::Clone() const
{
return new SCH_COMPONENT( *this );
}
void SCH_COMPONENT::ViewGetLayers( int aLayers[], int& aCount ) const
{
aCount = 3;
aLayers[0] = LAYER_DEVICE;
aLayers[1] = LAYER_DEVICE_BACKGROUND;
aLayers[2] = LAYER_SELECTION_SHADOWS;
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
void SCH_COMPONENT::SetLibId( const LIB_ID& aLibId )
{
if( m_lib_id != aLibId )
{
m_lib_id = aLibId;
SetModified();
}
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
wxString SCH_COMPONENT::GetSchSymbolLibraryName() const
{
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
if( !m_schLibSymbolName.IsEmpty() )
return m_schLibSymbolName;
else
return m_lib_id.Format().wx_str();
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
void SCH_COMPONENT::SetLibSymbol( LIB_PART* aLibSymbol )
{
wxCHECK2( ( aLibSymbol == nullptr ) || ( aLibSymbol->IsRoot() ), aLibSymbol = nullptr );
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
m_part.reset( aLibSymbol );
UpdatePins();
}
wxString SCH_COMPONENT::GetDescription() const
{
if( m_part )
return m_part->GetDescription();
return wxEmptyString;
}
wxString SCH_COMPONENT::GetDatasheet() const
{
if( m_part )
return m_part->GetDatasheetField().GetText();
return wxEmptyString;
}
void SCH_COMPONENT::UpdatePins()
{
std::map<wxString, wxString> altPinMap;
for( const std::unique_ptr<SCH_PIN>& pin : m_pins )
{
if( !pin->GetAlt().IsEmpty() )
altPinMap[ pin->GetNumber() ] = pin->GetAlt();
}
m_pins.clear();
m_pinMap.clear();
if( !m_part )
return;
unsigned i = 0;
for( LIB_PIN* libPin = m_part->GetNextPin(); libPin; libPin = m_part->GetNextPin( libPin ) )
{
wxASSERT( libPin->Type() == LIB_PIN_T );
if( libPin->GetConvert() && m_convert && ( m_convert != libPin->GetConvert() ) )
continue;
m_pins.push_back( std::make_unique<SCH_PIN>( libPin, this ) );
auto ii = altPinMap.find( libPin->GetNumber() );
if( ii != altPinMap.end() )
m_pins.back()->SetAlt( ii->second );
m_pinMap[ libPin ] = i;
++i;
}
}
void SCH_COMPONENT::SetUnit( int aUnit )
{
if( m_unit != aUnit )
{
m_unit = aUnit;
SetModified();
}
}
void SCH_COMPONENT::UpdateUnit( int aUnit )
{
m_unit = aUnit;
}
void SCH_COMPONENT::SetConvert( int aConvert )
{
if( m_convert != aConvert )
{
m_convert = aConvert;
// The convert may have a different pin layout so the update the pin map.
UpdatePins();
SetModified();
}
}
void SCH_COMPONENT::SetTransform( const TRANSFORM& aTransform )
{
if( m_transform != aTransform )
{
m_transform = aTransform;
SetModified();
}
}
int SCH_COMPONENT::GetUnitCount() const
{
if( m_part )
return m_part->GetUnitCount();
return 0;
}
2020-04-14 12:25:00 +00:00
void SCH_COMPONENT::Print( RENDER_SETTINGS* aSettings, const wxPoint& aOffset )
{
2020-04-14 12:25:00 +00:00
PART_DRAW_OPTIONS opts;
opts.transform = m_transform;
opts.draw_visible_fields = false;
opts.draw_hidden_fields = false;
if( m_part )
{
2020-11-16 13:15:54 +00:00
m_part->Print( aSettings, m_pos + aOffset, m_unit, m_convert, opts );
}
else // Use dummy() part if the actual cannot be found.
{
2020-11-16 13:15:54 +00:00
dummy()->Print( aSettings, m_pos + aOffset, 0, 0, opts );
}
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : m_fields )
2020-04-14 12:25:00 +00:00
field.Print( aSettings, aOffset );
}
void SCH_COMPONENT::AddHierarchicalReference( const KIID_PATH& aPath, const wxString& aRef,
int aUnit, const wxString& aValue,
const wxString& aFootprint )
2008-04-12 18:39:20 +00:00
{
2008-04-15 19:38:19 +00:00
// Search for an existing path and remove it if found (should not occur)
for( unsigned ii = 0; ii < m_instanceReferences.size(); ii++ )
2008-04-15 19:38:19 +00:00
{
if( m_instanceReferences[ii].m_Path == aPath )
2008-04-15 19:38:19 +00:00
{
wxLogTrace( traceSchSheetPaths, "Removing symbol instance:\n"
" sheet path %s\n"
" reference %s, unit %d from symbol %s.",
aPath.AsString(),
m_instanceReferences[ii].m_Reference,
m_instanceReferences[ii].m_Unit,
m_Uuid.AsString() );
m_instanceReferences.erase( m_instanceReferences.begin() + ii );
ii--;
2008-04-15 19:38:19 +00:00
}
}
2020-11-15 17:03:27 +00:00
SYMBOL_INSTANCE_REFERENCE instance;
instance.m_Path = aPath;
instance.m_Reference = aRef;
instance.m_Unit = aUnit;
instance.m_Value = aValue;
instance.m_Footprint = aFootprint;
wxLogTrace( traceSchSheetPaths, "Adding symbol instance:\n"
" sheet path %s\n"
" reference %s, unit %d to symbol %s.",
aPath.AsString(),
aRef,
aUnit,
m_Uuid.AsString() );
m_instanceReferences.push_back( instance );
}
const wxString SCH_COMPONENT::GetRef( const SCH_SHEET_PATH* sheet, bool aIncludeUnit ) const
{
KIID_PATH path = sheet->Path();
wxString ref;
2020-11-15 17:03:27 +00:00
for( const SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
if( instance.m_Path == path )
{
ref = instance.m_Reference;
break;
}
}
2019-07-02 20:09:23 +00:00
// If it was not found in m_Paths array, then see if it is in m_Field[REFERENCE] -- if so,
// use this as a default for this path. This will happen if we load a version 1 schematic
// file. It will also mean that multiple instances of the same sheet by default all have
// the same component references, but perhaps this is best.
2020-11-12 21:31:41 +00:00
if( ref.IsEmpty() && !GetField( REFERENCE_FIELD )->GetText().IsEmpty() )
{
2020-11-12 21:31:41 +00:00
const_cast<SCH_COMPONENT*>( this )->SetRef( sheet, GetField( REFERENCE_FIELD )->GetText() );
ref = GetField( REFERENCE_FIELD )->GetText();
}
2011-12-07 18:47:59 +00:00
if( ref.IsEmpty() )
ref = m_prefix;
if( aIncludeUnit && GetUnitCount() > 1 )
ref += LIB_PART::SubReference( GetUnit() );
return ref;
}
2007-09-20 21:06:49 +00:00
bool SCH_COMPONENT::IsReferenceStringValid( const wxString& aReferenceString )
{
wxString text = aReferenceString;
bool ok = true;
// Try to unannotate this reference
while( !text.IsEmpty() && ( text.Last() == '?' || wxIsdigit( text.Last() ) ) )
text.RemoveLast();
if( text.IsEmpty() )
ok = false;
return ok;
}
2016-02-15 20:18:32 +00:00
void SCH_COMPONENT::SetRef( const SCH_SHEET_PATH* sheet, const wxString& ref )
{
KIID_PATH path = sheet->Path();
bool notInArray = true;
2008-04-12 18:39:20 +00:00
// check to see if it is already there before inserting it
2020-11-15 17:03:27 +00:00
for( SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
if( instance.m_Path == path )
{
instance.m_Reference = ref;
notInArray = false;
}
}
if( notInArray )
AddHierarchicalReference( path, ref, m_unit );
for( std::unique_ptr<SCH_PIN>& pin : m_pins )
pin->ClearDefaultNetName( sheet );
2020-11-12 21:31:41 +00:00
SCH_FIELD* rf = GetField( REFERENCE_FIELD );
// @todo Should we really be checking for what is a "reasonable" position?
if( rf->GetText().IsEmpty()
2020-11-16 13:15:54 +00:00
|| ( abs( rf->GetTextPos().x - m_pos.x ) +
abs( rf->GetTextPos().y - m_pos.y ) > Mils2iu( 10000 ) ) )
{
// move it to a reasonable position
2020-11-16 13:15:54 +00:00
rf->SetTextPos( m_pos + wxPoint( Mils2iu( 50 ), Mils2iu( 50 ) ) );
}
rf->SetText( ref ); // for drawing.
// Reinit the m_prefix member if needed
wxString prefix = ref;
2011-12-07 18:47:59 +00:00
if( IsReferenceStringValid( prefix ) )
{
while( prefix.Last() == '?' || wxIsdigit( prefix.Last() ) )
prefix.RemoveLast();
}
else
2011-12-07 18:47:59 +00:00
{
prefix = wxT( "U" ); // Set to default ref prefix
2011-12-07 18:47:59 +00:00
}
if( m_prefix != prefix )
m_prefix = prefix;
2019-04-09 01:54:41 +00:00
// Power components have references starting with # and are not included in netlists
m_isInNetlist = ! ref.StartsWith( wxT( "#" ) );
}
bool SCH_COMPONENT::IsAnnotated( const SCH_SHEET_PATH* aSheet )
{
KIID_PATH path = aSheet->Path();
2020-11-15 17:03:27 +00:00
for( const SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
if( instance.m_Path == path )
return instance.m_Reference.Last() != '?';
}
return false;
}
int SCH_COMPONENT::GetUnitSelection( const SCH_SHEET_PATH* aSheet ) const
{
KIID_PATH path = aSheet->Path();
2020-11-15 17:03:27 +00:00
for( const SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
if( instance.m_Path == path )
return instance.m_Unit;
}
2019-07-02 20:09:23 +00:00
// If it was not found in m_Paths array, then use m_unit. This will happen if we load a
// version 1 schematic file.
return m_unit;
}
void SCH_COMPONENT::SetUnitSelection( const SCH_SHEET_PATH* aSheet, int aUnitSelection )
{
KIID_PATH path = aSheet->Path();
// check to see if it is already there before inserting it
2020-11-15 17:03:27 +00:00
for( SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
if( instance.m_Path == path )
{
instance.m_Unit = aUnitSelection;
return;
}
}
// didn't find it; better add it
AddHierarchicalReference( path, m_prefix, aUnitSelection );
}
const wxString SCH_COMPONENT::GetValue( const SCH_SHEET_PATH* sheet, bool aResolve ) const
{
KIID_PATH path = sheet->Path();
2020-11-15 17:03:27 +00:00
for( const SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
if( instance.m_Path == path && !instance.m_Value.IsEmpty() )
{
// This can only be an override from an Update Schematic from PCB, and therefore
// will always be fully resolved.
return instance.m_Value;
}
}
if( !aResolve )
return GetField( VALUE_FIELD )->GetText();
2020-11-12 21:31:41 +00:00
return GetField( VALUE_FIELD )->GetShownText();
}
void SCH_COMPONENT::SetValue( const SCH_SHEET_PATH* sheet, const wxString& aValue )
{
if( sheet == nullptr )
{
// Clear instance overrides and set primary field value
2020-11-15 17:03:27 +00:00
for( SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
instance.m_Value = wxEmptyString;
2020-11-16 13:15:54 +00:00
m_fields[ VALUE_FIELD ].SetText( aValue );
return;
}
KIID_PATH path = sheet->Path();
// check to see if it is already there before inserting it
2020-11-15 17:03:27 +00:00
for( SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
if( instance.m_Path == path )
{
instance.m_Value = aValue;
return;
}
}
// didn't find it; better add it
AddHierarchicalReference( path, m_prefix, m_unit, aValue, wxEmptyString );
}
const wxString SCH_COMPONENT::GetFootprint( const SCH_SHEET_PATH* sheet, bool aResolve ) const
{
KIID_PATH path = sheet->Path();
2020-11-15 17:03:27 +00:00
for( const SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
if( instance.m_Path == path && !instance.m_Footprint.IsEmpty() )
{
// This can only be an override from an Update Schematic from PCB, and therefore
// will always be fully resolved.
return instance.m_Footprint;
}
}
if( !aResolve )
return GetField( FOOTPRINT_FIELD )->GetText();
2020-11-12 21:31:41 +00:00
return GetField( FOOTPRINT_FIELD )->GetShownText();
}
void SCH_COMPONENT::SetFootprint( const SCH_SHEET_PATH* sheet, const wxString& aFootprint )
{
if( sheet == nullptr )
{
// Clear instance overrides and set primary field value
2020-11-15 17:03:27 +00:00
for( SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
2020-09-08 10:01:13 +00:00
instance.m_Footprint = wxEmptyString;
2020-11-16 13:15:54 +00:00
m_fields[ FOOTPRINT_FIELD ].SetText( aFootprint );
return;
}
KIID_PATH path = sheet->Path();
// check to see if it is already there before inserting it
2020-11-15 17:03:27 +00:00
for( SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
if( instance.m_Path == path )
{
instance.m_Footprint = aFootprint;
return;
}
}
// didn't find it; better add it
AddHierarchicalReference( path, m_prefix, m_unit, wxEmptyString, aFootprint );
}
SCH_FIELD* SCH_COMPONENT::GetField( int aFieldNdx )
2007-09-20 21:06:49 +00:00
{
2020-11-16 13:15:54 +00:00
if( (unsigned) aFieldNdx < m_fields.size() )
return &m_fields[aFieldNdx];
return nullptr;
}
const SCH_FIELD* SCH_COMPONENT::GetField( int aFieldNdx ) const
{
2020-11-16 13:15:54 +00:00
if( (unsigned) aFieldNdx < m_fields.size() )
return &m_fields[aFieldNdx];
return nullptr;
2007-05-06 16:03:28 +00:00
}
wxString SCH_COMPONENT::GetFieldText( const wxString& aFieldName, SCH_EDIT_FRAME* aFrame ) const
{
2020-11-16 13:15:54 +00:00
for( const SCH_FIELD& field : m_fields )
{
if( aFieldName == field.GetName() || aFieldName == field.GetCanonicalName() )
2019-07-02 20:09:23 +00:00
return field.GetText();
}
return wxEmptyString;
}
2007-05-06 16:03:28 +00:00
void SCH_COMPONENT::GetFields( std::vector<SCH_FIELD*>& aVector, bool aVisibleOnly )
{
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : m_fields )
{
2019-07-02 20:09:23 +00:00
if( !aVisibleOnly || ( field.IsVisible() && !field.IsVoid() ) )
aVector.push_back( &field );
}
}
SCH_FIELD* SCH_COMPONENT::AddField( const SCH_FIELD& aField )
2007-05-06 16:03:28 +00:00
{
2020-11-16 13:15:54 +00:00
int newNdx = m_fields.size();
2020-11-16 13:15:54 +00:00
m_fields.push_back( aField );
return &m_fields[newNdx];
}
void SCH_COMPONENT::RemoveField( const wxString& aFieldName )
{
2020-11-16 13:15:54 +00:00
for( unsigned i = MANDATORY_FIELDS; i < m_fields.size(); ++i )
{
2020-11-16 13:15:54 +00:00
if( aFieldName == m_fields[i].GetName( false ) )
{
2020-11-16 13:15:54 +00:00
m_fields.erase( m_fields.begin() + i );
return;
}
}
}
SCH_FIELD* SCH_COMPONENT::FindField( const wxString& aFieldName, bool aIncludeDefaultFields )
{
unsigned start = aIncludeDefaultFields ? 0 : MANDATORY_FIELDS;
2020-11-16 13:15:54 +00:00
for( unsigned i = start; i < m_fields.size(); ++i )
{
2020-11-16 13:15:54 +00:00
if( aFieldName == m_fields[i].GetName( false ) )
return &m_fields[i];
}
return NULL;
2007-05-06 16:03:28 +00:00
}
void SCH_COMPONENT::UpdateFields( bool aResetStyle, bool aResetRef )
{
if( m_part )
{
wxString symbolName;
LIB_FIELDS fields;
m_part->GetFields( fields );
for( const LIB_FIELD& libField : fields )
{
int idx = libField.GetId();
SCH_FIELD* schField;
2020-11-12 21:31:41 +00:00
if( idx == REFERENCE_FIELD && !aResetRef )
continue;
if( idx >= 0 && idx < MANDATORY_FIELDS )
{
schField = GetField( idx );
}
else
{
schField = FindField( libField.GetCanonicalName() );
if( !schField )
{
wxString fieldName = libField.GetCanonicalName();
SCH_FIELD newField( wxPoint( 0, 0), GetFieldCount(), this, fieldName );
schField = AddField( newField );
}
}
if( aResetStyle )
{
schField->ImportValues( libField );
2020-11-16 13:15:54 +00:00
schField->SetTextPos( m_pos + libField.GetTextPos() );
}
2020-11-12 21:31:41 +00:00
if( idx == VALUE_FIELD )
{
schField->SetText( m_lib_id.GetLibItemName() ); // fetch alias-specific value
symbolName = m_lib_id.GetLibItemName();
}
2020-11-12 21:31:41 +00:00
else if( idx == DATASHEET_FIELD )
{
schField->SetText( GetDatasheet() ); // fetch alias-specific value
}
else
{
schField->SetText( libField.GetText() );
}
}
}
}
void SCH_COMPONENT::RunOnChildren( const std::function<void( SCH_ITEM* )>& aFunction )
{
for( const std::unique_ptr<SCH_PIN>& pin : m_pins )
aFunction( pin.get() );
for( SCH_FIELD& field : m_fields )
aFunction( &field );
}
SCH_PIN* SCH_COMPONENT::GetPin( const wxString& aNumber )
{
for( const std::unique_ptr<SCH_PIN>& pin : m_pins )
{
if( pin->GetNumber() == aNumber )
return pin.get();
}
return nullptr;
}
void SCH_COMPONENT::GetLibPins( std::vector<LIB_PIN*>& aPinsList )
{
if( m_part )
m_part->GetPins( aPinsList, m_unit, m_convert );
}
SCH_PIN* SCH_COMPONENT::GetPin( LIB_PIN* aLibPin )
{
wxASSERT( m_pinMap.count( aLibPin ) );
return m_pins[ m_pinMap.at( aLibPin ) ].get();
}
std::vector<SCH_PIN*> SCH_COMPONENT::GetPins( const SCH_SHEET_PATH* aSheet ) const
{
std::vector<SCH_PIN*> pins;
if( aSheet == nullptr )
{
wxCHECK_MSG( Schematic(), pins, "Can't call GetPins on a component with no schematic" );
aSheet = &Schematic()->CurrentSheet();
}
int unit = GetUnitSelection( aSheet );
for( const auto& p : m_pins )
{
if( unit && p->GetLibPin()->GetUnit() && ( p->GetLibPin()->GetUnit() != unit ) )
continue;
pins.push_back( p.get() );
}
return pins;
}
void SCH_COMPONENT::SwapData( SCH_ITEM* aItem )
2007-05-06 16:03:28 +00:00
{
wxCHECK_RET( (aItem != NULL) && (aItem->Type() == SCH_COMPONENT_T),
wxT( "Cannot swap data with invalid component." ) );
SCH_COMPONENT* component = (SCH_COMPONENT*) aItem;
std::swap( m_lib_id, component->m_lib_id );
LIB_PART* part = component->m_part.release();
component->m_part.reset( m_part.release() );
component->UpdatePins();
m_part.reset( part );
UpdatePins();
2020-11-16 13:15:54 +00:00
std::swap( m_pos, component->m_pos );
std::swap( m_unit, component->m_unit );
std::swap( m_convert, component->m_convert );
2020-11-16 13:15:54 +00:00
m_fields.swap( component->m_fields ); // std::vector's swap()
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : component->m_fields )
2020-03-06 20:02:58 +00:00
field.SetParent( component );
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : m_fields )
2020-03-06 20:02:58 +00:00
field.SetParent( this );
TRANSFORM tmp = m_transform;
m_transform = component->m_transform;
component->m_transform = tmp;
std::swap( m_instanceReferences, component->m_instanceReferences );
2007-05-06 16:03:28 +00:00
}
void SCH_COMPONENT::GetContextualTextVars( wxArrayString* aVars ) const
{
for( int i = 0; i < MANDATORY_FIELDS; ++i )
2020-11-16 13:15:54 +00:00
aVars->push_back( m_fields[i].GetCanonicalName().Upper() );
2020-11-16 13:15:54 +00:00
for( size_t i = MANDATORY_FIELDS; i < m_fields.size(); ++i )
aVars->push_back( m_fields[i].GetName() );
aVars->push_back( wxT( "FOOTPRINT_LIBRARY" ) );
aVars->push_back( wxT( "FOOTPRINT_NAME" ) );
aVars->push_back( wxT( "UNIT" ) );
}
bool SCH_COMPONENT::ResolveTextVar( wxString* token, int aDepth ) const
{
SCHEMATIC* schematic = Schematic();
for( int i = 0; i < MANDATORY_FIELDS; ++i )
{
2020-11-16 13:15:54 +00:00
if( token->IsSameAs( m_fields[ i ].GetCanonicalName().Upper() ) )
{
2020-11-12 21:31:41 +00:00
if( i == REFERENCE_FIELD && schematic )
*token = GetRef( &schematic->CurrentSheet(), true );
2020-11-12 21:31:41 +00:00
else if( i == VALUE_FIELD && schematic )
*token = GetValue( &schematic->CurrentSheet(), true );
2020-11-12 21:31:41 +00:00
else if( i == FOOTPRINT_FIELD && schematic )
*token = GetFootprint( &schematic->CurrentSheet(), true );
else
2020-11-16 13:15:54 +00:00
*token = m_fields[ i ].GetShownText( aDepth + 1 );
return true;
}
}
2020-11-16 13:15:54 +00:00
for( size_t i = MANDATORY_FIELDS; i < m_fields.size(); ++i )
{
2020-11-16 13:15:54 +00:00
if( token->IsSameAs( m_fields[ i ].GetName() )
|| token->IsSameAs( m_fields[ i ].GetName().Upper() ) )
{
2020-11-16 13:15:54 +00:00
*token = m_fields[ i ].GetShownText( aDepth + 1 );
return true;
}
}
if( token->IsSameAs( wxT( "FOOTPRINT_LIBRARY" ) ) )
{
wxString footprint;
if( schematic )
footprint = GetFootprint( &schematic->CurrentSheet(), true );
else
2020-11-16 13:15:54 +00:00
footprint = m_fields[ FOOTPRINT_FIELD ].GetShownText();
wxArrayString parts = wxSplit( footprint, ':' );
*token = parts[ 0 ];
return true;
}
else if( token->IsSameAs( wxT( "FOOTPRINT_NAME" ) ) )
{
wxString footprint;
if( schematic )
footprint = GetFootprint( &schematic->CurrentSheet(), true );
else
2020-11-16 13:15:54 +00:00
footprint = m_fields[ FOOTPRINT_FIELD ].GetShownText();
wxArrayString parts = wxSplit( footprint, ':' );
*token = parts[ std::min( 1, (int) parts.size() - 1 ) ];
return true;
}
else if( token->IsSameAs( wxT( "UNIT" ) ) )
{
int unit;
if( schematic )
unit = GetUnitSelection( &schematic->CurrentSheet() );
else
unit = GetUnit();
*token = LIB_PART::SubReference( unit );
return true;
}
return false;
}
void SCH_COMPONENT::ClearAnnotation( const SCH_SHEET_PATH* aSheetPath )
{
// Build a reference with no annotation,
// i.e. a reference ended by only one '?'
wxString defRef = m_prefix;
2011-12-07 18:47:59 +00:00
if( !IsReferenceStringValid( defRef ) )
{ // This is a malformed reference: reinit this reference
2016-02-15 20:22:45 +00:00
m_prefix = defRef = wxT("U"); // Set to default ref prefix
}
2007-05-06 16:03:28 +00:00
while( defRef.Last() == '?' )
defRef.RemoveLast();
defRef.Append( wxT( "?" ) );
2008-04-15 19:38:19 +00:00
if( aSheetPath )
{
KIID_PATH path = aSheetPath->Path();
2020-11-15 17:03:27 +00:00
for( SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
2008-04-21 06:34:56 +00:00
{
if( instance.m_Path == path )
instance.m_Reference = defRef;
2008-04-21 06:34:56 +00:00
}
}
else
{
2020-11-15 17:03:27 +00:00
for( SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
instance.m_Reference = defRef;
}
for( std::unique_ptr<SCH_PIN>& pin : m_pins )
pin->ClearDefaultNetName( aSheetPath );
2008-04-21 06:34:56 +00:00
// These 2 changes do not work in complex hierarchy.
// When a clear annotation is made, the calling function must call a
// UpdateAllScreenReferences for the active sheet.
// But this call cannot made here.
2020-11-16 13:15:54 +00:00
m_fields[REFERENCE_FIELD].SetText( defRef ); //for drawing.
2007-05-06 16:03:28 +00:00
}
2007-09-20 21:06:49 +00:00
bool SCH_COMPONENT::AddSheetPathReferenceEntryIfMissing( const KIID_PATH& aSheetPath )
{
// a empty sheet path is illegal:
wxCHECK( aSheetPath.size() > 0, false );
wxString reference_path;
2020-11-15 17:03:27 +00:00
for( const SYMBOL_INSTANCE_REFERENCE& instance : m_instanceReferences )
{
// if aSheetPath is found, nothing to do:
if( instance.m_Path == aSheetPath )
return false;
}
// This entry does not exist: add it, with its last-used reference
2020-11-16 13:15:54 +00:00
AddHierarchicalReference( aSheetPath, m_fields[REFERENCE_FIELD].GetText(), m_unit );
return true;
}
bool SCH_COMPONENT::ReplaceInstanceSheetPath( const KIID_PATH& aOldSheetPath,
const KIID_PATH& aNewSheetPath )
{
auto it = std::find_if( m_instanceReferences.begin(), m_instanceReferences.end(),
2020-11-15 17:03:27 +00:00
[ aOldSheetPath ]( SYMBOL_INSTANCE_REFERENCE& r )->bool
{
return aOldSheetPath == r.m_Path;
}
);
if( it != m_instanceReferences.end() )
{
wxLogTrace( traceSchSheetPaths,
"Replacing sheet path %s\n with sheet path %s\n for symbol %s.",
aOldSheetPath.AsString(), aNewSheetPath.AsString(), m_Uuid.AsString() );
it->m_Path = aNewSheetPath;
return true;
}
wxLogTrace( traceSchSheetPaths,
"Could not find sheet path %s\n to replace with sheet path %s\n for symbol %s.",
aOldSheetPath.AsString(), aNewSheetPath.AsString(), m_Uuid.AsString() );
return false;
}
void SCH_COMPONENT::SetOrientation( int aOrientation )
2007-05-06 16:03:28 +00:00
{
TRANSFORM temp = TRANSFORM();
bool transform = false;
2007-09-20 21:06:49 +00:00
switch( aOrientation )
2007-09-20 21:06:49 +00:00
{
case CMP_ORIENT_0:
case CMP_NORMAL: // default transform matrix
m_transform.x1 = 1;
m_transform.y2 = -1;
m_transform.x2 = m_transform.y1 = 0;
2007-09-20 21:06:49 +00:00
break;
case CMP_ROTATE_COUNTERCLOCKWISE: // Rotate + (incremental rotation)
temp.x1 = temp.y2 = 0;
temp.y1 = 1;
temp.x2 = -1;
transform = true;
2007-09-20 21:06:49 +00:00
break;
case CMP_ROTATE_CLOCKWISE: // Rotate - (incremental rotation)
temp.x1 = temp.y2 = 0;
temp.y1 = -1;
temp.x2 = 1;
transform = true;
2007-09-20 21:06:49 +00:00
break;
case CMP_MIRROR_Y: // Mirror Y (incremental rotation)
temp.x1 = -1;
temp.y2 = 1;
temp.y1 = temp.x2 = 0;
transform = true;
2007-09-20 21:06:49 +00:00
break;
case CMP_MIRROR_X: // Mirror X (incremental rotation)
temp.x1 = 1;
temp.y2 = -1;
temp.y1 = temp.x2 = 0;
transform = true;
2007-09-20 21:06:49 +00:00
break;
case CMP_ORIENT_90:
SetOrientation( CMP_ORIENT_0 );
SetOrientation( CMP_ROTATE_COUNTERCLOCKWISE );
2007-09-20 21:06:49 +00:00
break;
case CMP_ORIENT_180:
SetOrientation( CMP_ORIENT_0 );
SetOrientation( CMP_ROTATE_COUNTERCLOCKWISE );
SetOrientation( CMP_ROTATE_COUNTERCLOCKWISE );
2007-09-20 21:06:49 +00:00
break;
case CMP_ORIENT_270:
SetOrientation( CMP_ORIENT_0 );
SetOrientation( CMP_ROTATE_CLOCKWISE );
2007-09-20 21:06:49 +00:00
break;
case ( CMP_ORIENT_0 + CMP_MIRROR_X ):
SetOrientation( CMP_ORIENT_0 );
SetOrientation( CMP_MIRROR_X );
2007-09-20 21:06:49 +00:00
break;
case ( CMP_ORIENT_0 + CMP_MIRROR_Y ):
SetOrientation( CMP_ORIENT_0 );
SetOrientation( CMP_MIRROR_Y );
2007-09-20 21:06:49 +00:00
break;
case ( CMP_ORIENT_90 + CMP_MIRROR_X ):
SetOrientation( CMP_ORIENT_90 );
SetOrientation( CMP_MIRROR_X );
2007-09-20 21:06:49 +00:00
break;
case ( CMP_ORIENT_90 + CMP_MIRROR_Y ):
SetOrientation( CMP_ORIENT_90 );
SetOrientation( CMP_MIRROR_Y );
2007-09-20 21:06:49 +00:00
break;
case ( CMP_ORIENT_180 + CMP_MIRROR_X ):
SetOrientation( CMP_ORIENT_180 );
SetOrientation( CMP_MIRROR_X );
2007-09-20 21:06:49 +00:00
break;
case ( CMP_ORIENT_180 + CMP_MIRROR_Y ):
SetOrientation( CMP_ORIENT_180 );
SetOrientation( CMP_MIRROR_Y );
2007-09-20 21:06:49 +00:00
break;
case ( CMP_ORIENT_270 + CMP_MIRROR_X ):
SetOrientation( CMP_ORIENT_270 );
SetOrientation( CMP_MIRROR_X );
2007-09-20 21:06:49 +00:00
break;
case ( CMP_ORIENT_270 + CMP_MIRROR_Y ):
SetOrientation( CMP_ORIENT_270 );
SetOrientation( CMP_MIRROR_Y );
2007-09-20 21:06:49 +00:00
break;
default:
transform = false;
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
wxFAIL_MSG( "Invalid schematic symbol orientation type." );
2007-09-20 21:06:49 +00:00
break;
}
if( transform )
2008-04-12 18:39:20 +00:00
{
/* The new matrix transform is the old matrix transform modified by the
* requested transformation, which is the temp transform (rot,
* mirror ..) in order to have (in term of matrix transform):
* transform coord = new_m_transform * coord
* where transform coord is the coord modified by new_m_transform from
* the initial value coord.
* new_m_transform is computed (from old_m_transform and temp) to
* have:
* transform coord = old_m_transform * temp
2008-04-12 18:39:20 +00:00
*/
TRANSFORM newTransform;
2007-09-20 21:06:49 +00:00
newTransform.x1 = m_transform.x1 * temp.x1 + m_transform.x2 * temp.y1;
newTransform.y1 = m_transform.y1 * temp.x1 + m_transform.y2 * temp.y1;
newTransform.x2 = m_transform.x1 * temp.x2 + m_transform.x2 * temp.y2;
newTransform.y2 = m_transform.y1 * temp.x2 + m_transform.y2 * temp.y2;
m_transform = newTransform;
2007-09-20 21:06:49 +00:00
}
2007-05-06 16:03:28 +00:00
}
int SCH_COMPONENT::GetOrientation()
2007-05-06 16:03:28 +00:00
{
int rotate_values[] =
2007-09-20 21:06:49 +00:00
{
CMP_ORIENT_0,
CMP_ORIENT_90,
CMP_ORIENT_180,
CMP_ORIENT_270,
CMP_MIRROR_X + CMP_ORIENT_0,
CMP_MIRROR_X + CMP_ORIENT_90,
CMP_MIRROR_X + CMP_ORIENT_270,
CMP_MIRROR_Y,
CMP_MIRROR_Y + CMP_ORIENT_0,
CMP_MIRROR_Y + CMP_ORIENT_90,
CMP_MIRROR_Y + CMP_ORIENT_180,
CMP_MIRROR_Y + CMP_ORIENT_270
};
2007-09-20 21:06:49 +00:00
// Try to find the current transform option:
TRANSFORM transform = m_transform;
2007-09-20 21:06:49 +00:00
for( int type_rotate : rotate_values )
2007-09-20 21:06:49 +00:00
{
SetOrientation( type_rotate );
if( transform == m_transform )
return type_rotate;
2007-09-20 21:06:49 +00:00
}
// Error: orientation not found in list (should not happen)
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
wxFAIL_MSG( "Schematic symbol orientation matrix internal error." );
m_transform = transform;
return CMP_NORMAL;
2007-05-06 16:03:28 +00:00
}
2007-09-20 21:06:49 +00:00
#if defined(DEBUG)
2007-09-20 21:06:49 +00:00
void SCH_COMPONENT::Show( int nestLevel, std::ostream& os ) const
2007-05-06 16:03:28 +00:00
{
2007-09-20 21:06:49 +00:00
// for now, make it look like XML:
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str()
<< " ref=\"" << TO_UTF8( GetField( 0 )->GetName() )
<< '"' << " chipName=\""
2020-11-16 13:15:54 +00:00
<< GetLibId().Format() << '"' << m_pos
2020-11-14 14:29:11 +00:00
<< " layer=\"" << m_layer
<< '"' << ">\n";
// skip the reference, it's been output already.
for( int i = 1; i < GetFieldCount(); ++i )
2007-09-20 21:06:49 +00:00
{
wxString value = GetField( i )->GetText();
2007-09-20 21:06:49 +00:00
if( !value.IsEmpty() )
{
NestedSpace( nestLevel + 1, os ) << "<field" << " name=\""
<< TO_UTF8( GetField( i )->GetName() )
<< '"' << " value=\""
<< TO_UTF8( value ) << "\"/>\n";
2007-09-20 21:06:49 +00:00
}
}
NestedSpace( nestLevel, os ) << "</" << TO_UTF8( GetClass().Lower() ) << ">\n";
2007-05-06 16:03:28 +00:00
}
2007-09-20 21:06:49 +00:00
#endif
2007-05-06 16:03:28 +00:00
EDA_RECT SCH_COMPONENT::GetBodyBoundingBox() const
2008-04-15 19:38:19 +00:00
{
EDA_RECT bBox;
if( m_part )
bBox = m_part->GetBodyBoundingBox( m_unit, m_convert );
else
bBox = dummy()->GetBodyBoundingBox( m_unit, m_convert );
int x0 = bBox.GetX();
int xm = bBox.GetRight();
// We must reverse Y values, because matrix orientation
// suppose Y axis normal for the library items coordinates,
// m_transform reverse Y values, but bBox is already reversed!
int y0 = -bBox.GetY();
int ym = -bBox.GetBottom();
// Compute the real Boundary box (rotated, mirrored ...)
int x1 = m_transform.x1 * x0 + m_transform.y1 * y0;
int y1 = m_transform.x2 * x0 + m_transform.y2 * y0;
int x2 = m_transform.x1 * xm + m_transform.y1 * ym;
int y2 = m_transform.x2 * xm + m_transform.y2 * ym;
bBox.SetX( x1 );
bBox.SetY( y1 );
bBox.SetWidth( x2 - x1 );
bBox.SetHeight( y2 - y1 );
bBox.Normalize();
2008-04-15 19:38:19 +00:00
2020-11-16 13:15:54 +00:00
bBox.Offset( m_pos );
return bBox;
}
const EDA_RECT SCH_COMPONENT::GetBoundingBox() const
{
EDA_RECT bbox = GetBodyBoundingBox();
2020-11-16 13:15:54 +00:00
for( const SCH_FIELD& field : m_fields )
bbox.Merge( field.GetBoundingBox() );
return bbox;
2008-04-12 18:39:20 +00:00
}
const EDA_RECT SCH_COMPONENT::GetBoundingBox( bool aIncludeInvisibleText ) const
{
EDA_RECT bbox = GetBodyBoundingBox();
2020-11-16 13:15:54 +00:00
for( const SCH_FIELD& field : m_fields )
{
if( field.IsVisible() || aIncludeInvisibleText )
bbox.Merge( field.GetBoundingBox() );
}
return bbox;
}
void SCH_COMPONENT::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, MSG_PANEL_ITEMS& aList )
{
wxString msg;
SCH_EDIT_FRAME* schframe = dynamic_cast<SCH_EDIT_FRAME*>( aFrame );
SCH_SHEET_PATH* currentSheet = schframe ? &schframe->GetCurrentSheet() : nullptr;
// part and alias can differ if alias is not the root
if( m_part )
{
if( m_part.get() != dummy() )
{
aList.push_back( MSG_PANEL_ITEM( _( "Reference" ), GetRef( currentSheet ) ) );
msg = m_part->IsPower() ? _( "Power symbol" ) : _( "Value" );
aList.push_back( MSG_PANEL_ITEM( msg, GetValue( currentSheet, true ) ) );
#if 0 // Display component flags, for debug only
aList.push_back( MSG_PANEL_ITEM( _( "flags" ), wxString::Format( "%X",
GetEditFlags() ) ) );
#endif
// Display component reference in library and library
aList.push_back( MSG_PANEL_ITEM( _( "Name" ), GetLibId().GetLibItemName() ) );
if( !m_part->IsRoot() )
{
msg = _( "Missing parent" );
std::shared_ptr< LIB_PART > parent = m_part->GetParent().lock();
if( parent )
msg = parent->GetName();
aList.push_back( MSG_PANEL_ITEM( _( "Alias of" ), msg ) );
}
else if( !m_lib_id.GetLibNickname().empty() )
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
{
aList.push_back( MSG_PANEL_ITEM( _( "Library" ), m_lib_id.GetLibNickname() ) );
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
}
else
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
{
aList.push_back( MSG_PANEL_ITEM( _( "Library" ), _( "Undefined!!!" ) ) );
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
}
// Display the current associated footprint, if exists.
msg = GetFootprint( currentSheet, true );
if( msg.IsEmpty() )
msg = _( "<Unknown>" );
aList.push_back( MSG_PANEL_ITEM( _( "Footprint" ), msg ) );
// Display description of the component, and keywords found in lib
aList.push_back( MSG_PANEL_ITEM( _( "Description" ), m_part->GetDescription(),
DARKCYAN ) );
aList.push_back( MSG_PANEL_ITEM( _( "Keywords" ), m_part->GetKeyWords() ) );
}
}
else
{
aList.push_back( MSG_PANEL_ITEM( _( "Reference" ), GetRef( currentSheet ) ) );
aList.push_back( MSG_PANEL_ITEM( _( "Value" ), GetValue( currentSheet, true ) ) );
aList.push_back( MSG_PANEL_ITEM( _( "Name" ), GetLibId().GetLibItemName() ) );
wxString libNickname = GetLibId().GetLibNickname();
if( libNickname.empty() )
{
aList.push_back( MSG_PANEL_ITEM( _( "Library" ), _( "No library defined!" ) ) );
}
else
{
msg.Printf( _( "Symbol not found in %s!" ), libNickname );
aList.push_back( MSG_PANEL_ITEM( _( "Library" ), msg ) );
}
}
}
BITMAP_DEF SCH_COMPONENT::GetMenuImage() const
{
return add_component_xpm;
}
void SCH_COMPONENT::MirrorY( int aYaxis_position )
{
2020-11-16 13:15:54 +00:00
int dx = m_pos.x;
SetOrientation( CMP_MIRROR_Y );
2020-11-16 13:15:54 +00:00
MIRROR( m_pos.x, aYaxis_position );
dx -= m_pos.x; // dx,0 is the move vector for this transform
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : m_fields )
{
// Move the fields to the new position because the component itself has moved.
2020-03-06 20:02:58 +00:00
wxPoint pos = field.GetTextPos();
pos.x -= dx;
2020-03-06 20:02:58 +00:00
field.SetTextPos( pos );
}
}
void SCH_COMPONENT::MirrorX( int aXaxis_position )
{
2020-11-16 13:15:54 +00:00
int dy = m_pos.y;
SetOrientation( CMP_MIRROR_X );
2020-11-16 13:15:54 +00:00
MIRROR( m_pos.y, aXaxis_position );
dy -= m_pos.y; // dy,0 is the move vector for this transform
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : m_fields )
{
// Move the fields to the new position because the component itself has moved.
2020-03-06 20:02:58 +00:00
wxPoint pos = field.GetTextPos();
pos.y -= dy;
2020-03-06 20:02:58 +00:00
field.SetTextPos( pos );
}
}
void SCH_COMPONENT::Rotate( wxPoint aPosition )
{
2020-11-16 13:15:54 +00:00
wxPoint prev = m_pos;
2020-11-16 13:15:54 +00:00
RotatePoint( &m_pos, aPosition, 900 );
SetOrientation( CMP_ROTATE_COUNTERCLOCKWISE );
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : m_fields )
{
// Move the fields to the new position because the component itself has moved.
wxPoint pos = field.GetTextPos();
2020-11-16 13:15:54 +00:00
pos.x -= prev.x - m_pos.x;
pos.y -= prev.y - m_pos.y;
field.SetTextPos( pos );
}
}
bool SCH_COMPONENT::Matches( wxFindReplaceData& aSearchData, void* aAuxData )
{
2019-12-20 14:11:39 +00:00
wxLogTrace( traceFindItem, wxT( " item " ) + GetSelectMenuText( EDA_UNITS::MILLIMETRES ) );
// Components are searchable via the child field and pin item text.
return false;
}
void SCH_COMPONENT::GetEndPoints( std::vector <DANGLING_END_ITEM>& aItemList )
{
for( auto& pin : m_pins )
{
LIB_PIN* lib_pin = pin->GetLibPin();
if( lib_pin->GetUnit() && m_unit && ( m_unit != lib_pin->GetUnit() ) )
continue;
DANGLING_END_ITEM item( PIN_END, lib_pin, GetPinPhysicalPosition( lib_pin ), this );
aItemList.push_back( item );
}
}
bool SCH_COMPONENT::UpdateDanglingState( std::vector<DANGLING_END_ITEM>& aItemList,
const SCH_SHEET_PATH* aPath )
{
bool changed = false;
for( std::unique_ptr<SCH_PIN>& pin : m_pins )
{
bool previousState = pin->IsDangling();
pin->SetIsDangling( true );
2020-11-16 13:15:54 +00:00
wxPoint pos = m_transform.TransformCoordinate( pin->GetLocalPosition() ) + m_pos;
for( DANGLING_END_ITEM& each_item : aItemList )
{
// Some people like to stack pins on top of each other in a symbol to indicate
// internal connection. While technically connected, it is not particularly useful
// to display them that way, so skip any pins that are in the same symbol as this
// one.
if( each_item.GetParent() == this )
continue;
switch( each_item.GetType() )
{
case PIN_END:
case LABEL_END:
case SHEET_LABEL_END:
case WIRE_START_END:
case WIRE_END_END:
case NO_CONNECT_END:
case JUNCTION_END:
if( pos == each_item.GetPosition() )
pin->SetIsDangling( false );
break;
default:
break;
}
if( !pin->IsDangling() )
break;
}
changed = ( changed || ( previousState != pin->IsDangling() ) );
}
return changed;
}
wxPoint SCH_COMPONENT::GetPinPhysicalPosition( const LIB_PIN* Pin ) const
{
wxCHECK_MSG( Pin != NULL && Pin->Type() == LIB_PIN_T, wxPoint( 0, 0 ),
wxT( "Cannot get physical position of pin." ) );
2020-11-16 13:15:54 +00:00
return m_transform.TransformCoordinate( Pin->GetPosition() ) + m_pos;
}
std::vector<wxPoint> SCH_COMPONENT::GetConnectionPoints() const
{
std::vector<wxPoint> retval;
for( const std::unique_ptr<SCH_PIN>& pin : m_pins )
{
// Collect only pins attached to the current unit and convert.
// others are not associated to this component instance
int pin_unit = pin->GetLibPin()->GetUnit();
int pin_convert = pin->GetLibPin()->GetConvert();
if( pin_unit > 0 && pin_unit != GetUnit() )
continue;
if( pin_convert > 0 && pin_convert != GetConvert() )
continue;
2020-11-16 13:15:54 +00:00
retval.push_back( m_transform.TransformCoordinate( pin->GetLocalPosition() ) + m_pos );
}
return retval;
}
LIB_ITEM* SCH_COMPONENT::GetDrawItem( const wxPoint& aPosition, KICAD_T aType )
{
if( m_part )
{
// Calculate the position relative to the component.
2020-11-16 13:15:54 +00:00
wxPoint libPosition = aPosition - m_pos;
return m_part->LocateDrawItem( m_unit, m_convert, aType, libPosition, m_transform );
}
return NULL;
}
2019-12-20 14:11:39 +00:00
wxString SCH_COMPONENT::GetSelectMenuText( EDA_UNITS aUnits ) const
{
return wxString::Format( _( "Symbol %s [%s]" ),
2020-11-12 21:31:41 +00:00
GetField( REFERENCE_FIELD )->GetShownText(),
GetLibId().GetLibItemName().wx_str() );
}
SEARCH_RESULT SCH_COMPONENT::Visit( INSPECTOR aInspector, void* aTestData,
const KICAD_T aFilterTypes[] )
{
KICAD_T stype;
for( const KICAD_T* p = aFilterTypes; (stype = *p) != EOT; ++p )
{
if( stype == SCH_LOCATE_ANY_T
|| ( stype == SCH_COMPONENT_T )
|| ( stype == SCH_COMPONENT_LOCATE_POWER_T && m_part && m_part->IsPower() ) )
{
2019-12-28 00:55:11 +00:00
if( SEARCH_RESULT::QUIT == aInspector( this, aTestData ) )
return SEARCH_RESULT::QUIT;
}
2019-05-08 18:56:03 +00:00
if( stype == SCH_LOCATE_ANY_T || stype == SCH_FIELD_T )
{
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : m_fields )
{
2020-03-06 20:02:58 +00:00
if( SEARCH_RESULT::QUIT == aInspector( &field, (void*) this ) )
2019-12-28 00:55:11 +00:00
return SEARCH_RESULT::QUIT;
}
2019-05-08 18:56:03 +00:00
}
if( stype == SCH_FIELD_LOCATE_REFERENCE_T )
2019-05-08 18:56:03 +00:00
{
2020-11-12 21:31:41 +00:00
if( SEARCH_RESULT::QUIT == aInspector( GetField( REFERENCE_FIELD ), (void*) this ) )
2019-12-28 00:55:11 +00:00
return SEARCH_RESULT::QUIT;
2019-05-08 18:56:03 +00:00
}
if( stype == SCH_FIELD_LOCATE_VALUE_T
|| ( stype == SCH_COMPONENT_LOCATE_POWER_T && m_part && m_part->IsPower() ) )
2019-05-08 18:56:03 +00:00
{
2020-11-12 21:31:41 +00:00
if( SEARCH_RESULT::QUIT == aInspector( GetField( VALUE_FIELD ), (void*) this ) )
2019-12-28 00:55:11 +00:00
return SEARCH_RESULT::QUIT;
2019-05-08 18:56:03 +00:00
}
if( stype == SCH_FIELD_LOCATE_FOOTPRINT_T )
2019-05-08 18:56:03 +00:00
{
2020-11-12 21:31:41 +00:00
if( SEARCH_RESULT::QUIT == aInspector( GetField( FOOTPRINT_FIELD ), (void*) this ) )
2019-12-28 00:55:11 +00:00
return SEARCH_RESULT::QUIT;
2019-05-08 18:56:03 +00:00
}
if( stype == SCH_FIELD_LOCATE_DATASHEET_T )
2019-05-08 18:56:03 +00:00
{
2020-11-12 21:31:41 +00:00
if( SEARCH_RESULT::QUIT == aInspector( GetField( DATASHEET_FIELD ), (void*) this ) )
2019-12-28 00:55:11 +00:00
return SEARCH_RESULT::QUIT;
2019-05-08 18:56:03 +00:00
}
2019-05-08 18:56:03 +00:00
if( stype == SCH_LOCATE_ANY_T || stype == SCH_PIN_T )
{
for( const std::unique_ptr<SCH_PIN>& pin : m_pins )
{
// Collect only pins attached to the current unit and convert.
// others are not associated to this component instance
int pin_unit = pin->GetLibPin()->GetUnit();
int pin_convert = pin->GetLibPin()->GetConvert();
if( pin_unit > 0 && pin_unit != GetUnit() )
continue;
if( pin_convert > 0 && pin_convert != GetConvert() )
continue;
if( SEARCH_RESULT::QUIT == aInspector( pin.get(), (void*) this ) )
2019-12-28 00:55:11 +00:00
return SEARCH_RESULT::QUIT;
}
}
}
2019-12-28 00:55:11 +00:00
return SEARCH_RESULT::CONTINUE;
}
bool SCH_COMPONENT::operator <( const SCH_ITEM& aItem ) const
{
if( Type() != aItem.Type() )
return Type() < aItem.Type();
auto component = static_cast<const SCH_COMPONENT*>( &aItem );
EDA_RECT rect = GetBodyBoundingBox();
if( rect.GetArea() != component->GetBodyBoundingBox().GetArea() )
return rect.GetArea() < component->GetBodyBoundingBox().GetArea();
2020-11-16 13:15:54 +00:00
if( m_pos.x != component->m_pos.x )
return m_pos.x < component->m_pos.x;
2020-11-16 13:15:54 +00:00
if( m_pos.y != component->m_pos.y )
return m_pos.y < component->m_pos.y;
2020-02-20 12:11:04 +00:00
return m_Uuid < aItem.m_Uuid; // Ensure deterministic sort
}
bool SCH_COMPONENT::operator==( const SCH_COMPONENT& aComponent ) const
{
if( GetFieldCount() != aComponent.GetFieldCount() )
return false;
2020-11-12 21:31:41 +00:00
for( int i = VALUE_FIELD; i < GetFieldCount(); i++ )
{
if( GetField( i )->GetText().Cmp( aComponent.GetField( i )->GetText() ) != 0 )
return false;
}
return true;
}
bool SCH_COMPONENT::operator!=( const SCH_COMPONENT& aComponent ) const
{
return !( *this == aComponent );
}
SCH_COMPONENT& SCH_COMPONENT::operator=( const SCH_ITEM& aItem )
{
wxCHECK_MSG( Type() == aItem.Type(), *this,
wxT( "Cannot assign object type " ) + aItem.GetClass() + wxT( " to type " ) +
GetClass() );
if( &aItem != this )
{
SCH_ITEM::operator=( aItem );
SCH_COMPONENT* c = (SCH_COMPONENT*) &aItem;
m_lib_id = c->m_lib_id;
LIB_PART* libSymbol = c->m_part ? new LIB_PART( *c->m_part.get() ) : nullptr;
m_part.reset( libSymbol );
2020-11-16 13:15:54 +00:00
m_pos = c->m_pos;
m_unit = c->m_unit;
m_convert = c->m_convert;
m_transform = c->m_transform;
m_instanceReferences = c->m_instanceReferences;
2020-11-16 13:15:54 +00:00
m_fields = c->m_fields; // std::vector's assignment operator
// Reparent fields after assignment to new component.
2020-11-16 13:15:54 +00:00
for( SCH_FIELD& field : m_fields )
field.SetParent( this );
UpdatePins();
}
return *this;
}
bool SCH_COMPONENT::HitTest( const wxPoint& aPosition, int aAccuracy ) const
{
EDA_RECT bBox = GetBodyBoundingBox();
bBox.Inflate( aAccuracy );
if( bBox.Contains( aPosition ) )
return true;
return false;
}
bool SCH_COMPONENT::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
{
2020-11-14 18:11:28 +00:00
if( m_flags & STRUCT_DELETED || m_flags & SKIP_STRUCT )
return false;
EDA_RECT rect = aRect;
rect.Inflate( aAccuracy );
if( aContained )
return rect.Contains( GetBodyBoundingBox() );
return rect.Intersects( GetBodyBoundingBox() );
}
bool SCH_COMPONENT::doIsConnected( const wxPoint& aPosition ) const
{
2020-11-16 13:15:54 +00:00
wxPoint new_pos = m_transform.InverseTransform().TransformCoordinate( aPosition - m_pos );
for( const auto& pin : m_pins )
{
// Collect only pins attached to the current unit and convert.
// others are not associated to this component instance
int pin_unit = pin->GetLibPin()->GetUnit();
int pin_convert = pin->GetLibPin()->GetConvert();
if( pin_unit > 0 && pin_unit != GetUnit() )
continue;
if( pin_convert > 0 && pin_convert != GetConvert() )
continue;
if( pin->GetLocalPosition() == new_pos )
return true;
}
return false;
}
bool SCH_COMPONENT::IsInNetlist() const
{
2019-04-09 01:54:41 +00:00
return m_isInNetlist;
}
2013-09-28 22:53:55 +00:00
void SCH_COMPONENT::Plot( PLOTTER* aPlotter )
{
if( m_part )
{
2020-04-14 12:25:00 +00:00
TRANSFORM temp = GetTransform();
aPlotter->StartBlock( nullptr );
2020-11-16 13:15:54 +00:00
m_part->Plot( aPlotter, GetUnit(), GetConvert(), m_pos, temp );
2020-11-16 13:15:54 +00:00
for( SCH_FIELD field : m_fields )
field.Plot( aPlotter );
aPlotter->EndBlock( nullptr );
}
}
bool SCH_COMPONENT::HasBrightenedPins()
{
for( const auto& pin : m_pins )
{
if( pin->IsBrightened() )
return true;
}
return false;
}
void SCH_COMPONENT::ClearBrightenedPins()
{
for( auto& pin : m_pins )
pin->ClearBrightened();
}