KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_reference_list.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) 1992-2018 jean-pierre Charras <jp.charras at wanadoo.fr>
5 * Copyright (C) 1992-2011 Wayne Stambaugh <[email protected]>
6 * Copyright (C) 1992-2023 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
31#include <sch_reference_list.h>
32#include <core/kicad_algo.h>
33
34#include <wx/regex.h>
35#include <algorithm>
36#include <vector>
37#include <unordered_set>
38
39#include <string_utils.h>
40#include <erc/erc_settings.h>
41#include <sch_symbol.h>
42#include <sch_edit_frame.h>
43
44
45void SCH_REFERENCE_LIST::RemoveItem( unsigned int aIndex )
46{
47 if( aIndex < m_flatList.size() )
48 m_flatList.erase( m_flatList.begin() + aIndex );
49}
50
51
53{
54 for( unsigned ii = 0; ii < GetCount(); ii++ )
55 {
56 if( m_flatList[ii].IsSameInstance( aItem ) )
57 return true;
58 }
59
60 return false;
61}
62
63
65{
66 int ii = item1.CompareRef( item2 );
67
68 if( ii == 0 )
69 ii = item1.m_sheetNum - item2.m_sheetNum;
70
71 if( ii == 0 )
72 ii = item1.m_symbolPos.x - item2.m_symbolPos.x;
73
74 if( ii == 0 )
75 ii = item1.m_symbolPos.y - item2.m_symbolPos.y;
76
77 if( ii == 0 )
78 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
79 else
80 return ii < 0;
81}
82
83
85{
86 int ii = item1.CompareRef( item2 );
87
88 if( ii == 0 )
89 ii = item1.m_sheetNum - item2.m_sheetNum;
90
91 if( ii == 0 )
92 ii = item1.m_symbolPos.y - item2.m_symbolPos.y;
93
94 if( ii == 0 )
95 ii = item1.m_symbolPos.x - item2.m_symbolPos.x;
96
97 if( ii == 0 )
98 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
99 else
100 return ii < 0;
101}
102
103
105 const SCH_REFERENCE& item2 )
106{
107 int ii = item1.CompareRef( item2 );
108
109 if( ii == 0 )
110 ii = item1.CompareValue( item2 );
111
112 if( ii == 0 )
113 ii = item1.m_unit - item2.m_unit;
114
115 if( ii == 0 )
116 ii = item1.m_sheetNum - item2.m_sheetNum;
117
118 if( ii == 0 )
119 ii = item1.m_symbolPos.x - item2.m_symbolPos.x;
120
121 if( ii == 0 )
122 ii = item1.m_symbolPos.y - item2.m_symbolPos.y;
123
124 if( ii == 0 )
125 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
126 else
127 return ii < 0;
128}
129
130
132 const SCH_REFERENCE& item2 )
133{
134 int ii = StrNumCmp( item1.GetRef(), item2.GetRef(), false );
135
136 if( ii == 0 )
137 ii = item1.m_unit - item2.m_unit;
138
139 if( ii == 0 )
140 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
141 else
142 return ii < 0;
143}
144
145
147 const SCH_REFERENCE& item2 )
148{
149 int ii = item1.m_sheetPath.Cmp( item2.m_sheetPath );
150
151 if( ii == 0 )
152 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
153 else
154 return ii < 0;
155}
156
157
158int SCH_REFERENCE_LIST::FindRefByFullPath( const wxString& aFullPath ) const
159{
160 for( size_t i = 0; i < m_flatList.size(); ++i )
161 {
162 if( m_flatList[i].GetFullPath() == aFullPath )
163 return i;
164 }
165
166 return -1;
167}
168
169
170int SCH_REFERENCE_LIST::FindRef( const wxString& aRef ) const
171{
172 for( size_t i = 0; i < m_flatList.size(); ++i )
173 {
174 if( m_flatList[i].GetRef() == aRef )
175 return i;
176 }
177
178 return -1;
179}
180
181
182void SCH_REFERENCE_LIST::GetRefsInUse( int aIndex, std::vector< int >& aIdList,
183 int aMinRefId ) const
184{
185 aIdList.clear();
186
187 for( const SCH_REFERENCE& ref : m_flatList )
188 {
189 // Don't add new references to the list as we will reannotate those
190 if( m_flatList[aIndex].CompareRef( ref ) == 0 && ref.m_numRef >= aMinRefId && !ref.m_isNew )
191 aIdList.push_back( ref.m_numRef );
192 }
193
194 std::sort( aIdList.begin(), aIdList.end() );
195
196 // Ensure each reference number appears only once. If there are symbols with
197 // multiple parts per package the same number will be stored for each part.
198 alg::remove_duplicates( aIdList );
199}
200
201
202std::vector<int> SCH_REFERENCE_LIST::GetUnitsMatchingRef( const SCH_REFERENCE& aRef ) const
203{
204 std::vector<int> unitsList;
205
206 // Always add this reference to the list
207 unitsList.push_back( aRef.m_unit );
208
209 for( SCH_REFERENCE ref : m_flatList )
210 {
211 if( ref.CompareValue( aRef ) != 0 )
212 continue;
213
214 if( ref.CompareLibName( aRef ) != 0 )
215 continue;
216
217 // Split if needed before comparing ref and number
218 if( ref.IsSplitNeeded() )
219 ref.Split();
220
221 if( ref.CompareRef( aRef ) != 0 )
222 continue;
223
224 if( ref.m_numRef != aRef.m_numRef )
225 continue;
226
227 unitsList.push_back( ref.m_unit );
228 }
229
230 std::sort( unitsList.begin(), unitsList.end() );
231
232 // Ensure each reference number appears only once. If there are symbols with
233 // multiple parts per package the same number will be stored for each part.
234 alg::remove_duplicates( unitsList );
235
236 return unitsList;
237}
238
239
241 const std::vector<int>& aRequiredUnits ) const
242{
243 // Create a map of references indexed by reference number, only including those with the same
244 // reference prefix as aRef
245 std::map<int, std::vector<SCH_REFERENCE>> refNumberMap;
246
247 for( const SCH_REFERENCE& ref : m_flatList )
248 {
249 // search only for the current reference prefix:
250 if( ref.CompareRef( aRef ) != 0 )
251 continue;
252
253 if( ref.m_isNew )
254 continue; // It will be reannotated
255
256 refNumberMap[ref.m_numRef].push_back( ref );
257 }
258
259 // Start at the given minimum value
260 int minFreeNumber = aMinValue;
261
262 for( ; refNumberMap[minFreeNumber].size() > 0; ++minFreeNumber )
263 {
264 auto isNumberInUse = [&]() -> bool
265 {
266 for( const int& unit : aRequiredUnits )
267 {
268 for( const SCH_REFERENCE& ref : refNumberMap[minFreeNumber] )
269 {
270 if( ref.CompareLibName( aRef ) || ref.CompareValue( aRef )
271 || ref.GetUnit() == unit )
272 {
273 return true;
274 }
275 }
276 }
277
278 return false;
279 };
280
281 if( !isNumberInUse() )
282 return minFreeNumber;
283 }
284
285 return minFreeNumber;
286}
287
288
289std::vector<SCH_SYMBOL_INSTANCE> SCH_REFERENCE_LIST::GetSymbolInstances() const
290{
291 std::vector<SCH_SYMBOL_INSTANCE> retval;
292
293 for( const SCH_REFERENCE& ref : m_flatList )
294 {
295 SCH_SYMBOL_INSTANCE instance;
296 instance.m_Path = ref.GetSheetPath().Path();
297 instance.m_Reference = ref.GetRef();
298 instance.m_Unit = ref.GetUnit();
299
300 retval.push_back( instance );
301 }
302
303 return retval;
304}
305
306
307int SCH_REFERENCE_LIST::createFirstFreeRefId( std::vector<int>& aIdList, int aFirstValue )
308{
309 int expectedId = aFirstValue;
310
311 // We search for expected Id a value >= aFirstValue.
312 // Skip existing Id < aFirstValue
313 unsigned ii = 0;
314
315 for( ; ii < aIdList.size(); ii++ )
316 {
317 if( expectedId <= aIdList[ii] )
318 break;
319 }
320
321 // Ids are sorted by increasing value, from aFirstValue
322 // So we search from aFirstValue the first not used value, i.e. the first hole in list.
323 for( ; ii < aIdList.size(); ii++ )
324 {
325 if( expectedId != aIdList[ii] ) // This id is not yet used.
326 {
327 // Insert this free Id, in order to keep list sorted
328 aIdList.insert( aIdList.begin() + ii, expectedId );
329 return expectedId;
330 }
331
332 expectedId++;
333 }
334
335 // All existing Id are tested, and all values are found in use.
336 // So Create a new one.
337 aIdList.push_back( expectedId );
338 return expectedId;
339}
340
341
342// A helper function to build a full reference string of a SCH_REFERENCE item
343wxString buildFullReference( const SCH_REFERENCE& aItem, int aUnitNumber = -1 )
344{
345 wxString fullref;
346 fullref = aItem.GetRef() + aItem.GetRefNumber();
347
348 if( aUnitNumber < 0 )
349 fullref << ".." << aItem.GetUnit();
350 else
351 fullref << ".." << aUnitNumber;
352
353 return fullref;
354}
355
356
358 ANNOTATE_ALGO_T aAlgoOption,
359 int aStartNumber,
360 const SCH_REFERENCE_LIST& aAdditionalRefs,
361 bool aStartAtCurrent,
362 SCH_SHEET_LIST* aHierarchy )
363{
365
366 // All multi-unit symbols always locked to ensure consistent re-annotation
367 SCH_MULTI_UNIT_REFERENCE_MAP lockedSymbols;
368
369 for( size_t i = 0; i < GetCount(); i++ )
370 {
371 SCH_REFERENCE& ref = m_flatList[i];
372 wxString refstr = ref.GetSymbol()->GetRef( &ref.GetSheetPath() );
373
374 // Update sheet numbers based on the reference's sheet's position within the full
375 // hierarchy; we do this now before we annotate so annotation by sheet number * X
376 // works correctly.
377 if( aHierarchy )
378 {
379 SCH_SHEET_PATH* path = aHierarchy->FindSheetForPath( &ref.GetSheetPath() );
380 wxASSERT_MSG( path, wxT( "Attempting to annotate item on sheet not part of the hierarchy?" ) );
381
382 ref.SetSheetNumber( path->GetVirtualPageNumber() );
383 }
384
385 // Never lock unassigned references
386 if( refstr[refstr.Len() - 1] == '?' )
387 continue;
388
389 ref.m_isNew = true; // We want to reannotate all references
390
391 lockedSymbols[refstr].AddItem( ref );
392 }
393
394 AnnotateByOptions( aSortOption, aAlgoOption, aStartNumber, lockedSymbols, aAdditionalRefs,
395 aStartAtCurrent );
396}
397
398
400{
401 ReannotateByOptions( UNSORTED, INCREMENTAL_BY_REF, 0, aAdditionalReferences, true, nullptr );
402}
403
404
406 ANNOTATE_ALGO_T aAlgoOption,
407 int aStartNumber,
408 SCH_MULTI_UNIT_REFERENCE_MAP aLockedUnitMap,
409 const SCH_REFERENCE_LIST& aAdditionalRefs,
410 bool aStartAtCurrent )
411{
412 switch( aSortOption )
413 {
414 default:
417 }
418
419 bool useSheetNum;
420 int idStep;
421
422 switch( aAlgoOption )
423 {
424 default:
426 useSheetNum = false;
427 idStep = 1;
428 break;
429
431 useSheetNum = true;
432 idStep = 100;
433 aStartAtCurrent = false; // Not implemented for sheet # * 100
434 break;
435
437 useSheetNum = true;
438 idStep = 1000;
439 aStartAtCurrent = false; // Not implemented for sheet # * 1000
440 break;
441 }
442
443 Annotate( useSheetNum, idStep, aStartNumber, aLockedUnitMap, aAdditionalRefs, aStartAtCurrent );
444}
445
446
447void SCH_REFERENCE_LIST::Annotate( bool aUseSheetNum, int aSheetIntervalId, int aStartNumber,
448 SCH_MULTI_UNIT_REFERENCE_MAP aLockedUnitMap,
449 const SCH_REFERENCE_LIST& aAdditionalRefs, bool aStartAtCurrent )
450{
451 if ( m_flatList.size() == 0 )
452 return;
453
454 size_t originalSize = GetCount();
455
456 // For multi units symbols, store the list of already used full references.
457 // The algorithm tries to allocate the new reference to symbols having the same
458 // old reference.
459 // This algo works fine as long as the previous annotation has no duplicates.
460 // But when a hierarchy is reannotated with this option, the previous annotation can
461 // have duplicate references, and obviously we must fix these duplicate.
462 // therefore do not try to allocate a full reference more than once when trying
463 // to keep this order of multi units.
464 // inUseRefs keep trace of previously allocated references
465 std::unordered_set<wxString> inUseRefs;
466
467 for( size_t i = 0; i < aAdditionalRefs.GetCount(); i++ )
468 {
469 SCH_REFERENCE additionalRef = aAdditionalRefs[i];
470 additionalRef.Split();
471
472 // Add the additional reference to the multi-unit set if annotated
473 if( !additionalRef.m_isNew )
474 inUseRefs.insert( buildFullReference( additionalRef ) );
475
476 // We don't want to reannotate the additional references even if not annotated
477 // so we change the m_isNew flag to be false after splitting
478 additionalRef.m_isNew = false;
479 AddItem( additionalRef ); //add to this container
480 }
481
482 int LastReferenceNumber = 0;
483
484 /* calculate index of the first symbol with the same reference prefix
485 * than the current symbol. All symbols having the same reference
486 * prefix will receive a reference number with consecutive values:
487 * IC .. will be set to IC4, IC4, IC5 ...
488 */
489 unsigned first = 0;
490
491 // calculate the last used number for this reference prefix:
492 int minRefId;
493
494 // when using sheet number, ensure ref number >= sheet number* aSheetIntervalId
495 if( aUseSheetNum )
496 minRefId = m_flatList[first].m_sheetNum * aSheetIntervalId + 1;
497 else
498 minRefId = aStartNumber + 1;
499
500
501 for( unsigned ii = 0; ii < m_flatList.size(); ii++ )
502 {
503 auto& ref_unit = m_flatList[ii];
504
505 if( ref_unit.m_flag )
506 continue;
507
508 // Check whether this symbol is in aLockedUnitMap.
509 SCH_REFERENCE_LIST* lockedList = nullptr;
510
511 for( SCH_MULTI_UNIT_REFERENCE_MAP::value_type& pair : aLockedUnitMap )
512 {
513 unsigned n_refs = pair.second.GetCount();
514
515 for( unsigned thisRefI = 0; thisRefI < n_refs; ++thisRefI )
516 {
517 SCH_REFERENCE &thisRef = pair.second[thisRefI];
518
519 if( thisRef.IsSameInstance( ref_unit ) )
520 {
521 lockedList = &pair.second;
522 break;
523 }
524 }
525
526 if( lockedList != nullptr )
527 break;
528 }
529
530 if( ( m_flatList[first].CompareRef( ref_unit ) != 0 )
531 || ( aUseSheetNum && ( m_flatList[first].m_sheetNum != ref_unit.m_sheetNum ) ) )
532 {
533 // New reference found: we need a new ref number for this reference
534 first = ii;
535
536 // when using sheet number, ensure ref number >= sheet number* aSheetIntervalId
537 if( aUseSheetNum )
538 minRefId = ref_unit.m_sheetNum * aSheetIntervalId + 1;
539 else
540 minRefId = aStartNumber + 1;
541 }
542
543 // Find references greater than current reference (unless not annotated)
544 if( aStartAtCurrent && ref_unit.m_numRef > 0 )
545 minRefId = ref_unit.m_numRef;
546
547 wxCHECK( ref_unit.GetLibPart(), /* void */ );
548
549 // Annotation of one part per package symbols (trivial case).
550 if( ref_unit.GetLibPart()->GetUnitCount() <= 1 )
551 {
552 if( ref_unit.m_isNew )
553 {
554 std::vector<int> idList;
555 GetRefsInUse( first, idList, minRefId );
556 LastReferenceNumber = createFirstFreeRefId( idList, minRefId );
557 ref_unit.m_numRef = LastReferenceNumber;
558 ref_unit.m_numRefStr = wxString::Format( "%d", LastReferenceNumber );
559 }
560
561 ref_unit.m_flag = 1;
562 ref_unit.m_isNew = false;
563 continue;
564 }
565
566 // If this symbol is in aLockedUnitMap, copy the annotation to all
567 // symbols that are not it
568 if( lockedList != nullptr )
569 {
570 unsigned n_refs = lockedList->GetCount();
571 std::vector<int> units = lockedList->GetUnitsMatchingRef( ref_unit );
572
573 if( ref_unit.m_isNew )
574 {
575 LastReferenceNumber = FindFirstUnusedReference( ref_unit, minRefId, units );
576 ref_unit.m_numRef = LastReferenceNumber;
577 ref_unit.m_numRefStr = wxString::Format( "%d", LastReferenceNumber );
578 ref_unit.m_isNew = false;
579 ref_unit.m_flag = 1;
580 }
581
582 for( unsigned lockedRefI = 0; lockedRefI < n_refs; ++lockedRefI )
583 {
584 SCH_REFERENCE& lockedRef = ( *lockedList )[lockedRefI];
585
586 if( lockedRef.IsSameInstance( ref_unit ) )
587 {
588 // This is the symbol we're currently annotating. Hold the unit!
589 ref_unit.m_unit = lockedRef.m_unit;
590
591 // lock this new full reference
592 inUseRefs.insert( buildFullReference( ref_unit ) );
593 }
594
595 if( lockedRef.CompareValue( ref_unit ) != 0 )
596 continue;
597
598 if( lockedRef.CompareLibName( ref_unit ) != 0 )
599 continue;
600
601 // Find the matching symbol
602 for( unsigned jj = ii + 1; jj < m_flatList.size(); jj++ )
603 {
604 if( !lockedRef.IsSameInstance( m_flatList[jj] ) )
605 continue;
606
607 wxString ref_candidate = buildFullReference( ref_unit, lockedRef.m_unit );
608
609 // propagate the new reference and unit selection to the "old" symbol,
610 // if this new full reference is not already used (can happens when initial
611 // multiunits symbols have duplicate references)
612 if( inUseRefs.find( ref_candidate ) == inUseRefs.end() )
613 {
614 m_flatList[jj].m_numRef = ref_unit.m_numRef;
615 m_flatList[jj].m_numRefStr = ref_unit.m_numRefStr;
616 m_flatList[jj].m_isNew = false;
617 m_flatList[jj].m_flag = 1;
618
619 // lock this new full reference
620 inUseRefs.insert( ref_candidate );
621 break;
622 }
623 }
624 }
625 }
626 else if( ref_unit.m_isNew )
627 {
628 // Reference belonging to multi-unit symbol that has not yet been annotated. We don't
629 // know what group this might belong to, so just find the first unused reference for
630 // this specific unit. The other units will be annotated in the following passes.
631 std::vector<int> units = { ref_unit.GetUnit() };
632 LastReferenceNumber = FindFirstUnusedReference( ref_unit, minRefId, units );
633 ref_unit.m_numRef = LastReferenceNumber;
634 ref_unit.m_isNew = false;
635 ref_unit.m_flag = 1;
636 }
637 }
638
639 // Remove aAdditionalRefs references
640 m_flatList.erase( m_flatList.begin() + originalSize, m_flatList.end() );
641
642 wxASSERT( originalSize == GetCount() ); // Make sure we didn't make a mistake
643}
644
645
647{
648 int error = 0;
649 wxString tmp;
650 wxString tmp2;
651 wxString msg;
652
654
655 // Split reference designators into name (prefix) and number: IC1 becomes IC, and 1.
657
658 // count not yet annotated items or annotation error.
659 for( unsigned ii = 0; ii < m_flatList.size(); ii++ )
660 {
661 msg.Empty();
662 tmp.Empty();
663
664 if( m_flatList[ii].m_isNew ) // Not yet annotated
665 {
666 if( m_flatList[ii].m_numRef >= 0 )
667 tmp << m_flatList[ii].m_numRef;
668 else
669 tmp = wxT( "?" );
670
671 if( ( m_flatList[ii].m_unit > 0 ) && ( m_flatList[ii].m_unit < 0x7FFFFFFF )
672 && m_flatList[ii].GetLibPart()->GetUnitCount() > 1 )
673 {
674 msg.Printf( _( "Item not annotated: %s%s (unit %d)" ),
675 m_flatList[ii].GetRef(),
676 tmp,
677 m_flatList[ii].m_unit );
678 }
679 else
680 {
681 msg.Printf( _( "Item not annotated: %s%s" ), m_flatList[ii].GetRef(), tmp );
682 }
683
684 aHandler( ERCE_UNANNOTATED, msg, &m_flatList[ii], nullptr );
685 error++;
686 break;
687 }
688
689 // Error if unit number selected does not exist (greater than the number of units in
690 // the symbol). This can happen if a symbol has changed in a library after a
691 // previous annotation.
692 if( std::max( m_flatList[ii].GetLibPart()->GetUnitCount(), 1 ) < m_flatList[ii].m_unit )
693 {
694 if( m_flatList[ii].m_numRef >= 0 )
695 tmp << m_flatList[ii].m_numRef;
696 else
697 tmp = wxT( "?" );
698
699 msg.Printf( _( "Error: symbol %s%s%s (unit %d) exceeds units defined (%d)" ),
700 m_flatList[ii].GetRef(),
701 tmp,
702 m_flatList[ii].GetSymbol()->SubReference( m_flatList[ii].GetUnit() ),
703 m_flatList[ii].m_unit,
704 m_flatList[ii].GetLibPart()->GetUnitCount() );
705
706 aHandler( ERCE_EXTRA_UNITS, msg, &m_flatList[ii], nullptr );
707 error++;
708 break;
709 }
710 }
711
712 // count the duplicated elements (if all are annotated)
713 int imax = m_flatList.size() - 1;
714
715 for( int ii = 0; ii < imax; ii++ )
716 {
717 msg.Empty();
718 tmp.Empty();
719 tmp2.Empty();
720
721 SCH_REFERENCE& first = m_flatList[ii];
722 SCH_REFERENCE& second = m_flatList[ii + 1];
723
724 if( ( first.CompareRef( second ) != 0 )
725 || ( first.m_numRef != second.m_numRef ) )
726 {
727 continue;
728 }
729
730 // Same reference found. If same unit, error!
731 if( first.m_unit == second.m_unit )
732 {
733 if( first.m_numRef >= 0 )
734 tmp << first.m_numRef;
735 else
736 tmp = wxT( "?" );
737
738 msg.Printf( _( "Duplicate items %s%s%s\n" ),
739 first.GetRef(),
740 tmp,
741 first.GetLibPart()->GetUnitCount() > 1 ? first.GetSymbol()->SubReference( first.GetUnit() )
742 : wxString( wxT( "" ) ) );
743
744 aHandler( ERCE_DUPLICATE_REFERENCE, msg, &first, &m_flatList[ii+1] );
745 error++;
746 continue;
747 }
748
749 /* Test error if units are different but number of parts per package
750 * too high (ex U3 ( 1 part) and we find U3B this is an error) */
751 if( first.GetLibPart()->GetUnitCount() != second.GetLibPart()->GetUnitCount() )
752 {
753 if( first.m_numRef >= 0 )
754 tmp << first.m_numRef;
755 else
756 tmp = wxT( "?" );
757
758 if( second.m_numRef >= 0 )
759 tmp2 << second.m_numRef;
760 else
761 tmp2 = wxT( "?" );
762
763 msg.Printf( _( "Differing unit counts for item %s%s%s and %s%s%s\n" ),
764 first.GetRef(),
765 tmp,
766 first.GetSymbol()->SubReference( first.GetUnit() ),
767 second.GetRef(),
768 tmp2,
769 first.GetSymbol()->SubReference( second.GetUnit() ) );
770
771 aHandler( ERCE_DUPLICATE_REFERENCE, msg, &first, &second );
772 error++;
773 continue;
774 }
775
776 // Error if values are different between units, for the same reference
777 if( first.CompareValue( second ) != 0 )
778 {
779 msg.Printf( _( "Different values for %s%d%s (%s) and %s%d%s (%s)" ),
780 first.GetRef(),
781 first.m_numRef,
782 first.GetSymbol()->SubReference( first.GetUnit() ),
783 first.m_value,
784 second.GetRef(),
785 second.m_numRef,
786 first.GetSymbol()->SubReference( second.GetUnit() ),
787 second.m_value );
788
789 aHandler( ERCE_DIFFERENT_UNIT_VALUE, msg, &first, &second );
790 error++;
791 }
792 }
793
794 return error;
795}
796
797
799 const SCH_SHEET_PATH& aSheetPath )
800{
801 wxASSERT( aSymbol != nullptr );
802
803 m_rootSymbol = aSymbol;
804 m_libPart = aLibSymbol; // Warning: can be nullptr for orphan symbols
805 // (i.e. with a symbol library not found)
806 m_unit = aSymbol->GetUnitSelection( &aSheetPath );
807 m_footprint = aSymbol->GetFootprintFieldText( true, &aSheetPath, false );
808 m_sheetPath = aSheetPath;
809 m_isNew = false;
810 m_flag = 0;
811 m_symbolUuid = aSymbol->m_Uuid;
812 m_symbolPos = aSymbol->GetPosition();
813 m_sheetNum = 0;
814
815 if( aSymbol->GetRef( &aSheetPath ).IsEmpty() )
816 aSymbol->SetRef( &aSheetPath, wxT( "DefRef?" ) );
817
818 wxString ref = aSymbol->GetRef( &aSheetPath );
819 SetRef( ref );
820
821 m_numRef = -1;
822
823 if( aSymbol->GetValue( false, &aSheetPath, false ).IsEmpty() )
824 aSymbol->SetValueFieldText( wxT( "~" ) );
825
826 m_value = aSymbol->GetValue( false, &aSheetPath, false );
827}
828
829
831{
832 if( m_numRef < 0 )
833 m_ref += '?';
834 else
835 m_ref = TO_UTF8( GetRef() << GetRefNumber() );
836
840}
841
842
844{
846 && !m_rootSymbol->GetRef( &m_sheetPath ).IsEmpty(), false );
847
848 return m_rootSymbol->GetLibSymbolRef()->IsPower()
849 || m_rootSymbol->GetRef( &m_sheetPath )[0] == wxUniChar( '#' );
850}
851
852
854{
855 std::string refText = GetRefStr();
856
857 m_numRef = -1;
858 m_numRefStr.Clear();
859
860 int ll = refText.length() - 1;
861
862 if( refText[ll] == '?' )
863 {
864 m_isNew = true;
865
866 refText.erase( ll ); // delete last char
867
868 SetRefStr( refText );
869 }
870 else if( isdigit( refText[ll] ) == 0 )
871 {
872 m_isNew = true;
873 }
874 else
875 {
876 while( ll >= 0 )
877 {
878 if( (refText[ll] <= ' ' ) || isdigit( refText[ll] ) )
879 ll--;
880 else
881 {
882 if( isdigit( refText[ll + 1] ) )
883 {
884 // null terminated C string into cp
885 const char* cp = refText.c_str() + ll + 1;
886
887 m_numRef = atoi( cp );
888 }
889
890 m_numRefStr = std::string( refText, ll + 1 );
891 refText.erase( ll + 1 );
892 break;
893 }
894 }
895
896 SetRefStr( refText );
897 }
898}
899
900
902{
903 std::string refText = GetRefStr();
904
905 int ll = refText.length() - 1;
906
907 return ( refText[ll] == '?' ) || isdigit( refText[ll] );
908}
909
910
911wxString SCH_REFERENCE_LIST::Shorthand( std::vector<SCH_REFERENCE> aList,
912 const wxString& refDelimiter,
913 const wxString& refRangeDelimiter )
914{
915 wxString retVal;
916 size_t i = 0;
917
918 while( i < aList.size() )
919 {
920 wxString ref = aList[ i ].GetRef();
921 int numRef = aList[ i ].m_numRef;
922
923 size_t range = 1;
924
925 while( i + range < aList.size()
926 && aList[ i + range ].GetRef() == ref
927 && aList[ i + range ].m_numRef == int( numRef + range ) )
928 {
929 range++;
930
931 if( range == 2 && refRangeDelimiter.IsEmpty() )
932 break;
933 }
934
935 if( !retVal.IsEmpty() )
936 retVal << refDelimiter;
937
938 if( range == 1 )
939 {
940 retVal << ref << aList[ i ].GetRefNumber();
941 }
942 else if( range == 2 || refRangeDelimiter.IsEmpty() )
943 {
944 retVal << ref << aList[ i ].GetRefNumber();
945 retVal << refDelimiter;
946 retVal << ref << aList[ i + 1 ].GetRefNumber();
947 }
948 else
949 {
950 retVal << ref << aList[ i ].GetRefNumber();
951 retVal << refRangeDelimiter;
952 retVal << ref << aList[ i + ( range - 1 ) ].GetRefNumber();
953 }
954
955 i+= range;
956 }
957
958 return retVal;
959}
960
961
962#if defined( DEBUG )
963void SCH_REFERENCE_LIST::Show( const char* aPrefix )
964{
965 printf( "%s\n", aPrefix );
966
967 for( unsigned i = 0; i < m_flatList.size(); ++i )
968 {
969 SCH_REFERENCE& schref = m_flatList[i];
970
971 printf( " [%-2d] ref:%-8s num:%-3d lib_part:%s\n", i, schref.m_ref.ToStdString().c_str(),
972 schref.m_numRef, TO_UTF8( schref.GetLibPart()->GetName() ) );
973 }
974}
975#endif
const KIID m_Uuid
Definition: eda_item.h:485
Define a library symbol object.
Definition: lib_symbol.h:77
wxString GetName() const override
Definition: lib_symbol.h:136
int GetUnitCount() const override
virtual void SetUnit(int aUnit)
Definition: sch_item.h:236
Container to create a flattened list of symbols because in a complex hierarchy, a symbol can be used ...
void ReannotateByOptions(ANNOTATE_ORDER_T aSortOption, ANNOTATE_ALGO_T aAlgoOption, int aStartNumber, const SCH_REFERENCE_LIST &aAdditionalRefs, bool aStartAtCurrent, SCH_SHEET_LIST *aHierarchy)
Forces reannotation of the provided references.
static int createFirstFreeRefId(std::vector< int > &aIdList, int aFirstValue)
Search for the first free reference number in aListId of reference numbers in use.
static bool sortByRefAndValue(const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
bool Contains(const SCH_REFERENCE &aItem) const
Return true if aItem exists in this list.
void SortByYCoordinate()
Sort the list of references by Y position.
void AnnotateByOptions(enum ANNOTATE_ORDER_T aSortOption, enum ANNOTATE_ALGO_T aAlgoOption, int aStartNumber, SCH_MULTI_UNIT_REFERENCE_MAP aLockedUnitMap, const SCH_REFERENCE_LIST &aAdditionalRefs, bool aStartAtCurrent)
Annotate the references by the provided options.
static bool sortByTimeStamp(const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
int FindRef(const wxString &aPath) const
Search the list for a symbol with a given reference.
void Annotate(bool aUseSheetNum, int aSheetIntervalId, int aStartNumber, SCH_MULTI_UNIT_REFERENCE_MAP aLockedUnitMap, const SCH_REFERENCE_LIST &aAdditionalRefs, bool aStartAtCurrent=false)
Set the reference designators in the list that have not been annotated.
void SortByXCoordinate()
Sort the list of references by X position.
static bool sortByXPosition(const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
size_t GetCount() const
int FindFirstUnusedReference(const SCH_REFERENCE &aRef, int aMinValue, const std::vector< int > &aRequiredUnits) const
Return the first unused reference number from the properties given in aRef, ensuring all of the units...
void SplitReferences()
Attempt to split all reference designators into a name (U) and number (1).
void SortByRefAndValue()
Sort the list of references by value.
std::vector< int > GetUnitsMatchingRef(const SCH_REFERENCE &aRef) const
Return all the unit numbers for a given reference, comparing library reference, value,...
std::vector< SCH_REFERENCE > m_flatList
static bool sortByReferenceOnly(const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
void GetRefsInUse(int aIndex, std::vector< int > &aIdList, int aMinRefId) const
Add all the reference designator numbers greater than aMinRefId to aIdList skipping the reference at ...
void ReannotateDuplicates(const SCH_REFERENCE_LIST &aAdditionalReferences)
Convenience function for the Paste Unique functionality.
static wxString Shorthand(std::vector< SCH_REFERENCE > aList, const wxString &refDelimiter, const wxString &refRangeDelimiter)
Return a shorthand string representing all the references in the list.
int FindRefByFullPath(const wxString &aFullPath) const
Search the list for a symbol with the given KIID path (as string).
std::vector< SCH_SYMBOL_INSTANCE > GetSymbolInstances() const
void AddItem(const SCH_REFERENCE &aItem)
void RemoveItem(unsigned int aIndex)
Remove an item from the list of references.
static bool sortByYPosition(const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
int CheckAnnotation(ANNOTATION_ERROR_HANDLER aErrorHandler)
Check for annotations errors.
A helper to define a symbol's reference designator in a schematic.
const SCH_SHEET_PATH & GetSheetPath() const
SCH_SYMBOL * m_rootSymbol
The symbol associated the reference object.
int m_unit
The unit number for symbol with multiple parts per package.
SCH_SHEET_PATH m_sheetPath
The sheet path for this reference.
wxString m_footprint
The footprint assigned.
int CompareLibName(const SCH_REFERENCE &item) const
int CompareRef(const SCH_REFERENCE &item) const
void SetRef(const wxString &aReference)
bool AlwaysAnnotate() const
Verify the reference should always be automatically annotated.
wxString m_numRefStr
The numeric part in original string form (may have leading zeroes)
bool m_isNew
True if not yet annotated.
void Split()
Attempt to split the reference designator into a name (U) and number (1).
bool IsSplitNeeded()
Determine if this reference needs to be split or if it likely already has been.
SCH_SYMBOL * GetSymbol() const
wxString m_ref
Symbol reference prefix, without number (for IC1, this is IC) )
wxString GetRef() const
int m_sheetNum
The sheet number for the reference.
void SetRefStr(const std::string &aReference)
int m_numRef
The numeric part of the reference designator.
LIB_SYMBOL * GetLibPart() const
void SetSheetNumber(int aSheetNumber)
const char * GetRefStr() const
Return reference name with unit altogether.
bool IsSameInstance(const SCH_REFERENCE &other) const
Return whether this reference refers to the same symbol instance (symbol and sheet) as another.
KIID m_symbolUuid
UUID of the symbol.
int GetUnit() const
LIB_SYMBOL * m_libPart
The source symbol from a library.
wxString m_value
The symbol value.
VECTOR2I m_symbolPos
The physical position of the symbol in schematic used to annotate by X or Y position.
wxString GetRefNumber() const
int CompareValue(const SCH_REFERENCE &item) const
void Annotate()
Update the annotation of the symbol according the current object state.
A container for handling SCH_SHEET_PATH objects in a flattened hierarchy.
SCH_SHEET_PATH * FindSheetForPath(const SCH_SHEET_PATH *aPath)
Return a pointer to the first SCH_SHEET_PATH object (not necessarily the only one) matching the provi...
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
int Cmp(const SCH_SHEET_PATH &aSheetPathToTest) const
Compare if this is the same sheet path as aSheetPathToTest.
Schematic symbol object.
Definition: sch_symbol.h:105
wxString SubReference(int aUnit, bool aAddSeparator=true) const
Definition: sch_symbol.cpp:829
void SetValueFieldText(const wxString &aValue)
Definition: sch_symbol.cpp:890
const wxString GetValue(bool aResolve, const SCH_SHEET_PATH *aPath, bool aAllowExtraText) const override
Definition: sch_symbol.cpp:880
void SetRef(const SCH_SHEET_PATH *aSheet, const wxString &aReference)
Set the reference for the given sheet path for this symbol.
Definition: sch_symbol.cpp:752
const wxString GetFootprintFieldText(bool aResolve, const SCH_SHEET_PATH *aPath, bool aAllowExtraText) const
Definition: sch_symbol.cpp:896
VECTOR2I GetPosition() const override
Definition: sch_symbol.h:802
int GetUnitSelection(const SCH_SHEET_PATH *aSheet) const
Return the instance-specific unit selection for the given sheet path.
Definition: sch_symbol.cpp:838
void SetUnitSelection(const SCH_SHEET_PATH *aSheet, int aUnitSelection)
Set the selected unit of this symbol on one sheet.
Definition: sch_symbol.cpp:854
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition: sch_symbol.h:213
const wxString GetRef(const SCH_SHEET_PATH *aSheet, bool aIncludeUnit=false) const override
Definition: sch_symbol.cpp:713
#define _(s)
@ ERCE_UNANNOTATED
Symbol has not been annotated.
Definition: erc_settings.h:80
@ ERCE_DUPLICATE_REFERENCE
More than one symbol with the same reference.
Definition: erc_settings.h:83
@ ERCE_EXTRA_UNITS
Symbol has more units than are defined.
Definition: erc_settings.h:81
@ ERCE_DIFFERENT_UNIT_VALUE
Units of same symbol have different values.
Definition: erc_settings.h:82
void remove_duplicates(_Container &__c)
Deletes all duplicate values from __c.
Definition: kicad_algo.h:183
wxString buildFullReference(const SCH_REFERENCE &aItem, int aUnitNumber=-1)
std::function< void(ERCE_T aType, const wxString &aMsg, SCH_REFERENCE *aItemA, SCH_REFERENCE *aItemB)> ANNOTATION_ERROR_HANDLER
Define a standard error handler for annotation errors.
ANNOTATE_ORDER_T
Schematic annotation order options.
@ UNSORTED
Annotate by position of symbol in the schematic sheet object list.
@ SORT_BY_X_POSITION
Annotate by X position from left to right.
@ SORT_BY_Y_POSITION
Annotate by Y position from top to bottom.
ANNOTATE_ALGO_T
Schematic annotation type options.
@ SHEET_NUMBER_X_1000
Annotate using the first free reference number starting at the sheet number * 1000.
@ INCREMENTAL_BY_REF
Annotate incrementally using the first free reference number.
@ SHEET_NUMBER_X_100
Annotate using the first free reference number starting at the sheet number * 100.
std::map< wxString, SCH_REFERENCE_LIST > SCH_MULTI_UNIT_REFERENCE_MAP
Container to map reference designators for multi-unit parts.
int StrNumCmp(const wxString &aString1, const wxString &aString2, bool aIgnoreCase)
Compare two strings with alphanumerical content.
wxString From_UTF8(const char *cstring)
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: string_utils.h:391
A simple container for schematic symbol instance information.