1898 lines
49 KiB
C++
1898 lines
49 KiB
C++
/*
|
|
* 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-2015 Wayne Stambaugh <stambaughw@verizon.net>
|
|
* Copyright (C) 2004-2016 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
|
|
*/
|
|
|
|
/**
|
|
* @file class_libentry.cpp
|
|
*/
|
|
|
|
#include <fctsys.h>
|
|
#include <macros.h>
|
|
#include <kicad_string.h>
|
|
#include <class_drawpanel.h>
|
|
#include <plot_common.h>
|
|
#include <gr_basic.h>
|
|
#include <class_sch_screen.h>
|
|
#include <richio.h>
|
|
|
|
#include <general.h>
|
|
#include <template_fieldnames.h>
|
|
#include <transform.h>
|
|
#include <class_library.h>
|
|
#include <class_libentry.h>
|
|
#include <lib_pin.h>
|
|
#include <lib_arc.h>
|
|
#include <lib_bezier.h>
|
|
#include <lib_circle.h>
|
|
#include <lib_polyline.h>
|
|
#include <lib_rectangle.h>
|
|
#include <lib_text.h>
|
|
|
|
|
|
// the separator char between the subpart id and the reference
|
|
// 0 (no separator) or '.' or some other character
|
|
int LIB_PART::m_subpartIdSeparator = 0;
|
|
|
|
// the ascii char value to calculate the subpart symbol id from the part number:
|
|
// 'A' or '1' usually. (to print U1.A or U1.1)
|
|
// if this a a digit, a number is used as id symbol
|
|
int LIB_PART::m_subpartFirstId = 'A';
|
|
|
|
|
|
const wxChar traceSchLibMem[] = wxT( "KISCHLIBMEM" ); // public
|
|
|
|
|
|
LIB_ALIAS::LIB_ALIAS( const wxString& aName, LIB_PART* aRootPart ):
|
|
EDA_ITEM( LIB_ALIAS_T ),
|
|
shared( aRootPart )
|
|
{
|
|
name = aName;
|
|
}
|
|
|
|
|
|
LIB_ALIAS::LIB_ALIAS( const LIB_ALIAS& aAlias, LIB_PART* aRootPart ) :
|
|
EDA_ITEM( aAlias ),
|
|
shared( aRootPart )
|
|
{
|
|
name = aAlias.name;
|
|
|
|
description = aAlias.description;
|
|
keyWords = aAlias.keyWords;
|
|
docFileName = aAlias.docFileName;
|
|
}
|
|
|
|
|
|
LIB_ALIAS::~LIB_ALIAS()
|
|
{
|
|
wxASSERT_MSG( shared, wxT( "~LIB_ALIAS() without a LIB_PART" ) );
|
|
|
|
wxLogTrace( traceSchLibMem,
|
|
wxT( "%s: destroying alias:'%s' of part:'%s'." ),
|
|
GetChars( wxString::FromAscii( __WXFUNCTION__ ) ), GetChars( name ),
|
|
GetChars( shared->GetName() ) );
|
|
|
|
if( shared )
|
|
shared->RemoveAlias( this );
|
|
}
|
|
|
|
|
|
const wxString LIB_ALIAS::GetLibraryName()
|
|
{
|
|
wxASSERT_MSG( shared, wxT( "LIB_ALIAS without a LIB_PART" ) );
|
|
|
|
if( shared )
|
|
return shared->GetLibraryName();
|
|
|
|
return wxString( _( "none" ) );
|
|
}
|
|
|
|
|
|
bool LIB_ALIAS::IsRoot() const
|
|
{
|
|
return name == shared->GetName();
|
|
}
|
|
|
|
|
|
PART_LIB* LIB_ALIAS::GetLib()
|
|
{
|
|
return shared->GetLib();
|
|
}
|
|
|
|
|
|
bool LIB_ALIAS::SaveDoc( OUTPUTFORMATTER& aFormatter )
|
|
{
|
|
if( description.IsEmpty() && keyWords.IsEmpty() && docFileName.IsEmpty() )
|
|
return true;
|
|
|
|
try
|
|
{
|
|
aFormatter.Print( 0, "#\n$CMP %s\n", TO_UTF8( name ) );
|
|
|
|
if( !description.IsEmpty() )
|
|
aFormatter.Print( 0, "D %s\n", TO_UTF8( description ) );
|
|
|
|
if( !keyWords.IsEmpty() )
|
|
aFormatter.Print( 0, "K %s\n", TO_UTF8( keyWords ) );
|
|
|
|
if( !docFileName.IsEmpty() )
|
|
aFormatter.Print( 0, "F %s\n", TO_UTF8( docFileName ) );
|
|
|
|
aFormatter.Print( 0, "$ENDCMP\n" );
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LIB_ALIAS::operator==( const wxChar* aName ) const
|
|
{
|
|
return name == aName;
|
|
}
|
|
|
|
|
|
bool operator<( const LIB_ALIAS& aItem1, const LIB_ALIAS& aItem2 )
|
|
{
|
|
return aItem1.GetName() < aItem2.GetName();
|
|
}
|
|
|
|
|
|
int LibraryEntryCompare( const LIB_ALIAS* aItem1, const LIB_ALIAS* aItem2 )
|
|
{
|
|
return aItem1->GetName().Cmp( aItem2->GetName() );
|
|
}
|
|
|
|
|
|
/// http://www.boost.org/doc/libs/1_55_0/libs/smart_ptr/sp_techniques.html#weak_without_shared
|
|
struct null_deleter
|
|
{
|
|
void operator()(void const *) const
|
|
{
|
|
}
|
|
};
|
|
|
|
|
|
LIB_PART::LIB_PART( const wxString& aName, PART_LIB* aLibrary ) :
|
|
EDA_ITEM( LIB_PART_T ),
|
|
m_me( this, null_deleter() )
|
|
{
|
|
m_name = aName;
|
|
m_library = aLibrary;
|
|
m_dateModified = 0;
|
|
m_unitCount = 1;
|
|
m_pinNameOffset = 40;
|
|
m_options = ENTRY_NORMAL;
|
|
m_unitsLocked = false;
|
|
m_showPinNumbers = true;
|
|
m_showPinNames = true;
|
|
|
|
// Create the default alias if the name parameter is not empty.
|
|
if( !aName.IsEmpty() )
|
|
m_aliases.push_back( new LIB_ALIAS( aName, this ) );
|
|
|
|
// Add the MANDATORY_FIELDS in RAM only. These are assumed to be present
|
|
// when the field editors are invoked.
|
|
LIB_FIELD* value = new LIB_FIELD( this, VALUE );
|
|
value->SetText( aName );
|
|
drawings.push_back( value );
|
|
|
|
drawings.push_back( new LIB_FIELD( this, REFERENCE ) );
|
|
drawings.push_back( new LIB_FIELD( this, FOOTPRINT ) );
|
|
drawings.push_back( new LIB_FIELD( this, DATASHEET ) );
|
|
}
|
|
|
|
|
|
LIB_PART::LIB_PART( LIB_PART& aPart, PART_LIB* aLibrary ) :
|
|
EDA_ITEM( aPart ),
|
|
m_me( this, null_deleter() )
|
|
{
|
|
LIB_ITEM* newItem;
|
|
|
|
m_library = aLibrary;
|
|
m_name = aPart.m_name;
|
|
m_FootprintList = aPart.m_FootprintList;
|
|
m_unitCount = aPart.m_unitCount;
|
|
m_unitsLocked = aPart.m_unitsLocked;
|
|
m_pinNameOffset = aPart.m_pinNameOffset;
|
|
m_showPinNumbers = aPart.m_showPinNumbers;
|
|
m_showPinNames = aPart.m_showPinNames;
|
|
m_dateModified = aPart.m_dateModified;
|
|
m_options = aPart.m_options;
|
|
|
|
for( LIB_ITEM& oldItem : aPart.GetDrawItemList() )
|
|
{
|
|
if( oldItem.IsNew() )
|
|
continue;
|
|
|
|
newItem = (LIB_ITEM*) oldItem.Clone();
|
|
newItem->SetParent( this );
|
|
drawings.push_back( newItem );
|
|
}
|
|
|
|
for( size_t i = 0; i < aPart.m_aliases.size(); i++ )
|
|
{
|
|
LIB_ALIAS* alias = new LIB_ALIAS( *aPart.m_aliases[i], this );
|
|
m_aliases.push_back( alias );
|
|
}
|
|
}
|
|
|
|
|
|
LIB_PART::~LIB_PART()
|
|
{
|
|
wxLogTrace( traceSchLibMem,
|
|
wxT( "%s: destroying part '%s' with alias list count of %llu." ),
|
|
GetChars( wxString::FromAscii( __WXFUNCTION__ ) ), GetChars( GetName() ),
|
|
(long long unsigned) m_aliases.size() );
|
|
|
|
// If the part is being deleted directly rather than through the library,
|
|
// delete all of the aliases.
|
|
while( m_aliases.size() )
|
|
{
|
|
LIB_ALIAS* alias = m_aliases.back();
|
|
m_aliases.pop_back();
|
|
delete alias;
|
|
}
|
|
}
|
|
|
|
|
|
const wxString LIB_PART::GetLibraryName()
|
|
{
|
|
if( m_library )
|
|
return m_library->GetName();
|
|
|
|
return wxString( _( "none" ) );
|
|
}
|
|
|
|
|
|
wxString LIB_PART::SubReference( int aUnit, bool aAddSeparator )
|
|
{
|
|
wxString subRef;
|
|
|
|
if( m_subpartIdSeparator != 0 && aAddSeparator )
|
|
subRef << wxChar( m_subpartIdSeparator );
|
|
|
|
if( m_subpartFirstId >= '0' && m_subpartFirstId <= '9' )
|
|
subRef << aUnit;
|
|
else
|
|
{
|
|
// use letters as notation. To allow more than 26 units, the sub ref
|
|
// use one letter if letter = A .. Z or a ... z, and 2 letters otherwise
|
|
// first letter is expected to be 'A' or 'a' (i.e. 26 letters are available)
|
|
int u;
|
|
aUnit -= 1; // Unit number starts to 1. now to 0.
|
|
|
|
while( aUnit >= 26 ) // more than one letter are needed
|
|
{
|
|
u = aUnit / 26;
|
|
subRef << wxChar( m_subpartFirstId + u -1 );
|
|
aUnit %= 26;
|
|
}
|
|
|
|
u = m_subpartFirstId + aUnit;
|
|
subRef << wxChar( u );
|
|
}
|
|
|
|
return subRef;
|
|
}
|
|
|
|
|
|
void LIB_PART::SetName( const wxString& aName )
|
|
{
|
|
m_name = aName;
|
|
GetValueField().SetText( aName );
|
|
m_aliases[0]->SetName( aName );
|
|
}
|
|
|
|
|
|
void LIB_PART::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDc, const wxPoint& aOffset, int aMulti,
|
|
int aConvert, GR_DRAWMODE aDrawMode, EDA_COLOR_T aColor,
|
|
const TRANSFORM& aTransform, bool aShowPinText, bool aDrawFields,
|
|
bool aOnlySelected, const std::vector<bool>* aPinsDangling )
|
|
{
|
|
BASE_SCREEN* screen = aPanel ? aPanel->GetScreen() : NULL;
|
|
|
|
GRSetDrawMode( aDc, aDrawMode );
|
|
|
|
/* draw background for filled items using background option
|
|
* Solid lines will be drawn after the background
|
|
* Note also, background is not drawn when:
|
|
* printing in black and white
|
|
* If the color is not the default color (aColor != -1 )
|
|
*/
|
|
if( ! (screen && screen->m_IsPrinting && GetGRForceBlackPenState())
|
|
&& (aColor == UNSPECIFIED_COLOR) )
|
|
{
|
|
for( LIB_ITEM& drawItem : drawings )
|
|
{
|
|
if( drawItem.m_Fill != FILLED_WITH_BG_BODYCOLOR )
|
|
continue;
|
|
|
|
if( aOnlySelected && !drawItem.IsSelected() )
|
|
continue;
|
|
|
|
// Do not draw an item while moving (the cursor handler does that)
|
|
if( drawItem.m_Flags & IS_MOVED )
|
|
continue;
|
|
|
|
// Do not draw items not attached to the current part
|
|
if( aMulti && drawItem.m_Unit && ( drawItem.m_Unit != aMulti ) )
|
|
continue;
|
|
|
|
if( aConvert && drawItem.m_Convert && ( drawItem.m_Convert != aConvert ) )
|
|
continue;
|
|
|
|
if( drawItem.Type() == LIB_FIELD_T )
|
|
continue;
|
|
|
|
if( drawItem.Type() == LIB_FIELD_T )
|
|
{
|
|
drawItem.Draw( aPanel, aDc, aOffset, aColor, aDrawMode, (void*) NULL, aTransform );
|
|
}
|
|
|
|
// Now, draw only the background for items with
|
|
// m_Fill == FILLED_WITH_BG_BODYCOLOR:
|
|
drawItem.Draw( aPanel, aDc, aOffset, aColor, aDrawMode, (void*) false, aTransform );
|
|
}
|
|
}
|
|
|
|
// Track the index into the dangling pins list
|
|
size_t pin_index = 0;
|
|
|
|
for( LIB_ITEM& drawItem : drawings )
|
|
{
|
|
if( aOnlySelected && !drawItem.IsSelected() )
|
|
continue;
|
|
|
|
// Do not draw an item while moving (the cursor handler does that)
|
|
if( drawItem.m_Flags & IS_MOVED )
|
|
continue;
|
|
|
|
// Do not draw items not attached to the current part
|
|
if( aMulti && drawItem.m_Unit && ( drawItem.m_Unit != aMulti ) )
|
|
continue;
|
|
|
|
if( aConvert && drawItem.m_Convert && ( drawItem.m_Convert != aConvert ) )
|
|
continue;
|
|
|
|
if( !aDrawFields && drawItem.Type() == LIB_FIELD_T )
|
|
continue;
|
|
|
|
if( drawItem.Type() == LIB_PIN_T )
|
|
{
|
|
LIB_PIN& pin = dynamic_cast<LIB_PIN&>( drawItem );
|
|
|
|
uintptr_t flags = 0;
|
|
if( aShowPinText )
|
|
flags |= PIN_DRAW_TEXTS;
|
|
|
|
if( !aPinsDangling || (aPinsDangling->size() > pin_index && (*aPinsDangling)[pin_index] ) )
|
|
flags |= PIN_DRAW_DANGLING;
|
|
|
|
if( pin.IsPowerConnection() && IsPower() )
|
|
flags |= PIN_DANGLING_HIDDEN;
|
|
|
|
drawItem.Draw( aPanel, aDc, aOffset, aColor, aDrawMode, (void*) flags, aTransform );
|
|
|
|
++pin_index;
|
|
}
|
|
else if( drawItem.Type() == LIB_FIELD_T )
|
|
{
|
|
drawItem.Draw( aPanel, aDc, aOffset, aColor, aDrawMode, (void*) NULL, aTransform );
|
|
}
|
|
else
|
|
{
|
|
bool forceNoFill = drawItem.m_Fill == FILLED_WITH_BG_BODYCOLOR;
|
|
drawItem.Draw( aPanel, aDc, aOffset, aColor, aDrawMode, (void*) forceNoFill,
|
|
aTransform );
|
|
}
|
|
|
|
}
|
|
|
|
// Enable this to draw the anchor of the component.
|
|
#if 0
|
|
int len = aDc->DeviceToLogicalXRel( 3 );
|
|
EDA_RECT* const clipbox = aPanel ? aPanel->GetClipBox() : NULL;
|
|
|
|
GRLine( clipbox, aDc, aOffset.x, aOffset.y - len, aOffset.x,
|
|
aOffset.y + len, 0, aColor );
|
|
GRLine( clipbox, aDc, aOffset.x - len, aOffset.y, aOffset.x + len,
|
|
aOffset.y, 0, aColor );
|
|
#endif
|
|
|
|
/* Enable this to draw the bounding box around the component to validate
|
|
* the bounding box calculations. */
|
|
#if 0
|
|
EDA_RECT bBox = GetBoundingBox( aMulti, aConvert );
|
|
bBox.RevertYAxis();
|
|
bBox = aTransform.TransformCoordinate( bBox );
|
|
bBox.Move( aOffset );
|
|
GRRect( aPanel ? aPanel->GetClipBox() : NULL, aDc, bBox, 0, LIGHTMAGENTA );
|
|
#endif
|
|
}
|
|
|
|
|
|
void LIB_PART::Plot( PLOTTER* aPlotter, int aUnit, int aConvert,
|
|
const wxPoint& aOffset, const TRANSFORM& aTransform )
|
|
{
|
|
wxASSERT( aPlotter != NULL );
|
|
|
|
aPlotter->SetColor( GetLayerColor( LAYER_DEVICE ) );
|
|
bool fill = aPlotter->GetColorMode();
|
|
|
|
// draw background for filled items using background option
|
|
// Solid lines will be drawn after the background
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
// Lib Fields are not plotted here, because this plot function
|
|
// is used to plot schematic items, which have they own fields
|
|
if( item.Type() == LIB_FIELD_T )
|
|
continue;
|
|
|
|
if( aUnit && item.m_Unit && ( item.m_Unit != aUnit ) )
|
|
continue;
|
|
|
|
if( aConvert && item.m_Convert && ( item.m_Convert != aConvert ) )
|
|
continue;
|
|
|
|
if( item.m_Fill == FILLED_WITH_BG_BODYCOLOR )
|
|
item.Plot( aPlotter, aOffset, fill, aTransform );
|
|
}
|
|
|
|
// Not filled items and filled shapes are now plotted
|
|
// (plot only items which are not already plotted)
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( item.Type() == LIB_FIELD_T )
|
|
continue;
|
|
|
|
if( aUnit && item.m_Unit && ( item.m_Unit != aUnit ) )
|
|
continue;
|
|
|
|
if( aConvert && item.m_Convert && ( item.m_Convert != aConvert ) )
|
|
continue;
|
|
|
|
if( item.m_Fill != FILLED_WITH_BG_BODYCOLOR )
|
|
item.Plot( aPlotter, aOffset, fill, aTransform );
|
|
}
|
|
}
|
|
|
|
void LIB_PART::PlotLibFields( PLOTTER* aPlotter, int aUnit, int aConvert,
|
|
const wxPoint& aOffset, const TRANSFORM& aTransform )
|
|
{
|
|
wxASSERT( aPlotter != NULL );
|
|
|
|
aPlotter->SetColor( GetLayerColor( LAYER_FIELDS ) );
|
|
bool fill = aPlotter->GetColorMode();
|
|
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( item.Type() != LIB_FIELD_T )
|
|
continue;
|
|
|
|
if( aUnit && item.m_Unit && ( item.m_Unit != aUnit ) )
|
|
continue;
|
|
|
|
if( aConvert && item.m_Convert && ( item.m_Convert != aConvert ) )
|
|
continue;
|
|
|
|
// The reference is a special case: we should change the basic text
|
|
// to add '?' and the part id
|
|
LIB_FIELD& field = (LIB_FIELD&) item;
|
|
wxString tmp = field.GetShownText();
|
|
if( field.GetId() == REFERENCE )
|
|
{
|
|
wxString text = field.GetFullText( aUnit );
|
|
field.SetText( text );
|
|
}
|
|
item.Plot( aPlotter, aOffset, fill, aTransform );
|
|
field.SetText( tmp );
|
|
}
|
|
}
|
|
|
|
|
|
void LIB_PART::RemoveDrawItem( LIB_ITEM* aItem, EDA_DRAW_PANEL* aPanel, wxDC* aDc )
|
|
{
|
|
wxASSERT( aItem != NULL );
|
|
|
|
// none of the MANDATORY_FIELDS may be removed in RAM, but they may be
|
|
// omitted when saving to disk.
|
|
if( aItem->Type() == LIB_FIELD_T )
|
|
{
|
|
LIB_FIELD* field = (LIB_FIELD*) aItem;
|
|
|
|
if( field->GetId() < MANDATORY_FIELDS )
|
|
{
|
|
wxLogWarning( _(
|
|
"An attempt was made to remove the %s field from component %s in library %s." ),
|
|
GetChars( field->GetName() ), GetChars( GetName() ),
|
|
GetChars( GetLibraryName() ) );
|
|
return;
|
|
}
|
|
}
|
|
|
|
LIB_ITEMS::iterator i;
|
|
|
|
for( i = drawings.begin(); i != drawings.end(); i++ )
|
|
{
|
|
if( *i == aItem )
|
|
{
|
|
if( aDc != NULL )
|
|
aItem->Draw( aPanel, aDc, wxPoint( 0, 0 ), UNSPECIFIED_COLOR,
|
|
g_XorMode, NULL, DefaultTransform );
|
|
|
|
drawings.erase( i );
|
|
SetModified();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void LIB_PART::AddDrawItem( LIB_ITEM* aItem )
|
|
{
|
|
wxASSERT( aItem != NULL );
|
|
|
|
drawings.push_back( aItem );
|
|
drawings.sort();
|
|
}
|
|
|
|
|
|
LIB_ITEM* LIB_PART::GetNextDrawItem( LIB_ITEM* aItem, KICAD_T aType )
|
|
{
|
|
/* Return the next draw object pointer.
|
|
* If item is NULL return the first item of type in the list.
|
|
*/
|
|
if( drawings.empty() )
|
|
return NULL;
|
|
|
|
if( aItem == NULL && aType == TYPE_NOT_INIT ) // type is unspecified
|
|
return &drawings[0];
|
|
|
|
// Search for last item
|
|
size_t idx = 0;
|
|
|
|
if( aItem )
|
|
{
|
|
for( ; idx < drawings.size(); idx++ )
|
|
{
|
|
if( aItem == &drawings[idx] )
|
|
{
|
|
idx++; // Prepare the next item search
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Search the next item
|
|
for( ; idx < drawings.size(); idx++ )
|
|
{
|
|
if( aType == TYPE_NOT_INIT || drawings[ idx ].Type() == aType )
|
|
return &drawings[ idx ];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void LIB_PART::GetPins( LIB_PINS& aList, int aUnit, int aConvert )
|
|
{
|
|
/* Notes:
|
|
* when aUnit == 0: no unit filtering
|
|
* when aConvert == 0: no convert (shape selection) filtering
|
|
* when .m_Unit == 0, the body item is common to units
|
|
* when .m_Convert == 0, the body item is common to shapes
|
|
*/
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( item.Type() != LIB_PIN_T ) // we search pins only
|
|
continue;
|
|
|
|
// Unit filtering:
|
|
if( aUnit && item.m_Unit && ( item.m_Unit != aUnit ) )
|
|
continue;
|
|
|
|
// Shape filtering:
|
|
if( aConvert && item.m_Convert && ( item.m_Convert != aConvert ) )
|
|
continue;
|
|
|
|
aList.push_back( (LIB_PIN*) &item );
|
|
}
|
|
}
|
|
|
|
|
|
LIB_PIN* LIB_PART::GetPin( const wxString& aNumber, int aUnit, int aConvert )
|
|
{
|
|
wxString pNumber;
|
|
LIB_PINS pinList;
|
|
|
|
GetPins( pinList, aUnit, aConvert );
|
|
|
|
for( size_t i = 0; i < pinList.size(); i++ )
|
|
{
|
|
wxASSERT( pinList[i]->Type() == LIB_PIN_T );
|
|
|
|
pinList[i]->PinStringNum( pNumber );
|
|
|
|
if( aNumber == pNumber )
|
|
return pinList[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
bool LIB_PART::PinsConflictWith( LIB_PART& aOtherPart, bool aTestNums, bool aTestNames,
|
|
bool aTestType, bool aTestOrientation, bool aTestLength )
|
|
{
|
|
LIB_PINS thisPinList;
|
|
GetPins( thisPinList, /* aUnit */ 0, /* aConvert */ 0 );
|
|
|
|
for( LIB_PIN* eachThisPin : thisPinList )
|
|
{
|
|
wxASSERT( eachThisPin );
|
|
LIB_PINS otherPinList;
|
|
aOtherPart.GetPins( otherPinList, /* aUnit */ 0, /* aConvert */ 0 );
|
|
bool foundMatch = false;
|
|
|
|
for( LIB_PIN* eachOtherPin : otherPinList )
|
|
{
|
|
wxASSERT( eachOtherPin );
|
|
// Same position?
|
|
if( eachThisPin->GetPosition() != eachOtherPin->GetPosition() )
|
|
continue;
|
|
|
|
// Same number?
|
|
wxString eachThisPinNumber, eachOtherPinNumber;
|
|
eachThisPin->PinStringNum( eachThisPinNumber );
|
|
eachOtherPin->PinStringNum( eachOtherPinNumber );
|
|
if( aTestNums && ( eachThisPinNumber != eachOtherPinNumber ))
|
|
continue;
|
|
|
|
// Same name?
|
|
if( aTestNames && ( eachThisPin->GetName() != eachOtherPin->GetName() ))
|
|
continue;
|
|
|
|
// Same electrical type?
|
|
if( aTestType && ( eachThisPin->GetType() != eachOtherPin->GetType() ))
|
|
continue;
|
|
|
|
// Same orientation?
|
|
if( aTestOrientation && ( eachThisPin->GetOrientation() != eachOtherPin->GetOrientation() ))
|
|
continue;
|
|
|
|
// Same length?
|
|
if( aTestLength && ( eachThisPin->GetLength() != eachOtherPin->GetLength() ))
|
|
continue;
|
|
|
|
foundMatch = true;
|
|
}
|
|
|
|
if( !foundMatch )
|
|
{
|
|
// This means there was not an identical (according to the arguments)
|
|
// pin at the same position in the other component.
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// The loop never gave up, so no conflicts were found.
|
|
return false;
|
|
}
|
|
|
|
|
|
bool LIB_PART::Save( OUTPUTFORMATTER& aFormatter )
|
|
{
|
|
LIB_FIELD& value = GetValueField();
|
|
|
|
// First line: it s a comment (component name for readers)
|
|
aFormatter.Print( 0, "#\n# %s\n#\n", TO_UTF8( value.GetText() ) );
|
|
|
|
// Save data
|
|
aFormatter.Print( 0, "DEF" );
|
|
|
|
#if 0 && defined(DEBUG)
|
|
if( value.GetText() == wxT( "R" ) )
|
|
{
|
|
int breakhere = 1;
|
|
(void) breakhere;
|
|
}
|
|
#endif
|
|
|
|
if( value.IsVisible() )
|
|
{
|
|
aFormatter.Print( 0, " %s", TO_UTF8( value.GetText() ) );
|
|
}
|
|
else
|
|
{
|
|
aFormatter.Print( 0, " ~%s", TO_UTF8( value.GetText() ) );
|
|
}
|
|
|
|
LIB_FIELD& reference = GetReferenceField();
|
|
|
|
if( !reference.GetText().IsEmpty() )
|
|
{
|
|
aFormatter.Print( 0, " %s", TO_UTF8( reference.GetText() ) );
|
|
}
|
|
else
|
|
{
|
|
aFormatter.Print( 0, " ~" );
|
|
}
|
|
|
|
aFormatter.Print( 0, " %d %d %c %c %d %c %c\n",
|
|
0, m_pinNameOffset,
|
|
m_showPinNumbers ? 'Y' : 'N',
|
|
m_showPinNames ? 'Y' : 'N',
|
|
m_unitCount, m_unitsLocked ? 'L' : 'F',
|
|
m_options == ENTRY_POWER ? 'P' : 'N' );
|
|
|
|
if( !SaveDateAndTime( aFormatter ) )
|
|
return false;
|
|
|
|
LIB_FIELDS fields;
|
|
GetFields( fields );
|
|
|
|
// Mandatory fields:
|
|
// may have their own save policy so there is a separate loop for them.
|
|
// Empty fields are saved, because the user may have set visibility,
|
|
// size and orientation
|
|
for( int i = 0; i < MANDATORY_FIELDS; ++i )
|
|
{
|
|
if( !fields[i].Save( aFormatter ) )
|
|
return false;
|
|
}
|
|
|
|
// User defined fields:
|
|
// may have their own save policy so there is a separate loop for them.
|
|
|
|
int fieldId = MANDATORY_FIELDS; // really wish this would go away.
|
|
|
|
for( unsigned i = MANDATORY_FIELDS; i < fields.size(); ++i )
|
|
{
|
|
// There is no need to save empty fields, i.e. no reason to preserve field
|
|
// names now that fields names come in dynamically through the template
|
|
// fieldnames.
|
|
if( !fields[i].GetText().IsEmpty() )
|
|
{
|
|
fields[i].SetId( fieldId++ );
|
|
|
|
if( !fields[i].Save( aFormatter ) )
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Save the alias list: a line starting by "ALIAS". The first alias is the root
|
|
// and has the same name as the component. In the old library file format this
|
|
// alias does not get added to the alias list.
|
|
if( m_aliases.size() > 1 )
|
|
{
|
|
aFormatter.Print( 0, "ALIAS" );
|
|
|
|
for( unsigned i = 1; i < m_aliases.size(); i++ )
|
|
{
|
|
aFormatter.Print( 0, " %s", TO_UTF8( m_aliases[i]->GetName() ) );
|
|
}
|
|
|
|
aFormatter.Print( 0, "\n" );
|
|
}
|
|
|
|
// Write the footprint filter list
|
|
if( m_FootprintList.GetCount() != 0 )
|
|
{
|
|
aFormatter.Print( 0, "$FPLIST\n" );
|
|
|
|
for( unsigned i = 0; i < m_FootprintList.GetCount(); i++ )
|
|
{
|
|
aFormatter.Print( 0, " %s\n", TO_UTF8( m_FootprintList[i] ) );
|
|
}
|
|
|
|
aFormatter.Print( 0, "$ENDFPLIST\n" );
|
|
}
|
|
|
|
// Save graphics items (including pins)
|
|
if( !drawings.empty() )
|
|
{
|
|
/* we sort the draw items, in order to have an edition more easy,
|
|
* when a file editing "by hand" is made */
|
|
drawings.sort();
|
|
|
|
aFormatter.Print( 0, "DRAW\n" );
|
|
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( item.Type() == LIB_FIELD_T )
|
|
continue;
|
|
|
|
if( !item.Save( aFormatter ) )
|
|
return false;
|
|
}
|
|
|
|
aFormatter.Print( 0, "ENDDRAW\n" );
|
|
}
|
|
|
|
aFormatter.Print( 0, "ENDDEF\n" );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LIB_PART::Load( LINE_READER& aLineReader, wxString& aErrorMsg )
|
|
{
|
|
int unused;
|
|
char* p;
|
|
char* componentName;
|
|
char* prefix = NULL;
|
|
char* line;
|
|
|
|
bool result;
|
|
wxString Msg;
|
|
|
|
line = aLineReader.Line();
|
|
|
|
p = strtok( line, " \t\r\n" );
|
|
|
|
if( strcmp( p, "DEF" ) != 0 )
|
|
{
|
|
aErrorMsg.Printf( wxT( "DEF command expected in line %d, aborted." ),
|
|
aLineReader.LineNumber() );
|
|
return false;
|
|
}
|
|
|
|
// Read DEF line:
|
|
char drawnum = 0;
|
|
char drawname = 0;
|
|
|
|
if( ( componentName = strtok( NULL, " \t\n" ) ) == NULL // Part name:
|
|
|| ( prefix = strtok( NULL, " \t\n" ) ) == NULL // Prefix name:
|
|
|| ( p = strtok( NULL, " \t\n" ) ) == NULL // NumOfPins:
|
|
|| sscanf( p, "%d", &unused ) != 1
|
|
|| ( p = strtok( NULL, " \t\n" ) ) == NULL // TextInside:
|
|
|| sscanf( p, "%d", &m_pinNameOffset ) != 1
|
|
|| ( p = strtok( NULL, " \t\n" ) ) == NULL // DrawNums:
|
|
|| sscanf( p, "%c", &drawnum ) != 1
|
|
|| ( p = strtok( NULL, " \t\n" ) ) == NULL // DrawNums:
|
|
|| sscanf( p, "%c", &drawname ) != 1
|
|
|| ( p = strtok( NULL, " \t\n" ) ) == NULL // m_unitCount:
|
|
|| sscanf( p, "%d", &m_unitCount ) != 1 )
|
|
{
|
|
aErrorMsg.Printf( wxT( "Wrong DEF format in line %d, skipped." ),
|
|
aLineReader.LineNumber() );
|
|
|
|
while( (line = aLineReader.ReadLine()) != NULL )
|
|
{
|
|
p = strtok( line, " \t\n" );
|
|
|
|
if( p && stricmp( p, "ENDDEF" ) == 0 )
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Ensure m_unitCount is >= 1 (could be read as 0 in old libraries)
|
|
if( m_unitCount < 1 )
|
|
m_unitCount = 1;
|
|
|
|
m_showPinNumbers = ( drawnum == 'N' ) ? false : true;
|
|
m_showPinNames = ( drawname == 'N' ) ? false : true;
|
|
|
|
// Copy part name and prefix.
|
|
LIB_FIELD& value = GetValueField();
|
|
|
|
if( componentName[0] != '~' )
|
|
{
|
|
m_name = FROM_UTF8( componentName );
|
|
value.SetText( m_name );
|
|
}
|
|
else
|
|
{
|
|
m_name = FROM_UTF8( &componentName[1] );
|
|
value.SetText( m_name );
|
|
value.SetVisible( false );
|
|
}
|
|
|
|
// Add the root alias to the alias list.
|
|
m_aliases.push_back( new LIB_ALIAS( m_name, this ) );
|
|
|
|
LIB_FIELD& reference = GetReferenceField();
|
|
|
|
if( strcmp( prefix, "~" ) == 0 )
|
|
{
|
|
reference.Empty();
|
|
reference.SetVisible( false );
|
|
}
|
|
else
|
|
{
|
|
reference.SetText( FROM_UTF8( prefix ) );
|
|
}
|
|
|
|
// Copy optional infos
|
|
if( ( p = strtok( NULL, " \t\n" ) ) != NULL && *p == 'L' )
|
|
m_unitsLocked = true;
|
|
|
|
if( ( p = strtok( NULL, " \t\n" ) ) != NULL && *p == 'P' )
|
|
m_options = ENTRY_POWER;
|
|
|
|
// Read next lines, until "ENDDEF" is found
|
|
while( ( line = aLineReader.ReadLine() ) != NULL )
|
|
{
|
|
p = strtok( line, " \t\r\n" );
|
|
|
|
// This is the error flag ( if an error occurs, result = false)
|
|
result = true;
|
|
|
|
if( *line == '#' ) // a comment
|
|
continue;
|
|
|
|
if( p == NULL ) // empty line
|
|
continue;
|
|
|
|
if( line[0] == 'T' && line[1] == 'i' )
|
|
result = LoadDateAndTime( aLineReader );
|
|
else if( *line == 'F' )
|
|
result = LoadField( aLineReader, Msg );
|
|
else if( strcmp( p, "ENDDEF" ) == 0 ) // End of component description
|
|
goto ok;
|
|
else if( strcmp( p, "DRAW" ) == 0 )
|
|
result = LoadDrawEntries( aLineReader, Msg );
|
|
else if( strncmp( p, "ALIAS", 5 ) == 0 )
|
|
{
|
|
p = strtok( NULL, "\r\n" );
|
|
result = LoadAliases( p, aErrorMsg );
|
|
}
|
|
else if( strncmp( p, "$FPLIST", 5 ) == 0 )
|
|
result = LoadFootprints( aLineReader, Msg );
|
|
|
|
// End line or block analysis: test for an error
|
|
if( !result )
|
|
{
|
|
if( Msg.IsEmpty() )
|
|
aErrorMsg.Printf( wxT( "error occurred at line %d " ), aLineReader.LineNumber() );
|
|
else
|
|
aErrorMsg.Printf( wxT( "error <%s> occurred at line %d " ),
|
|
GetChars( Msg ), aLineReader.LineNumber() );
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
|
|
ok:
|
|
// If we are here, this part is O.k. - put it in:
|
|
drawings.sort();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LIB_PART::LoadDrawEntries( LINE_READER& aLineReader, wxString& aErrorMsg )
|
|
{
|
|
char* line;
|
|
LIB_ITEM* newEntry = NULL;
|
|
|
|
while( true )
|
|
{
|
|
if( !( line = aLineReader.ReadLine() ) )
|
|
{
|
|
aErrorMsg = wxT( "file ended prematurely loading component draw element" );
|
|
return false;
|
|
}
|
|
|
|
if( strncmp( line, "ENDDRAW", 7 ) == 0 )
|
|
break;
|
|
|
|
newEntry = NULL;
|
|
|
|
switch( line[0] )
|
|
{
|
|
case 'A': // Arc
|
|
newEntry = ( LIB_ITEM* ) new LIB_ARC( this );
|
|
break;
|
|
|
|
case 'C': // Circle
|
|
newEntry = ( LIB_ITEM* ) new LIB_CIRCLE( this );
|
|
break;
|
|
|
|
case 'T': // Text
|
|
newEntry = ( LIB_ITEM* ) new LIB_TEXT( this );
|
|
break;
|
|
|
|
case 'S': // Square
|
|
newEntry = ( LIB_ITEM* ) new LIB_RECTANGLE( this );
|
|
break;
|
|
|
|
case 'X': // Pin Description
|
|
newEntry = ( LIB_ITEM* ) new LIB_PIN( this );
|
|
break;
|
|
|
|
case 'P': // Polyline
|
|
newEntry = ( LIB_ITEM* ) new LIB_POLYLINE( this );
|
|
break;
|
|
|
|
case 'B': // Bezier Curves
|
|
newEntry = ( LIB_ITEM* ) new LIB_BEZIER( this );
|
|
break;
|
|
|
|
case '#': // Comment
|
|
continue;
|
|
|
|
case '\n':
|
|
case '\r':
|
|
case 0: // empty line
|
|
continue;
|
|
|
|
default:
|
|
aErrorMsg.Printf( wxT( "undefined DRAW command %c" ), line[0] );
|
|
return false;
|
|
}
|
|
|
|
if( !newEntry->Load( aLineReader, aErrorMsg ) )
|
|
{
|
|
aErrorMsg.Printf( wxT( "error '%s' in DRAW command %c" ),
|
|
GetChars( aErrorMsg ), line[0] );
|
|
delete newEntry;
|
|
|
|
// Flush till end of draw section
|
|
do
|
|
{
|
|
if( !aLineReader.ReadLine() )
|
|
{
|
|
aErrorMsg = wxT( "file ended prematurely while attempting "
|
|
"to flush to end of drawing section." );
|
|
return false;
|
|
}
|
|
} while( strncmp( line, "ENDDRAW", 7 ) != 0 );
|
|
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
drawings.push_back( newEntry );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LIB_PART::LoadAliases( char* aLine, wxString& aErrorMsg )
|
|
{
|
|
char* text = strtok( aLine, " \t\r\n" );
|
|
|
|
while( text )
|
|
{
|
|
m_aliases.push_back( new LIB_ALIAS( FROM_UTF8( text ), this ) );
|
|
text = strtok( NULL, " \t\r\n" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LIB_PART::LoadField( LINE_READER& aLineReader, wxString& aErrorMsg )
|
|
{
|
|
LIB_FIELD* field = new LIB_FIELD( this );
|
|
|
|
if( !field->Load( aLineReader, aErrorMsg ) )
|
|
{
|
|
delete field;
|
|
return false;
|
|
}
|
|
|
|
if( field->GetId() < MANDATORY_FIELDS )
|
|
{
|
|
LIB_FIELD* fixedField = GetField( field->GetId() );
|
|
|
|
// this will fire only if somebody broke a constructor or editor.
|
|
// MANDATORY_FIELDS are always present in ram resident components, no
|
|
// exceptions, and they always have their names set, even fixed fields.
|
|
wxASSERT( fixedField );
|
|
|
|
*fixedField = *field;
|
|
|
|
if( field->GetId() == VALUE )
|
|
m_name = field->GetText();
|
|
|
|
delete field;
|
|
}
|
|
else
|
|
{
|
|
drawings.push_back( field );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LIB_PART::LoadFootprints( LINE_READER& aLineReader, wxString& aErrorMsg )
|
|
{
|
|
char* line;
|
|
char* p;
|
|
|
|
while( true )
|
|
{
|
|
if( !( line = aLineReader.ReadLine() ) )
|
|
{
|
|
aErrorMsg = wxT( "file ended prematurely while loading footprints" );
|
|
return false;
|
|
}
|
|
|
|
p = strtok( line, " \t\r\n" );
|
|
|
|
if( stricmp( p, "$ENDFPLIST" ) == 0 )
|
|
break;
|
|
|
|
m_FootprintList.Add( FROM_UTF8( p ) );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
const EDA_RECT LIB_PART::GetBoundingBox( int aUnit, int aConvert ) const
|
|
{
|
|
EDA_RECT bBox;
|
|
bool initialized = false;
|
|
|
|
for( unsigned ii = 0; ii < drawings.size(); ii++ )
|
|
{
|
|
const LIB_ITEM& item = drawings[ii];
|
|
|
|
if( ( item.m_Unit > 0 ) && ( ( m_unitCount > 1 ) && ( aUnit > 0 )
|
|
&& ( aUnit != item.m_Unit ) ) )
|
|
continue;
|
|
|
|
if( item.m_Convert > 0 && ( ( aConvert > 0 ) && ( aConvert != item.m_Convert ) ) )
|
|
continue;
|
|
|
|
if ( ( item.Type() == LIB_FIELD_T ) && !( ( LIB_FIELD& ) item ).IsVisible() )
|
|
continue;
|
|
|
|
if( initialized )
|
|
bBox.Merge( item.GetBoundingBox() );
|
|
else
|
|
{
|
|
bBox = item.GetBoundingBox();
|
|
initialized = true;
|
|
}
|
|
}
|
|
|
|
return bBox;
|
|
}
|
|
|
|
|
|
const EDA_RECT LIB_PART::GetBodyBoundingBox( int aUnit, int aConvert ) const
|
|
{
|
|
EDA_RECT bBox;
|
|
bool initialized = false;
|
|
|
|
for( unsigned ii = 0; ii < drawings.size(); ii++ )
|
|
{
|
|
const LIB_ITEM& item = drawings[ii];
|
|
|
|
if( ( item.m_Unit > 0 ) && ( ( m_unitCount > 1 ) && ( aUnit > 0 )
|
|
&& ( aUnit != item.m_Unit ) ) )
|
|
continue;
|
|
|
|
if( item.m_Convert > 0 && ( ( aConvert > 0 ) && ( aConvert != item.m_Convert ) ) )
|
|
continue;
|
|
|
|
if( item.Type() == LIB_FIELD_T )
|
|
continue;
|
|
|
|
if( initialized )
|
|
bBox.Merge( item.GetBoundingBox() );
|
|
else
|
|
{
|
|
bBox = item.GetBoundingBox();
|
|
initialized = true;
|
|
}
|
|
}
|
|
|
|
return bBox;
|
|
}
|
|
|
|
|
|
void LIB_PART::deleteAllFields()
|
|
{
|
|
LIB_ITEMS::iterator it;
|
|
|
|
for( it = drawings.begin(); it != drawings.end(); /* deleting */ )
|
|
{
|
|
if( it->Type() != LIB_FIELD_T )
|
|
{
|
|
++it;
|
|
continue;
|
|
}
|
|
|
|
// 'it' is not advanced, but should point to next in list after erase()
|
|
it = drawings.erase( it );
|
|
}
|
|
}
|
|
|
|
|
|
void LIB_PART::SetFields( const std::vector <LIB_FIELD>& aFields )
|
|
{
|
|
deleteAllFields();
|
|
|
|
for( unsigned i=0; i<aFields.size(); ++i )
|
|
{
|
|
// drawings is a ptr_vector, new and copy an object on the heap.
|
|
LIB_FIELD* field = new LIB_FIELD( aFields[i] );
|
|
|
|
field->SetParent( this );
|
|
drawings.push_back( field );
|
|
}
|
|
|
|
// Reorder drawings: transparent polygons first, pins and text last.
|
|
// so texts have priority on screen.
|
|
drawings.sort();
|
|
}
|
|
|
|
|
|
void LIB_PART::GetFields( LIB_FIELDS& aList )
|
|
{
|
|
LIB_FIELD* field;
|
|
|
|
// The only caller of this function is the library field editor, so it
|
|
// establishes policy here.
|
|
|
|
// Grab the MANDATORY_FIELDS first, in expected order given by
|
|
// enum NumFieldType
|
|
for( int id=0; id<MANDATORY_FIELDS; ++id )
|
|
{
|
|
field = GetField( id );
|
|
|
|
// the MANDATORY_FIELDS are exactly that in RAM.
|
|
wxASSERT( field );
|
|
|
|
aList.push_back( *field );
|
|
}
|
|
|
|
// Now grab all the rest of fields.
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( item.Type() != LIB_FIELD_T )
|
|
continue;
|
|
|
|
field = ( LIB_FIELD* ) &item;
|
|
|
|
if( (unsigned) field->GetId() < MANDATORY_FIELDS )
|
|
continue; // was added above
|
|
|
|
aList.push_back( *field );
|
|
}
|
|
}
|
|
|
|
|
|
LIB_FIELD* LIB_PART::GetField( int aId )
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( item.Type() != LIB_FIELD_T )
|
|
continue;
|
|
|
|
LIB_FIELD* field = ( LIB_FIELD* ) &item;
|
|
|
|
if( field->GetId() == aId )
|
|
return field;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
LIB_FIELD* LIB_PART::FindField( const wxString& aFieldName )
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( item.Type() != LIB_FIELD_T )
|
|
continue;
|
|
|
|
LIB_FIELD* field = ( LIB_FIELD* ) &item;
|
|
|
|
if( field->GetName() == aFieldName )
|
|
return field;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
LIB_FIELD& LIB_PART::GetValueField()
|
|
{
|
|
LIB_FIELD* field = GetField( VALUE );
|
|
wxASSERT( field != NULL );
|
|
return *field;
|
|
}
|
|
|
|
|
|
LIB_FIELD& LIB_PART::GetReferenceField()
|
|
{
|
|
LIB_FIELD* field = GetField( REFERENCE );
|
|
wxASSERT( field != NULL );
|
|
return *field;
|
|
}
|
|
|
|
|
|
bool LIB_PART::SaveDateAndTime( OUTPUTFORMATTER& aFormatter )
|
|
{
|
|
int year, mon, day, hour, min, sec;
|
|
|
|
if( m_dateModified == 0 )
|
|
return true;
|
|
|
|
sec = m_dateModified & 63;
|
|
min = ( m_dateModified >> 6 ) & 63;
|
|
hour = ( m_dateModified >> 12 ) & 31;
|
|
day = ( m_dateModified >> 17 ) & 31;
|
|
mon = ( m_dateModified >> 22 ) & 15;
|
|
year = ( m_dateModified >> 26 ) + 1990;
|
|
|
|
aFormatter.Print( 0, "Ti %d/%d/%d %d:%d:%d\n", year, mon, day, hour, min, sec );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LIB_PART::LoadDateAndTime( char* aLine )
|
|
{
|
|
int year, mon, day, hour, min, sec;
|
|
|
|
year = mon = day = hour = min = sec = 0;
|
|
strtok( aLine, " \r\t\n" );
|
|
strtok( NULL, " \r\t\n" );
|
|
|
|
if( sscanf( aLine, "%d/%d/%d %d:%d:%d", &year, &mon, &day, &hour, &min, &sec ) != 6 )
|
|
return false;
|
|
|
|
m_dateModified = ( sec & 63 ) + ( ( min & 63 ) << 6 ) +
|
|
( ( hour & 31 ) << 12 ) + ( ( day & 31 ) << 17 ) +
|
|
( ( mon & 15 ) << 22 ) + ( ( year - 1990 ) << 26 );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void LIB_PART::SetOffset( const wxPoint& aOffset )
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
item.SetOffset( aOffset );
|
|
}
|
|
}
|
|
|
|
|
|
void LIB_PART::RemoveDuplicateDrawItems()
|
|
{
|
|
drawings.unique();
|
|
}
|
|
|
|
|
|
bool LIB_PART::HasConversion() const
|
|
{
|
|
for( unsigned ii = 0; ii < drawings.size(); ii++ )
|
|
{
|
|
const LIB_ITEM& item = drawings[ii];
|
|
if( item.m_Convert > 1 )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void LIB_PART::ClearStatus()
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
item.m_Flags = 0;
|
|
}
|
|
}
|
|
|
|
|
|
int LIB_PART::SelectItems( EDA_RECT& aRect, int aUnit, int aConvert, bool aEditPinByPin )
|
|
{
|
|
int itemCount = 0;
|
|
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
item.ClearFlags( SELECTED );
|
|
|
|
if( ( item.m_Unit && item.m_Unit != aUnit )
|
|
|| ( item.m_Convert && item.m_Convert != aConvert ) )
|
|
{
|
|
if( item.Type() != LIB_PIN_T )
|
|
continue;
|
|
|
|
// Specific rules for pins.
|
|
if( aEditPinByPin || m_unitsLocked
|
|
|| ( item.m_Convert && item.m_Convert != aConvert ) )
|
|
continue;
|
|
}
|
|
|
|
if( item.Inside( aRect ) )
|
|
{
|
|
item.SetFlags( SELECTED );
|
|
itemCount++;
|
|
}
|
|
}
|
|
|
|
return itemCount;
|
|
}
|
|
|
|
|
|
void LIB_PART::MoveSelectedItems( const wxPoint& aOffset )
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( !item.IsSelected() )
|
|
continue;
|
|
|
|
item.SetOffset( aOffset );
|
|
item.m_Flags = 0;
|
|
}
|
|
|
|
drawings.sort();
|
|
}
|
|
|
|
|
|
void LIB_PART::ClearSelectedItems()
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
item.m_Flags = 0;
|
|
}
|
|
}
|
|
|
|
|
|
void LIB_PART::DeleteSelectedItems()
|
|
{
|
|
LIB_ITEMS::iterator item = drawings.begin();
|
|
|
|
// We *do not* remove the 2 mandatory fields: reference and value
|
|
// so skip them (do not remove) if they are flagged selected.
|
|
// Skip also not visible items.
|
|
// But I think fields must not be deleted by a block delete command or other global command
|
|
// because they are not really graphic items
|
|
while( item != drawings.end() )
|
|
{
|
|
if( item->Type() == LIB_FIELD_T )
|
|
{
|
|
#if 0 // Set to 1 to allows fields deletion on block delete or other global command
|
|
LIB_FIELD& field = ( LIB_FIELD& ) *item;
|
|
|
|
if( (field.GetId() == REFERENCE) || (field.m_FieldId == VALUE) ||
|
|
(field.m_Attributs & TEXT_NO_VISIBLE) )
|
|
#endif
|
|
item->ClearFlags( SELECTED );
|
|
}
|
|
|
|
if( !item->IsSelected() )
|
|
item++;
|
|
else
|
|
item = drawings.erase( item );
|
|
}
|
|
}
|
|
|
|
|
|
void LIB_PART::CopySelectedItems( const wxPoint& aOffset )
|
|
{
|
|
/* *do not* use iterators here, because new items
|
|
* are added to drawings that is a boost::ptr_vector.
|
|
* When push_back elements in buffer,
|
|
* a memory reallocation can happen and will break pointers
|
|
*/
|
|
unsigned icnt = drawings.size();
|
|
|
|
for( unsigned ii = 0; ii < icnt; ii++ )
|
|
{
|
|
LIB_ITEM& item = drawings[ii];
|
|
|
|
// We *do not* copy fields because they are unique for the whole component
|
|
// so skip them (do not duplicate) if they are flagged selected.
|
|
if( item.Type() == LIB_FIELD_T )
|
|
item.ClearFlags( SELECTED );
|
|
|
|
if( !item.IsSelected() )
|
|
continue;
|
|
|
|
item.ClearFlags( SELECTED );
|
|
LIB_ITEM* newItem = (LIB_ITEM*) item.Clone();
|
|
newItem->SetFlags( SELECTED );
|
|
drawings.push_back( newItem );
|
|
}
|
|
|
|
MoveSelectedItems( aOffset );
|
|
drawings.sort();
|
|
}
|
|
|
|
|
|
|
|
void LIB_PART::MirrorSelectedItemsH( const wxPoint& aCenter )
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( !item.IsSelected() )
|
|
continue;
|
|
|
|
item.MirrorHorizontal( aCenter );
|
|
item.m_Flags = 0;
|
|
}
|
|
|
|
drawings.sort();
|
|
}
|
|
|
|
void LIB_PART::MirrorSelectedItemsV( const wxPoint& aCenter )
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( !item.IsSelected() )
|
|
continue;
|
|
|
|
item.MirrorVertical( aCenter );
|
|
item.m_Flags = 0;
|
|
}
|
|
|
|
drawings.sort();
|
|
}
|
|
|
|
void LIB_PART::RotateSelectedItems( const wxPoint& aCenter )
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( !item.IsSelected() )
|
|
continue;
|
|
|
|
item.Rotate( aCenter );
|
|
item.m_Flags = 0;
|
|
}
|
|
|
|
drawings.sort();
|
|
}
|
|
|
|
|
|
|
|
LIB_ITEM* LIB_PART::LocateDrawItem( int aUnit, int aConvert,
|
|
KICAD_T aType, const wxPoint& aPoint )
|
|
{
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
if( ( aUnit && item.m_Unit && ( aUnit != item.m_Unit) )
|
|
|| ( aConvert && item.m_Convert && ( aConvert != item.m_Convert ) )
|
|
|| ( ( item.Type() != aType ) && ( aType != TYPE_NOT_INIT ) ) )
|
|
continue;
|
|
|
|
if( item.HitTest( aPoint ) )
|
|
return &item;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
LIB_ITEM* LIB_PART::LocateDrawItem( int aUnit, int aConvert, KICAD_T aType,
|
|
const wxPoint& aPoint, const TRANSFORM& aTransform )
|
|
{
|
|
/* we use LocateDrawItem( int aUnit, int convert, KICAD_T type, const
|
|
* wxPoint& pt ) to search items.
|
|
* because this function uses DefaultTransform as orient/mirror matrix
|
|
* we temporary copy aTransform in DefaultTransform
|
|
*/
|
|
LIB_ITEM* item;
|
|
TRANSFORM transform = DefaultTransform;
|
|
DefaultTransform = aTransform;
|
|
|
|
item = LocateDrawItem( aUnit, aConvert, aType, aPoint );
|
|
|
|
// Restore matrix
|
|
DefaultTransform = transform;
|
|
|
|
return item;
|
|
}
|
|
|
|
|
|
void LIB_PART::SetUnitCount( int aCount )
|
|
{
|
|
if( m_unitCount == aCount )
|
|
return;
|
|
|
|
if( aCount < m_unitCount )
|
|
{
|
|
LIB_ITEMS::iterator i;
|
|
i = drawings.begin();
|
|
|
|
while( i != drawings.end() )
|
|
{
|
|
if( i->m_Unit > aCount )
|
|
i = drawings.erase( i );
|
|
else
|
|
i++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int prevCount = m_unitCount;
|
|
|
|
// We cannot use an iterator here, because when adding items in vector
|
|
// the buffer can be reallocated, that change the previous value of
|
|
// .begin() and .end() iterators and invalidate others iterators
|
|
unsigned imax = drawings.size();
|
|
|
|
for( unsigned ii = 0; ii < imax; ii++ )
|
|
{
|
|
if( drawings[ii].m_Unit != 1 )
|
|
continue;
|
|
|
|
for( int j = prevCount + 1; j <= aCount; j++ )
|
|
{
|
|
LIB_ITEM* newItem = (LIB_ITEM*) drawings[ii].Clone();
|
|
newItem->m_Unit = j;
|
|
drawings.push_back( newItem );
|
|
}
|
|
}
|
|
|
|
drawings.sort();
|
|
}
|
|
|
|
m_unitCount = aCount;
|
|
}
|
|
|
|
|
|
void LIB_PART::SetConversion( bool aSetConvert )
|
|
{
|
|
if( aSetConvert == HasConversion() )
|
|
return;
|
|
|
|
// Duplicate items to create the converted shape
|
|
if( aSetConvert )
|
|
{
|
|
std::vector< LIB_ITEM* > tmp; // Temporarily store the duplicated pins here.
|
|
|
|
for( LIB_ITEM& item : drawings )
|
|
{
|
|
// Only pins are duplicated.
|
|
if( item.Type() != LIB_PIN_T )
|
|
continue;
|
|
|
|
if( item.m_Convert == 1 )
|
|
{
|
|
LIB_ITEM* newItem = (LIB_ITEM*) item.Clone();
|
|
newItem->m_Convert = 2;
|
|
tmp.push_back( newItem );
|
|
}
|
|
}
|
|
|
|
// Transfer the new pins to the LIB_PART.
|
|
for( unsigned i = 0; i < tmp.size(); i++ )
|
|
drawings.push_back( tmp[i] );
|
|
}
|
|
else
|
|
{
|
|
// Delete converted shape items because the converted shape does
|
|
// not exist
|
|
LIB_ITEMS::iterator i = drawings.begin();
|
|
|
|
while( i != drawings.end() )
|
|
{
|
|
if( i->m_Convert > 1 )
|
|
i = drawings.erase( i );
|
|
else
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
wxArrayString LIB_PART::GetAliasNames( bool aIncludeRoot ) const
|
|
{
|
|
wxArrayString names;
|
|
|
|
LIB_ALIASES::const_iterator it;
|
|
|
|
for( it=m_aliases.begin(); it != m_aliases.end(); ++it )
|
|
{
|
|
if( !aIncludeRoot && (*it)->IsRoot() )
|
|
continue;
|
|
|
|
names.Add( (*it)->GetName() );
|
|
}
|
|
|
|
return names;
|
|
}
|
|
|
|
|
|
bool LIB_PART::HasAlias( const wxString& aName ) const
|
|
{
|
|
wxCHECK2_MSG( !aName.IsEmpty(), return false,
|
|
wxT( "Cannot get alias with an empty name, bad programmer." ) );
|
|
|
|
for( size_t i = 0; i < m_aliases.size(); i++ )
|
|
{
|
|
if( aName == m_aliases[i]->GetName() )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void LIB_PART::SetAliases( const wxArrayString& aAliasList )
|
|
{
|
|
wxCHECK_RET( !m_library,
|
|
wxT( "Part aliases cannot be changed when they are owned by a library." ) );
|
|
|
|
if( aAliasList == GetAliasNames() )
|
|
return;
|
|
|
|
// Add names not existing in the current component alias list.
|
|
for( size_t i = 0; i < aAliasList.GetCount(); i++ )
|
|
{
|
|
if( HasAlias( aAliasList[ i ] ) )
|
|
continue;
|
|
|
|
m_aliases.push_back( new LIB_ALIAS( aAliasList[ i ], this ) );
|
|
}
|
|
|
|
// Remove names in the current component that are not in the new alias list.
|
|
LIB_ALIASES::iterator it = m_aliases.begin();
|
|
|
|
while( it != m_aliases.end() )
|
|
{
|
|
int index = aAliasList.Index( (*it)->GetName(), false );
|
|
|
|
if( index != wxNOT_FOUND || (*it)->IsRoot() )
|
|
++it;
|
|
else
|
|
it = m_aliases.erase( it );
|
|
}
|
|
}
|
|
|
|
|
|
#if 0 // this version looked suspect to me, it did not rename a deleted root
|
|
|
|
void LIB_PART::RemoveAlias( const wxString& aName )
|
|
{
|
|
wxCHECK_RET( m_library == NULL,
|
|
wxT( "Part aliases cannot be changed when they are owned by a library." ) );
|
|
wxCHECK_RET( !aName.IsEmpty(), wxT( "Cannot get alias with an empty name." ) );
|
|
|
|
LIB_ALIASES::iterator it;
|
|
|
|
for( it = m_aliases.begin(); it != m_aliases.end(); it++ )
|
|
{
|
|
if( aName == (*it)->GetName() )
|
|
{
|
|
m_aliases.erase( it );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#else
|
|
void LIB_PART::RemoveAlias( const wxString& aName )
|
|
{
|
|
LIB_ALIAS* a = GetAlias( aName );
|
|
|
|
if( a )
|
|
RemoveAlias( a );
|
|
}
|
|
#endif
|
|
|
|
|
|
LIB_ALIAS* LIB_PART::RemoveAlias( LIB_ALIAS* aAlias )
|
|
{
|
|
wxCHECK_MSG( aAlias, NULL, wxT( "Cannot remove alias by NULL pointer." ) );
|
|
|
|
LIB_ALIAS* nextAlias = NULL;
|
|
|
|
LIB_ALIASES::iterator it = find( m_aliases.begin(), m_aliases.end(), aAlias );
|
|
|
|
if( it != m_aliases.end() )
|
|
{
|
|
bool rename = aAlias->IsRoot();
|
|
|
|
wxLogTrace( traceSchLibMem,
|
|
wxT( "%s: part:'%s', alias:'%s', alias count %llu, reference count %ld." ),
|
|
GetChars( wxString::FromAscii( __WXFUNCTION__ ) ),
|
|
GetChars( m_name ),
|
|
GetChars( aAlias->GetName() ),
|
|
(long long unsigned) m_aliases.size(),
|
|
m_me.use_count() );
|
|
|
|
it = m_aliases.erase( it );
|
|
|
|
if( !m_aliases.empty() )
|
|
{
|
|
if( it == m_aliases.end() )
|
|
it = m_aliases.begin();
|
|
|
|
nextAlias = *it;
|
|
|
|
if( rename )
|
|
SetName( nextAlias->GetName() );
|
|
}
|
|
}
|
|
|
|
return nextAlias;
|
|
}
|
|
|
|
|
|
void LIB_PART::RemoveAllAliases()
|
|
{
|
|
// Remove all of the aliases except the root alias.
|
|
while( m_aliases.size() > 1 )
|
|
m_aliases.pop_back();
|
|
}
|
|
|
|
|
|
LIB_ALIAS* LIB_PART::GetAlias( const wxString& aName )
|
|
{
|
|
wxCHECK2_MSG( !aName.IsEmpty(), return NULL,
|
|
wxT( "Cannot get alias with an empty name. Bad programmer!" ) );
|
|
|
|
for( size_t i = 0; i < m_aliases.size(); i++ )
|
|
{
|
|
if( aName == m_aliases[i]->GetName() )
|
|
return m_aliases[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
LIB_ALIAS* LIB_PART::GetAlias( size_t aIndex )
|
|
{
|
|
wxCHECK2_MSG( aIndex < m_aliases.size(), return NULL,
|
|
wxT( "Illegal alias list index, bad programmer." ) );
|
|
|
|
return m_aliases[aIndex];
|
|
}
|
|
|
|
|
|
void LIB_PART::AddAlias( const wxString& aName )
|
|
{
|
|
wxCHECK_RET( !HasAlias( aName ),
|
|
wxT( "Part <" ) + GetName() + wxT( "> already has an alias <" ) +
|
|
aName + wxT( ">. Bad programmer." ) );
|
|
|
|
m_aliases.push_back( new LIB_ALIAS( aName, this ) );
|
|
}
|
|
|
|
|
|
void LIB_PART::SetSubpartIdNotation( int aSep, int aFirstId )
|
|
{
|
|
m_subpartFirstId = 'A';
|
|
m_subpartIdSeparator = 0;
|
|
|
|
if( aSep == '.' || aSep == '-' || aSep == '_' )
|
|
m_subpartIdSeparator = aSep;
|
|
|
|
if( aFirstId == '1' && aSep != 0 )
|
|
m_subpartFirstId = aFirstId;
|
|
}
|