KiCad PCB EDA Suite
sch_sheet_path.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) 2017 Jean-Pierre Charras, jp.charras at wanadoo.fr
5  * Copyright (C) 2011 Wayne Stambaugh <stambaughw@gmail.com>
6  * Copyright (C) 1992-2017 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 <fctsys.h>
32 
33 #include <general.h>
34 #include <dlist.h>
35 #include <class_sch_screen.h>
36 #include <sch_item_struct.h>
37 
38 #include <sch_reference_list.h>
39 #include <class_library.h>
40 #include <sch_sheet_path.h>
41 #include <sch_component.h>
42 #include <template_fieldnames.h>
43 
45 
46 #include <wx/filename.h>
47 
48 
50 {
51  m_pageNumber = 0;
52 }
53 
54 
55 int SCH_SHEET_PATH::Cmp( const SCH_SHEET_PATH& aSheetPathToTest ) const
56 {
57  if( size() > aSheetPathToTest.size() )
58  return 1;
59 
60  if( size() < aSheetPathToTest.size() )
61  return -1;
62 
63  //otherwise, same number of sheets.
64  for( unsigned i = 0; i < size(); i++ )
65  {
66  if( at( i )->GetTimeStamp() > aSheetPathToTest.at( i )->GetTimeStamp() )
67  return 1;
68 
69  if( at( i )->GetTimeStamp() < aSheetPathToTest.at( i )->GetTimeStamp() )
70  return -1;
71  }
72 
73  return 0;
74 }
75 
76 
78 {
79  if( !empty() )
80  return at( size() - 1 );
81 
82  return NULL;
83 }
84 
85 
87 {
88  SCH_SHEET* lastSheet = Last();
89 
90  if( lastSheet )
91  return lastSheet->GetScreen();
92 
93  return NULL;
94 }
95 
96 
98 {
99  SCH_SHEET* lastSheet = Last();
100 
101  if( lastSheet && lastSheet->GetScreen() )
102  return lastSheet->GetScreen()->GetDrawItems();
103 
104  return NULL;
105 }
106 
107 
109 {
110  SCH_ITEM* item = NULL;
111 
112  if( !empty() && at( 0 )->GetScreen() )
113  item = at( 0 )->GetScreen()->GetDrawItems();
114 
115  /* @fixme - These lists really should be one of the boost pointer containers. This
116  * is a brain dead hack to allow reverse iteration of EDA_ITEM linked
117  * list.
118  */
119  SCH_ITEM* lastItem = NULL;
120 
121  while( item )
122  {
123  lastItem = item;
124  item = item->Next();
125  }
126 
127  return lastItem;
128 }
129 
130 
131 wxString SCH_SHEET_PATH::Path() const
132 {
133  wxString s, t;
134 
135  s = wxT( "/" ); // This is the root path
136 
137  // start at 1 to avoid the root sheet,
138  // which does not need to be added to the path
139  // it's timestamp changes anyway.
140  for( unsigned i = 1; i < size(); i++ )
141  {
142  t.Printf( _( "%8.8lX/" ), (long unsigned) at( i )->GetTimeStamp() );
143  s = s + t;
144  }
145 
146  return s;
147 }
148 
149 
151 {
152  wxString s;
153 
154  s = wxT( "/" );
155 
156  // start at 1 to avoid the root sheet, as above.
157  for( unsigned i = 1; i < size(); i++ )
158  {
159  s = s + at( i )->GetName() + wxT( "/" );
160  }
161 
162  return s;
163 }
164 
165 
167 {
168  EDA_ITEM* t = LastDrawList();
169 
170  while( t )
171  {
172  if( t->Type() == SCH_COMPONENT_T )
173  {
174  SCH_COMPONENT* component = (SCH_COMPONENT*) t;
175  component->GetField( REFERENCE )->SetText( component->GetRef( this ) );
176  component->UpdateUnit( component->GetUnitSelection( this ) );
177  }
178 
179  t = t->Next();
180  }
181 }
182 
183 
184 
185 void SCH_SHEET_PATH::GetComponents( SCH_REFERENCE_LIST& aReferences, bool aIncludePowerSymbols,
186  bool aForceIncludeOrphanComponents )
187 {
188  for( SCH_ITEM* item = LastDrawList(); item; item = item->Next() )
189  {
190  if( item->Type() == SCH_COMPONENT_T )
191  {
192  SCH_COMPONENT* component = (SCH_COMPONENT*) item;
193 
194  // Skip pseudo components, which have a reference starting with #. This mainly
195  // affects power symbols.
196  if( !aIncludePowerSymbols && component->GetRef( this )[0] == wxT( '#' ) )
197  continue;
198 
199  LIB_PART* part = component->GetPartRef().lock().get();
200 
201  if( part || aForceIncludeOrphanComponents )
202  {
203  SCH_REFERENCE reference( component, part, *this );
204 
205  reference.SetSheetNumber( m_pageNumber );
206  aReferences.AddItem( reference );
207  }
208  }
209  }
210 }
211 
212 
214  bool aIncludePowerSymbols )
215 {
216 
217  for( SCH_ITEM* item = LastDrawList(); item; item = item->Next() )
218  {
219  if( item->Type() != SCH_COMPONENT_T )
220  continue;
221 
222  SCH_COMPONENT* component = (SCH_COMPONENT*) item;
223 
224  // Skip pseudo components, which have a reference starting with #. This mainly
225  // affects power symbols.
226  if( !aIncludePowerSymbols && component->GetRef( this )[0] == wxT( '#' ) )
227  continue;
228 
229  LIB_PART* part = component->GetPartRef().lock().get();
230 
231  if( part && part->GetUnitCount() > 1 )
232  {
233  SCH_REFERENCE reference = SCH_REFERENCE( component, part, *this );
234  reference.SetSheetNumber( m_pageNumber );
235  wxString reference_str = reference.GetRef();
236 
237  // Never lock unassigned references
238  if( reference_str[reference_str.Len() - 1] == '?' )
239  continue;
240 
241  aRefList[reference_str].AddItem( reference );
242  }
243  }
244 }
245 
246 
247 SCH_ITEM* SCH_SHEET_PATH::FindNextItem( KICAD_T aType, SCH_ITEM* aLastItem, bool aWrap ) const
248 {
249  bool hasWrapped = false;
250  bool firstItemFound = false;
251  SCH_ITEM* drawItem = LastDrawList();
252 
253  while( drawItem )
254  {
255  if( drawItem->Type() == aType )
256  {
257  if( !aLastItem || firstItemFound )
258  {
259  return drawItem;
260  }
261  else if( !firstItemFound && drawItem == aLastItem )
262  {
263  firstItemFound = true;
264  }
265  }
266 
267  drawItem = drawItem->Next();
268 
269  if( !drawItem && aLastItem && aWrap && !hasWrapped )
270  {
271  hasWrapped = true;
272  drawItem = LastDrawList();
273  }
274  }
275 
276  return NULL;
277 }
278 
279 
280 SCH_ITEM* SCH_SHEET_PATH::FindPreviousItem( KICAD_T aType, SCH_ITEM* aLastItem, bool aWrap ) const
281 {
282  bool hasWrapped = false;
283  bool firstItemFound = false;
284  SCH_ITEM* drawItem = FirstDrawList();
285 
286  while( drawItem )
287  {
288  if( drawItem->Type() == aType )
289  {
290  if( aLastItem == NULL || firstItemFound )
291  {
292  return drawItem;
293  }
294  else if( !firstItemFound && drawItem == aLastItem )
295  {
296  firstItemFound = true;
297  }
298  }
299 
300  drawItem = drawItem->Back();
301 
302  if( drawItem == NULL && aLastItem && aWrap && !hasWrapped )
303  {
304  hasWrapped = true;
305  drawItem = FirstDrawList();
306  }
307  }
308 
309  return NULL;
310 }
311 
312 
313 bool SCH_SHEET_PATH::SetComponentFootprint( const wxString& aReference, const wxString& aFootPrint,
314  bool aSetVisible )
315 {
316  SCH_SCREEN* screen = LastScreen();
317 
318  if( screen == NULL )
319  return false;
320 
321  return screen->SetComponentFootprint( this, aReference, aFootPrint, aSetVisible );
322 }
323 
324 
326 {
327  if( size() != d1.size() )
328  return false;
329 
330  for( unsigned i = 0; i < size(); i++ )
331  {
332  if( at( i ) != d1[i] )
333  return false;
334  }
335 
336  return true;
337 }
338 
339 
340 bool SCH_SHEET_PATH::TestForRecursion( const wxString& aSrcFileName,
341  const wxString& aDestFileName ) const
342 {
343  wxFileName rootFn = g_RootSheet->GetFileName();
344  wxFileName srcFn = aSrcFileName;
345  wxFileName destFn = aDestFileName;
346 
347  if( srcFn.IsRelative() )
348  srcFn.MakeAbsolute( rootFn.GetPath() );
349 
350  if( destFn.IsRelative() )
351  destFn.MakeAbsolute( rootFn.GetPath() );
352 
353 
354  // The source and destination sheet file names cannot be the same.
355  if( srcFn == destFn )
356  return true;
357 
361  unsigned i = 0;
362 
363  while( i < size() )
364  {
365  wxFileName cmpFn = at( i )->GetFileName();
366 
367  if( cmpFn.IsRelative() )
368  cmpFn.MakeAbsolute( rootFn.GetPath() );
369 
370  // Test if the file name of the destination sheet is in anywhere in this sheet path.
371  if( cmpFn == destFn )
372  break;
373 
374  i++;
375  }
376 
377  // The destination sheet file name was not found in the sheet path or the destination
378  // sheet file name is the root sheet so no recursion is possible.
379  if( i >= size() || i == 0 )
380  return false;
381 
382  // Walk back up to the root sheet to see if the source file name is already a parent in
383  // the sheet path. If so, recursion will occur.
384  do
385  {
386  i -= 1;
387 
388  wxFileName cmpFn = at( i )->GetFileName();
389 
390  if( cmpFn.IsRelative() )
391  cmpFn.MakeAbsolute( rootFn.GetPath() );
392 
393  if( cmpFn == srcFn )
394  return true;
395 
396  } while( i != 0 );
397 
398  // The source sheet file name is not a parent of the destination sheet file name.
399  return false;
400 }
401 
402 
403 int SCH_SHEET_PATH::FindSheet( const wxString& aFileName ) const
404 {
405  for( unsigned i = 0; i < size(); i++ )
406  {
407  if( at( i )->GetFileName().CmpNoCase( aFileName ) == 0 )
408  return (int)i;
409  }
410 
411  return SHEET_NOT_FOUND;
412 }
413 
414 
415 SCH_SHEET* SCH_SHEET_PATH::FindSheetByName( const wxString& aSheetName )
416 {
417  for( unsigned i = 0; i < size(); i++ )
418  {
419  if( at( i )->GetName().CmpNoCase( aSheetName ) == 0 )
420  return at( i );
421  }
422 
423  return NULL;
424 }
425 
426 
427 /********************************************************************/
428 /* Class SCH_SHEET_LIST to handle the list of Sheets in a hierarchy */
429 /********************************************************************/
431 {
432  m_isRootSheet = false;
433 
434  if( aSheet != NULL )
435  BuildSheetList( aSheet );
436 }
437 
438 
439 SCH_SHEET_PATH* SCH_SHEET_LIST::GetSheetByPath( const wxString aPath, bool aHumanReadable )
440 {
441  wxString sheetPath;
442 
443  for( unsigned i = 0; i < size(); i++ )
444  {
445  sheetPath = ( aHumanReadable ) ? at( i ).PathHumanReadable() : at( i ).Path();
446 
447  if( sheetPath == aPath )
448  return &at( i );
449  }
450 
451  return NULL;
452 }
453 
454 
456 {
457  wxCHECK_RET( aSheet != NULL, wxT( "Cannot build sheet list from undefined sheet." ) );
458 
459  if( aSheet == g_RootSheet )
460  m_isRootSheet = true;
461 
462  m_currentSheetPath.push_back( aSheet );
463 
469  m_currentSheetPath.SetPageNumber( size() + 1 );
470  push_back( m_currentSheetPath );
471 
472  if( aSheet->GetScreen() )
473  {
475 
476  while( item )
477  {
478  if( item->Type() == SCH_SHEET_T )
479  {
480  SCH_SHEET* sheet = (SCH_SHEET*) item;
481  BuildSheetList( sheet );
482  }
483 
484  item = item->Next();
485  }
486  }
487 
488  m_currentSheetPath.pop_back();
489 }
490 
491 
493 {
494  for( SCH_SHEET_PATHS_ITER it = begin(); it != end(); ++it )
495  {
496  if( (*it).LastScreen() && (*it).LastScreen()->IsModify() )
497  return true;
498  }
499 
500  return false;
501 }
502 
503 
505 {
506  for( SCH_SHEET_PATHS_ITER it = begin(); it != end(); ++it )
507  {
508  if( (*it).LastScreen() )
509  (*it).LastScreen()->ClrModify();
510  }
511 }
512 
513 
515 {
516  // List of reference for power symbols
517  SCH_REFERENCE_LIST references;
518 
519  // Map of locked components (not used, but needed by Annotate()
520  SCH_MULTI_UNIT_REFERENCE_MAP lockedComponents;
521 
522  // Build the list of power components:
523  for( SCH_SHEET_PATHS_ITER it = begin(); it != end(); ++it )
524  {
525  SCH_SHEET_PATH& spath = *it;
526 
527  for( EDA_ITEM* item = spath.LastDrawList(); item; item = item->Next() )
528  {
529  if( item->Type() != SCH_COMPONENT_T )
530  continue;
531 
532  SCH_COMPONENT* component = (SCH_COMPONENT*) item;
533  LIB_PART* part = component->GetPartRef().lock().get();
534 
535  if( !part || !part->IsPower() )
536  continue;
537 
538  if( part )
539  {
540  SCH_REFERENCE reference( component, part, spath );
541  references.AddItem( reference );
542  }
543  }
544  }
545 
546  // Find duplicate, and silently clear annotation of duplicate
547  std::map<wxString, int> ref_list; // stores the existing references
548 
549  for( unsigned ii = 0; ii< references.GetCount(); ++ii )
550  {
551  wxString curr_ref = references[ii].GetRef();
552 
553  if( ref_list.find( curr_ref ) == ref_list.end() )
554  {
555  ref_list[curr_ref] = ii;
556  continue;
557  }
558 
559  // Possible duplicate, if the ref ends by a number:
560  if( curr_ref.Last() < '0' && curr_ref.Last() > '9' )
561  continue; // not annotated
562 
563  // Duplicate: clear annotation by removing the number ending the ref
564  while( curr_ref.Last() >= '0' && curr_ref.Last() <= '9' )
565  curr_ref.RemoveLast();
566 
567  references[ii].SetRef( curr_ref );
568  }
569 
570 
571  // Break full components reference in name (prefix) and number:
572  // example: IC1 become IC, and 1
573  references.SplitReferences();
574 
575  // Ensure all power symbols have the reference starting by '#'
576  // (No sure this is really useful)
577  for( unsigned ii = 0; ii< references.GetCount(); ++ii )
578  {
579  if( references[ii].GetRef()[0] != '#' )
580  {
581  wxString new_ref = "#" + references[ii].GetRef();
582  references[ii].SetRef( new_ref );
583  }
584  }
585 
586  // Recalculate and update reference numbers in schematic
587  references.Annotate( false, 100, lockedComponents );
588  references.UpdateAnnotation();
589 }
590 
591 
592 void SCH_SHEET_LIST::GetComponents( SCH_REFERENCE_LIST& aReferences, bool aIncludePowerSymbols,
593  bool aForceIncludeOrphanComponents )
594 {
595  for( SCH_SHEET_PATHS_ITER it = begin(); it != end(); ++it )
596  (*it).GetComponents( aReferences, aIncludePowerSymbols, aForceIncludeOrphanComponents );
597 }
598 
600  bool aIncludePowerSymbols )
601 {
602  for( SCH_SHEET_PATHS_ITER it = begin(); it != end(); ++it )
603  {
605  (*it).GetMultiUnitComponents( tempMap );
606 
607  for( SCH_MULTI_UNIT_REFERENCE_MAP::value_type& pair : tempMap )
608  {
609  // Merge this list into the main one
610  unsigned n_refs = pair.second.GetCount();
611 
612  for( unsigned thisRef = 0; thisRef < n_refs; ++thisRef )
613  {
614  aRefList[pair.first].AddItem( pair.second[thisRef] );
615  }
616  }
617  }
618 }
619 
620 
622  SCH_ITEM* aLastItem, bool aWrap )
623 {
624  bool hasWrapped = false;
625  bool firstItemFound = false;
626 
627  SCH_ITEM* drawItem = NULL;
628  SCH_SHEET_PATHS_ITER it = begin();
629 
630  while( it != end() )
631  {
632  drawItem = (*it).LastDrawList();
633 
634  while( drawItem )
635  {
636  if( drawItem->Type() == aType )
637  {
638  if( aLastItem == NULL || firstItemFound )
639  {
640  if( aSheetFoundIn )
641  *aSheetFoundIn = &(*it);
642 
643  return drawItem;
644  }
645  else if( !firstItemFound && drawItem == aLastItem )
646  {
647  firstItemFound = true;
648  }
649  }
650 
651  drawItem = drawItem->Next();
652  }
653 
654  ++it;
655 
656  if( it == end() && aLastItem && aWrap && !hasWrapped )
657  {
658  hasWrapped = true;
659  it = begin();
660  }
661  }
662 
663  return NULL;
664 }
665 
666 
668  SCH_ITEM* aLastItem, bool aWrap )
669 {
670  bool hasWrapped = false;
671  bool firstItemFound = false;
672  SCH_ITEM* drawItem = NULL;
673  SCH_SHEET_PATHS_RITER it = rbegin();
674 
675  while( it != rend() )
676  {
677  drawItem = (*it).FirstDrawList();
678 
679  while( drawItem )
680  {
681  if( drawItem->Type() == aType )
682  {
683  if( aLastItem == NULL || firstItemFound )
684  {
685  if( aSheetFoundIn )
686  *aSheetFoundIn = &(*it);
687 
688  return drawItem;
689  }
690  else if( !firstItemFound && drawItem == aLastItem )
691  {
692  firstItemFound = true;
693  }
694  }
695 
696  drawItem = drawItem->Back();
697  }
698 
699  ++it;
700 
701  if( it == rend() && aLastItem && aWrap && !hasWrapped )
702  {
703  hasWrapped = true;
704  it = rbegin();
705  }
706  }
707 
708  return NULL;
709 }
710 
711 
712 bool SCH_SHEET_LIST::SetComponentFootprint( const wxString& aReference,
713  const wxString& aFootPrint, bool aSetVisible )
714 {
715  bool found = false;
716 
717  for( SCH_SHEET_PATHS_ITER it = begin(); it != end(); ++it )
718  found = (*it).SetComponentFootprint( aReference, aFootPrint, aSetVisible );
719 
720  return found;
721 }
722 
723 
725 {
726  wxString fileName;
727 
728  for( unsigned i = 0; i < size(); i++ )
729  {
730  fileName = at( i ).Last()->GetFileName();
731 
732  for( unsigned j = 0; j < size(); j++ )
733  {
734  if( i == j )
735  continue;
736 
737  if( fileName == at( j ).Last()->GetFileName() )
738  return true;
739  }
740  }
741 
742  return false;
743 }
744 
745 
746 bool SCH_SHEET_LIST::TestForRecursion( const SCH_SHEET_LIST& aSrcSheetHierarchy,
747  const wxString& aDestFileName ) const
748 {
749  wxFileName rootFn = g_RootSheet->GetFileName();
750  wxFileName destFn = aDestFileName;
751 
752  if( destFn.IsRelative() )
753  destFn.MakeAbsolute( rootFn.GetPath() );
754 
755  // Test each SCH_SHEET_PATH in this SCH_SHEET_LIST for potential recursion.
756  for( unsigned i = 0; i < size(); i++ )
757  {
758  // Test each SCH_SHEET_PATH in the source sheet.
759  for( unsigned j = 0; j < aSrcSheetHierarchy.size(); j++ )
760  {
761  const SCH_SHEET_PATH* sheetPath = &aSrcSheetHierarchy[j];
762 
763  for( unsigned k = 0; k < sheetPath->size(); k++ )
764  {
765  if( at( i ).TestForRecursion( sheetPath->GetSheet( k )->GetFileName(),
766  aDestFileName ) )
767  return true;
768  }
769  }
770  }
771 
772  // The source sheet file can safely be added to the destination sheet file.
773  return false;
774 }
775 
776 
777 SCH_SHEET* SCH_SHEET_LIST::FindSheetByName( const wxString& aSheetName )
778 {
779  for( unsigned i = 0; i < size(); i++ )
780  {
781  SCH_SHEET* sheet = at( i ).FindSheetByName( aSheetName );
782 
783  if( sheet )
784  return sheet;
785  }
786 
787  return NULL;
788 }
SCH_ITEM * LastDrawList() const
Function LastDrawList.
void GetComponents(SCH_REFERENCE_LIST &aReferences, bool aIncludePowerSymbols=true, bool aForceIncludeOrphanComponents=false)
Function GetComponents adds a SCH_REFERENCE() object to aReferences for each component in the sheet...
void SetSheetNumber(int aSheetNumber)
Class SCH_SHEET_LIST.
KICAD_T Type() const
Function Type()
Definition: base_struct.h:212
bool IsModified()
Function IsModified checks the entire hierarchy for any modifications.
SCH_SHEET * FindSheetByName(const wxString &aSheetName)
Function FindSheetByName.
int FindSheet(const wxString &aFileName) const
SCH_ITEM * FindPreviousItem(KICAD_T aType, SCH_SHEET_PATH **aSheetFound=NULL, SCH_ITEM *aLastItem=NULL, bool aWrap=true)
Function FindPreviousItem searches the entire schematic for the previous schematic item...
PART_REF & GetPartRef()
void UpdateUnit(int aUnit)
Change the unit number to aUnit without setting any internal flags.
SCH_SHEET_PATHS::iterator SCH_SHEET_PATHS_ITER
bool IsPower() const
const SCH_SHEET * GetSheet(unsigned aIndex) const
Base schematic object class definition.
SCH_ITEM * FindNextItem(KICAD_T aType, SCH_SHEET_PATH **aSheetFound=NULL, SCH_ITEM *aLastItem=NULL, bool aWrap=true)
Function FindNextItem searches the entire schematic for the next schematic object.
void SetPageNumber(int aPageNumber)
void AddItem(SCH_REFERENCE &aItem)
Function AddItem adds a SCH_REFERENCE object to the list of references.
int GetUnitSelection(SCH_SHEET_PATH *aSheet)
bool operator==(const SCH_SHEET_PATH &d1) const
SCH_SCREEN * LastScreen() const
Function LastScreen.
EDA_ITEM * Next() const
Definition: base_struct.h:220
void UpdateAllScreenReferences()
Function UpdateAllScreenReferences updates the reference and the m_Multi parameter (part selection) f...
SCH_SCREEN * GetScreen()
Definition: sch_sheet.h:279
SCH_ITEM * Next() const
Field Reference of part, i.e. "IC21".
#define SHEET_NOT_FOUND
KICAD_T
Enum KICAD_T is the set of class identification values, stored in EDA_ITEM::m_StructType.
Definition: typeinfo.h:78
SCH_SHEET_LIST(SCH_SHEET *aSheet=NULL)
Constructor build a flattened list of SCH_SHEET_PATH objects from aSheet.
Class SCH_REFERENCE_LIST is used to create a flattened list of components because in a complex hierar...
SCH_ITEM * Back() const
wxString Path() const
Function Path the path uses the time stamps which do not changes even when editing sheet parameters a...
void UpdateAnnotation()
function UpdateAnnotation Updates the reference components for the schematic project (or the current ...
SCH_SHEET * FindSheetByName(const wxString &aSheetName)
Function FindSheetByName.
SCH_SHEET * g_RootSheet
Definition: eeschema.cpp:55
SCH_FIELD * GetField(int aFieldNdx) const
Returns a field in this symbol.
SCH_SHEET_PATH m_currentSheetPath
void Annotate(bool aUseSheetNum, int aSheetIntervalId, SCH_MULTI_UNIT_REFERENCE_MAP aLockedUnitMap)
Function Annotate set the reference designators in the list that have not been annotated.
SCH_ITEM * FirstDrawList() const
Get the last schematic item relative to the first sheet in the list.
Definitions for the Eeschema program SCH_SCREEN class.
Subclass of DIALOG_SCH_FIND_BASE, which is generated by wxFormBuilder.
bool SetComponentFootprint(const wxString &aReference, const wxString &aFootPrint, bool aSetVisible)
Function SetFootprintField searches all the sheets for a component with aReference and set the footpr...
bool IsComplexHierarchy() const
Function IsComplexHierarchy searches all of the sheets for duplicate files names which indicates a co...
wxString PathHumanReadable() const
Function PathHumanReadable returns the sheet path in a human readable form, i.e.
bool SetComponentFootprint(const wxString &aReference, const wxString &aFootPrint, bool aSetVisible)
Function SetFootprintField searches last sheet in the path for a component with aReference and set th...
Class LIB_PART defines a library part object.
SCH_ITEM * FindPreviousItem(KICAD_T aType, SCH_ITEM *aLastItem=NULL, bool aWrap=false) const
Find the previous schematic item in this sheet path object.
SCH_SHEET_PATH()
Page numbers are maintained by the sheet load order.
Class SCH_SHEET_PATH.
SCH_SHEET * Last() const
Function Last returns a pointer to the last sheet of the list One can see the others sheet as the "pa...
void BuildSheetList(SCH_SHEET *aSheet)
Function BuildSheetList builds the list of sheets and their sheet path from aSheet.
const wxString GetRef(const SCH_SHEET_PATH *aSheet)
Return the reference for the given sheet path.
wxString GetFileName(void) const
Return the filename corresponding to this sheet.
Definition: sch_sheet.cpp:645
std::map< wxString, SCH_REFERENCE_LIST > SCH_MULTI_UNIT_REFERENCE_MAP
Type SCH_MULTI_UNIT_REFERENCE_MAP is used to create a map of reference designators for multi-unit par...
SCH_ITEM * FindNextItem(KICAD_T aType, SCH_ITEM *aLastItem=NULL, bool aWrap=false) const
Find the next schematic item in this sheet object.
time_t GetTimeStamp() const
Definition: base_struct.h:218
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition: sch_sheet.h:209
void GetMultiUnitComponents(SCH_MULTI_UNIT_REFERENCE_MAP &aRefList, bool aIncludePowerSymbols=true)
Function GetMultiUnitComponents adds a SCH_REFERENCE_LIST object to aRefList for each same-reference ...
int GetUnitCount() const
wxString GetRef() const
bool TestForRecursion(const wxString &aSrcFileName, const wxString &aDestFileName) const
Function TestForRecursion.
SCH_ITEM * GetDrawItems() const
Definition the SCH_COMPONENT class for Eeschema.
SCH_SHEET_PATH * GetSheetByPath(const wxString aPath, bool aHumanReadable=true)
Function GetSheetByPath returns a sheet matching the path name in aPath.
void SplitReferences()
Function SplitReferences attempts to split all reference designators into a name (U) and number (1)...
SCH_SHEET_PATHS::reverse_iterator SCH_SHEET_PATHS_RITER
Class SCH_COMPONENT describes a real schematic component.
Definition: sch_component.h:69
static bool empty(const wxTextEntryBase *aCtrl)
Class EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boa...
Definition: base_struct.h:165
int Cmp(const SCH_SHEET_PATH &aSheetPathToTest) const
Function Cmp Compare if this is the same sheet path as aSheetPathToTest.
void AnnotatePowerSymbols()
Function AnnotatePowerSymbols Silently annotates the not yet annotated power symbols of the entire hi...
void GetMultiUnitComponents(SCH_MULTI_UNIT_REFERENCE_MAP &aRefList, bool aIncludePowerSymbols=true)
Function GetMultiUnitComponents adds a SCH_REFERENCE_LIST object to aRefList for each same-reference ...
Definition for part library class.
void GetComponents(SCH_REFERENCE_LIST &aReferences, bool aIncludePowerSymbols=true, bool aForceIncludeOrphanComponents=false)
Function GetComponents adds a SCH_REFERENCE() object to aReferences for each component in the list of...
Definition of the SCH_SHEET_PATH and SCH_SHEET_LIST classes for Eeschema.
unsigned GetCount()
Function GetCount.
Class SCH_ITEM is a base class for any item which can be embedded within the SCHEMATIC container clas...
Class SCH_REFERENCE is used as a helper to define a component's reference designator in a schematic...
bool TestForRecursion(const SCH_SHEET_LIST &aSrcSheetHierarchy, const wxString &aDestFileName) const
Function TestForRecursion.
virtual void SetText(const wxString &aText)
Definition: eda_text.h:141
bool SetComponentFootprint(SCH_SHEET_PATH *aSheetPath, const wxString &aReference, const wxString &aFootPrint, bool aSetVisible)
Search this screen for a symbol with aReference and set the footprint field to aFootPrint if found...