KiCad PCB EDA Suite
lib_symbol.cpp
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KiCad, a free EDA CAD application.
3  *
4  * Copyright (C) 2004-2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
5  * Copyright (C) 2008 Wayne Stambaugh <stambaughw@gmail.com>
6  * Copyright (C) 2004-2021 KiCad Developers, see AUTHORS.txt for contributors.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, you may find one here:
20  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21  * or you may search the http://www.gnu.org website for the version 2 license,
22  * or you may write to the Free Software Foundation, Inc.,
23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24  */
25 
26 #include <sch_draw_panel.h>
27 #include <plotter.h>
28 #include <sch_screen.h>
29 #include <richio.h>
30 #include <general.h>
31 #include <template_fieldnames.h>
32 #include <transform.h>
33 #include <symbol_library.h>
34 #include <lib_pin.h>
35 #include <lib_arc.h>
37 
38 
39 // the separator char between the subpart id and the reference
40 // 0 (no separator) or '.' or some other character
42 
43 // the ascii char value to calculate the subpart symbol id from the part number:
44 // 'A' or '1' usually. (to print U1.A or U1.1)
45 // if this a digit, a number is used as id symbol
47 
48 
50 {
51  // Matches are scored by offset from front of string, so inclusion of this spacer
52  // discounts matches found after it.
53  static const wxString discount( wxT( " " ) );
54 
55  wxString text = GetKeyWords() + discount + GetDescription();
56  wxString footprint = GetFootprintField().GetText();
57 
58  if( !footprint.IsEmpty() )
59  {
60  text += discount + footprint;
61  }
62 
63  return text;
64 }
65 
66 
67 bool operator<( const LIB_SYMBOL& aItem1, const LIB_SYMBOL& aItem2 )
68 {
69  return aItem1.GetName() < aItem2.GetName();
70 }
71 
72 
75 {
76  void operator()(void const *) const
77  {
78  }
79 };
80 
81 
82 LIB_SYMBOL::LIB_SYMBOL( const wxString& aName, LIB_SYMBOL* aParent, SYMBOL_LIB* aLibrary ) :
84  m_me( this, null_deleter() ),
85  m_includeInBom( true ),
86  m_includeOnBoard( true )
87 {
88  m_lastModDate = 0;
89  m_unitCount = 1;
92  m_unitsLocked = false;
93  m_showPinNumbers = true;
94  m_showPinNames = true;
95 
96  // Add the MANDATORY_FIELDS in RAM only. These are assumed to be present
97  // when the field editors are invoked.
98  m_drawings[LIB_FIELD_T].reserve( 4 );
103 
104  SetName( aName );
105 
106  if( aParent )
107  SetParent( aParent );
108 
109  SetLib( aLibrary );
110 }
111 
112 
113 LIB_SYMBOL::LIB_SYMBOL( const LIB_SYMBOL& aSymbol, SYMBOL_LIB* aLibrary ) :
114  EDA_ITEM( aSymbol ),
115  m_me( this, null_deleter() )
116 {
117  LIB_ITEM* newItem;
118 
119  m_library = aLibrary;
120  m_name = aSymbol.m_name;
121  m_fpFilters = wxArrayString( aSymbol.m_fpFilters );
122  m_unitCount = aSymbol.m_unitCount;
123  m_unitsLocked = aSymbol.m_unitsLocked;
126  m_includeInBom = aSymbol.m_includeInBom;
128  m_showPinNames = aSymbol.m_showPinNames;
129  m_lastModDate = aSymbol.m_lastModDate;
130  m_options = aSymbol.m_options;
131  m_libId = aSymbol.m_libId;
132  m_description = aSymbol.m_description;
133  m_keyWords = aSymbol.m_keyWords;
134 
135  ClearSelected();
136 
137  for( const LIB_ITEM& oldItem : aSymbol.m_drawings )
138  {
139  if( ( oldItem.GetFlags() & ( IS_NEW | STRUCT_DELETED ) ) != 0 )
140  continue;
141 
142  try
143  {
144  newItem = (LIB_ITEM*) oldItem.Clone();
145  newItem->ClearSelected();
146  newItem->SetParent( this );
147  m_drawings.push_back( newItem );
148  }
149  catch( ... )
150  {
151  wxFAIL_MSG( "Failed to clone LIB_ITEM." );
152  }
153  }
154 
155  LIB_SYMBOL_SPTR parent = aSymbol.m_parent.lock();
156 
157  if( parent )
158  SetParent( parent.get() );
159 }
160 
161 
163 {
164 }
165 
166 
168 {
169  if( &aSymbol == this )
170  return aSymbol;
171 
172  LIB_ITEM* newItem;
173 
174  m_library = aSymbol.m_library;
175  m_name = aSymbol.m_name;
176  m_fpFilters = wxArrayString( aSymbol.m_fpFilters );
177  m_unitCount = aSymbol.m_unitCount;
178  m_unitsLocked = aSymbol.m_unitsLocked;
181  m_showPinNames = aSymbol.m_showPinNames;
182  m_includeInBom = aSymbol.m_includeInBom;
184  m_lastModDate = aSymbol.m_lastModDate;
185  m_options = aSymbol.m_options;
186  m_libId = aSymbol.m_libId;
187  m_description = aSymbol.m_description;
188  m_keyWords = aSymbol.m_keyWords;
189 
190  m_drawings.clear();
191 
192  for( const LIB_ITEM& oldItem : aSymbol.m_drawings )
193  {
194  if( ( oldItem.GetFlags() & ( IS_NEW | STRUCT_DELETED ) ) != 0 )
195  continue;
196 
197  newItem = (LIB_ITEM*) oldItem.Clone();
198  newItem->SetParent( this );
199  m_drawings.push_back( newItem );
200  }
201 
202  m_drawings.sort();
203 
204  LIB_SYMBOL_SPTR parent = aSymbol.m_parent.lock();
205 
206  if( parent )
207  SetParent( parent.get() );
208 
209  return *this;
210 }
211 
212 
213 int LIB_SYMBOL::Compare( const LIB_SYMBOL& aRhs ) const
214 {
215  if( m_me == aRhs.m_me )
216  return 0;
217 
218  int retv = m_name.Cmp( aRhs.m_name );
219 
220  if( retv )
221  return retv;
222 
223  retv = m_libId.compare( aRhs.m_libId );
224 
225  if( retv )
226  return retv;
227 
228  if( m_parent.lock() < aRhs.m_parent.lock() )
229  return -1;
230 
231  if( m_parent.lock() > aRhs.m_parent.lock() )
232  return 1;
233 
234  if( m_options != aRhs.m_options )
235  return ( m_options == ENTRY_NORMAL ) ? -1 : 1;
236 
237  if( m_unitCount != aRhs.m_unitCount )
238  return m_unitCount - aRhs.m_unitCount;
239 
240  if( m_drawings.size() != aRhs.m_drawings.size() )
241  return m_drawings.size() - aRhs.m_drawings.size();
242 
245 
246  while( lhsItemIt != m_drawings.end() )
247  {
248  const LIB_ITEM* lhsItem = static_cast<const LIB_ITEM*>( &(*lhsItemIt) );
249  const LIB_ITEM* rhsItem = static_cast<const LIB_ITEM*>( &(*rhsItemIt) );
250 
251  wxCHECK( lhsItem && rhsItem, lhsItem - rhsItem );
252 
253  if( lhsItem->Type() != rhsItem->Type() )
254  return lhsItem->Type() - rhsItem->Type();
255 
256  retv = lhsItem->compare( *rhsItem );
257 
258  if( retv )
259  return retv;
260 
261  ++lhsItemIt;
262  ++rhsItemIt;
263  }
264 
265  if( m_fpFilters.GetCount() != aRhs.m_fpFilters.GetCount() )
266  return m_fpFilters.GetCount() - aRhs.m_fpFilters.GetCount();
267 
268  for( size_t i = 0; i < m_fpFilters.GetCount(); i++ )
269  {
270  retv = m_fpFilters[i].Cmp( aRhs.m_fpFilters[i] );
271 
272  if( retv )
273  return retv;
274  }
275 
276  retv = m_description.Cmp( aRhs.m_description );
277 
278  if( retv )
279  return retv;
280 
281  retv = m_keyWords.Cmp( aRhs.m_keyWords );
282 
283  if( retv )
284  return retv;
285 
286  if( m_pinNameOffset != aRhs.m_pinNameOffset )
287  return m_pinNameOffset - aRhs.m_pinNameOffset;
288 
289  if( m_unitsLocked != aRhs.m_unitsLocked )
290  return ( m_unitsLocked ) ? 1 : -1;
291 
292  if( m_showPinNames != aRhs.m_showPinNames )
293  return ( m_showPinNames ) ? 1 : -1;
294 
295  if( m_showPinNumbers != aRhs.m_showPinNumbers )
296  return ( m_showPinNumbers ) ? 1 : -1;
297 
298  if( m_includeInBom != aRhs.m_includeInBom )
299  return ( m_includeInBom ) ? 1 : -1;
300 
301  if( m_includeOnBoard != aRhs.m_includeOnBoard )
302  return ( m_includeOnBoard ) ? 1 : -1;
303 
304  return 0;
305 }
306 
307 
308 wxString LIB_SYMBOL::GetUnitReference( int aUnit )
309 {
310  return LIB_SYMBOL::SubReference( aUnit, false );
311 }
312 
313 
314 void LIB_SYMBOL::SetName( const wxString& aName )
315 {
316  wxString validatedName = LIB_ID::FixIllegalChars( aName );
317 
318  m_name = validatedName;
319  m_libId.SetLibItemName( validatedName, false );
320 
321  GetValueField().SetText( validatedName );
322 }
323 
324 
326 {
327  if( aParent )
328  m_parent = aParent->SharedPtr();
329  else
330  m_parent.reset();
331 }
332 
333 
334 std::unique_ptr< LIB_SYMBOL > LIB_SYMBOL::Flatten() const
335 {
336  std::unique_ptr< LIB_SYMBOL > retv;
337 
338  if( IsAlias() )
339  {
340  LIB_SYMBOL_SPTR parent = m_parent.lock();
341 
342  wxCHECK_MSG( parent, retv,
343  wxString::Format( "Parent of derived symbol '%s' undefined", m_name ) );
344 
345  // Copy the parent.
346  retv.reset( new LIB_SYMBOL( *parent.get() ) );
347 
348  retv->SetName( m_name );
349 
350  // Now add the inherited part mandatory field (this) information.
351  for( int i = 0; i < MANDATORY_FIELDS; i++ )
352  {
353  wxString tmp = GetFieldById( i )->GetText();
354 
355  // If the field isn't defined then inherit the parent field value.
356  if( tmp.IsEmpty() )
357  retv->GetFieldById( i )->SetText( parent->GetFieldById( i )->GetText() );
358  else
359  *retv->GetFieldById( i ) = *GetFieldById( i );
360  }
361 
362  // Grab all the rest of derived symbol fields.
363  for( const LIB_ITEM& item : m_drawings[ LIB_FIELD_T ] )
364  {
365  const LIB_FIELD* aliasField = dynamic_cast<const LIB_FIELD*>( &item );
366 
367  wxCHECK2( aliasField, continue );
368 
369  // Mandatory fields were already resolved.
370  if( aliasField->IsMandatory() )
371  continue;
372 
373  LIB_FIELD* newField = new LIB_FIELD( *aliasField );
374  newField->SetParent( retv.get() );
375 
376  LIB_FIELD* parentField = retv->FindField( aliasField->GetName() );
377 
378  if( !parentField ) // Derived symbol field does not exist in parent symbol.
379  {
380  retv->AddDrawItem( newField );
381  }
382  else // Derived symbol field overrides the parent symbol field.
383  {
384  retv->RemoveDrawItem( parentField );
385  retv->AddDrawItem( newField );
386  }
387  }
388 
389  retv->SetKeyWords( m_keyWords.IsEmpty() ? parent->GetKeyWords() : m_keyWords );
390  retv->SetDescription( m_description.IsEmpty() ? parent->GetDescription() : m_description );
391  retv->SetFPFilters( m_fpFilters.IsEmpty() ? parent->GetFPFilters() : m_fpFilters );
392  }
393  else
394  {
395  retv.reset( new LIB_SYMBOL( *this ) );
396  }
397 
398  return retv;
399 }
400 
401 
402 const wxString LIB_SYMBOL::GetLibraryName() const
403 {
404  if( m_library )
405  return m_library->GetName();
406 
407  return m_libId.GetLibNickname();
408 }
409 
410 
412 {
413  if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
414  return parent->m_options == ENTRY_POWER;
415 
416  return m_options == ENTRY_POWER;
417 }
418 
419 
421 {
422  if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
423  parent->m_options = ENTRY_POWER;
424 
426 }
427 
428 
430 {
431  if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
432  return parent->m_options == ENTRY_NORMAL;
433 
434  return m_options == ENTRY_NORMAL;
435 }
436 
437 
439 {
440  if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
441  parent->m_options = ENTRY_NORMAL;
442 
444 }
445 
446 
447 wxString LIB_SYMBOL::SubReference( int aUnit, bool aAddSeparator )
448 {
449  wxString subRef;
450 
451  if( m_subpartIdSeparator != 0 && aAddSeparator )
452  subRef << wxChar( m_subpartIdSeparator );
453 
454  if( m_subpartFirstId >= '0' && m_subpartFirstId <= '9' )
455  subRef << aUnit;
456  else
457  {
458  // use letters as notation. To allow more than 26 units, the sub ref
459  // use one letter if letter = A .. Z or a ... z, and 2 letters otherwise
460  // first letter is expected to be 'A' or 'a' (i.e. 26 letters are available)
461  int u;
462  aUnit -= 1; // Unit number starts to 1. now to 0.
463 
464  while( aUnit >= 26 ) // more than one letter are needed
465  {
466  u = aUnit / 26;
467  subRef << wxChar( m_subpartFirstId + u -1 );
468  aUnit %= 26;
469  }
470 
471  u = m_subpartFirstId + aUnit;
472  subRef << wxChar( u );
473  }
474 
475  return subRef;
476 }
477 
478 
479 void LIB_SYMBOL::Print( const RENDER_SETTINGS* aSettings, const wxPoint& aOffset,
480  int aMulti, int aConvert, const LIB_SYMBOL_OPTIONS& aOpts )
481 {
482  /* draw background for filled items using background option
483  * Solid lines will be drawn after the background
484  * Note also, background is not drawn when printing in black and white
485  */
486  if( !GetGRForceBlackPenState() )
487  {
488  for( LIB_ITEM& drawItem : m_drawings )
489  {
490  if( drawItem.m_fill != FILL_TYPE::FILLED_WITH_BG_BODYCOLOR )
491  continue;
492 
493  // Do not draw items not attached to the current part
494  if( aMulti && drawItem.m_unit && ( drawItem.m_unit != aMulti ) )
495  continue;
496 
497  if( aConvert && drawItem.m_convert && ( drawItem.m_convert != aConvert ) )
498  continue;
499 
500  if( drawItem.Type() == LIB_FIELD_T )
501  continue;
502 
503  // Now, draw only the background for items with
504  // m_fill == FILLED_WITH_BG_BODYCOLOR:
505  drawItem.Print( aSettings, aOffset, (void*) false, aOpts.transform );
506  }
507  }
508 
509  for( LIB_ITEM& drawItem : m_drawings )
510  {
511  // Do not draw items not attached to the current part
512  if( aMulti && drawItem.m_unit && ( drawItem.m_unit != aMulti ) )
513  continue;
514 
515  if( aConvert && drawItem.m_convert && ( drawItem.m_convert != aConvert ) )
516  continue;
517 
518  if( drawItem.Type() == LIB_FIELD_T )
519  {
520  LIB_FIELD& field = static_cast<LIB_FIELD&>( drawItem );
521 
522  if( field.IsVisible() && !aOpts.draw_visible_fields )
523  continue;
524 
525  if( !field.IsVisible() && !aOpts.draw_hidden_fields )
526  continue;
527  }
528 
529  if( drawItem.Type() == LIB_PIN_T )
530  {
531  drawItem.Print( aSettings, aOffset, (void*) &aOpts, aOpts.transform );
532  }
533  else if( drawItem.Type() == LIB_FIELD_T )
534  {
535  drawItem.Print( aSettings, aOffset, (void*) NULL, aOpts.transform );
536  }
537  else
538  {
539  bool forceNoFill = drawItem.m_fill == FILL_TYPE::FILLED_WITH_BG_BODYCOLOR;
540  drawItem.Print( aSettings, aOffset, (void*) forceNoFill, aOpts.transform );
541  }
542  }
543 }
544 
545 
546 void LIB_SYMBOL::Plot( PLOTTER* aPlotter, int aUnit, int aConvert, const wxPoint& aOffset,
547  const TRANSFORM& aTransform ) const
548 {
549  wxASSERT( aPlotter != NULL );
550 
551  aPlotter->SetColor( aPlotter->RenderSettings()->GetLayerColor( LAYER_DEVICE ) );
552  bool fill = aPlotter->GetColorMode();
553 
554  // draw background for filled items using background option
555  // Solid lines will be drawn after the background
556  for( const LIB_ITEM& item : m_drawings )
557  {
558  // Lib Fields are not plotted here, because this plot function
559  // is used to plot schematic items, which have they own fields
560  if( item.Type() == LIB_FIELD_T )
561  continue;
562 
563  if( aUnit && item.m_unit && ( item.m_unit != aUnit ) )
564  continue;
565 
566  if( aConvert && item.m_convert && ( item.m_convert != aConvert ) )
567  continue;
568 
569  if( item.m_fill == FILL_TYPE::FILLED_WITH_BG_BODYCOLOR )
570  item.Plot( aPlotter, aOffset, fill, aTransform );
571  }
572 
573  // Not filled items and filled shapes are now plotted
574  // Items that have BG fills only get re-stroked to ensure the edges are in the foreground
575  for( const LIB_ITEM& item : m_drawings )
576  {
577  if( item.Type() == LIB_FIELD_T )
578  continue;
579 
580  if( aUnit && item.m_unit && ( item.m_unit != aUnit ) )
581  continue;
582 
583  if( aConvert && item.m_convert && ( item.m_convert != aConvert ) )
584  continue;
585 
586  item.Plot( aPlotter, aOffset,
587  fill && ( item.m_fill != FILL_TYPE::FILLED_WITH_BG_BODYCOLOR ), aTransform );
588  }
589 }
590 
591 
592 void LIB_SYMBOL::PlotLibFields( PLOTTER* aPlotter, int aUnit, int aConvert,
593  const wxPoint& aOffset, const TRANSFORM& aTransform )
594 {
595  wxASSERT( aPlotter != NULL );
596 
597  aPlotter->SetColor( aPlotter->RenderSettings()->GetLayerColor( LAYER_FIELDS ) );
598  bool fill = aPlotter->GetColorMode();
599 
600  for( LIB_ITEM& item : m_drawings )
601  {
602  if( item.Type() != LIB_FIELD_T )
603  continue;
604 
605  if( aUnit && item.m_unit && ( item.m_unit != aUnit ) )
606  continue;
607 
608  if( aConvert && item.m_convert && ( item.m_convert != aConvert ) )
609  continue;
610 
611  LIB_FIELD& field = (LIB_FIELD&) item;
612 
613  // The reference is a special case: we should change the basic text
614  // to add '?' and the part id
615  wxString tmp = field.GetShownText();
616 
617  if( field.GetId() == REFERENCE_FIELD )
618  {
619  wxString text = field.GetFullText( aUnit );
620  field.SetText( text );
621  }
622 
623  item.Plot( aPlotter, aOffset, fill, aTransform );
624  field.SetText( tmp );
625  }
626 }
627 
628 
630 {
631  wxASSERT( aItem != NULL );
632 
633  // none of the MANDATORY_FIELDS may be removed in RAM, but they may be
634  // omitted when saving to disk.
635  if( aItem->Type() == LIB_FIELD_T )
636  {
637  if( static_cast<LIB_FIELD*>( aItem )->IsMandatory() )
638  return;
639  }
640 
641  LIB_ITEMS& items = m_drawings[ aItem->Type() ];
642 
643  for( LIB_ITEMS::iterator i = items.begin(); i != items.end(); i++ )
644  {
645  if( *i == aItem )
646  {
647  items.erase( i );
648  SetModified();
649  break;
650  }
651  }
652 }
653 
654 
655 void LIB_SYMBOL::AddDrawItem( LIB_ITEM* aItem, bool aSort )
656 {
657  wxCHECK( aItem, /* void */ );
658 
659  m_drawings.push_back( aItem );
660 
661  if( aSort )
662  m_drawings.sort();
663 }
664 
665 
667 {
668  if( aItem == NULL )
669  {
671 
672  return (it1 != m_drawings.end( aType ) ) ? &( *( m_drawings.begin( aType ) ) ) : nullptr;
673  }
674 
675  // Search for the last item, assume aItem is of type aType
676  wxASSERT( ( aType == TYPE_NOT_INIT ) || ( aType == aItem->Type() ) );
678 
679  while( ( it != m_drawings.end( aType ) ) && ( aItem != &( *it ) ) )
680  ++it;
681 
682  // Search the next item
683  if( it != m_drawings.end( aType ) )
684  {
685  ++it;
686 
687  if( it != m_drawings.end( aType ) )
688  return &( *it );
689  }
690 
691  return NULL;
692 }
693 
694 
695 void LIB_SYMBOL::GetPins( LIB_PINS& aList, int aUnit, int aConvert ) const
696 {
697  /* Notes:
698  * when aUnit == 0: no unit filtering
699  * when aConvert == 0: no convert (shape selection) filtering
700  * when m_unit == 0, the body item is common to units
701  * when m_convert == 0, the body item is common to shapes
702  */
703 
704  LIB_SYMBOL_SPTR parent = m_parent.lock();
705  const LIB_ITEMS_CONTAINER& drawItems = parent ? parent->m_drawings : m_drawings;
706 
707  for( const LIB_ITEM& item : drawItems[LIB_PIN_T] )
708  {
709  // Unit filtering:
710  if( aUnit && item.m_unit && ( item.m_unit != aUnit ) )
711  continue;
712 
713  // Shape filtering:
714  if( aConvert && item.m_convert && ( item.m_convert != aConvert ) )
715  continue;
716 
717  aList.push_back( (LIB_PIN*) &item );
718  }
719 }
720 
721 
722 LIB_PIN* LIB_SYMBOL::GetPin( const wxString& aNumber, int aUnit, int aConvert ) const
723 {
724  LIB_PINS pinList;
725 
726  GetPins( pinList, aUnit, aConvert );
727 
728  for( size_t i = 0; i < pinList.size(); i++ )
729  {
730  wxASSERT( pinList[i]->Type() == LIB_PIN_T );
731 
732  if( aNumber == pinList[i]->GetNumber() )
733  return pinList[i];
734  }
735 
736  return NULL;
737 }
738 
739 
740 bool LIB_SYMBOL::PinsConflictWith( const LIB_SYMBOL& aOtherPart, bool aTestNums, bool aTestNames,
741  bool aTestType, bool aTestOrientation, bool aTestLength ) const
742 {
743  LIB_PINS thisPinList;
744  GetPins( thisPinList, /* aUnit */ 0, /* aConvert */ 0 );
745 
746  for( const LIB_PIN* eachThisPin : thisPinList )
747  {
748  wxASSERT( eachThisPin );
749  LIB_PINS otherPinList;
750  aOtherPart.GetPins( otherPinList, /* aUnit */ 0, /* aConvert */ 0 );
751  bool foundMatch = false;
752 
753  for( const LIB_PIN* eachOtherPin : otherPinList )
754  {
755  wxASSERT( eachOtherPin );
756 
757  // Same unit?
758  if( eachThisPin->GetUnit() != eachOtherPin->GetUnit() )
759  continue;
760 
761  // Same body stype?
762  if( eachThisPin->GetConvert() != eachOtherPin->GetConvert() )
763  continue;
764 
765  // Same position?
766  if( eachThisPin->GetPosition() != eachOtherPin->GetPosition() )
767  continue;
768 
769  // Same number?
770  if( aTestNums && ( eachThisPin->GetNumber() != eachOtherPin->GetNumber() ) )
771  continue;
772 
773  // Same name?
774  if( aTestNames && ( eachThisPin->GetName() != eachOtherPin->GetName() ) )
775  continue;
776 
777  // Same electrical type?
778  if( aTestType && ( eachThisPin->GetType() != eachOtherPin->GetType() ) )
779  continue;
780 
781  // Same orientation?
782  if( aTestOrientation
783  && ( eachThisPin->GetOrientation() != eachOtherPin->GetOrientation() ) )
784  continue;
785 
786  // Same length?
787  if( aTestLength && ( eachThisPin->GetLength() != eachOtherPin->GetLength() ) )
788  continue;
789 
790  foundMatch = true;
791  break; // Match found so search is complete.
792  }
793 
794  if( !foundMatch )
795  {
796  // This means there was not an identical (according to the arguments)
797  // pin at the same position in the other symbol.
798  return true;
799  }
800  }
801 
802  // The loop never gave up, so no conflicts were found.
803  return false;
804 }
805 
806 
807 const EDA_RECT LIB_SYMBOL::GetUnitBoundingBox( int aUnit, int aConvert ) const
808 {
809  EDA_RECT bBox;
810  bool initialized = false;
811 
812  for( const LIB_ITEM& item : m_drawings )
813  {
814  if( item.m_unit > 0
815  && m_unitCount > 1
816  && aUnit > 0
817  && aUnit != item.m_unit )
818  {
819  continue;
820  }
821 
822  if( item.m_convert > 0 && aConvert > 0 && aConvert != item.m_convert )
823  continue;
824 
825  if ( ( item.Type() == LIB_FIELD_T ) && !( ( LIB_FIELD& ) item ).IsVisible() )
826  continue;
827 
828  if( initialized )
829  bBox.Merge( item.GetBoundingBox() );
830  else
831  {
832  bBox = item.GetBoundingBox();
833  initialized = true;
834  }
835  }
836 
837  return bBox;
838 }
839 
840 
841 void LIB_SYMBOL::ViewGetLayers( int aLayers[], int& aCount ) const
842 {
843  aCount = 6;
844  aLayers[0] = LAYER_DEVICE;
845  aLayers[1] = LAYER_DEVICE_BACKGROUND;
846  aLayers[2] = LAYER_REFERENCEPART;
847  aLayers[3] = LAYER_VALUEPART;
848  aLayers[4] = LAYER_FIELDS;
849  aLayers[5] = LAYER_SELECTION_SHADOWS;
850 }
851 
852 
853 const EDA_RECT LIB_SYMBOL::GetBodyBoundingBox( int aUnit, int aConvert ) const
854 {
855  EDA_RECT bbox;
856 
857  for( const LIB_ITEM& item : m_drawings )
858  {
859  if( item.m_unit > 0 && aUnit > 0 && aUnit != item.m_unit )
860  continue;
861 
862  if( item.m_convert > 0 && aConvert > 0 && aConvert != item.m_convert )
863  continue;
864 
865  if( item.Type() == LIB_FIELD_T )
866  continue;
867 
868  if( item.Type() == LIB_PIN_T )
869  bbox.Merge( static_cast<const LIB_PIN&>( item ).GetBoundingBox( false, true ) );
870  else
871  bbox.Merge( item.GetBoundingBox() );
872  }
873 
874  return bbox;
875 }
876 
877 
879 {
881 }
882 
883 
885 {
886  AddDrawItem( aField );
887 }
888 
889 
890 void LIB_SYMBOL::SetFields( const std::vector <LIB_FIELD>& aFields )
891 {
892  deleteAllFields();
893 
894  for( unsigned i=0; i<aFields.size(); ++i )
895  {
896  // drawings is a ptr_vector, new and copy an object on the heap.
897  LIB_FIELD* field = new LIB_FIELD( aFields[i] );
898 
899  field->SetParent( this );
900  m_drawings.push_back( field );
901  }
902 
903  m_drawings.sort();
904 }
905 
906 
907 void LIB_SYMBOL::GetFields( std::vector<LIB_FIELD*>& aList )
908 {
909  // Grab the MANDATORY_FIELDS first, in expected order given by enum MANDATORY_FIELD_T
910  for( int id = 0; id < MANDATORY_FIELDS; ++id )
911  aList.push_back( GetFieldById( id ) );
912 
913  // Now grab all the rest of fields.
914  for( LIB_ITEM& item : m_drawings[ LIB_FIELD_T ] )
915  {
916  LIB_FIELD* field = static_cast<LIB_FIELD*>( &item );
917 
918  if( !field->IsMandatory() )
919  aList.push_back( field );
920  }
921 }
922 
923 
924 void LIB_SYMBOL::GetFields( std::vector<LIB_FIELD>& aList )
925 {
926  // Grab the MANDATORY_FIELDS first, in expected order given by enum MANDATORY_FIELD_T
927  for( int id = 0; id < MANDATORY_FIELDS; ++id )
928  aList.push_back( *GetFieldById( id ) );
929 
930  // Now grab all the rest of fields.
931  for( LIB_ITEM& item : m_drawings[ LIB_FIELD_T ] )
932  {
933  LIB_FIELD* field = static_cast<LIB_FIELD*>( &item );
934 
935  if( !field->IsMandatory() )
936  aList.push_back( *field );
937  }
938 }
939 
940 
942 {
943  for( const LIB_ITEM& item : m_drawings[ LIB_FIELD_T ] )
944  {
945  LIB_FIELD* field = ( LIB_FIELD* ) &item;
946 
947  if( field->GetId() == aId )
948  return field;
949  }
950 
951  return NULL;
952 }
953 
954 
955 LIB_FIELD* LIB_SYMBOL::FindField( const wxString& aFieldName )
956 {
957  for( LIB_ITEM& item : m_drawings[ LIB_FIELD_T ] )
958  {
959  if( static_cast<LIB_FIELD*>( &item )->GetCanonicalName() == aFieldName )
960  return static_cast<LIB_FIELD*>( &item );
961  }
962 
963  return NULL;
964 }
965 
966 
967 const LIB_FIELD* LIB_SYMBOL::FindField( const wxString& aFieldName ) const
968 {
969  for( const LIB_ITEM& item : m_drawings[ LIB_FIELD_T ] )
970  {
971  if( static_cast<const LIB_FIELD*>( &item )->GetCanonicalName() == aFieldName )
972  return static_cast<const LIB_FIELD*>( &item );
973  }
974 
975  return NULL;
976 }
977 
978 
980 {
981  LIB_FIELD* field = GetFieldById( VALUE_FIELD );
982  wxASSERT( field != NULL );
983  return *field;
984 }
985 
986 
988 {
990  wxASSERT( field != NULL );
991  return *field;
992 }
993 
994 
996 {
998  wxASSERT( field != NULL );
999  return *field;
1000 }
1001 
1002 
1004 {
1006  wxASSERT( field != NULL );
1007  return *field;
1008 }
1009 
1010 
1011 void LIB_SYMBOL::SetOffset( const wxPoint& aOffset )
1012 {
1013  for( LIB_ITEM& item : m_drawings )
1014  item.Offset( aOffset );
1015 }
1016 
1017 
1019 {
1020  m_drawings.unique();
1021 }
1022 
1023 
1025 {
1026  for( const LIB_ITEM& item : m_drawings )
1027  {
1028  if( item.m_convert > LIB_ITEM::LIB_CONVERT::BASE )
1029  return true;
1030  }
1031 
1032  if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
1033  {
1034  for( const LIB_ITEM& item : parent->GetDrawItems() )
1035  {
1036  if( item.m_convert > LIB_ITEM::LIB_CONVERT::BASE )
1037  return true;
1038  }
1039  }
1040 
1041  return false;
1042 }
1043 
1044 
1046 {
1047  for( LIB_ITEM& item : m_drawings )
1048  item.ClearTempFlags();
1049 }
1050 
1051 
1053 {
1054  for( LIB_ITEM& item : m_drawings )
1055  item.ClearEditFlags();
1056 }
1057 
1058 
1059 LIB_ITEM* LIB_SYMBOL::LocateDrawItem( int aUnit, int aConvert,
1060  KICAD_T aType, const wxPoint& aPoint )
1061 {
1062  for( LIB_ITEM& item : m_drawings )
1063  {
1064  if( ( aUnit && item.m_unit && aUnit != item.m_unit )
1065  || ( aConvert && item.m_convert && aConvert != item.m_convert )
1066  || ( item.Type() != aType && aType != TYPE_NOT_INIT ) )
1067  {
1068  continue;
1069  }
1070 
1071  if( item.HitTest( aPoint ) )
1072  return &item;
1073  }
1074 
1075  return NULL;
1076 }
1077 
1078 
1079 LIB_ITEM* LIB_SYMBOL::LocateDrawItem( int aUnit, int aConvert, KICAD_T aType,
1080  const wxPoint& aPoint, const TRANSFORM& aTransform )
1081 {
1082  /* we use LocateDrawItem( int aUnit, int convert, KICAD_T type, const
1083  * wxPoint& pt ) to search items.
1084  * because this function uses DefaultTransform as orient/mirror matrix
1085  * we temporary copy aTransform in DefaultTransform
1086  */
1087  LIB_ITEM* item;
1088  TRANSFORM transform = DefaultTransform;
1089  DefaultTransform = aTransform;
1090 
1091  item = LocateDrawItem( aUnit, aConvert, aType, aPoint );
1092 
1093  // Restore matrix
1094  DefaultTransform = transform;
1095 
1096  return item;
1097 }
1098 
1099 
1100 SEARCH_RESULT LIB_SYMBOL::Visit( INSPECTOR aInspector, void* aTestData,
1101  const KICAD_T aFilterTypes[] )
1102 {
1103  // The part itself is never inspected, only its children
1104  for( LIB_ITEM& item : m_drawings )
1105  {
1106  if( item.IsType( aFilterTypes ) )
1107  {
1108  if( aInspector( &item, aTestData ) == SEARCH_RESULT::QUIT )
1109  return SEARCH_RESULT::QUIT;
1110  }
1111  }
1112 
1113  return SEARCH_RESULT::CONTINUE;
1114 }
1115 
1116 
1117 void LIB_SYMBOL::SetUnitCount( int aCount, bool aDuplicateDrawItems )
1118 {
1119  if( m_unitCount == aCount )
1120  return;
1121 
1122  if( aCount < m_unitCount )
1123  {
1125 
1126  while( i != m_drawings.end() )
1127  {
1128  if( i->m_unit > aCount )
1129  i = m_drawings.erase( i );
1130  else
1131  ++i;
1132  }
1133  }
1134  else if( aDuplicateDrawItems )
1135  {
1136  int prevCount = m_unitCount;
1137 
1138  // Temporary storage for new items, as adding new items directly to
1139  // m_drawings may cause the buffer reallocation which invalidates the
1140  // iterators
1141  std::vector< LIB_ITEM* > tmp;
1142 
1143  for( LIB_ITEM& item : m_drawings )
1144  {
1145  if( item.m_unit != 1 )
1146  continue;
1147 
1148  for( int j = prevCount + 1; j <= aCount; j++ )
1149  {
1150  LIB_ITEM* newItem = (LIB_ITEM*) item.Clone();
1151  newItem->m_unit = j;
1152  tmp.push_back( newItem );
1153  }
1154  }
1155 
1156  for( auto item : tmp )
1157  m_drawings.push_back( item );
1158  }
1159 
1160  m_drawings.sort();
1161  m_unitCount = aCount;
1162 }
1163 
1164 
1166 {
1167  if( LIB_SYMBOL_SPTR parent = m_parent.lock() )
1168  return parent->GetUnitCount();
1169 
1170  return m_unitCount;
1171 }
1172 
1173 
1174 void LIB_SYMBOL::SetConversion( bool aSetConvert, bool aDuplicatePins )
1175 {
1176  if( aSetConvert == HasConversion() )
1177  return;
1178 
1179  // Duplicate items to create the converted shape
1180  if( aSetConvert )
1181  {
1182  if( aDuplicatePins )
1183  {
1184  std::vector< LIB_ITEM* > tmp; // Temporarily store the duplicated pins here.
1185 
1186  for( LIB_ITEM& item : m_drawings )
1187  {
1188  // Only pins are duplicated.
1189  if( item.Type() != LIB_PIN_T )
1190  continue;
1191 
1192  if( item.m_convert == 1 )
1193  {
1194  LIB_ITEM* newItem = (LIB_ITEM*) item.Clone();
1195  newItem->m_convert = 2;
1196  tmp.push_back( newItem );
1197  }
1198  }
1199 
1200  // Transfer the new pins to the LIB_SYMBOL.
1201  for( unsigned i = 0; i < tmp.size(); i++ )
1202  m_drawings.push_back( tmp[i] );
1203  }
1204  }
1205  else
1206  {
1207  // Delete converted shape items because the converted shape does
1208  // not exist
1210 
1211  while( i != m_drawings.end() )
1212  {
1213  if( i->m_convert > 1 )
1214  i = m_drawings.erase( i );
1215  else
1216  ++i;
1217  }
1218  }
1219 
1220  m_drawings.sort();
1221 }
1222 
1223 
1224 void LIB_SYMBOL::SetSubpartIdNotation( int aSep, int aFirstId )
1225 {
1226  m_subpartFirstId = 'A';
1228 
1229  if( aSep == '.' || aSep == '-' || aSep == '_' )
1230  m_subpartIdSeparator = aSep;
1231 
1232  if( aFirstId == '1' && aSep != 0 )
1233  m_subpartFirstId = aFirstId;
1234 }
1235 
1236 
1237 std::vector<LIB_ITEM*> LIB_SYMBOL::GetUnitItems( int aUnit, int aConvert )
1238 {
1239  std::vector<LIB_ITEM*> unitItems;
1240 
1241  for( LIB_ITEM& item : m_drawings )
1242  {
1243  if( item.Type() == LIB_FIELD_T )
1244  continue;
1245 
1246  if( ( aConvert == -1 && item.GetUnit() == aUnit )
1247  || ( aUnit == -1 && item.GetConvert() == aConvert )
1248  || ( aUnit == item.GetUnit() && aConvert == item.GetConvert() ) )
1249  unitItems.push_back( &item );
1250  }
1251 
1252  return unitItems;
1253 }
1254 
1255 
1256 std::vector<struct LIB_SYMBOL_UNITS> LIB_SYMBOL::GetUnitDrawItems()
1257 {
1258  std::vector<struct LIB_SYMBOL_UNITS> units;
1259 
1260  for( LIB_ITEM& item : m_drawings )
1261  {
1262  if( item.Type() == LIB_FIELD_T )
1263  continue;
1264 
1265  int unit = item.GetUnit();
1266  int convert = item.GetConvert();
1267 
1268  auto it = std::find_if( units.begin(), units.end(),
1269  [unit, convert] ( const auto& a ) {
1270  return a.m_unit == unit && a.m_convert == convert;
1271  } );
1272 
1273  if( it == units.end() )
1274  {
1275  struct LIB_SYMBOL_UNITS newUnit;
1276  newUnit.m_unit = item.GetUnit();
1277  newUnit.m_convert = item.GetConvert();
1278  newUnit.m_items.push_back( &item );
1279  units.emplace_back( newUnit );
1280  }
1281  else
1282  {
1283  it->m_items.push_back( &item );
1284  }
1285  }
1286 
1287  return units;
1288 }
1289 
1290 
1291 std::vector<struct LIB_SYMBOL_UNITS> LIB_SYMBOL::GetUniqueUnits()
1292 {
1293  int unitNum;
1294  size_t i;
1295  struct LIB_SYMBOL_UNITS unit;
1296  std::vector<LIB_ITEM*> compareDrawItems;
1297  std::vector<LIB_ITEM*> currentDrawItems;
1298  std::vector<struct LIB_SYMBOL_UNITS> uniqueUnits;
1299 
1300  // The first unit is guaranteed to be unique so always include it.
1301  unit.m_unit = 1;
1302  unit.m_convert = 1;
1303  unit.m_items = GetUnitItems( 1, 1 );
1304 
1305  // There are no unique units if there are no draw items other than fields.
1306  if( unit.m_items.size() == 0 )
1307  return uniqueUnits;
1308 
1309  uniqueUnits.emplace_back( unit );
1310 
1311  if( ( GetUnitCount() == 1 || UnitsLocked() ) && !HasConversion() )
1312  return uniqueUnits;
1313 
1314  currentDrawItems = unit.m_items;
1315 
1316  for( unitNum = 2; unitNum <= GetUnitCount(); unitNum++ )
1317  {
1318  compareDrawItems = GetUnitItems( unitNum, 1 );
1319 
1320  wxCHECK2_MSG( compareDrawItems.size() != 0, continue,
1321  "Multiple unit symbol defined with empty units." );
1322 
1323  if( currentDrawItems.size() != compareDrawItems.size() )
1324  {
1325  unit.m_unit = unitNum;
1326  unit.m_convert = 1;
1327  unit.m_items = compareDrawItems;
1328  uniqueUnits.emplace_back( unit );
1329  }
1330  else
1331  {
1332  for( i = 0; i < currentDrawItems.size(); i++ )
1333  {
1334  if( currentDrawItems[i]->compare( *compareDrawItems[i],
1335  LIB_ITEM::COMPARE_FLAGS::UNIT ) != 0 )
1336  {
1337  unit.m_unit = unitNum;
1338  unit.m_convert = 1;
1339  unit.m_items = compareDrawItems;
1340  uniqueUnits.emplace_back( unit );
1341  }
1342  }
1343  }
1344  }
1345 
1346  if( HasConversion() )
1347  {
1348  currentDrawItems = GetUnitItems( 1, 2 );
1349 
1350  if( ( GetUnitCount() == 1 || UnitsLocked() ) )
1351  {
1352  unit.m_unit = 1;
1353  unit.m_convert = 2;
1354  unit.m_items = currentDrawItems;
1355  uniqueUnits.emplace_back( unit );
1356 
1357  return uniqueUnits;
1358  }
1359 
1360  for( unitNum = 2; unitNum <= GetUnitCount(); unitNum++ )
1361  {
1362  compareDrawItems = GetUnitItems( unitNum, 2 );
1363 
1364  wxCHECK2_MSG( compareDrawItems.size() != 0, continue,
1365  "Multiple unit symbol defined with empty units." );
1366 
1367  if( currentDrawItems.size() != compareDrawItems.size() )
1368  {
1369  unit.m_unit = unitNum;
1370  unit.m_convert = 2;
1371  unit.m_items = compareDrawItems;
1372  uniqueUnits.emplace_back( unit );
1373  }
1374  else
1375  {
1376  for( i = 0; i < currentDrawItems.size(); i++ )
1377  {
1378  if( currentDrawItems[i]->compare( *compareDrawItems[i],
1379  LIB_ITEM::COMPARE_FLAGS::UNIT ) != 0 )
1380  {
1381  unit.m_unit = unitNum;
1382  unit.m_convert = 2;
1383  unit.m_items = compareDrawItems;
1384  uniqueUnits.emplace_back( unit );
1385  }
1386  }
1387  }
1388  }
1389  }
1390 
1391  return uniqueUnits;
1392 }
Field Reference of part, i.e. "IC21".
bool m_showPinNumbers
Definition: lib_symbol.h:674
LIB_FIELD * FindField(const wxString &aFieldName)
Find a field within this symbol matching aFieldName and returns it or NULL if not found.
Definition: lib_symbol.cpp:955
void GetPins(LIB_PINS &aList, int aUnit=0, int aConvert=0) const
Return a list of pin object pointers from the draw item list.
Definition: lib_symbol.cpp:695
void SetModified()
Definition: eda_item.cpp:65
LIB_SYMBOL_SPTR SharedPtr() const
Definition: lib_symbol.h:107
ITERATOR begin(int aType=UNDEFINED_TYPE)
Definition: multivector.h:188
Plot settings, and plotting engines (PostScript, Gerber, HPGL and DXF)
static UTF8 FixIllegalChars(const UTF8 &aLibItemName, bool aLib=false)
Replace illegal LIB_ID item name characters with underscores '_'.
Definition: lib_id.cpp:347
void SetFields(const std::vector< LIB_FIELD > &aFieldsList)
Overwrite all the existing fields in this symbol with fields supplied in aFieldsList.
Definition: lib_symbol.cpp:890
bool operator<(const LIB_SYMBOL &aItem1, const LIB_SYMBOL &aItem2)
Definition: lib_symbol.cpp:67
void Merge(const EDA_RECT &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: eda_rect.cpp:432
void AddField(LIB_FIELD *aField)
Add a field.
Definition: lib_symbol.cpp:884
std::vector< LIB_ITEM * > m_items
The items unique to this unit and alternate body style.
Definition: lib_symbol.h:86
LIB_FIELD & GetFootprintField()
Return reference to the footprint field.
Definition: lib_symbol.cpp:995
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
bool m_showPinNames
Definition: lib_symbol.h:673
#define IS_NEW
New item, just created.
Object used to load, save, search, and otherwise manipulate symbol library files.
std::vector< struct LIB_SYMBOL_UNITS > GetUniqueUnits()
Return a list of unit numbers that are unique to this symbol.
wxString GetName() const override
Definition: lib_symbol.h:133
void SetOffset(const wxPoint &aOffset)
Move the symbol aOffset.
void ClearSelected()
Definition: eda_item.h:132
std::vector< LIB_PIN * > LIB_PINS
Helper for defining a list of pin object pointers.
Definition: lib_item.h:55
bool IsVisible() const
Definition: eda_text.h:193
void SetConversion(bool aSetConvert, bool aDuplicatePins=true)
Set or clear the alternate body style (DeMorgan) for the symbol.
void clear(int aType=UNDEFINED_TYPE)
Definition: multivector.h:212
Field object used in symbol libraries.
Definition: lib_field.h:59
void unique()
Remove duplicate elements in list.
Definition: multivector.h:256
bool IsAlias() const
Definition: lib_symbol.h:172
void SetUnitCount(int aCount, bool aDuplicateDrawItems=true)
Set the units per symbol count.
std::shared_ptr< LIB_SYMBOL > LIB_SYMBOL_SPTR
shared pointer to LIB_SYMBOL
Definition: lib_symbol.h:42
void sort()
Definition: multivector.h:247
const COLOR4D & GetLayerColor(int aLayer) const
Return the color used to draw a layer.
wxString m_description
Definition: lib_symbol.h:684
bool IsPower() const
Definition: lib_symbol.cpp:411
static wxString SubReference(int aUnit, bool aAddSeparator=true)
Definition: lib_symbol.cpp:447
int GetId() const
Definition: lib_field.h:115
void SetLib(SYMBOL_LIB *aLibrary)
Definition: lib_symbol.h:177
LIB_FIELD & GetValueField()
Return reference to the value field.
Definition: lib_symbol.cpp:979
void RemoveDrawItem(LIB_ITEM *aItem)
Remove draw aItem from list.
Definition: lib_symbol.cpp:629
wxString m_name
Definition: lib_symbol.h:683
bool draw_visible_fields
Definition: lib_symbol.h:65
LIB_ITEMS_CONTAINER::ITEM_PTR_VECTOR LIB_ITEMS
Definition: lib_symbol.h:48
Define a library symbol object.
Definition: lib_symbol.h:96
void PlotLibFields(PLOTTER *aPlotter, int aUnit, int aConvert, const wxPoint &aOffset, const TRANSFORM &aTransform)
Plot Lib Fields only of the symbol to plotter.
Definition: lib_symbol.cpp:592
void ClearEditFlags()
std::unique_ptr< LIB_SYMBOL > Flatten() const
Return a flattened symbol inheritance to the caller.
Definition: lib_symbol.cpp:334
int compare(const LIB_ID &aLibId) const
Compare the contents of LIB_ID objects by performing a std::string comparison of the library nickname...
Definition: lib_id.cpp:311
LIB_FIELD & GetReferenceField()
Return reference to the reference designator field.
Definition: lib_symbol.cpp:987
const INSPECTOR_FUNC & INSPECTOR
Definition: eda_item.h:94
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:116
wxString GetName(bool aUseDefaultName=true) const
Return the field name.
Definition: lib_field.cpp:363
name of datasheet
virtual EDA_ITEM * Clone() const
Create a duplicate of this item with linked list members set to NULL.
Definition: eda_item.cpp:83
The base class for drawable items used by schematic library symbols.
Definition: lib_item.h:61
void GetFields(std::vector< LIB_FIELD * > &aList)
Return a list of fields within this symbol.
Definition: lib_symbol.cpp:907
bool PinsConflictWith(const LIB_SYMBOL &aOtherSymbol, bool aTestNums, bool aTestNames, bool aTestType, bool aTestOrientation, bool aTestLength) const
Return true if this symbol's pins do not match another symbol's pins.
Definition: lib_symbol.cpp:740
timestamp_t m_lastModDate
Definition: lib_symbol.h:665
TRANSFORM transform
Definition: lib_symbol.h:64
ITERATOR end(int aType=UNDEFINED_TYPE)
Definition: multivector.h:194
LIB_SYMBOL_REF m_parent
Use for inherited symbols.
Definition: lib_symbol.h:663
int Compare(const LIB_SYMBOL &aRhs) const
Comparison test that can be used for operators.
Definition: lib_symbol.cpp:213
wxString GetSearchText() override
Definition: lib_symbol.cpp:49
const LIB_SYMBOL & operator=(const LIB_SYMBOL &aSymbol)
Definition: lib_symbol.cpp:167
bool HasConversion() const
Test if symbol has more than one body conversion type (DeMorgan).
int m_unit
Unit identification for multiple parts per package.
Definition: lib_item.h:314
std::vector< struct LIB_SYMBOL_UNITS > GetUnitDrawItems()
Return a list of LIB_ITEM objects separated by unit and convert number.
void operator()(void const *) const
Definition: lib_symbol.cpp:76
for transforming drawing coordinates for a wxDC device context.
Definition: transform.h:45
SEARCH_RESULT Visit(INSPECTOR inspector, void *testData, const KICAD_T scanTypes[]) override
May be re-implemented for each derived class in order to handle all the types given by its member dat...
void RemoveDuplicateDrawItems()
Remove duplicate draw items from list.
wxString GetKeyWords() const
Definition: lib_symbol.h:155
Field Value of part, i.e. "3.3K".
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:114
#define NULL
const wxString GetName() const
Return the file name without path or extension.
LIB_ITEM * GetNextDrawItem(const LIB_ITEM *aItem=NULL, KICAD_T aType=TYPE_NOT_INIT)
Return the next draw object pointer.
Definition: lib_symbol.cpp:666
bool m_unitsLocked
True if symbol has multiple units and changing one unit does not automatically change another unit.
Definition: lib_symbol.h:668
void push_back(T *aItem)
Definition: multivector.h:174
virtual void SetName(const wxString &aName)
Definition: lib_symbol.cpp:314
bool m_includeOnBoard
Definition: lib_symbol.h:677
int m_convert
Shape identification for alternate body styles.
Definition: lib_item.h:320
int GetUnitCount() const override
For items with units, return the number of units.
const EDA_RECT GetUnitBoundingBox(int aUnit, int aConvert) const
Get the bounding box for the symbol.
Definition: lib_symbol.cpp:807
void ViewGetLayers(int aLayers[], int &aCount) const override
Return the all the layers within the VIEW the object is painted on.
Definition: lib_symbol.cpp:841
int m_unit
The unit number.
Definition: lib_symbol.h:84
void deleteAllFields()
Definition: lib_symbol.cpp:878
Definition for symbol library class.
#define STRUCT_DELETED
flag indication structures to be erased
const UTF8 & GetLibNickname() const
Return the logical library name portion of a LIB_ID.
Definition: lib_id.h:92
void AddDrawItem(LIB_ITEM *aItem, bool aSort=true)
Add a new draw aItem to the draw object list and sort according to aSort.
Definition: lib_symbol.cpp:655
void SetParent(LIB_SYMBOL *aParent=nullptr)
Definition: lib_symbol.cpp:325
#define DEFAULT_PIN_NAME_OFFSET
The intersheets references prefix string.
int SetLibItemName(const UTF8 &aLibItemName, bool aTestForRev=true)
Override the library item name portion of the LIB_ID to aLibItemName.
Definition: lib_id.cpp:204
bool UnitsLocked() const
Check whether symbol units are interchangeable.
Definition: lib_symbol.h:241
EDA_ITEM_FLAGS GetFlags() const
Definition: eda_item.h:155
const EDA_RECT GetBodyBoundingBox(int aUnit, int aConvert) const
Get the symbol bounding box excluding fields.
Definition: lib_symbol.cpp:853
void ClearTempFlags()
Clears the status flag all draw objects in this symbol.
ITERATOR erase(const ITERATOR &aIterator)
Definition: multivector.h:179
virtual void SetColor(const COLOR4D &color)=0
http://www.boost.org/doc/libs/1_55_0/libs/smart_ptr/sp_techniques.html#weak_without_shared
Definition: lib_symbol.cpp:74
int m_convert
The alternate body style of the unit.
Definition: lib_symbol.h:85
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
ITERATOR_BASE< LIB_ITEM, MULTIVECTOR< LIB_ITEM, FIRST_TYPE_VAL, LAST_TYPE_VAL >, typename ITEM_PTR_VECTOR::iterator > ITERATOR
The const iterator.
Definition: multivector.h:164
The first 4 are mandatory, and must be instantiated in SCH_COMPONENT and LIB_PART constructors.
void Print(const RENDER_SETTINGS *aSettings, const wxPoint &aOffset, int aMulti, int aConvert, const LIB_SYMBOL_OPTIONS &aOpts)
Print symbol.
Definition: lib_symbol.cpp:479
LIB_ITEMS_CONTAINER m_drawings
Definition: lib_symbol.h:680
Base plotter engine class.
Definition: plotter.h:121
LIB_ITEM * LocateDrawItem(int aUnit, int aConvert, KICAD_T aType, const wxPoint &aPoint)
Locate a draw object.
LIB_FIELD * GetFieldById(int aId) const
Return pointer to the requested field.
Definition: lib_symbol.cpp:941
bool m_includeInBom
Definition: lib_symbol.h:676
RENDER_SETTINGS * RenderSettings()
Definition: plotter.h:156
TRANSFORM DefaultTransform
Definition: eeschema.cpp:56
std::vector< LIB_ITEM * > GetUnitItems(int aUnit, int aConvert)
Return a list of item pointers for aUnit and aConvert for this symbol.
void SetPower()
Definition: lib_symbol.cpp:420
static int m_subpartFirstId
the ASCII char value to calculate the subpart symbol id from the symbol number: only 'A',...
Definition: lib_symbol.h:692
LIB_FIELD & GetDatasheetField()
Return reference to the datasheet field.
Handle the component boundary box.
Definition: eda_rect.h:42
wxString GetFullText(int unit=1) const
Return the text of a field.
Definition: lib_field.cpp:295
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100
const wxString GetLibraryName() const
Definition: lib_symbol.cpp:402
wxString GetUnitReference(int aUnit) override
Return an identifier for aUnit for symbols with units.
Definition: lib_symbol.cpp:308
LIB_SYMBOL(const wxString &aName, LIB_SYMBOL *aParent=nullptr, SYMBOL_LIB *aLibrary=nullptr)
Definition: lib_symbol.cpp:82
ITERATOR_BASE< const LIB_ITEM, const MULTIVECTOR< LIB_ITEM, FIRST_TYPE_VAL, LAST_TYPE_VAL >, typename ITEM_PTR_VECTOR::const_iterator > CONST_ITERATOR
Definition: multivector.h:167
virtual ~LIB_SYMBOL()
http://www.boost.org/doc/libs/1_55_0/libs/smart_ptr/sp_techniques.html#weak_without_shared
Definition: lib_symbol.cpp:162
LIB_SYMBOL_SPTR m_me
Definition: lib_symbol.h:662
int m_pinNameOffset
The offset in mils to draw the pin name.
Definition: lib_symbol.h:671
wxArrayString m_fpFilters
List of suitable footprint names for the symbol (wild card names accepted).
Definition: lib_symbol.h:686
bool IsNormal() const
Definition: lib_symbol.cpp:429
LIB_ID m_libId
Definition: lib_symbol.h:664
bool GetGRForceBlackPenState(void)
Function GetGRForceBlackPenState.
Definition: gr_basic.cpp:209
wxString m_keyWords
Search keywords.
Definition: lib_symbol.h:685
SEARCH_RESULT
Definition: eda_item.h:41
wxString GetDescription() override
Definition: lib_symbol.h:142
static void SetSubpartIdNotation(int aSep, int aFirstId)
Set the separator char between the subpart id and the reference 0 (no separator) or '.
void Plot(PLOTTER *aPlotter, int aUnit, int aConvert, const wxPoint &aOffset, const TRANSFORM &aTransform) const
Plot lib symbol to plotter.
Definition: lib_symbol.cpp:546
LIBRENTRYOPTIONS m_options
Special symbol features such as POWER or NORMAL.)
Definition: lib_symbol.h:678
int m_unitCount
Number of units (parts) per package.
Definition: lib_symbol.h:667
static int m_subpartIdSeparator
the separator char between the subpart id and the reference like U1A ( m_subpartIdSeparator = 0 ) or ...
Definition: lib_symbol.h:689
virtual int compare(const LIB_ITEM &aOther, LIB_ITEM::COMPARE_FLAGS aCompareFlags=LIB_ITEM::COMPARE_FLAGS::NORMAL) const
Provide the draw object specific comparison called by the == and < operators.
Definition: lib_item.cpp:74
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:133
size_t size(int aType=UNDEFINED_TYPE) const
Definition: multivector.h:225
LIB_PIN * GetPin(const wxString &aNumber, int aUnit=0, int aConvert=0) const
Return pin object with the requested pin aNumber.
Definition: lib_symbol.cpp:722
virtual wxString GetShownText(int aDepth=0) const
Return the string actually shown after processing of the base text.
Definition: eda_text.h:141
SYMBOL_LIB * m_library
Definition: lib_symbol.h:682
void SetNormal()
Definition: lib_symbol.cpp:438
bool IsMandatory() const
Definition: lib_field.cpp:453
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113
Field Name Module PCB, i.e. "16DIP300".
bool GetColorMode() const
Definition: plotter.h:153