KiCad PCB EDA Suite
Loading...
Searching...
No Matches
cadstar_sch_archive_loader.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) 2020-2021 Roberto Fernandez Bautista <[email protected]>
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software: you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation, either version 3 of the License, or (at your
10 * option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
28
29#include <bus_alias.h>
30#include <core/mirror.h>
31#include <core/kicad_algo.h>
32#include <eda_text.h>
33#include <macros.h>
34#include <progress_reporter.h>
35#include <string_utils.h>
36#include <sch_bus_entry.h>
37#include <sch_edit_frame.h> //SYMBOL_ORIENTATION_T
38#include <sch_io/sch_io_mgr.h>
39#include <sch_junction.h>
40#include <sch_line.h>
41#include <sch_screen.h>
42#include <sch_shape.h>
43#include <sch_sheet.h>
44#include <sch_sheet_path.h>
45#include <sch_sheet_pin.h>
46#include <sch_label.h>
47#include <schematic.h>
48#include <sim/sim_model.h>
49#include <trigo.h>
51
52
53const wxString PartNameFieldName = "Part Name";
54const wxString PartNumberFieldName = "Part Number";
55const wxString PartVersionFieldName = "Part Version";
56const wxString PartAcceptanceFieldName = "Part Acceptance";
57
58
59wxString CADSTAR_SCH_ARCHIVE_LOADER::CreateLibName( const wxFileName& aFileName,
60 const SCH_SHEET* aRootSheet )
61{
62 wxString libName = aFileName.GetName();
63
64 if( libName.IsEmpty() && aRootSheet )
65 {
66 wxFileName fn( aRootSheet->GetFileName() );
67 libName = fn.GetName();
68 }
69
70 if( libName.IsEmpty() )
71 libName = "noname";
72
73 libName = LIB_ID::FixIllegalChars( libName, true ).wx_str();
74
75 return libName;
76}
77
78
79std::vector<LIB_SYMBOL*> CADSTAR_SCH_ARCHIVE_LOADER::LoadPartsLib( const wxString& aFilename )
80{
82 m_progressReporter->SetNumPhases( 3 ); // (0) Read csa, (1) Parse csa, (3) Load lib
83
84 Parse();
85
87
88 if( !p.CheckFileHeader( aFilename.utf8_string() ) )
89 THROW_IO_ERROR( _( "File does not appear to be a CADSTAR parts Library file" ) );
90
91 // TODO: we could add progress reporting for reading .lib
92 CADSTAR_PARTS_LIB_MODEL csLib = p.ReadFile( aFilename.utf8_string() );
93
95 {
97 long numSteps = csLib.m_PartEntries.size();
99 }
100
101 std::vector<LIB_SYMBOL*> retVal;
102
103 for( const CADSTAR_PART_ENTRY& part : csLib.m_PartEntries )
104 {
105 std::unique_ptr<LIB_SYMBOL> loadedPart = loadLibPart( part );
106
107 checkPoint();
108
109 if( loadedPart )
110 retVal.push_back( loadedPart.release() );
111 }
112
113 return retVal;
114}
115
116
117std::unique_ptr<LIB_SYMBOL>
119{
120 wxString escapedPartName = EscapeString( aPart.m_Name, CTX_LIBID );
121 std::unique_ptr<LIB_SYMBOL> retSym;
122
123 int unit = 0;
124
125 for( const CADSTAR_PART_SYMBOL_ENTRY& sym : aPart.m_Symbols )
126 {
127 ++unit;
128 wxString alternateName = sym.m_SymbolAlternateName.value_or( "" );
129 SYMDEF_ID symbolID = getSymDefFromName( sym.m_SymbolName, alternateName );
130
131 if( !Library.SymbolDefinitions.count( symbolID ) )
132 {
133 m_reporter->Report( wxString::Format( _( "Unable to find symbol %s, referenced by part "
134 "%s. The part was not loaded." ),
135 generateLibName( sym.m_SymbolName, alternateName ),
136 aPart.m_Name ),
138
139 return nullptr;
140 }
141
142 // Load the graphical symbol for this gate
143 std::unique_ptr<LIB_SYMBOL> kiSymDef( loadSymdef( symbolID )->Duplicate() );
144
145 if( (int)sym.m_Pins.size() != kiSymDef->GetPinCount() )
146 {
147 m_reporter->Report( wxString::Format( _( "Inconsistent pin numbers in symbol %s "
148 "compared to the one defined in part %s. The "
149 "part was not loaded." ),
150 generateLibName( sym.m_SymbolName, alternateName ),
151 aPart.m_Name ),
153
154 return nullptr;
155 }
156
157 wxASSERT( m_symDefTerminalsMap.count( symbolID ) ); //loadSymDef should have populated this
158
159
160 // Update the pin numbers to match those defined in the Cadstar part
161 for( auto& [storedPinNum, termID] : m_symDefTerminalsMap[symbolID] )
162 {
163 wxCHECK( termID > 0 && sym.m_Pins.size() >= size_t( termID ), nullptr );
164 SCH_PIN* pin = kiSymDef->GetPin( storedPinNum );
165 size_t termIdx = size_t( termID ) - 1;
166
167 // For now leave numerical pin number. Otherwise, when loading the
168 // .cpa file we won't be able to link up to the footprint pads, but if
169 // we solve this, we could then load alphanumeric pin numbers as below:
170 //
171 // if( aPart.m_PinNamesMap.count( termID ) )
172 // partPinNum = wxString( aPart.m_PinNamesMap.at( termID ) );
173 //
174 wxString partPinNum = wxString::Format( "%ld", sym.m_Pins[termIdx].m_Identifier );
175 pin->SetNumber( partPinNum );
176
177 if( aPart.m_PinNamesMap.count( termID ) )
178 pin->SetName( HandleTextOverbar( aPart.m_PinNamesMap.at( termID ) ) );
179 else if( aPart.m_PinLabelsMap.count( termID ) )
180 pin->SetName( HandleTextOverbar( aPart.m_PinLabelsMap.at( termID ) ) );
181
182 pin->SetType( getKiCadPinType( sym.m_Pins[termIdx].m_Type ) );
183
184 // @todo: Load pin/gate swapping information once kicad supports this
185 }
186
187 if( unit == 1 )
188 {
189 wxCHECK( kiSymDef->GetUnitCount() == 1, nullptr );
190 // The first unit can just be moved to the part symbol
191 retSym = std::move( kiSymDef );
192
193 retSym->SetUnitCount( aPart.m_Symbols.size(), true );
194
195 retSym->SetName( escapedPartName );
196 retSym->GetReferenceField().SetText( aPart.m_ComponentStem );
197 retSym->GetValueField().SetText( aPart.m_Value.value_or( "" ) );
199 retSym->SetDescription( aPart.m_Description.value_or( "" ) );
200
201 auto addFieldIfHasValue =
202 [&]( const wxString& name, const std::optional<std::string>& value )
203 {
204 if( value.has_value() )
205 addNewFieldToSymbol( name, retSym )->SetText( value.value() );
206 };
207
208 addFieldIfHasValue( PartNumberFieldName, aPart.m_Number );
209 addFieldIfHasValue( PartVersionFieldName, aPart.m_Version );
210 addFieldIfHasValue( PartAcceptanceFieldName, aPart.m_AcceptancePartName );
211
213 aPart.m_Pcb_alternate.value_or( "" ) );
214
215 if( aPart.m_SpiceModel.has_value() )
216 {
217 wxString modelVal = wxString::Format( "model=\"%s\"", aPart.m_SpiceModel.value() );
218 addNewFieldToSymbol( SIM_DEVICE_FIELD, retSym )->SetText( "SPICE" );
219 addNewFieldToSymbol( SIM_PARAMS_FIELD, retSym )->SetText( modelVal );
220 }
221
222 // Load all part attributes, regardless of original cadstar type, to the symbol
223
224 // @todo some cadstar part attributes have a "read-only" flag. We should load this
225 // when KiCad supports read-only fields.
226
227 for( auto& [fieldName, value] : aPart.m_UserAttributes )
228 addNewFieldToSymbol( fieldName, retSym )->SetText( value );
229
230 for( auto& [fieldName, attrValue] : aPart.m_SchAttributes )
231 addNewFieldToSymbol( fieldName, retSym )->SetText( attrValue.m_Value );
232
233 for( auto& [fieldName, attrValue] : aPart.m_PcbAttributes )
234 addNewFieldToSymbol( fieldName, retSym )->SetText( attrValue.m_Value );
235
236 for( auto& [fieldName, attrValue] : aPart.m_SchAndPcbAttributes )
237 addNewFieldToSymbol( fieldName, retSym )->SetText( attrValue.m_Value );
238
239 for( auto& [fieldName, attrValue] : aPart.m_PartAttributes )
240 addNewFieldToSymbol( fieldName, retSym )->SetText( attrValue.m_Value );
241
242 // Load all hidden pins onto the first unit of the symbol in KiCad
243 // We load them in a spiral sequence, starting at the center of the symbol BBOX
244 VECTOR2I symCenter = retSym->GetBodyBoundingBox( unit, 0, false, false ).GetCenter();
245 symCenter.y = -symCenter.y; // need to invert the y coord for lib symbols.
246
247 VECTOR2I delta( 0, 1 );
248 VECTOR2I direction( 0, -1 );
249 int spacing = schIUScale.MilsToIU( 50 ); // for now, place on a 50mil grid
250
251 for( auto& [signalName, csPinVector] : aPart.m_HiddenPins )
252 {
253 for( const CADSTAR_PART_PIN& csPin : csPinVector )
254 {
255 std::unique_ptr<SCH_PIN> pin = std::make_unique<SCH_PIN>( retSym.get() );
256
257 long pinNum = csPin.m_Identifier;
258 pin->SetNumber( wxString::Format( "%ld", pinNum ) );
259 pin->SetName( signalName );
260 pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN );
261
262 pin->SetVisible( false );
263
264 // Generate the coordinate for the pin. We don't want overlapping pins
265 // and ideally close to the center of the symbol, so we load pins in a
266 // spiral sequence around the center
267 if( delta.x == delta.y
268 || ( delta.x < 0 && delta.x == -delta.y )
269 || ( delta.x > 0 && delta.x == 1 - delta.y ) )
270 {
271 // change direction
272 direction = { -direction.y, direction.x };
273 }
274
275 delta += direction;
276 VECTOR2I offset = delta * spacing;
277 pin->SetPosition( symCenter + offset );
278 pin->SetLength( 0 ); //CADSTAR Pins are just a point (have no length)
279 pin->SetShape( GRAPHIC_PINSHAPE::LINE );
280 pin->SetUnit( unit );
281 retSym->AddDrawItem( pin.release() );
282 }
283 }
284 }
285 else
286 { // Source: Dest:
287 copySymbolItems( kiSymDef, retSym, unit, false /* aOverrideFields */ );
288 }
289
290
291 retSym->SetShowPinNames( aPart.m_PinsVisible );
292 retSym->SetShowPinNumbers( aPart.m_PinsVisible );
293 }
294
295
296 return retSym;
297}
298
299
300void CADSTAR_SCH_ARCHIVE_LOADER::copySymbolItems( std::unique_ptr<LIB_SYMBOL>& aSourceSym,
301 std::unique_ptr<LIB_SYMBOL>& aDestSym,
302 int aDestUnit, bool aOverrideFields )
303{
304 // Ensure there are no items on the unit we want to load onto
305 for( SCH_ITEM* item : aDestSym->GetUnitDrawItems( aDestUnit, 0 /*aConvert*/ ) )
306 aDestSym->RemoveDrawItem( item );
307
308 // Copy all draw items
309 for( SCH_ITEM* newItem : aSourceSym->GetUnitDrawItems( 1, 0 /*aConvert*/ ) )
310 {
311 SCH_ITEM* itemCopy = static_cast<SCH_ITEM*>( newItem->Clone() );
312 itemCopy->SetParent( aDestSym.get() );
313 itemCopy->SetUnit( aDestUnit );
314 aDestSym->AddDrawItem( itemCopy );
315 }
316
317 //Copy / override all fields
318 if( aOverrideFields )
319 {
320 std::vector<SCH_FIELD*> fieldsToCopy;
321 aSourceSym->GetFields( fieldsToCopy );
322
323 for( SCH_FIELD* templateField : fieldsToCopy )
324 {
325 SCH_FIELD* appliedField = addNewFieldToSymbol( templateField->GetName(), aDestSym );
326 templateField->Copy( appliedField );
327 }
328 }
329}
330
331
333{
334 wxCHECK( aSchematic, /* void */ );
335
337 m_progressReporter->SetNumPhases( 3 ); // (0) Read file, (1) Parse file, (2) Load file
338
339 Parse();
340
341 checkDesignLimits(); // Throws if error found
342
343 // Assume the center at 0,0 since we are going to be translating the design afterwards anyway
344 m_designCenter = { 0, 0 };
345
346 m_schematic = aSchematic;
347 m_rootSheet = aRootSheet;
348
350 {
352 long numSteps = 11; // one step for each of below functions + one at the end of import
353
354 // Step 4 is by far the longest - add granularity in reporting
355 numSteps += Parts.PartDefinitions.size();
356
358 }
359
360 loadTextVariables(); // Load text variables right at the start to ensure bounding box
361 // calculations work correctly for text items
362 checkPoint(); // Step 1
363 loadSheets();
364 checkPoint(); // Step 2
366 checkPoint(); // Step 3
368 checkPoint(); // Step 4, Subdivided into extra steps
370 checkPoint(); // Step 5
371 loadBusses();
372 checkPoint(); // Step 6
373 loadNets();
374 checkPoint(); // Step 7
375 loadFigures();
376 checkPoint(); // Step 8
377 loadTexts();
378 checkPoint(); // Step 9
380 checkPoint(); // Step 10
381
382 if( Schematic.VariantHierarchy.Variants.size() > 0 )
383 {
384 m_reporter->Report( wxString::Format( _( "The CADSTAR design contains variants which has "
385 "no KiCad equivalent. Only the master variant "
386 "('%s') was loaded." ),
387 Schematic.VariantHierarchy.Variants.at( "V0" ).Name ),
389 }
390
391 if( Schematic.Groups.size() > 0 )
392 {
393 m_reporter->Report( _( "The CADSTAR design contains grouped items which has no KiCad "
394 "equivalent. Any grouped items have been ungrouped." ),
396 }
397
398 if( Schematic.ReuseBlocks.size() > 0 )
399 {
400 m_reporter->Report( _( "The CADSTAR design contains re-use blocks which has no KiCad "
401 "equivalent. The re-use block information has been discarded during "
402 "the import." ),
404 }
405
406
407 // For all sheets, center all elements and re calculate the page size:
408 for( std::pair<LAYER_ID, SCH_SHEET*> sheetPair : m_sheetMap )
409 {
410 SCH_SHEET* sheet = sheetPair.second;
411
412 // Calculate the new sheet size.
413 BOX2I sheetBoundingBox;
414
415 for( SCH_ITEM* item : sheet->GetScreen()->Items() )
416 {
417 BOX2I bbox;
418
419 // Only use the visible fields of the symbols to calculate their bounding box
420 // (hidden fields could be very long and artificially enlarge the sheet bounding box)
421 if( item->Type() == SCH_SYMBOL_T )
422 {
423 SCH_SYMBOL* comp = static_cast<SCH_SYMBOL*>( item );
424 bbox = comp->GetBodyAndPinsBoundingBox();
425
426 for( const SCH_FIELD& field : comp->GetFields() )
427 {
428 if( field.IsVisible() )
429 bbox.Merge( field.GetBoundingBox() );
430 }
431 }
432 else if( item->Type() == SCH_TEXT_T )
433 {
434 SCH_TEXT* txtItem = static_cast<SCH_TEXT*>( item );
435 wxString txt = txtItem->GetText();
436
437 if( txt.Contains( "${" ) )
438 continue; // We can't calculate bounding box of text items with variables
439 else
440 bbox = txtItem->GetBoundingBox();
441 }
442 else
443 {
444 bbox = item->GetBoundingBox();
445 }
446
447 sheetBoundingBox.Merge( bbox );
448 }
449
450 // Find the screen grid of the original CADSTAR design
452
457
459
460 auto roundToNearestGrid =
461 [&]( int aNumber ) -> int
462 {
463 int error = aNumber % grid;
464 int absError = sign( error ) * error;
465
466 if( absError > ( grid / 2 ) )
467 return aNumber + ( sign( error ) * grid ) - error;
468 else
469 return aNumber - error;
470 };
471
472 // When exporting to pdf, CADSTAR applies a margin of 3% of the longest dimension (height
473 // or width) to all 4 sides (top, bottom, left right). For the import, we are also rounding
474 // the margin to the nearest grid, ensuring all items remain on the grid.
475 VECTOR2I targetSheetSize = sheetBoundingBox.GetSize();
476 int longestSide = std::max( targetSheetSize.x, targetSheetSize.y );
477 int margin = ( (double) longestSide * 0.03 );
478 margin = roundToNearestGrid( margin );
479 targetSheetSize += margin * 2;
480
481 // Update page size always
482 PAGE_INFO pageInfo = sheet->GetScreen()->GetPageSettings();
483 pageInfo.SetWidthMils( schIUScale.IUToMils( targetSheetSize.x ) );
484 pageInfo.SetHeightMils( schIUScale.IUToMils( targetSheetSize.y ) );
485
486 // Set the new sheet size.
487 sheet->GetScreen()->SetPageSettings( pageInfo );
488
490 VECTOR2I sheetcentre( pageSizeIU.x / 2, pageSizeIU.y / 2 );
491 VECTOR2I itemsCentre = sheetBoundingBox.Centre();
492
493 // round the translation to nearest point on the grid
494 VECTOR2I translation = sheetcentre - itemsCentre;
495 translation.x = roundToNearestGrid( translation.x );
496 translation.y = roundToNearestGrid( translation.y );
497
498 // Translate the items.
499 std::vector<SCH_ITEM*> allItems;
500
501 std::copy( sheet->GetScreen()->Items().begin(), sheet->GetScreen()->Items().end(),
502 std::back_inserter( allItems ) );
503
504 for( SCH_ITEM* item : allItems )
505 {
506 item->Move( translation );
507 item->ClearFlags();
508 sheet->GetScreen()->Update( item );
509 }
510 }
511
512 checkPoint();
513
514 m_reporter->Report( _( "CADSTAR fonts are different to the ones in KiCad. This will likely "
515 "result in alignment issues. Please review the imported text elements "
516 "carefully and correct manually if required." ),
518
519 m_reporter->Report( _( "The CADSTAR design has been imported successfully.\n"
520 "Please review the import errors and warnings (if any)." ) );
521}
522
523
525{
527
528 //Note: can't use getKiCadPoint() due VECTOR2I being int - need long long to make the check
529 long long designSizeXkicad = (long long) designLimit.x / KiCadUnitDivider;
530 long long designSizeYkicad = (long long) designLimit.y / KiCadUnitDivider;
531
532 // Max size limited by the positive dimension of VECTOR2I (which is an int)
533 constexpr long long maxDesignSizekicad = std::numeric_limits<int>::max();
534
535 if( designSizeXkicad > maxDesignSizekicad || designSizeYkicad > maxDesignSizekicad )
536 {
537 THROW_IO_ERROR( wxString::Format(
538 _( "The design is too large and cannot be imported into KiCad. \n"
539 "Please reduce the maximum design size in CADSTAR by navigating to: \n"
540 "Design Tab -> Properties -> Design Options -> Maximum Design Size. \n"
541 "Current Design size: %.2f, %.2f millimeters. \n"
542 "Maximum permitted design size: %.2f, %.2f millimeters.\n" ),
543 (double) designSizeXkicad / SCH_IU_PER_MM,
544 (double) designSizeYkicad / SCH_IU_PER_MM,
545 (double) maxDesignSizekicad / SCH_IU_PER_MM,
546 (double) maxDesignSizekicad / SCH_IU_PER_MM ) );
547 }
548}
549
550
552{
553 const std::vector<LAYER_ID>& orphanSheets = findOrphanSheets();
554 SCH_SHEET_PATH rootPath;
555 rootPath.push_back( m_rootSheet );
556 rootPath.SetPageNumber( wxT( "1" ) );
557
558 if( orphanSheets.size() > 1 )
559 {
560 int x = 1;
561 int y = 1;
562
563 for( LAYER_ID sheetID : orphanSheets )
564 {
565 VECTOR2I pos( x * schIUScale.MilsToIU( 1000 ), y * schIUScale.MilsToIU( 1000 ) );
566 VECTOR2I siz( schIUScale.MilsToIU( 1000 ), schIUScale.MilsToIU( 1000 ) );
567
568 loadSheetAndChildSheets( sheetID, pos, siz, rootPath );
569
570 x += 2;
571
572 if( x > 10 ) // start next row
573 {
574 x = 1;
575 y += 2;
576 }
577 }
578 }
579 else if( orphanSheets.size() > 0 )
580 {
581 LAYER_ID rootSheetID = orphanSheets.at( 0 );
582
583 wxFileName loadedFilePath = wxFileName( Filename );
584
585 std::string filename = wxString::Format( "%s_%02d", loadedFilePath.GetName(),
586 getSheetNumber( rootSheetID ) )
587 .ToStdString();
588 ReplaceIllegalFileNameChars( &filename );
589 filename += wxT( "." ) + wxString( FILEEXT::KiCadSchematicFileExtension );
590
591 wxFileName fn( m_schematic->Prj().GetProjectPath() + filename );
592 m_rootSheet->GetScreen()->SetFileName( fn.GetFullPath() );
593
594 m_sheetMap.insert( { rootSheetID, m_rootSheet } );
595 loadChildSheets( rootSheetID, rootPath );
596 }
597 else if( Header.Format.Type == "SYMBOL" )
598 {
599 THROW_IO_ERROR( _( "The selected file is a CADSTAR symbol library. It does not contain a "
600 "schematic design so cannot be imported/opened in this way." ) );
601 }
602 else
603 {
604 THROW_IO_ERROR( _( "The CADSTAR schematic might be corrupt: there is no root sheet." ) );
605 }
606}
607
608
610{
611 for( std::pair<BLOCK_ID, BLOCK> blockPair : Schematic.Blocks )
612 {
613 BLOCK& block = blockPair.second;
614 LAYER_ID sheetID = "";
615
616 if( block.Type == BLOCK::TYPE::PARENT )
617 sheetID = block.LayerID;
618 else if( block.Type == BLOCK::TYPE::CHILD )
619 sheetID = block.AssocLayerID;
620 else
621 continue;
622
623 if( m_sheetMap.find( sheetID ) != m_sheetMap.end() )
624 {
625 SCH_SHEET* sheet = m_sheetMap.at( sheetID );
626
627 for( std::pair<TERMINAL_ID, TERMINAL> termPair : block.Terminals )
628 {
629 TERMINAL term = termPair.second;
630 wxString name = "YOU SHOULDN'T SEE THIS TEXT. THIS IS A BUG.";
631
632 SCH_HIERLABEL* sheetPin = nullptr;
633
634 if( block.Type == BLOCK::TYPE::PARENT )
635 sheetPin = new SCH_HIERLABEL();
636 else if( block.Type == BLOCK::TYPE::CHILD )
637 sheetPin = new SCH_SHEET_PIN( sheet );
638
639 sheetPin->SetText( name );
640 sheetPin->SetShape( LABEL_FLAG_SHAPE::L_UNSPECIFIED );
641 sheetPin->SetSpinStyle( getSpinStyle( term.OrientAngle, false ) );
642 sheetPin->SetPosition( getKiCadPoint( term.Position ) );
643
644 if( sheetPin->Type() == SCH_SHEET_PIN_T )
645 sheet->AddPin( (SCH_SHEET_PIN*) sheetPin );
646 else
647 sheet->GetScreen()->Append( sheetPin );
648
649 BLOCK_PIN_ID blockPinID = std::make_pair( block.ID, term.ID );
650 m_sheetPinMap.insert( { blockPinID, sheetPin } );
651 }
652 }
653 }
654}
655
656
658{
659 for( std::pair<PART_ID, PART> partPair : Parts.PartDefinitions )
660 {
661 PART_ID partID = partPair.first;
662 PART part = partPair.second;
663
664 wxString escapedPartName = EscapeString( part.Name, CTX_LIBID );
665 LIB_SYMBOL* kiSym = new LIB_SYMBOL( escapedPartName );
666
667 kiSym->SetUnitCount( part.Definition.GateSymbols.size() );
668 bool ok = true;
669
670 for( std::pair<GATE_ID, PART::DEFINITION::GATE> gatePair : part.Definition.GateSymbols )
671 {
672 GATE_ID gateID = gatePair.first;
673 PART::DEFINITION::GATE gate = gatePair.second;
674 SYMDEF_ID symbolID = getSymDefFromName( gate.Name, gate.Alternate );
675
676 if( symbolID.IsEmpty() )
677 {
678 m_reporter->Report( wxString::Format( _( "Part definition '%s' references symbol "
679 "'%s' (alternate '%s') which could not be "
680 "found in the symbol library. The part has "
681 "not been loaded into the KiCad library." ),
682 part.Name,
683 gate.Name,
684 gate.Alternate ),
686
687 ok = false;
688 break;
689 }
690
691 m_partSymbolsMap.insert( { { partID, gateID }, symbolID } );
692 loadSymbolGateAndPartFields( symbolID, part, gateID, kiSym );
693 }
694
695 if( ok && part.Definition.GateSymbols.size() != 0 )
696 {
697 m_loadedSymbols.push_back( kiSym );
698 }
699 else
700 {
701 if( part.Definition.GateSymbols.size() == 0 )
702 {
703 m_reporter->Report( wxString::Format( _( "Part definition '%s' has an incomplete "
704 "definition (no symbol definitions are "
705 "associated with it). The part has not "
706 "been loaded into the KiCad library." ),
707 part.Name ),
709 }
710
711 // Don't save in the library, but still keep it cached as some of the units might have
712 // been loaded correctly (saving us time later on), plus the part definition contains
713 // the part name, which is important to load
714 }
715
716 m_partMap.insert( { partID, kiSym } );
717
718 checkPoint();
719 }
720}
721
722
724{
725 for( std::pair<SYMBOL_ID, SYMBOL> symPair : Schematic.Symbols )
726 {
727 SYMBOL sym = symPair.second;
728
729 if( !sym.VariantID.empty() && sym.VariantParentSymbolID != sym.ID )
730 continue; // Only load master Variant
731
732 if( sym.IsComponent )
733 {
734 if( m_partMap.find( sym.PartRef.RefID ) == m_partMap.end() )
735 {
736 m_reporter->Report( wxString::Format( _( "Symbol '%s' references part '%s' which "
737 "could not be found in the library. The "
738 "symbol was not loaded" ),
740 sym.PartRef.RefID ),
742
743 continue;
744 }
745
746 if( sym.GateID.IsEmpty() )
747 sym.GateID = wxT( "A" ); // Assume Gate "A" if unspecified
748
749 PART_GATE_ID partSymbolID = { sym.PartRef.RefID, sym.GateID };
750 LIB_SYMBOL* kiSym = m_partMap.at( sym.PartRef.RefID );
751 bool copy = false;
752
753 // The symbol definition in the part either does not exist for this gate number
754 // or is different to the symbol instance. We need to reload the gate for this
755 // symbol
756 if( m_partSymbolsMap.find( partSymbolID ) == m_partSymbolsMap.end()
757 || m_partSymbolsMap.at( partSymbolID ) != sym.SymdefID )
758 {
759 kiSym = new LIB_SYMBOL( *kiSym ); // Make a copy
760 copy = true;
761 const PART& part = Parts.PartDefinitions.at( sym.PartRef.RefID );
762 loadSymbolGateAndPartFields( sym.SymdefID, part, sym.GateID, kiSym );
763 }
764
765 LIB_SYMBOL* scaledPart = getScaledLibPart( kiSym, sym.ScaleRatioNumerator,
767
768 EDA_ANGLE symOrient = ANGLE_0;
769 SCH_SYMBOL* symbol = loadSchematicSymbol( sym, *scaledPart, symOrient );
770
771 delete scaledPart;
772
773 if( copy )
774 delete kiSym;
775
776 SCH_FIELD* refField = symbol->GetField( FIELD_T::REFERENCE );
777
778 sym.ComponentRef.Designator.Replace( wxT( "\n" ), wxT( "\\n" ) );
779 sym.ComponentRef.Designator.Replace( wxT( "\r" ), wxT( "\\r" ) );
780 sym.ComponentRef.Designator.Replace( wxT( "\t" ), wxT( "\\t" ) );
781 sym.ComponentRef.Designator.Replace( wxT( " " ), wxT( "_" ) );
782
783 refField->SetText( sym.ComponentRef.Designator );
784 loadSymbolFieldAttribute( sym.ComponentRef.AttrLoc, symOrient, sym.Mirror, refField );
785
786 if( sym.HasPartRef )
787 {
788 SCH_FIELD* partField = symbol->GetField( PartNameFieldName );
789
790 if( !partField )
791 partField = symbol->AddField( SCH_FIELD( symbol, FIELD_T::USER, PartNameFieldName ) );
792
793 wxASSERT( partField->GetName() == PartNameFieldName );
794
795 wxString partname = getPart( sym.PartRef.RefID ).Name;
796 partname.Replace( wxT( "\n" ), wxT( "\\n" ) );
797 partname.Replace( wxT( "\r" ), wxT( "\\r" ) );
798 partname.Replace( wxT( "\t" ), wxT( "\\t" ) );
799 partField->SetText( partname );
800
801 loadSymbolFieldAttribute( sym.PartRef.AttrLoc, symOrient, sym.Mirror, partField );
802
804 }
805
806 for( auto& attr : sym.AttributeValues )
807 {
808 ATTRIBUTE_VALUE attrVal = attr.second;
809
810 if( attrVal.HasLocation )
811 {
812 wxString attrName = getAttributeName( attrVal.AttributeID );
813 SCH_FIELD* attrField = symbol->GetField( attrName );
814
815 if( !attrField )
816 attrField = symbol->AddField( SCH_FIELD( symbol, FIELD_T::USER, attrName ) );
817
818 wxASSERT( attrField->GetName() == attrName );
819
820 attrVal.Value.Replace( wxT( "\n" ), wxT( "\\n" ) );
821 attrVal.Value.Replace( wxT( "\r" ), wxT( "\\r" ) );
822 attrVal.Value.Replace( wxT( "\t" ), wxT( "\\t" ) );
823 attrField->SetText( attrVal.Value );
824
825 loadSymbolFieldAttribute( attrVal.AttributeLocation, symOrient, sym.Mirror,
826 attrField );
827 attrField->SetVisible( isAttributeVisible( attrVal.AttributeID ) );
828 }
829 }
830 }
831 else if( sym.IsSymbolVariant )
832 {
834 {
835 THROW_IO_ERROR( wxString::Format( _( "Symbol ID '%s' references library symbol "
836 "'%s' which could not be found in the "
837 "library. Did you export all items of the "
838 "design?" ),
839 sym.ID,
840 sym.PartRef.RefID ) );
841 }
842
843 SYMDEF_SCM libSymDef = Library.SymbolDefinitions.at( sym.SymdefID );
844
845 if( libSymDef.Terminals.size() != 1 )
846 {
847 THROW_IO_ERROR( wxString::Format( _( "Symbol ID '%s' is a signal reference or "
848 "global signal but it has too many pins. The "
849 "expected number of pins is 1 but %d were "
850 "found." ),
851 sym.ID,
852 libSymDef.Terminals.size() ) );
853 }
854
855 if( sym.SymbolVariant.Type == SYMBOLVARIANT::TYPE::GLOBALSIGNAL )
856 {
857 SYMDEF_ID symID = sym.SymdefID;
858 LIB_SYMBOL* kiPart = nullptr;
859
860 // In CADSTAR "GlobalSignal" is a special type of symbol which defines
861 // a Power Symbol. The "Alternate" name defines the default net name of
862 // the power symbol but this can be overridden in the design itself.
863 wxString libraryNetName = Library.SymbolDefinitions.at( symID ).Alternate;
864
865 // Name of the net that the symbol instance in CADSTAR refers to:
866 wxString symbolInstanceNetName = sym.SymbolVariant.Reference;
867 symbolInstanceNetName = EscapeString( symbolInstanceNetName, CTX_LIBID );
868
869 // Name of the symbol we will use for saving the part in KiCad
870 // Note: In CADSTAR all power symbols will start have the reference name be
871 // "GLOBALSIGNAL" followed by the default net name, so it makes sense to save
872 // the symbol in KiCad as the default net name as well.
873 wxString libPartName = libraryNetName;
874
875 // In CADSTAR power symbol instances can refer to a different net to that defined
876 // in the library. This causes problems in KiCad v6 as it breaks connectivity when
877 // the user decides to update all symbols from library. We handle this by creating
878 // individual versions of the power symbol for each net name.
879 if( libPartName != symbolInstanceNetName )
880 {
881 libPartName += wxT( " (" ) + symbolInstanceNetName + wxT( ")" );
882 }
883
884 if( m_powerSymLibMap.find( libPartName ) == m_powerSymLibMap.end() )
885 {
886 const LIB_SYMBOL* templatePart = loadSymdef( symID );
887 wxCHECK( templatePart, /*void*/ );
888
889 kiPart = new LIB_SYMBOL( *templatePart );
890 kiPart->SetGlobalPower();
891 kiPart->SetName( libPartName );
892 kiPart->GetValueField().SetText( symbolInstanceNetName );
893 kiPart->SetShowPinNames( false );
894 kiPart->SetShowPinNumbers( false );
895
896 std::vector<SCH_PIN*> pins = kiPart->GetPins();
897 wxCHECK( pins.size() == 1, /*void*/ );
898
899 pins.at( 0 )->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN );
900 pins.at( 0 )->SetName( symbolInstanceNetName );
901
902 if( libSymDef.TextLocations.find( SIGNALNAME_ORIGIN_ATTRID )
903 != libSymDef.TextLocations.end() )
904 {
905 TEXT_LOCATION& txtLoc =
907
908 VECTOR2I valPos = getKiCadLibraryPoint( txtLoc.Position, libSymDef.Origin );
909
910 kiPart->GetValueField().SetPosition( valPos );
911 kiPart->GetValueField().SetVisible( true );
912 }
913 else
914 {
915 kiPart->GetValueField().SetVisible( false );
916 }
917
918 kiPart->GetReferenceField().SetText( "#PWR" );
919 kiPart->GetReferenceField().SetVisible( false );
920 m_loadedSymbols.push_back( kiPart );
921 m_powerSymLibMap.insert( { libPartName, kiPart } );
922 }
923 else
924 {
925 kiPart = m_powerSymLibMap.at( libPartName );
926 wxASSERT( kiPart->GetValueField().GetText() == symbolInstanceNetName );
927 }
928
929 LIB_SYMBOL* scaledPart = getScaledLibPart( kiPart, sym.ScaleRatioNumerator,
931
932 EDA_ANGLE returnedOrient = ANGLE_0;
933 SCH_SYMBOL* symbol = loadSchematicSymbol( sym, *scaledPart, returnedOrient );
934 m_powerSymMap.insert( { sym.ID, symbol } );
935
936 delete scaledPart;
937 }
938 else if( sym.SymbolVariant.Type == SYMBOLVARIANT::TYPE::SIGNALREF )
939 {
940 // There should only be one pin and we'll use that to set the position
941 TERMINAL& symbolTerminal = libSymDef.Terminals.begin()->second;
942 VECTOR2I terminalPosOffset = symbolTerminal.Position - libSymDef.Origin;
943 EDA_ANGLE rotate = getAngle( sym.OrientAngle );
944
945 if( sym.Mirror )
946 rotate += ANGLE_180;
947
948 RotatePoint( terminalPosOffset, -rotate );
949
950 SCH_GLOBALLABEL* netLabel = new SCH_GLOBALLABEL;
951 netLabel->SetPosition( getKiCadPoint( (VECTOR2I)sym.Origin + terminalPosOffset ) );
952 netLabel->SetText( "***UNKNOWN NET****" ); // This should be later updated when we load the netlist
953 netLabel->SetTextSize( VECTOR2I( schIUScale.MilsToIU( 50 ), schIUScale.MilsToIU( 50 ) ) );
954
955 SYMDEF_SCM symbolDef = Library.SymbolDefinitions.at( sym.SymdefID );
956
957 if( symbolDef.TextLocations.count( LINK_ORIGIN_ATTRID ) )
958 {
959 TEXT_LOCATION linkOrigin = symbolDef.TextLocations.at( LINK_ORIGIN_ATTRID );
960 applyTextSettings( netLabel, linkOrigin.TextCodeID, linkOrigin.Alignment,
961 linkOrigin.Justification );
962 }
963
964 netLabel->SetSpinStyle( getSpinStyle( sym.OrientAngle, sym.Mirror ) );
965
966 if( libSymDef.Alternate.Lower().Contains( "in" ) )
967 netLabel->SetShape( LABEL_FLAG_SHAPE::L_INPUT );
968 else if( libSymDef.Alternate.Lower().Contains( "bi" ) )
969 netLabel->SetShape( LABEL_FLAG_SHAPE::L_BIDI );
970 else if( libSymDef.Alternate.Lower().Contains( "out" ) )
971 netLabel->SetShape( LABEL_FLAG_SHAPE::L_OUTPUT );
972 else
973 netLabel->SetShape( LABEL_FLAG_SHAPE::L_UNSPECIFIED );
974
975 SCH_SCREEN* screen = m_sheetMap.at( sym.LayerID )->GetScreen();
976
977 // autoplace intersheet refs
978 netLabel->AutoplaceFields( screen, AUTOPLACE_AUTO );
979
980 screen->Append( netLabel );
981 m_globalLabelsMap.insert( { sym.ID, netLabel } );
982 }
983 else
984 {
985 wxASSERT_MSG( false, "Unknown Symbol Variant." );
986 }
987 }
988 else
989 {
990 m_reporter->Report( wxString::Format( _( "Symbol ID '%s' is of an unknown type. It is "
991 "neither a symbol or a net power / symbol. "
992 "The symbol was not loaded." ),
993 sym.ID ),
995 }
996
997 if( sym.ScaleRatioDenominator != 1 || sym.ScaleRatioNumerator != 1 )
998 {
999 wxString symbolName = sym.ComponentRef.Designator;
1000
1001 if( symbolName.empty() )
1002 symbolName = wxString::Format( "ID: %s", sym.ID );
1003 else
1004 symbolName += sym.GateID;
1005
1006 m_reporter->Report( wxString::Format( _( "Symbol '%s' is scaled in the original "
1007 "CADSTAR schematic but this is not supported "
1008 "in KiCad. When the symbol is reloaded from "
1009 "the library, it will revert to the original "
1010 "1:1 scale." ),
1011 symbolName,
1012 sym.PartRef.RefID ),
1014 }
1015 }
1016}
1017
1018
1020{
1021 for( std::pair<BUS_ID, BUS> busPair : Schematic.Buses )
1022 {
1023 BUS bus = busPair.second;
1024 bool firstPt = true;
1025 VERTEX last;
1026
1027 if( bus.LayerID != wxT( "NO_SHEET" ) )
1028 {
1029 SCH_SCREEN* screen = m_sheetMap.at( bus.LayerID )->GetScreen();
1030 std::shared_ptr<BUS_ALIAS> kiBusAlias = std::make_shared<BUS_ALIAS>();
1031
1032 kiBusAlias->SetName( bus.Name );
1033 kiBusAlias->SetParent( screen );
1034 screen->AddBusAlias( kiBusAlias );
1035 m_busesMap.insert( { bus.ID, kiBusAlias } );
1036
1037 SCH_LABEL* label = new SCH_LABEL();
1038
1039 wxString busname = HandleTextOverbar( bus.Name );
1040
1041 label->SetText( wxT( "{" ) + busname + wxT( "}" ) );
1042 label->SetVisible( true );
1043 screen->Append( label );
1044
1045 SHAPE_LINE_CHAIN busLineChain; // to compute nearest segment to bus label
1046
1047 for( const VERTEX& cur : bus.Shape.Vertices )
1048 {
1049 busLineChain.Append( getKiCadPoint( cur.End ) );
1050
1051 if( firstPt )
1052 {
1053 last = cur;
1054 firstPt = false;
1055
1056 if( !bus.HasBusLabel )
1057 {
1058 // Add a bus label on the starting point if the original CADSTAR design
1059 // does not have an explicit label
1060 label->SetPosition( getKiCadPoint( last.End ) );
1061 }
1062
1063 continue;
1064 }
1065
1066
1067 SCH_LINE* kiBus = new SCH_LINE();
1068
1069 kiBus->SetStartPoint( getKiCadPoint( last.End ) );
1070 kiBus->SetEndPoint( getKiCadPoint( cur.End ) );
1071 kiBus->SetLayer( LAYER_BUS );
1072 kiBus->SetLineWidth( getLineThickness( bus.LineCodeID ) );
1073 screen->Append( kiBus );
1074
1075 last = cur;
1076 }
1077
1078 if( bus.HasBusLabel )
1079 {
1080 //lets find the closest point in the busline to the label
1081 VECTOR2I busLabelLoc = getKiCadPoint( bus.BusLabel.Position );
1082 VECTOR2I nearestPt = busLineChain.NearestPoint( busLabelLoc );
1083
1084 label->SetPosition( nearestPt );
1085
1087 bus.BusLabel.Justification );
1088
1089 // Re-set bus name as it might have been "double-escaped" after applyTextSettings
1090 label->SetText( wxT( "{" ) + busname + wxT( "}" ) );
1091
1092 // Note orientation of the bus label will be determined in loadNets
1093 // (the position of the wire will determine how best to place the bus label)
1094 }
1095 }
1096 }
1097}
1098
1099
1101{
1102 for( std::pair<NET_ID, NET_SCH> netPair : Schematic.Nets )
1103 {
1104 NET_SCH net = netPair.second;
1105 wxString netName = net.Name;
1106 std::map<NETELEMENT_ID, SCH_LABEL*> netlabels;
1107
1108 if( netName.IsEmpty() )
1109 netName = wxString::Format( "$%ld", net.SignalNum );
1110
1111 netName = HandleTextOverbar( netName );
1112
1113 for( std::pair<NETELEMENT_ID, NET_SCH::SYM_TERM> terminalPair : net.Terminals )
1114 {
1115 NET_SCH::SYM_TERM netTerm = terminalPair.second;
1116
1117 if( m_powerSymMap.find( netTerm.SymbolID ) != m_powerSymMap.end() )
1118 {
1119 SCH_FIELD* val = m_powerSymMap.at( netTerm.SymbolID )->GetField( FIELD_T::VALUE );
1120 val->SetText( netName );
1121 val->SetBold( false );
1122 val->SetVisible( false );
1123
1124 if( netTerm.HasNetLabel )
1125 {
1126 val->SetVisible( true );
1127 val->SetPosition( getKiCadPoint( netTerm.NetLabel.Position ) );
1128
1129 applyTextSettings( val, netTerm.NetLabel.TextCodeID, netTerm.NetLabel.Alignment,
1130 netTerm.NetLabel.Justification, netTerm.NetLabel.OrientAngle,
1131 netTerm.NetLabel.Mirror );
1132 }
1133 }
1134 else if( m_globalLabelsMap.find( netTerm.SymbolID ) != m_globalLabelsMap.end() )
1135 {
1136 m_globalLabelsMap.at( netTerm.SymbolID )->SetText( netName );
1137
1138 LAYER_ID sheet = Schematic.Symbols.at( netTerm.SymbolID ).LayerID;
1139
1140 if( m_sheetMap.count( sheet ) )
1141 {
1142 SCH_SCREEN* screen = m_sheetMap.at( sheet )->GetScreen();
1143
1144 // autoplace intersheet refs again since we've changed the name
1145 m_globalLabelsMap.at( netTerm.SymbolID )->AutoplaceFields( screen, AUTOPLACE_AUTO );
1146 }
1147 }
1148 else if( !net.Name.IsEmpty() && Schematic.Symbols.count( netTerm.SymbolID )
1149 && netTerm.HasNetLabel )
1150 {
1151 // This is a named net that connects to a schematic symbol pin - we need to put a label
1152 SCH_LABEL* label = new SCH_LABEL();
1153 label->SetText( netName );
1154
1155 POINT pinLocation = getLocationOfNetElement( net, netTerm.ID );
1156 label->SetPosition( getKiCadPoint( pinLocation ) );
1157 label->SetVisible( true );
1158
1159 applyTextSettings( label, netTerm.NetLabel.TextCodeID, netTerm.NetLabel.Alignment,
1160 netTerm.NetLabel.Justification );
1161
1162 netlabels.insert( { netTerm.ID, label } );
1163
1164 LAYER_ID sheet = Schematic.Symbols.at( netTerm.SymbolID ).LayerID;
1165 m_sheetMap.at( sheet )->GetScreen()->Append( label );
1166 }
1167 }
1168
1169 auto getHierarchicalLabel =
1170 [&]( const NETELEMENT_ID& aNode ) -> SCH_HIERLABEL*
1171 {
1172 if( aNode.Contains( "BLKT" ) )
1173 {
1174 NET_SCH::BLOCK_TERM blockTerm = net.BlockTerminals.at( aNode );
1175 BLOCK_PIN_ID blockPinID = std::make_pair( blockTerm.BlockID,
1176 blockTerm.TerminalID );
1177
1178 if( m_sheetPinMap.find( blockPinID ) != m_sheetPinMap.end() )
1179 return m_sheetPinMap.at( blockPinID );
1180 }
1181
1182 return nullptr;
1183 };
1184
1185 //Add net name to all hierarchical pins (block terminals in CADSTAR)
1186 for( std::pair<NETELEMENT_ID, NET_SCH::BLOCK_TERM> blockPair : net.BlockTerminals )
1187 {
1188 SCH_HIERLABEL* label = getHierarchicalLabel( blockPair.first );
1189
1190 if( label )
1191 label->SetText( netName );
1192 }
1193
1194 // Load all bus entries and add net label if required
1195 for( std::pair<NETELEMENT_ID, NET_SCH::BUS_TERM> busPair : net.BusTerminals )
1196 {
1197 NET_SCH::BUS_TERM busTerm = busPair.second;
1198 BUS bus = Schematic.Buses.at( busTerm.BusID );
1199
1200 if( !alg::contains( m_busesMap.at( bus.ID )->Members(), netName ) )
1201 m_busesMap.at( bus.ID )->Members().emplace_back( netName );
1202
1203 SCH_BUS_WIRE_ENTRY* busEntry =
1204 new SCH_BUS_WIRE_ENTRY( getKiCadPoint( busTerm.FirstPoint ), false );
1205
1206 VECTOR2I size =
1207 getKiCadPoint( busTerm.SecondPoint ) - getKiCadPoint( busTerm.FirstPoint );
1208 busEntry->SetSize( VECTOR2I( size.x, size.y ) );
1209
1210 m_sheetMap.at( bus.LayerID )->GetScreen()->Append( busEntry );
1211
1212 // Always add a label at bus terminals to ensure connectivity.
1213 // If the original design does not have a label, just make it very small
1214 // to keep connectivity but make the design look visually similar to
1215 // the original.
1216 SCH_LABEL* label = new SCH_LABEL();
1217 label->SetText( netName );
1218 label->SetPosition( getKiCadPoint( busTerm.SecondPoint ) );
1219 label->SetVisible( true );
1220
1221 if( busTerm.HasNetLabel )
1222 {
1223 applyTextSettings( label, busTerm.NetLabel.TextCodeID, busTerm.NetLabel.Alignment,
1224 busTerm.NetLabel.Justification );
1225 }
1226 else
1227 {
1229 }
1230
1231 netlabels.insert( { busTerm.ID, label } );
1232 m_sheetMap.at( bus.LayerID )->GetScreen()->Append( label );
1233 }
1234
1235 for( std::pair<NETELEMENT_ID, NET_SCH::DANGLER> danglerPair : net.Danglers )
1236 {
1237 NET_SCH::DANGLER dangler = danglerPair.second;
1238
1239 SCH_LABEL* label = new SCH_LABEL();
1240 label->SetPosition( getKiCadPoint( dangler.Position ) );
1241 label->SetVisible( true );
1242
1243 if( dangler.HasNetLabel )
1244 {
1245 applyTextSettings( label, dangler.NetLabel.TextCodeID, dangler.NetLabel.Alignment,
1246 dangler.NetLabel.Justification );
1247 }
1248
1249 label->SetText( netName ); // set text after applying settings to avoid double-escaping
1250 netlabels.insert( { dangler.ID, label } );
1251
1252 m_sheetMap.at( dangler.LayerID )->GetScreen()->Append( label );
1253 }
1254
1255 for( NET_SCH::CONNECTION_SCH conn : net.Connections )
1256 {
1257 if( conn.LayerID == wxT( "NO_SHEET" ) )
1258 continue; // No point loading virtual connections. KiCad handles that internally
1259
1260 POINT start = getLocationOfNetElement( net, conn.StartNode );
1261 POINT end = getLocationOfNetElement( net, conn.EndNode );
1262
1263 if( start.x == UNDEFINED_VALUE || end.x == UNDEFINED_VALUE )
1264 continue;
1265
1266 // Connections in CADSTAR are always implied between symbols even if the route
1267 // doesn't start and end exactly at the connection points
1268 if( conn.Path.size() < 1 || conn.Path.front() != start )
1269 conn.Path.insert( conn.Path.begin(), start );
1270
1271 if( conn.Path.size() < 2 || conn.Path.back() != end )
1272 conn.Path.push_back( end );
1273
1274 bool firstPt = true;
1275 bool secondPt = false;
1276 VECTOR2I last;
1277 SCH_LINE* wire = nullptr;
1278
1279 SHAPE_LINE_CHAIN wireChain; // Create a temp. line chain representing the connection
1280
1281 for( const POINT& pt : conn.Path )
1282 wireChain.Append( getKiCadPoint( pt ) );
1283
1284 // AUTO-FIX SHEET PINS
1285 //--------------------
1286 // KiCad constrains the sheet pin on the edge of the sheet object whereas in
1287 // CADSTAR it can be anywhere. Let's find the intersection of the wires with the sheet
1288 // and place the hierarchical
1289 std::vector<NETELEMENT_ID> nodes;
1290 nodes.push_back( conn.StartNode );
1291 nodes.push_back( conn.EndNode );
1292
1293 for( const NETELEMENT_ID& node : nodes )
1294 {
1295 SCH_HIERLABEL* sheetPin = getHierarchicalLabel( node );
1296
1297 if( sheetPin )
1298 {
1299 if( sheetPin->Type() == SCH_SHEET_PIN_T
1300 && SCH_SHEET::ClassOf( sheetPin->GetParent() ) )
1301 {
1302 SCH_SHEET* parentSheet = static_cast<SCH_SHEET*>( sheetPin->GetParent() );
1303 VECTOR2I sheetSize = parentSheet->GetSize();
1304 VECTOR2I sheetPosition = parentSheet->GetPosition();
1305
1306 int leftSide = sheetPosition.x;
1307 int rightSide = sheetPosition.x + sheetSize.x;
1308 int topSide = sheetPosition.y;
1309 int botSide = sheetPosition.y + sheetSize.y;
1310
1311 SHAPE_LINE_CHAIN sheetEdge;
1312
1313 sheetEdge.Append( leftSide, topSide );
1314 sheetEdge.Append( rightSide, topSide );
1315 sheetEdge.Append( rightSide, botSide );
1316 sheetEdge.Append( leftSide, botSide );
1317 sheetEdge.Append( leftSide, topSide );
1318
1319 SHAPE_LINE_CHAIN::INTERSECTIONS wireToSheetIntersects;
1320
1321 if( !wireChain.Intersect( sheetEdge, wireToSheetIntersects ) )
1322 {
1323 // The block terminal is outside the block shape in the original
1324 // CADSTAR design. Since KiCad's Sheet Pin will already be constrained
1325 // on the edge, we will simply join to it with a straight line.
1326 if( node == conn.StartNode )
1327 wireChain = wireChain.Reverse();
1328
1329 wireChain.Append( sheetPin->GetPosition() );
1330
1331 if( node == conn.StartNode )
1332 wireChain = wireChain.Reverse();
1333 }
1334 else
1335 {
1336 // The block terminal is either inside or on the shape edge. Lets use
1337 // the first intersection point.
1338 VECTOR2I intsctPt = wireToSheetIntersects.at( 0 ).p;
1339 int intsctIndx = wireChain.FindSegment( intsctPt );
1340 wxASSERT_MSG( intsctIndx != -1, "Can't find intersecting segment" );
1341
1342 if( node == conn.StartNode )
1343 wireChain.Replace( 0, intsctIndx, intsctPt );
1344 else
1345 wireChain.Replace( intsctIndx + 1, /*end index*/ -1, intsctPt );
1346
1347 sheetPin->SetPosition( intsctPt );
1348 }
1349 }
1350 }
1351 }
1352
1353 auto fixNetLabelsAndSheetPins =
1354 [&]( const EDA_ANGLE& aWireAngle, NETELEMENT_ID& aNetEleID )
1355 {
1356 SPIN_STYLE spin = getSpinStyle( aWireAngle );
1357
1358 if( netlabels.find( aNetEleID ) != netlabels.end() )
1359 netlabels.at( aNetEleID )->SetSpinStyle( spin.MirrorY() );
1360
1361 SCH_HIERLABEL* sheetPin = getHierarchicalLabel( aNetEleID );
1362
1363 if( sheetPin )
1364 sheetPin->SetSpinStyle( spin.MirrorX() );
1365 };
1366
1367 // Now we can load the wires and fix the label orientations
1368 for( const VECTOR2I& pt : wireChain.CPoints() )
1369 {
1370 if( firstPt )
1371 {
1372 last = pt;
1373 firstPt = false;
1374 secondPt = true;
1375 continue;
1376 }
1377
1378 if( secondPt )
1379 {
1380 secondPt = false;
1381
1382 EDA_ANGLE wireAngle( last - pt );
1383 fixNetLabelsAndSheetPins( wireAngle, conn.StartNode );
1384 }
1385
1386 wire = new SCH_LINE();
1387
1388 wire->SetStartPoint( last );
1389 wire->SetEndPoint( pt );
1390 wire->SetLayer( LAYER_WIRE );
1391
1392 if( !conn.ConnectionLineCode.IsEmpty() )
1393 wire->SetLineWidth( getLineThickness( conn.ConnectionLineCode ) );
1394
1395 last = pt;
1396
1397 m_sheetMap.at( conn.LayerID )->GetScreen()->Append( wire );
1398 }
1399
1400 //Fix labels on the end wire
1401 if( wire )
1402 {
1403 EDA_ANGLE wireAngle( wire->GetEndPoint() - wire->GetStartPoint() );
1404 fixNetLabelsAndSheetPins( wireAngle, conn.EndNode );
1405 }
1406 }
1407
1408 for( std::pair<NETELEMENT_ID, NET_SCH::JUNCTION_SCH> juncPair : net.Junctions )
1409 {
1410 NET_SCH::JUNCTION_SCH junc = juncPair.second;
1411
1412 SCH_JUNCTION* kiJunc = new SCH_JUNCTION();
1413
1414 kiJunc->SetPosition( getKiCadPoint( junc.Location ) );
1415 m_sheetMap.at( junc.LayerID )->GetScreen()->Append( kiJunc );
1416
1417 if( junc.HasNetLabel )
1418 {
1419 // In CADSTAR the label can be placed anywhere, but in KiCad it has to be placed
1420 // in the same location as the junction for it to be connected to it.
1421 SCH_LABEL* label = new SCH_LABEL();
1422 label->SetText( netName );
1423 label->SetPosition( getKiCadPoint( junc.Location ) );
1424 label->SetVisible( true );
1425
1426 EDA_ANGLE labelAngle = getAngle( junc.NetLabel.OrientAngle );
1427 SPIN_STYLE spin = getSpinStyle( labelAngle );
1428
1429 label->SetSpinStyle( spin );
1430
1431 m_sheetMap.at( junc.LayerID )->GetScreen()->Append( label );
1432 }
1433 }
1434 }
1435}
1436
1437
1439{
1440 for( std::pair<FIGURE_ID, FIGURE> figPair : Schematic.Figures )
1441 {
1442 FIGURE fig = figPair.second;
1443
1444 loadFigure( fig, fig.LayerID, LAYER_NOTES );
1445 }
1446}
1447
1448
1450{
1451 for( std::pair<TEXT_ID, TEXT> textPair : Schematic.Texts )
1452 {
1453 TEXT txt = textPair.second;
1454
1455 SCH_TEXT* kiTxt = getKiCadSchText( txt );
1456 loadItemOntoKiCadSheet( txt.LayerID, kiTxt );
1457 }
1458}
1459
1460
1462{
1463 for( std::pair<DOCUMENTATION_SYMBOL_ID, DOCUMENTATION_SYMBOL> docSymPair :
1465 {
1466 DOCUMENTATION_SYMBOL docSym = docSymPair.second;
1467
1468 if( Library.SymbolDefinitions.find( docSym.SymdefID ) == Library.SymbolDefinitions.end() )
1469 {
1470 m_reporter->Report( wxString::Format( _( "Documentation Symbol '%s' refers to symbol "
1471 "definition ID '%s' which does not exist in "
1472 "the library. The symbol was not loaded." ),
1473 docSym.ID,
1474 docSym.SymdefID ),
1476 continue;
1477 }
1478
1479 SYMDEF_SCM docSymDef = Library.SymbolDefinitions.at( docSym.SymdefID );
1480 VECTOR2I moveVector = getKiCadPoint( docSym.Origin ) - getKiCadPoint( docSymDef.Origin );
1481 EDA_ANGLE rotationAngle = getAngle( docSym.OrientAngle );
1482 double scalingFactor = (double) docSym.ScaleRatioNumerator
1483 / (double) docSym.ScaleRatioDenominator;
1484 VECTOR2I centreOfTransform = getKiCadPoint( docSymDef.Origin );
1485 bool mirrorInvert = docSym.Mirror;
1486
1487 for( std::pair<FIGURE_ID, FIGURE> figPair : docSymDef.Figures )
1488 {
1489 FIGURE fig = figPair.second;
1490
1491 loadFigure( fig, docSym.LayerID, LAYER_NOTES, moveVector, rotationAngle, scalingFactor,
1492 centreOfTransform, mirrorInvert );
1493 }
1494
1495 for( std::pair<TEXT_ID, TEXT> textPair : docSymDef.Texts )
1496 {
1497 TEXT txt = textPair.second;
1498
1499 txt.Mirror = ( txt.Mirror ) ? !mirrorInvert : mirrorInvert;
1500 txt.OrientAngle = docSym.OrientAngle - txt.OrientAngle;
1501
1502 SCH_TEXT* kiTxt = getKiCadSchText( txt );
1503
1504 VECTOR2I newPosition = applyTransform( kiTxt->GetPosition(), moveVector, rotationAngle,
1505 scalingFactor, centreOfTransform, mirrorInvert );
1506
1507 int newTxtWidth = KiROUND( kiTxt->GetTextWidth() * scalingFactor );
1508 int newTxtHeight = KiROUND( kiTxt->GetTextHeight() * scalingFactor );
1509 int newTxtThickness = KiROUND( kiTxt->GetTextThickness() * scalingFactor );
1510
1511 kiTxt->SetPosition( newPosition );
1512 kiTxt->SetTextWidth( newTxtWidth );
1513 kiTxt->SetTextHeight( newTxtHeight );
1514 kiTxt->SetTextThickness( newTxtThickness );
1515
1516 loadItemOntoKiCadSheet( docSym.LayerID, kiTxt );
1517 }
1518 }
1519}
1520
1521
1523{
1524 auto findAndReplaceTextField =
1525 [&]( TEXT_FIELD_NAME aField, wxString aValue )
1526 {
1527 if( m_context.TextFieldToValuesMap.find( aField ) != m_context.TextFieldToValuesMap.end() )
1528 {
1529 if( m_context.TextFieldToValuesMap.at( aField ) != aValue )
1530 {
1531 m_context.TextFieldToValuesMap.at( aField ) = aValue;
1532 m_context.InconsistentTextFields.insert( aField );
1533 return false;
1534 }
1535 }
1536 else
1537 {
1538 m_context.TextFieldToValuesMap.insert( { aField, aValue } );
1539 }
1540
1541 return true;
1542 };
1543
1544 PROJECT* pj = &m_schematic->Prj();
1545
1546 if( pj )
1547 {
1548 std::map<wxString, wxString>& txtVars = pj->GetTextVars();
1549
1550 // Most of the design text fields can be derived from other elements
1551 if( Schematic.VariantHierarchy.Variants.size() > 0 )
1552 {
1553 VARIANT loadedVar = Schematic.VariantHierarchy.Variants.begin()->second;
1554
1555 findAndReplaceTextField( TEXT_FIELD_NAME::VARIANT_NAME, loadedVar.Name );
1556 findAndReplaceTextField( TEXT_FIELD_NAME::VARIANT_DESCRIPTION, loadedVar.Description );
1557 }
1558
1559 findAndReplaceTextField( TEXT_FIELD_NAME::DESIGN_TITLE, Header.JobTitle );
1560
1561 for( std::pair<TEXT_FIELD_NAME, wxString> txtvalue : m_context.TextFieldToValuesMap )
1562 {
1563 wxString varName = CADSTAR_TO_KICAD_FIELDS.at( txtvalue.first );
1564 wxString varValue = txtvalue.second;
1565
1566 txtVars.insert( { varName, varValue } );
1567 }
1568
1569 for( std::pair<wxString, wxString> txtvalue : m_context.FilenamesToTextMap )
1570 {
1571 wxString varName = txtvalue.first;
1572 wxString varValue = txtvalue.second;
1573
1574 txtVars.insert( { varName, varValue } );
1575 }
1576 }
1577 else
1578 {
1579 m_reporter->Report( _( "Text Variables could not be set as there is no project attached." ),
1581 }
1582}
1583
1584
1585SCH_FIELD*
1587 std::unique_ptr<LIB_SYMBOL>& aKiCadSymbol )
1588{
1589 // First Check if field already exists
1590 if( SCH_FIELD* existingField = aKiCadSymbol->GetField( aFieldName ) )
1591 return existingField;
1592
1593 SCH_FIELD* newfield = new SCH_FIELD( aKiCadSymbol.get(), FIELD_T::USER, aFieldName );
1594 newfield->SetVisible( false );
1595 aKiCadSymbol->AddField( newfield );
1596 /*
1597 @todo we should load that a field is a URL by checking if it starts with "Link"
1598 e.g.:
1599 if( aFieldName.Lower().StartsWith( "link" ) )
1600 newfield->SetAsURL*/
1601
1602 return newfield;
1603}
1604
1605
1607{
1608 wxCHECK( Library.SymbolDefinitions.find( aSymdefID ) != Library.SymbolDefinitions.end(), nullptr );
1609
1610 if( m_symDefMap.count( aSymdefID ) )
1611 return m_symDefMap.at( aSymdefID ).get(); // return a non-owning ptr
1612
1613 SYMDEF_SCM csSym = Library.SymbolDefinitions.at( aSymdefID );
1614 std::unique_ptr<LIB_SYMBOL> kiSym = std::make_unique<LIB_SYMBOL>( csSym.BuildLibName() );
1615 const int gateNumber = 1; // Always load to gate "A" - we will change the unit later
1616
1617 // Load Graphical Figures
1618 for( std::pair<FIGURE_ID, FIGURE> figPair : csSym.Figures )
1619 {
1620 FIGURE fig = figPair.second;
1621 int lineThickness = getLineThickness( fig.LineCodeID );
1622 LINE_STYLE linestyle = getLineStyle( fig.LineCodeID );
1623
1624 if( fig.Shape.Type == SHAPE_TYPE::OPENSHAPE )
1625 {
1626 loadLibrarySymbolShapeVertices( fig.Shape.Vertices, csSym.Origin, kiSym.get(),
1627 gateNumber,
1628 lineThickness );
1629 }
1630 else
1631 {
1632 SCH_SHAPE* shape = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
1633
1635 [&]( const VECTOR2I& aPt )
1636 {
1637 return getKiCadLibraryPoint( aPt, csSym.Origin );
1638 },
1639 ARC_ACCURACY ) );
1640
1641 shape->SetUnit( gateNumber );
1642
1643 shape->SetStroke( STROKE_PARAMS( lineThickness, linestyle ) );
1644
1645 if( fig.Shape.Type == SHAPE_TYPE::SOLID )
1646 shape->SetFillMode( FILL_T::FILLED_SHAPE );
1647 else if( fig.Shape.Type == SHAPE_TYPE::OUTLINE )
1648 shape->SetFillMode( FILL_T::NO_FILL );
1649 else if( fig.Shape.Type == SHAPE_TYPE::HATCHED ) // We don't have an equivalent
1650 shape->SetFillMode( FILL_T::FILLED_WITH_BG_BODYCOLOR );
1651
1652 kiSym->AddDrawItem( shape );
1653 }
1654 }
1655
1656 PINNUM_TO_TERMINAL_MAP pinNumToTerminals;
1657
1658 // Load Pins
1659 for( std::pair<TERMINAL_ID, TERMINAL> termPair : csSym.Terminals )
1660 {
1661 TERMINAL term = termPair.second;
1662 wxString pinNum = wxString::Format( "%ld", term.ID );
1663 wxString pinName = wxEmptyString;
1664 std::unique_ptr<SCH_PIN> pin = std::make_unique<SCH_PIN>( kiSym.get() );
1665
1666 // Assume passive pin for now (we will set it later once we load the parts)
1667 pin->SetType( ELECTRICAL_PINTYPE::PT_PASSIVE );
1668
1669 pin->SetPosition( getKiCadLibraryPoint( term.Position, csSym.Origin ) );
1670 pin->SetLength( 0 ); //CADSTAR Pins are just a point (have no length)
1671 pin->SetShape( GRAPHIC_PINSHAPE::LINE );
1672 pin->SetUnit( gateNumber );
1673 pin->SetNumber( pinNum );
1674 pin->SetName( pinName );
1675
1676 // TC0 is the default CADSTAR text size for name/number if none specified
1677 int pinNumberHeight = getTextHeightFromTextCode( wxT( "TC0" ) );
1678 int pinNameHeight = getTextHeightFromTextCode( wxT( "TC0" ) );
1679
1680 if( csSym.PinNumberLocations.count( term.ID ) )
1681 {
1682 PIN_NUM_LABEL_LOC pinNumLocation = csSym.PinNumberLocations.at( term.ID );
1683 pinNumberHeight = getTextHeightFromTextCode( pinNumLocation.TextCodeID );
1684 }
1685
1686 if( csSym.PinLabelLocations.count( term.ID ) )
1687 {
1688 PIN_NUM_LABEL_LOC pinNameLocation = csSym.PinLabelLocations.at( term.ID );
1689 pinNameHeight = getTextHeightFromTextCode( pinNameLocation.TextCodeID );
1690 }
1691
1692 pin->SetNumberTextSize( pinNumberHeight );
1693 pin->SetNameTextSize( pinNameHeight );
1694
1695 pinNumToTerminals.insert( { pin->GetNumber(), term.ID } );
1696 kiSym->AddDrawItem( pin.release() );
1697 }
1698
1699 m_symDefTerminalsMap.insert( { aSymdefID, pinNumToTerminals } );
1700 fixUpLibraryPins( kiSym.get(), gateNumber );
1701
1702
1703 // Load Text items
1704 for( std::pair<TEXT_ID, TEXT> textPair : csSym.Texts )
1705 {
1706 TEXT csText = textPair.second;
1707 VECTOR2I pos = getKiCadLibraryPoint( csText.Position, csSym.Origin );
1708 auto libtext = std::make_unique<SCH_TEXT>( pos, csText.Text, LAYER_DEVICE );
1709
1710 libtext->SetUnit( gateNumber );
1711 libtext->SetPosition( getKiCadLibraryPoint( csText.Position, csSym.Origin ) );
1712 libtext->SetMultilineAllowed( true ); // temporarily so that we calculate bbox correctly
1713
1714 applyTextSettings( libtext.get(), csText.TextCodeID, csText.Alignment, csText.Justification,
1715 csText.OrientAngle, csText.Mirror );
1716
1717 // Split out multi line text items into individual text elements
1718 if( csText.Text.Contains( "\n" ) )
1719 {
1720 wxArrayString strings;
1721 wxStringSplit( csText.Text, strings, '\n' );
1722 wxPoint firstLinePos;
1723
1724 for( size_t ii = 0; ii < strings.size(); ++ii )
1725 {
1726 BOX2I bbox = libtext->GetTextBox( ii );
1727 VECTOR2I linePos = { bbox.GetLeft(), -bbox.GetBottom() };
1728
1729 RotatePoint( linePos, libtext->GetTextPos(), -libtext->GetTextAngle() );
1730
1731 SCH_TEXT* textLine = static_cast<SCH_TEXT*>( libtext->Duplicate( IGNORE_PARENT_GROUP ) );
1732 textLine->SetText( strings[ii] );
1735 textLine->SetTextPos( linePos );
1736
1737 // Multiline text not allowed in LIB_TEXT
1738 textLine->SetMultilineAllowed( false );
1739 kiSym->AddDrawItem( textLine );
1740 }
1741 }
1742 else
1743 {
1744 // Multiline text not allowed in LIB_TEXT
1745 libtext->SetMultilineAllowed( false );
1746 kiSym->AddDrawItem( libtext.release() );
1747 }
1748 }
1749
1750 // CADSTAR uses TC1 when fields don't have explicit text/attribute location
1751 static const TEXTCODE_ID defaultTextCode = "TC1";
1752
1753 // Load field locations (Attributes in CADSTAR)
1754
1755 // Symbol name (e.g. R1)
1756 if( csSym.TextLocations.count( SYMBOL_NAME_ATTRID ) )
1757 {
1758 TEXT_LOCATION& textLoc = csSym.TextLocations.at( SYMBOL_NAME_ATTRID );
1759 applyToLibraryFieldAttribute( textLoc, csSym.Origin, &kiSym->GetReferenceField() );
1760 }
1761 else
1762 {
1763 applyTextCodeIfExists( &kiSym->GetReferenceField(), defaultTextCode );
1764 }
1765
1766 // Always add the part name field (even if it doesn't have a specific location defined)
1767 SCH_FIELD* partField = addNewFieldToSymbol( PartNameFieldName, kiSym );
1768 wxCHECK( partField, nullptr );
1769 wxASSERT( partField->GetName() == PartNameFieldName );
1770
1771 if( csSym.TextLocations.count( PART_NAME_ATTRID ) )
1772 {
1773 TEXT_LOCATION& textLoc = csSym.TextLocations.at( PART_NAME_ATTRID );
1774 applyToLibraryFieldAttribute( textLoc, csSym.Origin, partField );
1775 }
1776 else
1777 {
1778 applyTextCodeIfExists( partField, defaultTextCode );
1779 }
1780
1782
1783
1784 for( auto& [attributeId, textLocation] : csSym.TextLocations )
1785 {
1786 if( attributeId == PART_NAME_ATTRID || attributeId == SYMBOL_NAME_ATTRID
1787 || attributeId == SIGNALNAME_ORIGIN_ATTRID || attributeId == LINK_ORIGIN_ATTRID )
1788 {
1789 continue;
1790 }
1791
1792 wxString attributeName = getAttributeName( attributeId );
1793 SCH_FIELD* field = addNewFieldToSymbol( attributeName, kiSym );
1794 applyToLibraryFieldAttribute( textLocation, csSym.Origin, field );
1795 }
1796
1797
1798 for( auto& [attributeId, attrValue] : csSym.AttributeValues )
1799 {
1800 if( attributeId == PART_NAME_ATTRID || attributeId == SYMBOL_NAME_ATTRID
1801 || attributeId == SIGNALNAME_ORIGIN_ATTRID || attributeId == LINK_ORIGIN_ATTRID )
1802 {
1803 continue;
1804 }
1805
1806 wxString attributeName = getAttributeName( attributeId );
1807 SCH_FIELD* field = addNewFieldToSymbol( attributeName, kiSym );
1808
1809 if( attrValue.HasLocation )
1810 applyToLibraryFieldAttribute( attrValue.AttributeLocation, csSym.Origin, field );
1811 else
1812 applyTextCodeIfExists( field, defaultTextCode );
1813 }
1814
1815
1816 m_symDefMap.insert( { aSymdefID, std::move( kiSym ) } );
1817
1818 return m_symDefMap.at( aSymdefID ).get(); // return a non-owning ptr
1819}
1820
1821
1823 const PART& aCadstarPart,
1824 const GATE_ID& aGateID,
1825 LIB_SYMBOL* aSymbol )
1826{
1827 wxCHECK( Library.SymbolDefinitions.find( aSymdefID ) != Library.SymbolDefinitions.end(), /*void*/ );
1828
1829 std::unique_ptr<LIB_SYMBOL> kiSymDef( loadSymdef( aSymdefID )->Duplicate() );
1830 wxCHECK( kiSymDef, /*void*/ );
1831
1832 //todo: need to use unique_ptr more. For now just create it here and release at end of function
1833 std::unique_ptr<LIB_SYMBOL> tempSymbol( aSymbol );
1834
1835 // Update the pin numbers to match those defined in the Cadstar part
1836 TERMINAL_TO_PINNUM_MAP pinNumMap;
1837
1838 for( auto&& [storedPinNum, termID] : m_symDefTerminalsMap[aSymdefID] )
1839 {
1840 PART::DEFINITION::PIN csPin = getPartDefinitionPin( aCadstarPart, aGateID, termID );
1841 SCH_PIN* pin = kiSymDef->GetPin( storedPinNum );
1842
1843 wxString pinName = HandleTextOverbar( csPin.Label );
1844 wxString pinNum = HandleTextOverbar( csPin.Name );
1845
1846 if( pinNum.IsEmpty() )
1847 {
1848 if( !csPin.Identifier.IsEmpty() )
1849 pinNum = csPin.Identifier;
1850 else if( csPin.ID == UNDEFINED_VALUE )
1851 pinNum = wxString::Format( "%ld", termID );
1852 else
1853 pinNum = wxString::Format( "%ld", csPin.ID );
1854 }
1855
1856 pin->SetType( getKiCadPinType( csPin.Type ) );
1857 pin->SetNumber( pinNum );
1858 pin->SetName( pinName );
1859
1860 pinNumMap.insert( { termID, pinNum } );
1861 }
1862
1863 m_pinNumsMap.insert( { aCadstarPart.ID + aGateID, pinNumMap } );
1864
1865 // COPY ITEMS
1866 int gateNumber = getKiCadUnitNumberFromGate( aGateID );
1867 copySymbolItems( kiSymDef, tempSymbol, gateNumber );
1868
1869 // Hide the value field for now (it might get unhidden if an attribute exists in the cadstar
1870 // design with the text "Value"
1871 tempSymbol->GetValueField().SetVisible( false );
1872
1873
1874 if( SCH_FIELD* partNameField = tempSymbol->GetField( PartNameFieldName ) )
1875 partNameField->SetText( EscapeFieldText( aCadstarPart.Name ) );
1876
1877 const POINT& symDefOrigin = Library.SymbolDefinitions.at( aSymdefID ).Origin;
1878 wxString footprintRefName = wxEmptyString;
1879 wxString footprintAlternateName = wxEmptyString;
1880
1881 auto loadLibraryField = [&]( const ATTRIBUTE_VALUE& aAttributeVal )
1882 {
1883 wxString attrName = getAttributeName( aAttributeVal.AttributeID );
1884
1885 // Remove invalid field characters
1886 wxString attributeValue = aAttributeVal.Value;
1887 attributeValue.Replace( wxT( "\n" ), wxT( "\\n" ) );
1888 attributeValue.Replace( wxT( "\r" ), wxT( "\\r" ) );
1889 attributeValue.Replace( wxT( "\t" ), wxT( "\\t" ) );
1890
1891 //TODO: Handle "links": In cadstar a field can be a "link" if its name starts
1892 // with the characters "Link ". Need to figure out how to convert them to
1893 // equivalent in KiCad.
1894
1895 if( attrName == wxT( "(PartDefinitionNameStem)" ) )
1896 {
1897 //Space not allowed in Reference field
1898 attributeValue.Replace( wxT( " " ), "_" );
1899 tempSymbol->GetReferenceField().SetText( attributeValue );
1900 return;
1901 }
1902 else if( attrName == wxT( "(PartDescription)" ) )
1903 {
1904 tempSymbol->SetDescription( attributeValue );
1905 return;
1906 }
1907 else if( attrName == wxT( "(PartDefinitionReferenceName)" ) )
1908 {
1909 footprintRefName = attributeValue;
1910 return;
1911 }
1912 else if( attrName == wxT( "(PartDefinitionAlternateName)" ) )
1913 {
1914 footprintAlternateName = attributeValue;
1915 return;
1916 }
1917
1918 bool attrIsNew = tempSymbol->GetField( attrName ) == nullptr;
1919 SCH_FIELD* attrField = addNewFieldToSymbol( attrName, tempSymbol );
1920
1921 wxASSERT( attrField->GetName() == attrName );
1922 attrField->SetText( aAttributeVal.Value );
1923 attrField->SetUnit( gateNumber );
1924
1925 const ATTRIBUTE_ID& attrid = aAttributeVal.AttributeID;
1926 attrField->SetVisible( isAttributeVisible( attrid ) );
1927
1928 if( aAttributeVal.HasLocation )
1929 {
1930 // Check if the part itself defined a location for the field
1931 applyToLibraryFieldAttribute( aAttributeVal.AttributeLocation, symDefOrigin,
1932 attrField );
1933 }
1934 else if( attrIsNew )
1935 {
1936 attrField->SetVisible( false );
1937 applyTextSettings( attrField, wxT( "TC1" ), ALIGNMENT::NO_ALIGNMENT,
1938 JUSTIFICATION::LEFT, false, true );
1939 }
1940 };
1941
1942 // Load all attributes in the Part Definition
1943 for( auto& [attrId, attrVal] : aCadstarPart.Definition.AttributeValues )
1944 loadLibraryField( attrVal );
1945
1946 // Load all attributes in the Part itself.
1947 for( auto& [attrId, attrVal] : aCadstarPart.AttributeValues )
1948 loadLibraryField( attrVal );
1949
1950 setFootprintOnSymbol( tempSymbol, footprintRefName, footprintAlternateName );
1951
1952 if( aCadstarPart.Definition.HidePinNames )
1953 {
1954 tempSymbol->SetShowPinNames( false );
1955 tempSymbol->SetShowPinNumbers( false );
1956 }
1957
1958 // Update aSymbol just to keep lint happy.
1959 aSymbol = tempSymbol.release();
1960}
1961
1962
1963void CADSTAR_SCH_ARCHIVE_LOADER::setFootprintOnSymbol( std::unique_ptr<LIB_SYMBOL>& aKiCadSymbol,
1964 const wxString& aFootprintName,
1965 const wxString& aFootprintAlternate )
1966{
1967 wxString fpNameInLibrary = generateLibName( aFootprintName, aFootprintAlternate );
1968
1969 if( !fpNameInLibrary.IsEmpty() )
1970 {
1971 wxArrayString fpFilters;
1972 fpFilters.Add( aFootprintName ); // In cadstar one footprint has several "alternates"
1973
1974 if( !aFootprintAlternate.IsEmpty() )
1975 fpFilters.Add( fpNameInLibrary );
1976
1977 aKiCadSymbol->SetFPFilters( fpFilters );
1978
1979 LIB_ID libID( m_footprintLibName, fpNameInLibrary );
1980 aKiCadSymbol->GetFootprintField().SetText( libID.Format() );
1981 }
1982}
1983
1984
1985void CADSTAR_SCH_ARCHIVE_LOADER::loadLibrarySymbolShapeVertices( const std::vector<VERTEX>& aCadstarVertices,
1986 const VECTOR2I& aSymbolOrigin,
1987 LIB_SYMBOL* aSymbol,
1988 int aGateNumber,
1989 int aLineThickness )
1990{
1991 const VERTEX* prev = &aCadstarVertices.at( 0 );
1992 const VERTEX* cur;
1993
1994 wxASSERT_MSG( prev->Type == VERTEX_TYPE::POINT, "First vertex should always be a point." );
1995
1996 for( size_t i = 1; i < aCadstarVertices.size(); i++ )
1997 {
1998 cur = &aCadstarVertices.at( i );
1999
2000 SCH_SHAPE* shape = nullptr;
2001 bool cw = false;
2002 VECTOR2I startPoint = getKiCadLibraryPoint( prev->End, aSymbolOrigin );
2003 VECTOR2I endPoint = getKiCadLibraryPoint( cur->End, aSymbolOrigin );
2004 VECTOR2I centerPoint;
2005
2008 {
2009 centerPoint = ( startPoint + endPoint ) / 2;
2010 }
2011 else
2012 {
2013 centerPoint = getKiCadLibraryPoint( cur->Center, aSymbolOrigin );
2014 }
2015
2016
2017 switch( cur->Type )
2018 {
2019 case VERTEX_TYPE::POINT:
2020 shape = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
2021 shape->AddPoint( startPoint );
2022 shape->AddPoint( endPoint );
2023 break;
2024
2027 cw = true;
2029
2032 shape = new SCH_SHAPE( SHAPE_T::ARC, LAYER_DEVICE );
2033
2034 shape->SetPosition( centerPoint );
2035
2036 if( cw )
2037 {
2038 shape->SetStart( endPoint );
2039 shape->SetEnd( startPoint );
2040 }
2041 else
2042 {
2043 shape->SetStart( startPoint );
2044 shape->SetEnd( endPoint );
2045 }
2046
2047 break;
2048 }
2049
2050 shape->SetUnit( aGateNumber );
2051 shape->SetStroke( STROKE_PARAMS( aLineThickness, LINE_STYLE::SOLID ) );
2052 aSymbol->AddDrawItem( shape, false );
2053
2054 prev = cur;
2055 }
2056
2057 aSymbol->GetDrawItems().sort();
2058}
2059
2060
2062 const VECTOR2I& aSymbolOrigin,
2063 SCH_FIELD* aKiCadField )
2064{
2065 aKiCadField->SetTextPos( getKiCadLibraryPoint( aCadstarAttrLoc.Position, aSymbolOrigin ) );
2066
2067 applyTextSettings( aKiCadField, aCadstarAttrLoc.TextCodeID, aCadstarAttrLoc.Alignment,
2068 aCadstarAttrLoc.Justification, aCadstarAttrLoc.OrientAngle,
2069 aCadstarAttrLoc.Mirror );
2070}
2071
2072
2074 const LIB_SYMBOL& aKiCadPart,
2075 EDA_ANGLE& aComponentOrientation )
2076{
2077 wxString libName = CreateLibName( m_footprintLibName, m_rootSheet );
2078
2079 LIB_ID libId;
2080 libId.SetLibItemName( aKiCadPart.GetName() );
2081 libId.SetLibNickname( libName );
2082
2083 int unit = getKiCadUnitNumberFromGate( aCadstarSymbol.GateID );
2084
2085 SCH_SHEET_PATH sheetpath;
2086 SCH_SHEET* kiSheet = m_sheetMap.at( aCadstarSymbol.LayerID );
2087 m_rootSheet->LocatePathOfScreen( kiSheet->GetScreen(), &sheetpath );
2088
2089 SCH_SYMBOL* symbol = new SCH_SYMBOL( aKiCadPart, libId, &sheetpath, unit );
2090
2091 if( aCadstarSymbol.IsComponent )
2092 symbol->SetRef( &sheetpath, aCadstarSymbol.ComponentRef.Designator );
2093
2094 symbol->SetPosition( getKiCadPoint( aCadstarSymbol.Origin ) );
2095
2096 EDA_ANGLE compAngle = getAngle( aCadstarSymbol.OrientAngle );
2097 int compOrientation = 0;
2098
2099 if( aCadstarSymbol.Mirror )
2100 {
2101 compAngle = -compAngle;
2102 compOrientation += SYMBOL_ORIENTATION_T::SYM_MIRROR_Y;
2103 }
2104
2105 compOrientation += getComponentOrientation( compAngle, aComponentOrientation );
2106 EDA_ANGLE test1( compAngle );
2107 EDA_ANGLE test2( aComponentOrientation );
2108
2109 if( test1.Normalize180() != test2.Normalize180() )
2110 {
2111 m_reporter->Report( wxString::Format( _( "Symbol '%s' is rotated by an angle of %.1f "
2112 "degrees in the original CADSTAR design but "
2113 "KiCad only supports rotation angles multiples "
2114 "of 90 degrees. The connecting wires will need "
2115 "manual fixing." ),
2116 aCadstarSymbol.ComponentRef.Designator,
2117 compAngle.AsDegrees() ),
2119 }
2120
2121 symbol->SetOrientation( compOrientation );
2122
2123 if( m_sheetMap.find( aCadstarSymbol.LayerID ) == m_sheetMap.end() )
2124 {
2125 m_reporter->Report( wxString::Format( _( "Symbol '%s' references sheet ID '%s' which does "
2126 "not exist in the design. The symbol was not "
2127 "loaded." ),
2128 aCadstarSymbol.ComponentRef.Designator,
2129 aCadstarSymbol.LayerID ),
2131
2132 delete symbol;
2133 return nullptr;
2134 }
2135
2136 wxString gate = ( aCadstarSymbol.GateID.IsEmpty() ) ? wxString( wxT( "A" ) ) : aCadstarSymbol.GateID;
2137 wxString partGateIndex = aCadstarSymbol.PartRef.RefID + gate;
2138
2139 //Handle pin swaps
2140 if( m_pinNumsMap.find( partGateIndex ) != m_pinNumsMap.end() )
2141 {
2142 TERMINAL_TO_PINNUM_MAP termNumMap = m_pinNumsMap.at( partGateIndex );
2143
2144 std::map<wxString, SCH_PIN*> pinNumToLibPinMap;
2145
2146 for( auto& term : termNumMap )
2147 {
2148 wxString pinNum = term.second;
2149 pinNumToLibPinMap.insert( { pinNum,
2150 symbol->GetLibSymbolRef()->GetPin( term.second ) } );
2151 }
2152
2153 auto replacePinNumber =
2154 [&]( wxString aOldPinNum, wxString aNewPinNum )
2155 {
2156 if( aOldPinNum == aNewPinNum )
2157 return;
2158
2159 SCH_PIN* libpin = pinNumToLibPinMap.at( aOldPinNum );
2160 libpin->SetNumber( HandleTextOverbar( aNewPinNum ) );
2161 };
2162
2163 //Older versions of Cadstar used pin numbers
2164 for( auto& pinPair : aCadstarSymbol.PinNumbers )
2165 {
2166 SYMBOL::PIN_NUM pin = pinPair.second;
2167
2168 replacePinNumber( termNumMap.at( pin.TerminalID ),
2169 wxString::Format( "%ld", pin.PinNum ) );
2170 }
2171
2172 //Newer versions of Cadstar use pin names
2173 for( auto& pinPair : aCadstarSymbol.PinNames )
2174 {
2175 SYMPINNAME_LABEL pin = pinPair.second;
2176 replacePinNumber( termNumMap.at( pin.TerminalID ), pin.NameOrLabel );
2177 }
2178
2179 symbol->UpdatePins();
2180 }
2181
2182 kiSheet->GetScreen()->Append( symbol );
2183
2184 return symbol;
2185}
2186
2187
2189 const EDA_ANGLE& aComponentOrientation,
2190 bool aIsMirrored,
2191 SCH_FIELD* aKiCadField )
2192{
2193 aKiCadField->SetPosition( getKiCadPoint( aCadstarAttrLoc.Position ) );
2194 aKiCadField->SetVisible( true );
2195
2196 ALIGNMENT alignment = aCadstarAttrLoc.Alignment;
2197 EDA_ANGLE textAngle = getAngle( aCadstarAttrLoc.OrientAngle );
2198
2199 if( aIsMirrored )
2200 {
2201 // We need to change the aligment when the symbol is mirrored based on the text orientation
2202 // To ensure the anchor point is the same in KiCad.
2203
2204 int textIsVertical = KiROUND( textAngle.AsDegrees() / 90.0 ) % 2;
2205
2206 if( textIsVertical )
2207 alignment = rotate180( alignment );
2208
2209 alignment = mirrorX( alignment );
2210 }
2211
2212 applyTextSettings( aKiCadField, aCadstarAttrLoc.TextCodeID, alignment,
2213 aCadstarAttrLoc.Justification,
2214 getCadstarAngle( textAngle - aComponentOrientation ),
2215 aCadstarAttrLoc.Mirror );
2216}
2217
2218
2220 EDA_ANGLE& aReturnedOrientation )
2221{
2222 int compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_0;
2223
2224 EDA_ANGLE oDeg = aOrientAngle;
2225 oDeg.Normalize180();
2226
2227 if( oDeg >= -ANGLE_45 && oDeg <= ANGLE_45 )
2228 {
2229 compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_0;
2230 aReturnedOrientation = ANGLE_0;
2231 }
2232 else if( oDeg >= ANGLE_45 && oDeg <= ANGLE_135 )
2233 {
2234 compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_90;
2235 aReturnedOrientation = ANGLE_90;
2236 }
2237 else if( oDeg >= ANGLE_135 || oDeg <= -ANGLE_135 )
2238 {
2239 compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_180;
2240 aReturnedOrientation = ANGLE_180;
2241 }
2242 else
2243 {
2244 compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_270;
2245 aReturnedOrientation = ANGLE_270;
2246 }
2247
2248 return compOrientation;
2249}
2250
2251
2254 const NETELEMENT_ID& aNetElementID )
2255{
2256 // clang-format off
2257 auto logUnknownNetElementError =
2258 [&]()
2259 {
2260 m_reporter->Report( wxString::Format( _( "Net %s references unknown net element %s. "
2261 "The net was not properly loaded and may "
2262 "require manual fixing." ),
2263 getNetName( aNet ),
2264 aNetElementID ),
2266
2267 return POINT();
2268 };
2269 // clang-format on
2270
2271 if( aNetElementID.Contains( "J" ) ) // Junction
2272 {
2273 if( aNet.Junctions.find( aNetElementID ) == aNet.Junctions.end() )
2274 return logUnknownNetElementError();
2275
2276 return aNet.Junctions.at( aNetElementID ).Location;
2277 }
2278 else if( aNetElementID.Contains( "P" ) ) // Terminal/Pin of a symbol
2279 {
2280 if( aNet.Terminals.find( aNetElementID ) == aNet.Terminals.end() )
2281 return logUnknownNetElementError();
2282
2283 SYMBOL_ID symid = aNet.Terminals.at( aNetElementID ).SymbolID;
2284 TERMINAL_ID termid = aNet.Terminals.at( aNetElementID ).TerminalID;
2285
2286 if( Schematic.Symbols.find( symid ) == Schematic.Symbols.end() )
2287 return logUnknownNetElementError();
2288
2289 SYMBOL sym = Schematic.Symbols.at( symid );
2290 SYMDEF_ID symdefid = sym.SymdefID;
2291 VECTOR2I symbolOrigin = sym.Origin;
2292
2293 if( Library.SymbolDefinitions.find( symdefid ) == Library.SymbolDefinitions.end() )
2294 return logUnknownNetElementError();
2295
2296 VECTOR2I libpinPosition =
2297 Library.SymbolDefinitions.at( symdefid ).Terminals.at( termid ).Position;
2298 VECTOR2I libOrigin = Library.SymbolDefinitions.at( symdefid ).Origin;
2299
2300 VECTOR2I pinOffset = libpinPosition - libOrigin;
2301 pinOffset.x = ( pinOffset.x * sym.ScaleRatioNumerator ) / sym.ScaleRatioDenominator;
2302 pinOffset.y = ( pinOffset.y * sym.ScaleRatioNumerator ) / sym.ScaleRatioDenominator;
2303
2304 VECTOR2I pinPosition = symbolOrigin + pinOffset;
2305 EDA_ANGLE compAngle = getAngle( sym.OrientAngle );
2306
2307 if( sym.Mirror )
2308 pinPosition.x = ( 2 * symbolOrigin.x ) - pinPosition.x;
2309
2310 EDA_ANGLE adjustedOrientation;
2311 getComponentOrientation( compAngle, adjustedOrientation );
2312
2313 RotatePoint( pinPosition, symbolOrigin, -adjustedOrientation );
2314
2315 POINT retval;
2316 retval.x = pinPosition.x;
2317 retval.y = pinPosition.y;
2318
2319 return retval;
2320 }
2321 else if( aNetElementID.Contains( "BT" ) ) // Bus Terminal
2322 {
2323 if( aNet.BusTerminals.find( aNetElementID ) == aNet.BusTerminals.end() )
2324 return logUnknownNetElementError();
2325
2326 return aNet.BusTerminals.at( aNetElementID ).SecondPoint;
2327 }
2328 else if( aNetElementID.Contains( "BLKT" ) ) // Block Terminal (sheet hierarchy connection)
2329 {
2330 if( aNet.BlockTerminals.find( aNetElementID ) == aNet.BlockTerminals.end() )
2331 return logUnknownNetElementError();
2332
2333 BLOCK_ID blockid = aNet.BlockTerminals.at( aNetElementID ).BlockID;
2334 TERMINAL_ID termid = aNet.BlockTerminals.at( aNetElementID ).TerminalID;
2335
2336 if( Schematic.Blocks.find( blockid ) == Schematic.Blocks.end() )
2337 return logUnknownNetElementError();
2338
2339 return Schematic.Blocks.at( blockid ).Terminals.at( termid ).Position;
2340 }
2341 else if( aNetElementID.Contains( "D" ) ) // Dangler
2342 {
2343 if( aNet.Danglers.find( aNetElementID ) == aNet.Danglers.end() )
2344 return logUnknownNetElementError();
2345
2346 return aNet.Danglers.at( aNetElementID ).Position;
2347 }
2348 else
2349 {
2350 return logUnknownNetElementError();
2351 }
2352}
2353
2354
2356{
2357 wxString netname = aNet.Name;
2358
2359 if( netname.IsEmpty() )
2360 netname = wxString::Format( "$%ld", aNet.SignalNum );
2361
2362 return netname;
2363}
2364
2365
2366void CADSTAR_SCH_ARCHIVE_LOADER::loadShapeVertices( const std::vector<VERTEX>& aCadstarVertices,
2367 LINECODE_ID aCadstarLineCodeID,
2368 LAYER_ID aCadstarSheetID,
2369 SCH_LAYER_ID aKiCadSchLayerID,
2370 const VECTOR2I& aMoveVector,
2371 const EDA_ANGLE& aRotation,
2372 const double& aScalingFactor,
2373 const VECTOR2I& aTransformCentre,
2374 const bool& aMirrorInvert )
2375{
2376 int lineWidth = KiROUND( getLineThickness( aCadstarLineCodeID ) * aScalingFactor );
2377 LINE_STYLE lineStyle = getLineStyle( aCadstarLineCodeID );
2378
2379 const VERTEX* prev = &aCadstarVertices.at( 0 );
2380 const VERTEX* cur;
2381
2382 wxASSERT_MSG( prev->Type == VERTEX_TYPE::POINT,
2383 "First vertex should always be a point vertex" );
2384
2385 auto pointTransform =
2386 [&]( const VECTOR2I& aV )
2387 {
2388 return applyTransform( getKiCadPoint( aV ), aMoveVector, aRotation,
2389 aScalingFactor, aTransformCentre, aMirrorInvert );
2390 };
2391
2392 for( size_t ii = 1; ii < aCadstarVertices.size(); ii++ )
2393 {
2394 cur = &aCadstarVertices.at( ii );
2395
2396 VECTOR2I transformedStartPoint = pointTransform( prev->End );
2397 VECTOR2I transformedEndPoint = pointTransform( cur->End );
2398
2399 switch( cur->Type )
2400 {
2405 {
2406 SHAPE_ARC tempArc = cur->BuildArc( transformedStartPoint, pointTransform );
2407
2408 SCH_SHAPE* arcShape = new SCH_SHAPE( SHAPE_T::ARC, LAYER_NOTES, lineWidth );
2409 arcShape->SetArcGeometry( tempArc.GetP0(), tempArc.GetArcMid(), tempArc.GetP1() );
2410
2411 loadItemOntoKiCadSheet( aCadstarSheetID, arcShape );
2412 break;
2413 }
2414
2415 case VERTEX_TYPE::POINT:
2416 {
2417 SCH_LINE* segment = new SCH_LINE();
2418
2419 segment->SetLayer( aKiCadSchLayerID );
2420 segment->SetLineWidth( lineWidth );
2421 segment->SetLineStyle( lineStyle );
2422
2423 segment->SetStartPoint( transformedStartPoint );
2424 segment->SetEndPoint( transformedEndPoint );
2425
2426 loadItemOntoKiCadSheet( aCadstarSheetID, segment );
2427 break;
2428 }
2429
2430 default:
2431 wxFAIL_MSG( "Unknown CADSTAR Vertex type" );
2432 }
2433
2434 prev = cur;
2435 }
2436}
2437
2438
2440 const LAYER_ID& aCadstarSheetIDOverride,
2441 SCH_LAYER_ID aKiCadSchLayerID,
2442 const VECTOR2I& aMoveVector,
2443 const EDA_ANGLE& aRotation,
2444 const double& aScalingFactor,
2445 const VECTOR2I& aTransformCentre,
2446 const bool& aMirrorInvert )
2447{
2448 loadShapeVertices( aCadstarFigure.Shape.Vertices, aCadstarFigure.LineCodeID,
2449 aCadstarSheetIDOverride, aKiCadSchLayerID, aMoveVector, aRotation,
2450 aScalingFactor, aTransformCentre, aMirrorInvert );
2451
2452 for( const CUTOUT& cutout : aCadstarFigure.Shape.Cutouts )
2453 {
2454 loadShapeVertices( cutout.Vertices, aCadstarFigure.LineCodeID, aCadstarSheetIDOverride,
2455 aKiCadSchLayerID, aMoveVector, aRotation, aScalingFactor,
2456 aTransformCentre, aMirrorInvert );
2457 }
2458}
2459
2460
2462 const VECTOR2I& aPosition,
2463 const VECTOR2I& aSheetSize,
2464 const SCH_SHEET_PATH& aParentSheet )
2465{
2466 wxCHECK_MSG( m_sheetMap.find( aCadstarSheetID ) == m_sheetMap.end(), ,
2467 "Sheet already loaded!" );
2468
2469 SCH_SHEET* sheet = new SCH_SHEET(
2470 /* aParent */ aParentSheet.Last(),
2471 /* aPosition */ aPosition,
2472 /* aSize */ VECTOR2I( aSheetSize ) );
2473 SCH_SCREEN* screen = new SCH_SCREEN( m_schematic );
2474 SCH_SHEET_PATH instance( aParentSheet );
2475
2476 sheet->SetScreen( screen );
2477
2478 wxString name = Sheets.SheetNames.at( aCadstarSheetID );
2479
2480 sheet->GetField( FIELD_T::SHEET_NAME )->SetText( name );
2481
2482 int sheetNum = getSheetNumber( aCadstarSheetID );
2483 wxString loadedFilename = wxFileName( Filename ).GetName();
2484 std::string filename = wxString::Format( "%s_%02d", loadedFilename, sheetNum ).ToStdString();
2485
2486 ReplaceIllegalFileNameChars( &filename );
2487 filename += wxT( "." ) + wxString( FILEEXT::KiCadSchematicFileExtension );
2488
2489 sheet->GetField( FIELD_T::SHEET_FILENAME )->SetText( filename );
2490
2491 wxFileName fn( m_schematic->Prj().GetProjectPath() + filename );
2492 sheet->GetScreen()->SetFileName( fn.GetFullPath() );
2493 aParentSheet.Last()->GetScreen()->Append( sheet );
2494 instance.push_back( sheet );
2495
2496 wxString pageNumStr = wxString::Format( "%d", getSheetNumber( aCadstarSheetID ) );
2497 instance.SetPageNumber( pageNumStr );
2498
2499 sheet->AutoplaceFields( nullptr, AUTOPLACE_AUTO );
2500
2501 m_sheetMap.insert( { aCadstarSheetID, sheet } );
2502
2503 loadChildSheets( aCadstarSheetID, instance );
2504}
2505
2506
2508 const SCH_SHEET_PATH& aSheet )
2509{
2510 wxCHECK_MSG( m_sheetMap.find( aCadstarSheetID ) != m_sheetMap.end(), ,
2511 "FIXME! Parent sheet should be loaded before attempting to load subsheets" );
2512
2513 for( std::pair<BLOCK_ID, BLOCK> blockPair : Schematic.Blocks )
2514 {
2515 BLOCK& block = blockPair.second;
2516
2517 if( block.LayerID == aCadstarSheetID && block.Type == BLOCK::TYPE::CHILD )
2518 {
2519 if( block.AssocLayerID == wxT( "NO_LINK" ) )
2520 {
2521 if( block.Figures.size() > 0 )
2522 {
2523 m_reporter->Report( wxString::Format( _( "The block ID %s (Block name: '%s') "
2524 "is drawn on sheet '%s' but is not "
2525 "linked to another sheet in the "
2526 "design. KiCad requires all sheet "
2527 "symbols to be associated to a sheet, "
2528 "so the block was not loaded." ),
2529 block.ID, block.Name,
2530 Sheets.SheetNames.at( aCadstarSheetID ) ),
2532 }
2533
2534 continue;
2535 }
2536
2537 // In KiCad you can only draw rectangular shapes whereas in Cadstar arbitrary shapes
2538 // are allowed. We will calculate the extents of the Cadstar shape and draw a rectangle
2539
2540 std::pair<VECTOR2I, VECTOR2I> blockExtents;
2541
2542 if( block.Figures.size() > 0 )
2543 {
2544 blockExtents = getFigureExtentsKiCad( block.Figures.begin()->second );
2545 }
2546 else
2547 {
2548 THROW_IO_ERROR( wxString::Format( _( "The CADSTAR schematic might be corrupt: "
2549 "Block %s references a child sheet but has no "
2550 "Figure defined." ),
2551 block.ID ) );
2552 }
2553
2554 loadSheetAndChildSheets( block.AssocLayerID, blockExtents.first, blockExtents.second,
2555 aSheet );
2556
2557 // Hide all KiCad sheet properties (sheet name/filename is not applicable in CADSTAR)
2558 SCH_SHEET* loadedSheet = m_sheetMap.at( block.AssocLayerID );
2559 SCH_FIELDS fields = loadedSheet->GetFields();
2560
2561 for( SCH_FIELD& field : fields )
2562 {
2563 field.SetVisible( false );
2564 }
2565
2566 if( block.HasBlockLabel )
2567 {
2568 //@todo use below code when KiCad supports multi-line fields
2569 /*
2570 // Add the block label as a separate field
2571 SCH_FIELD blockNameField( getKiCadPoint( block.BlockLabel.Position ), 2,
2572 loadedSheet, wxString( "Block name" ) );
2573 blockNameField.SetText( block.Name );
2574 blockNameField.SetVisible( true );
2575
2576 applyTextSettings( &blockNameField,
2577 block.BlockLabel.TextCodeID,
2578 block.BlockLabel.Alignment,
2579 block.BlockLabel.Justification,
2580 block.BlockLabel.OrientAngle,
2581 block.BlockLabel.Mirror );
2582
2583 fields.push_back( blockNameField );*/
2584
2585 // For now as as a text item (supports multi-line properly)
2586 SCH_TEXT* kiTxt = new SCH_TEXT();
2587
2588 kiTxt->SetParent( m_schematic );
2589 kiTxt->SetPosition( getKiCadPoint( block.BlockLabel.Position ) );
2590 kiTxt->SetText( block.Name );
2591
2594 block.BlockLabel.Mirror );
2595
2596 loadItemOntoKiCadSheet( aCadstarSheetID, kiTxt );
2597 }
2598
2599 loadedSheet->SetFields( fields );
2600 }
2601 }
2602}
2603
2604
2605std::vector<CADSTAR_SCH_ARCHIVE_LOADER::LAYER_ID> CADSTAR_SCH_ARCHIVE_LOADER::findOrphanSheets()
2606{
2607 std::vector<LAYER_ID> childSheets, orphanSheets;
2608
2609 //Find all sheets that are child of another
2610 for( std::pair<BLOCK_ID, BLOCK> blockPair : Schematic.Blocks )
2611 {
2612 BLOCK& block = blockPair.second;
2613 LAYER_ID& assocSheetID = block.AssocLayerID;
2614
2615 if( block.Type == BLOCK::TYPE::CHILD )
2616 childSheets.push_back( assocSheetID );
2617 }
2618
2619 //Add sheets that do not have a parent
2620 for( const LAYER_ID& sheetID : Sheets.SheetOrder )
2621 {
2622 if( std::find( childSheets.begin(), childSheets.end(), sheetID ) == childSheets.end() )
2623 orphanSheets.push_back( sheetID );
2624 }
2625
2626 return orphanSheets;
2627}
2628
2629
2631{
2632 int i = 1;
2633
2634 for( const LAYER_ID& sheetID : Sheets.SheetOrder )
2635 {
2636 if( sheetID == aCadstarSheetID )
2637 return i;
2638
2639 ++i;
2640 }
2641
2642 return -1;
2643}
2644
2645
2647 SCH_ITEM* aItem )
2648{
2649 wxCHECK_MSG( aItem, /*void*/, wxT( "aItem is null" ) );
2650
2651 if( aCadstarSheetID == "ALL_SHEETS" )
2652 {
2653 SCH_ITEM* duplicateItem = nullptr;
2654
2655 for( std::pair<LAYER_ID, SHEET_NAME> sheetPair : Sheets.SheetNames )
2656 {
2657 LAYER_ID sheetID = sheetPair.first;
2658 duplicateItem = aItem->Duplicate( IGNORE_PARENT_GROUP );
2659 m_sheetMap.at( sheetID )->GetScreen()->Append( aItem->Duplicate( IGNORE_PARENT_GROUP ) );
2660 }
2661
2662 //Get rid of the extra copy:
2663 delete aItem;
2664 aItem = duplicateItem;
2665 }
2666 else if( aCadstarSheetID == "NO_SHEET" )
2667 {
2668 wxFAIL_MSG( wxT( "Trying to add an item to NO_SHEET? This might be a documentation symbol." ) );
2669 }
2670 else
2671 {
2672 if( m_sheetMap.find( aCadstarSheetID ) != m_sheetMap.end() )
2673 {
2674 m_sheetMap.at( aCadstarSheetID )->GetScreen()->Append( aItem );
2675 }
2676 else
2677 {
2678 delete aItem;
2679 wxFAIL_MSG( wxT( "Unknown Sheet ID." ) );
2680 }
2681 }
2682}
2683
2684
2687 const wxString& aSymDefAlternate )
2688{
2689 if( m_SymDefNamesCache.size() != Library.SymbolDefinitions.size() )
2690 {
2691 // Re-initialise
2692 m_SymDefNamesCache.clear();
2694
2695 // Create a lower case cache to avoid searching each time
2696 for( auto& [id, symdef] : Library.SymbolDefinitions )
2697 {
2698 wxString refKey = symdef.ReferenceName.Lower();
2699 wxString altKey = symdef.Alternate.Lower();
2700
2701 m_SymDefNamesCache[{ refKey, altKey }] = id;
2702
2703 // Secondary cache to find symbols just by the Name (e.g. if the alternate
2704 // does not exist, we still want to return a symbo - the same behaviour
2705 // as CADSTAR
2706
2707 if( !m_DefaultSymDefNamesCache.count( refKey ) )
2708 {
2709 m_DefaultSymDefNamesCache.insert( { refKey, id } );
2710 }
2711 else if( altKey.IsEmpty() )
2712 {
2713 // Always use the empty alternate if it exists
2714 m_DefaultSymDefNamesCache[refKey] = id;
2715 }
2716 }
2717 }
2718
2719 wxString refKeyToFind = aSymdefName.Lower();
2720 wxString altKeyToFind = aSymDefAlternate.Lower();
2721
2722 if( m_SymDefNamesCache.count( { refKeyToFind, altKeyToFind } ) )
2723 {
2724 return m_SymDefNamesCache[{ refKeyToFind, altKeyToFind }];
2725 }
2726 else if( m_DefaultSymDefNamesCache.count( refKeyToFind ) )
2727 {
2728 return m_DefaultSymDefNamesCache[refKeyToFind];
2729 }
2730
2731 return SYMDEF_ID();
2732}
2733
2734
2736{
2737 // Use CADSTAR visibility settings to determine if an attribute is visible
2738 if( AttrColors.AttributeColors.find( aCadstarAttributeID ) != AttrColors.AttributeColors.end() )
2739 return AttrColors.AttributeColors.at( aCadstarAttributeID ).IsVisible;
2740
2741 return false; // If there is no visibility setting, assume not displayed
2742}
2743
2744
2746{
2747 wxCHECK( Assignments.Codedefs.LineCodes.find( aCadstarLineCodeID )
2750
2751 return getKiCadLength( Assignments.Codedefs.LineCodes.at( aCadstarLineCodeID ).Width );
2752}
2753
2754
2756{
2757 wxCHECK( Assignments.Codedefs.LineCodes.find( aCadstarLineCodeID )
2759 LINE_STYLE::SOLID );
2760
2761 // clang-format off
2762 switch( Assignments.Codedefs.LineCodes.at( aCadstarLineCodeID ).Style )
2763 {
2764 case LINESTYLE::DASH: return LINE_STYLE::DASH;
2765 case LINESTYLE::DASHDOT: return LINE_STYLE::DASHDOT;
2766 case LINESTYLE::DASHDOTDOT: return LINE_STYLE::DASHDOT; //TODO: update in future
2767 case LINESTYLE::DOT: return LINE_STYLE::DOT;
2768 case LINESTYLE::SOLID: return LINE_STYLE::SOLID;
2769 default: return LINE_STYLE::DEFAULT;
2770 }
2771 // clang-format on
2772}
2773
2774
2777{
2778 wxCHECK( Assignments.Codedefs.TextCodes.find( aCadstarTextCodeID )
2780 TEXTCODE() );
2781
2782 return Assignments.Codedefs.TextCodes.at( aCadstarTextCodeID );
2783}
2784
2785
2787{
2788 TEXTCODE txtCode = getTextCode( aCadstarTextCodeID );
2789
2790 return KiROUND( (double) getKiCadLength( txtCode.Height ) * TXT_HEIGHT_RATIO );
2791}
2792
2793
2795{
2796 wxCHECK( Assignments.Codedefs.AttributeNames.find( aCadstarAttributeID )
2798 aCadstarAttributeID );
2799
2800 return Assignments.Codedefs.AttributeNames.at( aCadstarAttributeID ).Name;
2801}
2802
2803
2806{
2807 wxCHECK( Parts.PartDefinitions.find( aCadstarPartID ) != Parts.PartDefinitions.end(), PART() );
2808
2809 return Parts.PartDefinitions.at( aCadstarPartID );
2810}
2811
2812
2815{
2816 wxCHECK( Assignments.Codedefs.RouteCodes.find( aCadstarRouteCodeID )
2818 ROUTECODE() );
2819
2820 return Assignments.Codedefs.RouteCodes.at( aCadstarRouteCodeID );
2821}
2822
2823
2824CADSTAR_SCH_ARCHIVE_LOADER::PART::DEFINITION::PIN
2826 const TERMINAL_ID& aTerminalID )
2827{
2828 for( std::pair<PART_DEFINITION_PIN_ID, PART::DEFINITION::PIN> pinPair :
2829 aCadstarPart.Definition.Pins )
2830 {
2831 PART::DEFINITION::PIN partPin = pinPair.second;
2832
2833 if( partPin.TerminalGate == aGateID && partPin.TerminalPin == aTerminalID )
2834 return partPin;
2835 }
2836
2837 return PART::DEFINITION::PIN();
2838}
2839
2840
2842{
2843 switch( aPinType )
2844 {
2845 case CADSTAR_PIN_TYPE::UNCOMMITTED: return ELECTRICAL_PINTYPE::PT_PASSIVE;
2846 case CADSTAR_PIN_TYPE::INPUT: return ELECTRICAL_PINTYPE::PT_INPUT;
2847 case CADSTAR_PIN_TYPE::OUTPUT_OR: return ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR;
2848 case CADSTAR_PIN_TYPE::OUTPUT_NOT_OR: return ELECTRICAL_PINTYPE::PT_OUTPUT;
2849 case CADSTAR_PIN_TYPE::OUTPUT_NOT_NORM_OR: return ELECTRICAL_PINTYPE::PT_OUTPUT;
2850 case CADSTAR_PIN_TYPE::POWER: return ELECTRICAL_PINTYPE::PT_POWER_IN;
2851 case CADSTAR_PIN_TYPE::GROUND: return ELECTRICAL_PINTYPE::PT_POWER_IN;
2852 case CADSTAR_PIN_TYPE::TRISTATE_BIDIR: return ELECTRICAL_PINTYPE::PT_BIDI;
2853 case CADSTAR_PIN_TYPE::TRISTATE_INPUT: return ELECTRICAL_PINTYPE::PT_INPUT;
2854 case CADSTAR_PIN_TYPE::TRISTATE_DRIVER: return ELECTRICAL_PINTYPE::PT_OUTPUT;
2855 }
2856
2857 return ELECTRICAL_PINTYPE::PT_UNSPECIFIED;
2858}
2859
2861{
2862 if( aCadstarGateID.IsEmpty() )
2863 return 1;
2864
2865 return (int) aCadstarGateID.Upper().GetChar( 0 ) - (int) wxUniChar( 'A' ) + 1;
2866}
2867
2868
2869SPIN_STYLE CADSTAR_SCH_ARCHIVE_LOADER::getSpinStyle( const long long& aCadstarOrientation,
2870 bool aMirror )
2871{
2872 EDA_ANGLE orientation = getAngle( aCadstarOrientation );
2873 SPIN_STYLE spinStyle = getSpinStyle( orientation );
2874
2875 if( aMirror )
2876 {
2877 spinStyle = spinStyle.RotateCCW();
2878 spinStyle = spinStyle.RotateCCW();
2879 }
2880
2881 return spinStyle;
2882}
2883
2884
2886{
2887 SPIN_STYLE spinStyle = SPIN_STYLE::LEFT;
2888
2889 EDA_ANGLE oDeg = aOrientation;
2890 oDeg.Normalize180();
2891
2892 if( oDeg >= -ANGLE_45 && oDeg <= ANGLE_45 )
2893 spinStyle = SPIN_STYLE::RIGHT; // 0deg
2894 else if( oDeg >= ANGLE_45 && oDeg <= ANGLE_135 )
2895 spinStyle = SPIN_STYLE::UP; // 90deg
2896 else if( oDeg >= ANGLE_135 || oDeg <= -ANGLE_135 )
2897 spinStyle = SPIN_STYLE::LEFT; // 180deg
2898 else
2899 spinStyle = SPIN_STYLE::BOTTOM; // 270deg
2900
2901 return spinStyle;
2902}
2903
2904
2907{
2908 switch( aCadstarAlignment )
2909 {
2910 // Change left to right:
2915
2916 //Change right to left:
2920
2921 // Center alignment does not mirror:
2924 case ALIGNMENT::TOPCENTER: return aCadstarAlignment;
2925
2926 // Shouldn't be here
2927 default: wxFAIL_MSG( "Unknown Cadstar Alignment" ); return aCadstarAlignment;
2928 }
2929}
2930
2931
2934{
2935 switch( aCadstarAlignment )
2936 {
2947
2948 // Shouldn't be here
2949 default: wxFAIL_MSG( "Unknown Cadstar Alignment" ); return aCadstarAlignment;
2950 }
2951}
2952
2953
2955 const TEXTCODE_ID& aCadstarTextCodeID )
2956{
2957 // Ensure we have no Cadstar overbar characters
2958 wxString escapedText = HandleTextOverbar( aKiCadTextItem->GetText() );
2959 aKiCadTextItem->SetText( escapedText );
2960
2961 if( !Assignments.Codedefs.TextCodes.count( aCadstarTextCodeID ) )
2962 return;
2963
2964 TEXTCODE textCode = getTextCode( aCadstarTextCodeID );
2965 int textHeight = KiROUND( (double) getKiCadLength( textCode.Height ) * TXT_HEIGHT_RATIO );
2966 int textWidth = getKiCadLength( textCode.Width );
2967
2968 // The width is zero for all non-cadstar fonts. Using a width equal to 2/3 the height seems
2969 // to work well for most fonts.
2970 if( textWidth == 0 )
2971 textWidth = getKiCadLength( 2LL * textCode.Height / 3LL );
2972
2973 aKiCadTextItem->SetTextWidth( textWidth );
2974 aKiCadTextItem->SetTextHeight( textHeight );
2975
2976#if 0
2977 // EEschema currently supports only normal vs bold for text thickness.
2978 aKiCadTextItem->SetTextThickness( getKiCadLength( textCode.LineWidth ) );
2979#endif
2980
2981 // Must come after SetTextSize()
2982 aKiCadTextItem->SetBold( textCode.Font.Modifier1 == FONT_BOLD );
2983 aKiCadTextItem->SetItalic( textCode.Font.Italic );
2984}
2985
2986
2988 const TEXTCODE_ID& aCadstarTextCodeID,
2989 const ALIGNMENT& aCadstarAlignment,
2990 const JUSTIFICATION& aCadstarJustification,
2991 const long long aCadstarOrientAngle,
2992 bool aMirrored )
2993{
2994 applyTextCodeIfExists( aKiCadTextItem, aCadstarTextCodeID );
2995 aKiCadTextItem->SetTextAngle( getAngle( aCadstarOrientAngle ) );
2996
2997 // Justification ignored for now as not supported in Eeschema, but leaving this code in
2998 // place for future upgrades.
2999 // TODO update this when Eeschema supports justification independent of anchor position.
3000 ALIGNMENT textAlignment = aCadstarAlignment;
3001
3002 // KiCad mirrors the justification and alignment when the symbol is mirrored but CADSTAR
3003 // specifies it post-mirroring. In contrast, if the text item itself is mirrored (not
3004 // supported in KiCad), CADSTAR specifies the alignment and justification pre-mirroring
3005 if( aMirrored )
3006 textAlignment = mirrorX( aCadstarAlignment );
3007
3008 auto setAlignment =
3009 [&]( EDA_TEXT* aText, ALIGNMENT aAlignment )
3010 {
3011 switch( aAlignment )
3012 {
3013 case ALIGNMENT::NO_ALIGNMENT: // Bottom left of the first line
3014 //No exact KiCad equivalent, so lets move the position of the text
3020 break;
3021
3025 break;
3026
3030 break;
3031
3035 break;
3036
3040 break;
3041
3045 break;
3046
3047 case ALIGNMENT::TOPLEFT:
3050 break;
3051
3055 break;
3056
3060 break;
3061 }
3062 };
3063
3064 SPIN_STYLE spin = getSpinStyle( aCadstarOrientAngle, aMirrored );
3065 EDA_ITEM* textEdaItem = dynamic_cast<EDA_ITEM*>( aKiCadTextItem );
3066 wxCHECK( textEdaItem, /* void */ ); // ensure this is a EDA_ITEM
3067
3068 if( textEdaItem->Type() == SCH_FIELD_T )
3069 {
3070 // Spin style not used. All text justifications are permitted. However, only orientations
3071 // of 0 deg or 90 deg are supported
3072 EDA_ANGLE angle = aKiCadTextItem->GetTextAngle();
3073 angle.Normalize();
3074
3075 int quadrant = KiROUND( angle.AsDegrees() / 90.0 );
3076 quadrant %= 4;
3077
3078 switch( quadrant )
3079 {
3080 case 0:
3081 angle = ANGLE_HORIZONTAL;
3082 break;
3083 case 1:
3084 angle = ANGLE_VERTICAL;
3085 break;
3086 case 2:
3087 angle = ANGLE_HORIZONTAL;
3088 textAlignment = rotate180( textAlignment );
3089 break;
3090 case 3:
3091 angle = ANGLE_VERTICAL;
3092 textAlignment = rotate180( textAlignment );
3093 break;
3094 default:
3095 wxFAIL_MSG( "Unknown Quadrant" );
3096 }
3097
3098 aKiCadTextItem->SetTextAngle( angle );
3099 setAlignment( aKiCadTextItem, textAlignment );
3100 }
3101 else if( textEdaItem->Type() == SCH_TEXT_T )
3102 {
3103 // Note spin style in a SCH_TEXT results in a vertical alignment GR_TEXT_V_ALIGN_BOTTOM
3104 // so need to adjust the location of the text element based on Cadstar's original text
3105 // alignment (anchor position).
3106 setAlignment( aKiCadTextItem, textAlignment );
3107 BOX2I bb = textEdaItem->GetBoundingBox();
3108 int off = static_cast<SCH_TEXT*>( aKiCadTextItem )->GetTextOffset();
3109 VECTOR2I pos;
3110
3111 // Change the anchor point of the text item to make it match the same bounding box
3112 // And correct the error introduced by the text offsetting in KiCad
3113 switch( spin )
3114 {
3115 case SPIN_STYLE::BOTTOM: pos = { bb.GetRight() - off, bb.GetTop() }; break;
3116 case SPIN_STYLE::UP: pos = { bb.GetRight() - off, bb.GetBottom() }; break;
3117 case SPIN_STYLE::LEFT: pos = { bb.GetRight() , bb.GetBottom() + off }; break;
3118 case SPIN_STYLE::RIGHT: pos = { bb.GetLeft() , bb.GetBottom() + off }; break;
3119 default: wxFAIL_MSG( "Unexpected Spin Style" ); break;
3120 }
3121
3122 aKiCadTextItem->SetTextPos( pos );
3123
3124 switch( spin )
3125 {
3126 case SPIN_STYLE::RIGHT: // Horiz Normal Orientation
3127 aKiCadTextItem->SetTextAngle( ANGLE_HORIZONTAL );
3128 aKiCadTextItem->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
3129 break;
3130
3131 case SPIN_STYLE::UP: // Vert Orientation UP
3132 aKiCadTextItem->SetTextAngle( ANGLE_VERTICAL );
3133 aKiCadTextItem->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
3134 break;
3135
3136 case SPIN_STYLE::LEFT: // Horiz Orientation - Right justified
3137 aKiCadTextItem->SetTextAngle( ANGLE_HORIZONTAL );
3138 aKiCadTextItem->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
3139 break;
3140
3141 case SPIN_STYLE::BOTTOM: // Vert Orientation BOTTOM
3142 aKiCadTextItem->SetTextAngle( ANGLE_VERTICAL );
3143 aKiCadTextItem->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
3144 break;
3145
3146 default:
3147 wxFAIL_MSG( "Unexpected Spin Style" );
3148 break;
3149 }
3150
3151 aKiCadTextItem->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
3152 }
3153 else if( SCH_LABEL_BASE* label = dynamic_cast<SCH_LABEL_BASE*>( aKiCadTextItem ) )
3154 {
3155 // We don't want to change position of net labels as that would break connectivity
3156 label->SetSpinStyle( spin );
3157 }
3158 else
3159 {
3160 wxFAIL_MSG( "Unexpected item type" );
3161 }
3162}
3163
3164
3166{
3167 SCH_TEXT* kiTxt = new SCH_TEXT();
3168
3169 kiTxt->SetParent( m_schematic ); // set to the schematic for now to avoid asserts
3170 kiTxt->SetPosition( getKiCadPoint( aCadstarTextElement.Position ) );
3171 kiTxt->SetText( aCadstarTextElement.Text );
3172
3173 applyTextSettings( kiTxt, aCadstarTextElement.TextCodeID, aCadstarTextElement.Alignment,
3174 aCadstarTextElement.Justification, aCadstarTextElement.OrientAngle,
3175 aCadstarTextElement.Mirror );
3176
3177 return kiTxt;
3178}
3179
3180
3182 long long aScalingFactorNumerator,
3183 long long aScalingFactorDenominator )
3184{
3185 LIB_SYMBOL* retval = new LIB_SYMBOL( *aSymbol );
3186
3187 if( aScalingFactorNumerator == aScalingFactorDenominator )
3188 return retval; // 1:1 scale, nothing to do
3189
3190 auto scaleLen =
3191 [&]( int aLength ) -> int
3192 {
3193 return( aLength * aScalingFactorNumerator ) / aScalingFactorDenominator;
3194 };
3195
3196 auto scalePt =
3197 [&]( VECTOR2I aCoord ) -> VECTOR2I
3198 {
3199 return VECTOR2I( scaleLen( aCoord.x ), scaleLen( aCoord.y ) );
3200 };
3201
3202 auto scaleSize =
3203 [&]( VECTOR2I aSize ) -> VECTOR2I
3204 {
3205 return VECTOR2I( scaleLen( aSize.x ), scaleLen( aSize.y ) );
3206 };
3207
3208 LIB_ITEMS_CONTAINER& items = retval->GetDrawItems();
3209
3210 for( SCH_ITEM& item : items )
3211 {
3212 switch( item.Type() )
3213 {
3214 case KICAD_T::SCH_SHAPE_T:
3215 {
3216 SCH_SHAPE& shape = static_cast<SCH_SHAPE&>( item );
3217
3218 if( shape.GetShape() == SHAPE_T::ARC )
3219 {
3220 shape.SetPosition( scalePt( shape.GetPosition() ) );
3221 shape.SetStart( scalePt( shape.GetStart() ) );
3222 shape.SetEnd( scalePt( shape.GetEnd() ) );
3223 }
3224 else if( shape.GetShape() == SHAPE_T::POLY )
3225 {
3226 SHAPE_LINE_CHAIN& poly = shape.GetPolyShape().Outline( 0 );
3227
3228 for( size_t ii = 0; ii < poly.GetPointCount(); ++ii )
3229 poly.SetPoint( ii, scalePt( poly.CPoint( ii ) ) );
3230 }
3231 break;
3232 }
3233
3234 case KICAD_T::SCH_PIN_T:
3235 {
3236 SCH_PIN& pin = static_cast<SCH_PIN&>( item );
3237
3238 pin.SetPosition( scalePt( pin.GetPosition() ) );
3239 pin.SetLength( scaleLen( pin.GetLength() ) );
3240 break;
3241 }
3242
3243 case KICAD_T::SCH_TEXT_T:
3244 {
3245 SCH_TEXT& txt = static_cast<SCH_TEXT&>( item );
3246
3247 txt.SetPosition( scalePt( txt.GetPosition() ) );
3248 txt.SetTextSize( scaleSize( txt.GetTextSize() ) );
3249 break;
3250 }
3251
3252 default:
3253 break;
3254 }
3255 }
3256
3257 return retval;
3258}
3259
3260
3261void CADSTAR_SCH_ARCHIVE_LOADER::fixUpLibraryPins( LIB_SYMBOL* aSymbolToFix, int aGateNumber )
3262{
3263 auto compLambda =
3264 []( const VECTOR2I& aA, const VECTOR2I& aB )
3265 {
3266 return LexicographicalCompare( aA, aB ) < 0;
3267 };
3268
3269 // Store a list of vertical or horizontal segments in the symbol
3270 // Note: Need the custom comparison function to ensure the map is sorted correctly
3271 std::map<VECTOR2I, SHAPE_LINE_CHAIN, decltype( compLambda )> uniqueSegments( compLambda );
3272
3273 LIB_ITEMS_CONTAINER::ITERATOR shapeIt = aSymbolToFix->GetDrawItems().begin( SCH_SHAPE_T );
3274
3275 for( ; shapeIt != aSymbolToFix->GetDrawItems().end( SCH_SHAPE_T ); ++shapeIt )
3276 {
3277 SCH_SHAPE& shape = static_cast<SCH_SHAPE&>( *shapeIt );
3278
3279 if( aGateNumber > 0 && shape.GetUnit() != aGateNumber )
3280 continue;
3281
3282 if( shape.GetShape() != SHAPE_T::POLY )
3283 continue;
3284
3285 SHAPE_LINE_CHAIN poly = shape.GetPolyShape().Outline( 0 );
3286
3287 if( poly.GetPointCount() == 2 )
3288 {
3289 VECTOR2I pt0 = poly.CPoint( 0 );
3290 VECTOR2I pt1 = poly.CPoint( 1 );
3291
3292 if( pt0 != pt1 && uniqueSegments.count( pt0 ) == 0 && uniqueSegments.count( pt1 ) == 0 )
3293 {
3294 // we are only interested in vertical or horizontal segments
3295 if( pt0.x == pt1.x || pt0.y == pt1.y )
3296 {
3297 uniqueSegments.insert( { pt0, poly } );
3298 uniqueSegments.insert( { pt1, poly } );
3299 }
3300 }
3301 }
3302 }
3303
3304 for( SCH_PIN* pin : aSymbolToFix->GetPins( aGateNumber, 0 ) )
3305 {
3306 auto setPinOrientation =
3307 [&]( const EDA_ANGLE& aAngle )
3308 {
3309 EDA_ANGLE angle( aAngle );
3310 angle.Normalize180();
3311
3312 if( angle >= -ANGLE_45 && angle <= ANGLE_45 )
3313 pin->SetOrientation( PIN_ORIENTATION::PIN_RIGHT ); // 0 degrees
3314 else if( angle >= ANGLE_45 && angle <= ANGLE_135 )
3315 pin->SetOrientation( PIN_ORIENTATION::PIN_UP ); // 90 degrees
3316 else if( angle >= ANGLE_135 || angle <= -ANGLE_135 )
3317 pin->SetOrientation( PIN_ORIENTATION::PIN_LEFT ); // 180 degrees
3318 else
3319 pin->SetOrientation( PIN_ORIENTATION::PIN_DOWN ); // -90 degrees
3320 };
3321
3322 if( uniqueSegments.count( pin->GetPosition() ) )
3323 {
3324 SHAPE_LINE_CHAIN& poly = uniqueSegments.at( pin->GetPosition() );
3325
3326 VECTOR2I otherPt = poly.CPoint( 0 );
3327
3328 if( otherPt == pin->GetPosition() )
3329 otherPt = poly.CPoint( 1 );
3330
3331 VECTOR2I vec( otherPt - pin->GetPosition() );
3332
3333 pin->SetLength( vec.EuclideanNorm() );
3334 setPinOrientation( EDA_ANGLE( vec ) );
3335 }
3336 }
3337}
3338
3339
3340std::pair<VECTOR2I, VECTOR2I>
3342{
3343 VECTOR2I upperLeft( Assignments.Settings.DesignLimit.x, 0 );
3344 VECTOR2I lowerRight( 0, Assignments.Settings.DesignLimit.y );
3345
3346 for( const VERTEX& v : aCadstarFigure.Shape.Vertices )
3347 {
3348 if( upperLeft.x > v.End.x )
3349 upperLeft.x = v.End.x;
3350
3351 if( upperLeft.y < v.End.y )
3352 upperLeft.y = v.End.y;
3353
3354 if( lowerRight.x < v.End.x )
3355 lowerRight.x = v.End.x;
3356
3357 if( lowerRight.y > v.End.y )
3358 lowerRight.y = v.End.y;
3359 }
3360
3361 for( CUTOUT cutout : aCadstarFigure.Shape.Cutouts )
3362 {
3363 for( const VERTEX& v : aCadstarFigure.Shape.Vertices )
3364 {
3365 if( upperLeft.x > v.End.x )
3366 upperLeft.x = v.End.x;
3367
3368 if( upperLeft.y < v.End.y )
3369 upperLeft.y = v.End.y;
3370
3371 if( lowerRight.x < v.End.x )
3372 lowerRight.x = v.End.x;
3373
3374 if( lowerRight.y > v.End.y )
3375 lowerRight.y = v.End.y;
3376 }
3377 }
3378
3379 VECTOR2I upperLeftKiCad = getKiCadPoint( upperLeft );
3380 VECTOR2I lowerRightKiCad = getKiCadPoint( lowerRight );
3381
3382 VECTOR2I size = lowerRightKiCad - upperLeftKiCad;
3383
3384 return { upperLeftKiCad, VECTOR2I( abs( size.x ), abs( size.y ) ) };
3385}
3386
3387
3389{
3390 VECTOR2I retval;
3391
3392 retval.x = getKiCadLength( aCadstarPoint.x - m_designCenter.x );
3393 retval.y = -getKiCadLength( aCadstarPoint.y - m_designCenter.y );
3394
3395 return retval;
3396}
3397
3398
3400 const VECTOR2I& aCadstarCentre )
3401{
3402 VECTOR2I retval;
3403
3404 retval.x = getKiCadLength( aCadstarPoint.x - aCadstarCentre.x );
3405 retval.y = -getKiCadLength( aCadstarPoint.y - aCadstarCentre.y );
3406
3407 return retval;
3408}
3409
3410
3412 const VECTOR2I& aMoveVector,
3413 const EDA_ANGLE& aRotation,
3414 const double& aScalingFactor,
3415 const VECTOR2I& aTransformCentre,
3416 const bool& aMirrorInvert )
3417{
3418 VECTOR2I retVal = aPoint;
3419
3420 if( aScalingFactor != 1.0 )
3421 {
3422 //scale point
3423 retVal -= aTransformCentre;
3424 retVal.x = KiROUND( retVal.x * aScalingFactor );
3425 retVal.y = KiROUND( retVal.y * aScalingFactor );
3426 retVal += aTransformCentre;
3427 }
3428
3429 if( aMirrorInvert )
3430 MIRROR( retVal.x, aTransformCentre.x );
3431
3432 if( !aRotation.IsZero() )
3433 RotatePoint( retVal, aTransformCentre, aRotation );
3434
3435 if( aMoveVector != VECTOR2I{ 0, 0 } )
3436 retVal += aMoveVector;
3437
3438 return retVal;
3439}
3440
3441
3443{
3444 return sqrt( ( (double) aPoint.x * (double) aPoint.x )
3445 + ( (double) aPoint.y * (double) aPoint.y ) );
3446}
const char * name
Definition: DXF_plotter.cpp:62
constexpr EDA_IU_SCALE schIUScale
Definition: base_units.h:114
constexpr double SCH_IU_PER_MM
Schematic internal units 1=100nm.
Definition: base_units.h:72
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition: box2.h:990
CADSTAR_PIN_TYPE
file: cadstar_archive_objects.h Contains common object definitions
#define SYMBOL_NAME_ATTRID
Symbol Name attribute ID - used for placement of designators on the schematic.
#define SIGNALNAME_ORIGIN_ATTRID
#define LINK_ORIGIN_ATTRID
#define PART_NAME_ATTRID
const wxString PartAcceptanceFieldName
const wxString PartNumberFieldName
const wxString PartNameFieldName
const wxString PartVersionFieldName
Loads a csa file into a KiCad SCHEMATIC object.
constexpr Vec Centre() const
Definition: box2.h:97
constexpr BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: box2.h:658
constexpr coord_type GetLeft() const
Definition: box2.h:228
constexpr coord_type GetRight() const
Definition: box2.h:217
constexpr const SizeVec & GetSize() const
Definition: box2.h:206
constexpr coord_type GetTop() const
Definition: box2.h:229
constexpr coord_type GetBottom() const
Definition: box2.h:222
static wxString EscapeFieldText(const wxString &aFieldText)
@ FRACTIONALGRID
Param1 = Units, Param2 = Divisor.
static const std::map< TEXT_FIELD_NAME, wxString > CADSTAR_TO_KICAD_FIELDS
Map between CADSTAR fields and KiCad text variables.
long TERMINAL_ID
Terminal is the pin identifier in the schematic.
TEXT_FIELD_NAME
These are special fields in text objects enclosed between the tokens '<@' and '>' such as <@[FIELD_NA...
ALIGNMENT
From CADSTAR Help: "Text Alignment enables you to define the position of an alignment origin for all ...
@ NO_ALIGNMENT
NO_ALIGNMENT has different meaning depending on the object type.
static const long UNDEFINED_VALUE
static wxString generateLibName(const wxString &aRefName, const wxString &aAlternateName)
wxString LAYER_ID
ID of a Sheet (if schematic) or board Layer (if PCB)
static void FixTextPositionNoAlignment(EDA_TEXT *aKiCadTextItem)
Correct the position of a text element that had NO_ALIGNMENT in CADSTAR.
@ OUTLINE
Unfilled closed shape.
@ OPENSHAPE
Unfilled open shape. Cannot have cutouts.
@ SOLID
Filled closed shape (solid fill).
@ HATCHED
Filled closed shape (hatch fill).
static const double TXT_HEIGHT_RATIO
CADSTAR fonts are drawn on a 24x24 integer matrix, where the each axis goes from 0 to 24.
void checkPoint()
Updates m_progressReporter or throws if user canceled.
static wxString HandleTextOverbar(wxString aCadstarString)
Convert a string with CADSTAR overbar characters to equivalent in KiCad.
JUSTIFICATION
From CADSTAR Help: "Multi Line Text can also be justified as Left, Centre or Right.
PROGRESS_REPORTER * m_progressReporter
bool CheckFileHeader(const std::filesystem::path &aPath) const
CADSTAR_PARTS_LIB_MODEL ReadFile(const std::filesystem::path &aPath) const
static SCH_FIELD * addNewFieldToSymbol(const wxString &aFieldName, std::unique_ptr< LIB_SYMBOL > &aKiCadSymbol)
void loadItemOntoKiCadSheet(const LAYER_ID &aCadstarSheetID, SCH_ITEM *aItem)
void Load(SCHEMATIC *aSchematic, SCH_SHEET *aRootSheet)
Loads a CADSTAR Schematic Archive file into the KiCad SCHEMATIC object given.
ROUTECODE getRouteCode(const ROUTECODE_ID &aCadstarRouteCodeID)
static wxString CreateLibName(const wxFileName &aFileName, const SCH_SHEET *aRootSheet)
std::map< BLOCK_PIN_ID, SCH_HIERLABEL * > m_sheetPinMap
Cadstar->KiCad Sheet Pins.
VECTOR2I applyTransform(const VECTOR2I &aPoint, const VECTOR2I &aMoveVector={ 0, 0 }, const EDA_ANGLE &aRotation=ANGLE_0, const double &aScalingFactor=1.0, const VECTOR2I &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
std::map< SYMBOL_ID, SCH_GLOBALLABEL * > m_globalLabelsMap
Cadstar->KiCad Global Labels.
SCH_SYMBOL * loadSchematicSymbol(const SYMBOL &aCadstarSymbol, const LIB_SYMBOL &aKiCadPart, EDA_ANGLE &aComponentOrientation)
void applyTextSettings(EDA_TEXT *aKiCadTextItem, const TEXTCODE_ID &aCadstarTextCodeID, const ALIGNMENT &aCadstarAlignment, const JUSTIFICATION &aCadstarJustification, const long long aCadstarOrientAngle=0, bool aMirrored=false)
void loadSheetAndChildSheets(const LAYER_ID &aCadstarSheetID, const VECTOR2I &aPosition, const VECTOR2I &aSheetSize, const SCH_SHEET_PATH &aParentSheet)
wxString getAttributeName(const ATTRIBUTE_ID &aCadstarAttributeID)
std::vector< LIB_SYMBOL * > m_loadedSymbols
Loaded symbols so far.
PART getPart(const PART_ID &aCadstarPartID)
std::vector< LAYER_ID > findOrphanSheets()
std::map< BUS_ID, std::shared_ptr< BUS_ALIAS > > m_busesMap
Cadstar->KiCad Buses.
SCH_TEXT * getKiCadSchText(const TEXT &aCadstarTextElement)
std::map< TERMINAL_ID, wxString > TERMINAL_TO_PINNUM_MAP
Map between a terminal ID in a symbol definition to the pin number that should be imported into KiCad...
wxString getNetName(const NET_SCH &aNet)
std::pair< BLOCK_ID, TERMINAL_ID > BLOCK_PIN_ID
std::map< SYMBOL_ID, SCH_SYMBOL * > m_powerSymMap
Cadstar->KiCad Power Symbols.
std::pair< PART_ID, GATE_ID > PART_GATE_ID
VECTOR2I getKiCadLibraryPoint(const VECTOR2I &aCadstarPoint, const VECTOR2I &aCadstarCentre)
PART::DEFINITION::PIN getPartDefinitionPin(const PART &aCadstarPart, const GATE_ID &aGateID, const TERMINAL_ID &aTerminalID)
std::map< wxString, TERMINAL_ID > PINNUM_TO_TERMINAL_MAP
std::map< SYMDEF_ID, PINNUM_TO_TERMINAL_MAP > m_symDefTerminalsMap
int getTextHeightFromTextCode(const TEXTCODE_ID &aCadstarTextCodeID)
void loadChildSheets(const LAYER_ID &aCadstarSheetID, const SCH_SHEET_PATH &aSheet)
void applyToLibraryFieldAttribute(const ATTRIBUTE_LOCATION &aCadstarAttrLoc, const VECTOR2I &aSymbolOrigin, SCH_FIELD *aKiCadField)
double getPolarRadius(const VECTOR2I &aPoint)
void setFootprintOnSymbol(std::unique_ptr< LIB_SYMBOL > &aKiCadSymbol, const wxString &aFootprintName, const wxString &aFootprintAlternate)
void applyTextCodeIfExists(EDA_TEXT *aKiCadTextItem, const TEXTCODE_ID &aCadstarTextCodeID)
int getSheetNumber(const LAYER_ID &aCadstarSheetID)
void copySymbolItems(std::unique_ptr< LIB_SYMBOL > &aSourceSym, std::unique_ptr< LIB_SYMBOL > &aDestSym, int aDestUnit, bool aOverrideFields=true)
int getLineThickness(const LINECODE_ID &aCadstarLineCodeID)
TEXTCODE getTextCode(const TEXTCODE_ID &aCadstarTextCodeID)
SPIN_STYLE getSpinStyle(const long long &aCadstarOrientation, bool aMirror)
std::map< wxString, LIB_SYMBOL * > m_powerSymLibMap
NetName->KiCad Power Lib Symbol.
std::map< std::pair< wxString, wxString >, SYMDEF_ID > m_SymDefNamesCache
Cache storing symbol names and alternates to symdef IDs.
std::map< PART_ID, TERMINAL_TO_PINNUM_MAP > m_pinNumsMap
Cadstar Part->KiCad Pin number map.
std::vector< LIB_SYMBOL * > LoadPartsLib(const wxString &aFilename)
ELECTRICAL_PINTYPE getKiCadPinType(const CADSTAR_PIN_TYPE &aPinType)
wxString m_footprintLibName
Name of the footprint library to prepend all footprints with.
int getKiCadLength(long long aCadstarLength)
std::map< PART_ID, LIB_SYMBOL * > m_partMap
Cadstar->KiCad Parts.
bool isAttributeVisible(const ATTRIBUTE_ID &aCadstarAttributeID)
VECTOR2I getKiCadPoint(const VECTOR2I &aCadstarPoint)
EDA_ANGLE getAngle(const long long &aCadstarAngle)
std::map< wxString, SYMDEF_ID > m_DefaultSymDefNamesCache
Cache storing symbol names (default alternate) to symdef IDs.
void loadSymbolGateAndPartFields(const SYMDEF_ID &aSymdefID, const PART &aCadstarPart, const GATE_ID &aGateID, LIB_SYMBOL *aSymbol)
void loadFigure(const FIGURE &aCadstarFigure, const LAYER_ID &aCadstarSheetIDOverride, SCH_LAYER_ID aKiCadSchLayerID, const VECTOR2I &aMoveVector={ 0, 0 }, const EDA_ANGLE &aRotation=ANGLE_0, const double &aScalingFactor=1.0, const VECTOR2I &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
std::map< PART_GATE_ID, SYMDEF_ID > m_partSymbolsMap
Map holding the symbols loaded so far for a particular PART_ID and GATE_ID.
LIB_SYMBOL * getScaledLibPart(const LIB_SYMBOL *aSymbol, long long aScalingFactorNumerator, long long aScalingFactorDenominator)
SYMDEF_ID getSymDefFromName(const wxString &aSymdefName, const wxString &aSymDefAlternate)
std::pair< VECTOR2I, VECTOR2I > getFigureExtentsKiCad(const FIGURE &aCadstarFigure)
std::map< LAYER_ID, SCH_SHEET * > m_sheetMap
Cadstar->KiCad Sheets.
POINT getLocationOfNetElement(const NET_SCH &aNet, const NETELEMENT_ID &aNetElementID)
void fixUpLibraryPins(LIB_SYMBOL *aSymbolToFix, int aGateNumber)
std::map< SYMDEF_ID, std::unique_ptr< const LIB_SYMBOL > > m_symDefMap
Cadstar->KiCad Lib Symbols loaded so far.
std::unique_ptr< LIB_SYMBOL > loadLibPart(const CADSTAR_PART_ENTRY &aPart)
ALIGNMENT rotate180(const ALIGNMENT &aCadstarAlignment)
long long getCadstarAngle(const EDA_ANGLE &aAngle)
void loadLibrarySymbolShapeVertices(const std::vector< VERTEX > &aCadstarVertices, const VECTOR2I &aSymbolOrigin, LIB_SYMBOL *aSymbol, int aGateNumber, int aLineThickness)
LINE_STYLE getLineStyle(const LINECODE_ID &aCadstarLineCodeID)
VECTOR2I m_designCenter
Required for calculating the offset to apply to the Cadstar design so that it fits in the KiCad canva...
ALIGNMENT mirrorX(const ALIGNMENT &aCadstarAlignment)
int getComponentOrientation(const EDA_ANGLE &aOrientAngle, EDA_ANGLE &aReturnedOrientation)
void loadShapeVertices(const std::vector< VERTEX > &aCadstarVertices, LINECODE_ID aCadstarLineCodeID, LAYER_ID aCadstarSheetID, SCH_LAYER_ID aKiCadSchLayerID, const VECTOR2I &aMoveVector={ 0, 0 }, const EDA_ANGLE &aRotation=ANGLE_0, const double &aScalingFactor=1.0, const VECTOR2I &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
const LIB_SYMBOL * loadSymdef(const SYMDEF_ID &aSymdefID)
int getKiCadUnitNumberFromGate(const GATE_ID &aCadstarGateID)
void loadSymbolFieldAttribute(const ATTRIBUTE_LOCATION &aCadstarAttrLoc, const EDA_ANGLE &aComponentOrientation, bool aIsMirrored, SCH_FIELD *aKiCadField)
int KiCadUnitDivider
Use this value to convert units in this CSA file to KiCad units.
EDA_ANGLE Normalize()
Definition: eda_angle.h:224
double AsDegrees() const
Definition: eda_angle.h:116
bool IsZero() const
Definition: eda_angle.h:136
EDA_ANGLE Normalize180()
Definition: eda_angle.h:263
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:97
virtual const BOX2I GetBoundingBox() const
Return the orthogonal bounding box of this object for display purposes.
Definition: eda_item.cpp:110
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:109
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:112
EDA_ITEM * GetParent() const
Definition: eda_item.h:111
SHAPE_POLY_SET & GetPolyShape()
Definition: eda_shape.h:337
SHAPE_T GetShape() const
Definition: eda_shape.h:168
void SetPolyShape(const SHAPE_POLY_SET &aShape)
Definition: eda_shape.h:345
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition: eda_shape.h:215
void SetStart(const VECTOR2I &aStart)
Definition: eda_shape.h:177
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
Definition: eda_shape.h:173
void SetEnd(const VECTOR2I &aEnd)
Definition: eda_shape.h:219
void SetArcGeometry(const VECTOR2I &aStart, const VECTOR2I &aMid, const VECTOR2I &aEnd)
Set the three controlling points for an arc.
Definition: eda_shape.cpp:1037
void SetFillMode(FILL_T aFill)
Definition: eda_shape.cpp:539
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:79
int GetTextHeight() const
Definition: eda_text.h:264
const EDA_ANGLE & GetTextAngle() const
Definition: eda_text.h:144
void SetTextSize(VECTOR2I aNewSize, bool aEnforceMinTextSize=true)
Definition: eda_text.cpp:533
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:97
void SetTextPos(const VECTOR2I &aPoint)
Definition: eda_text.cpp:578
int GetTextWidth() const
Definition: eda_text.h:261
void SetVertJustify(GR_TEXT_V_ALIGN_T aType)
Definition: eda_text.cpp:417
void SetTextWidth(int aWidth)
Definition: eda_text.cpp:556
virtual void SetVisible(bool aVisible)
Definition: eda_text.cpp:386
void SetTextThickness(int aWidth)
The TextThickness is that set by the user.
Definition: eda_text.cpp:284
void SetTextHeight(int aHeight)
Definition: eda_text.cpp:567
void SetBold(bool aBold)
Set the text to be bold - this will also update the font if needed.
Definition: eda_text.cpp:335
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:270
virtual void SetTextAngle(const EDA_ANGLE &aAngle)
Definition: eda_text.cpp:299
int GetTextThickness() const
Definition: eda_text.h:125
void SetItalic(bool aItalic)
Set the text to be italic - this will also update the font if needed.
Definition: eda_text.cpp:307
void SetMultilineAllowed(bool aAllow)
Definition: eda_text.cpp:401
VECTOR2I GetTextSize() const
Definition: eda_text.h:258
void SetHorizJustify(GR_TEXT_H_ALIGN_T aType)
Definition: eda_text.cpp:409
iterator end()
Return a read/write iterator that points to one past the last element in the EE_RTREE.
Definition: sch_rtree.h:289
iterator begin()
Return a read/write iterator that points to the first.
Definition: sch_rtree.h:281
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:49
int SetLibItemName(const UTF8 &aLibItemName)
Override the library item name portion of the LIB_ID to aLibItemName.
Definition: lib_id.cpp:111
int SetLibNickname(const UTF8 &aLibNickname)
Override the logical library name portion of the LIB_ID to aLibNickname.
Definition: lib_id.cpp:100
UTF8 Format() const
Definition: lib_id.cpp:119
static UTF8 FixIllegalChars(const UTF8 &aLibItemName, bool aLib)
Replace illegal LIB_ID item name characters with underscores '_'.
Definition: lib_id.cpp:192
Define a library symbol object.
Definition: lib_symbol.h:85
void SetGlobalPower()
Definition: lib_symbol.cpp:476
std::vector< SCH_PIN * > GetPins(int aUnit, int aBodyStyle) const
Return a list of pin object pointers from the draw item list.
Definition: lib_symbol.cpp:800
void SetUnitCount(int aCount, bool aDuplicateDrawItems=true)
Set the units per symbol count.
LIB_ITEMS_CONTAINER & GetDrawItems()
Return a reference to the draw item list.
Definition: lib_symbol.h:519
wxString GetName() const override
Definition: lib_symbol.h:149
SCH_FIELD & GetValueField()
Return reference to the value field.
Definition: lib_symbol.h:334
void AddDrawItem(SCH_ITEM *aItem, bool aSort=true)
Add a new draw aItem to the draw object list and sort according to aSort.
Definition: lib_symbol.cpp:786
virtual void SetName(const wxString &aName)
Definition: lib_symbol.cpp:329
SCH_FIELD & GetReferenceField()
Return reference to the reference designator field.
Definition: lib_symbol.h:338
void sort()
Definition: multivector.h:248
ITERATOR_BASE< SCH_ITEM, MULTIVECTOR< SCH_ITEM, FIRST_TYPE_VAL, LAST_TYPE_VAL >, typename ITEM_PTR_VECTOR::iterator > ITERATOR
The const iterator.
Definition: multivector.h:165
ITERATOR end(int aType=UNDEFINED_TYPE)
Definition: multivector.h:195
ITERATOR begin(int aType=UNDEFINED_TYPE)
Definition: multivector.h:189
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition: page_info.h:59
void SetHeightMils(double aHeightInMils)
Definition: page_info.cpp:261
const VECTOR2D GetSizeIU(double aIUScale) const
Gets the page size in internal units.
Definition: page_info.h:171
void SetWidthMils(double aWidthInMils)
Definition: page_info.cpp:247
virtual void SetNumPhases(int aNumPhases)=0
Set the number of phases.
virtual void BeginPhase(int aPhase)=0
Initialize the aPhase virtual zone of the dialog progress bar.
virtual void SetMaxProgress(int aMaxProgress)=0
Fix the value that gives the 100 percent progress bar length (inside the current virtual zone).
Container for project specific data.
Definition: project.h:65
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition: project.cpp:148
virtual std::map< wxString, wxString > & GetTextVars() const
Definition: project.cpp:97
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)
Report a string with a given severity.
Definition: reporter.h:102
Holds all the data relating to one schematic.
Definition: schematic.h:87
PROJECT & Prj() const
Return a reference to the project this schematic is part of.
Definition: schematic.h:102
void SetSize(const VECTOR2I &aSize)
Definition: sch_bus_entry.h:74
Class for a wire to bus entry.
wxString GetName(bool aUseDefaultName=true) const
Return the field name (not translated).
Definition: sch_field.cpp:1106
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_field.cpp:1324
void SetText(const wxString &aText) override
Definition: sch_field.cpp:1092
void SetSpinStyle(SPIN_STYLE aSpinStyle) override
Definition: sch_label.cpp:1945
void SetSpinStyle(SPIN_STYLE aSpinStyle) override
Definition: sch_label.cpp:2126
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:168
SCH_ITEM * Duplicate(bool addToParentGroup, SCH_COMMIT *aCommit=nullptr, bool doClone=false) const
Routine to create a new copy of given item.
Definition: sch_item.cpp:159
int GetUnit() const
Definition: sch_item.h:242
void SetLayer(SCH_LAYER_ID aLayer)
Definition: sch_item.h:310
virtual void SetUnit(int aUnit)
Definition: sch_item.h:241
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_junction.h:108
void SetShape(LABEL_FLAG_SHAPE aShape)
Definition: sch_label.h:177
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_label.cpp:377
void AutoplaceFields(SCH_SCREEN *aScreen, AUTOPLACE_ALGO aAlgo) override
Definition: sch_label.cpp:567
virtual void SetSpinStyle(SPIN_STYLE aSpinStyle)
Definition: sch_label.cpp:303
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:42
void SetStartPoint(const VECTOR2I &aPosition)
Definition: sch_line.h:140
void SetLineWidth(const int aSize)
Definition: sch_line.cpp:315
VECTOR2I GetEndPoint() const
Definition: sch_line.h:144
VECTOR2I GetStartPoint() const
Definition: sch_line.h:139
void SetLineStyle(const LINE_STYLE aStyle)
Definition: sch_line.cpp:286
void SetEndPoint(const VECTOR2I &aPosition)
Definition: sch_line.h:145
void SetNumber(const wxString &aNumber)
Definition: sch_pin.cpp:554
const PAGE_INFO & GetPageSettings() const
Definition: sch_screen.h:134
void Append(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
Definition: sch_screen.cpp:158
void AddBusAlias(std::shared_ptr< BUS_ALIAS > aAlias)
Add a bus alias definition (and transfers ownership of the pointer).
void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: sch_screen.h:135
EE_RTREE & Items()
Get the full RTree, usually for iterating.
Definition: sch_screen.h:112
void SetFileName(const wxString &aFileName)
Set the file name for this screen to aFileName.
Definition: sch_screen.cpp:123
void Update(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
Update aItem's bounding box in the tree.
Definition: sch_screen.cpp:321
void SetPosition(const VECTOR2I &aPos) override
Definition: sch_shape.h:85
void SetStroke(const STROKE_PARAMS &aStroke) override
Definition: sch_shape.cpp:61
void AddPoint(const VECTOR2I &aPosition)
Definition: sch_shape.cpp:403
VECTOR2I GetPosition() const override
Definition: sch_shape.h:84
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
void SetPageNumber(const wxString &aPageNumber)
Set the sheet instance user definable page number.
SCH_SHEET * Last() const
Return a pointer to the last SCH_SHEET of the list.
void push_back(SCH_SHEET *aSheet)
Forwarded method from std::vector.
Define a sheet pin (label) used in sheets to create hierarchical schematics.
Definition: sch_sheet_pin.h:66
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition: sch_sheet.h:47
wxString GetFileName() const
Return the filename corresponding to this sheet.
Definition: sch_sheet.h:321
void AddPin(SCH_SHEET_PIN *aSheetPin)
Add aSheetPin to the sheet.
Definition: sch_sheet.cpp:398
std::vector< SCH_FIELD > & GetFields()
Return a reference to the vector holding the sheet's fields.
Definition: sch_sheet.h:87
SCH_FIELD * GetField(FIELD_T aFieldType)
Return a mandatory field in this sheet.
Definition: sch_sheet.cpp:367
bool LocatePathOfScreen(SCH_SCREEN *aScreen, SCH_SHEET_PATH *aList)
Search the existing hierarchy for an instance of screen loaded from aFileName.
Definition: sch_sheet.cpp:787
VECTOR2I GetSize() const
Definition: sch_sheet.h:118
SCH_SCREEN * GetScreen() const
Definition: sch_sheet.h:116
VECTOR2I GetPosition() const override
Definition: sch_sheet.h:415
void SetFields(const std::vector< SCH_FIELD > &aFields)
Set multiple schematic fields.
Definition: sch_sheet.cpp:389
void SetScreen(SCH_SCREEN *aScreen)
Set the SCH_SCREEN associated with this sheet to aScreen.
Definition: sch_sheet.cpp:137
static bool ClassOf(const EDA_ITEM *aItem)
Definition: sch_sheet.h:63
void AutoplaceFields(SCH_SCREEN *aScreen, AUTOPLACE_ALGO aAlgo) override
Definition: sch_sheet.cpp:635
Schematic symbol object.
Definition: sch_symbol.h:75
BOX2I GetBodyAndPinsBoundingBox() const override
Return a bounding box for the symbol body and pins but not the fields.
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_symbol.h:778
void UpdatePins()
Updates the cache of SCH_PIN objects for each pin.
Definition: sch_symbol.cpp:288
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:592
void GetFields(std::vector< SCH_FIELD * > &aVector, bool aVisibleOnly) const override
Populate a std::vector with SCH_FIELDs, sorted in ordinal order.
Definition: sch_symbol.cpp:780
void SetOrientation(int aOrientation)
Compute the new transform matrix based on aOrientation for the symbol which is applied to the current...
SCH_FIELD * AddField(const SCH_FIELD &aField)
Add a field to the symbol.
Definition: sch_symbol.cpp:807
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition: sch_symbol.h:183
SCH_FIELD * GetField(FIELD_T aFieldType)
Return a mandatory field in this symbol.
Definition: sch_symbol.cpp:752
VECTOR2I GetPosition() const override
Definition: sch_text.h:139
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_text.h:140
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition: sch_text.cpp:297
const VECTOR2I & GetArcMid() const
Definition: shape_arc.h:118
const VECTOR2I & GetP1() const
Definition: shape_arc.h:117
const VECTOR2I & GetP0() const
Definition: shape_arc.h:116
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
const SHAPE_LINE_CHAIN Reverse() const
Reverse point order in the line chain.
void SetPoint(int aIndex, const VECTOR2I &aPos)
Move a point to a specific location.
int FindSegment(const VECTOR2I &aP, int aThreshold=1) const
Search for segment containing point aP.
int Intersect(const SEG &aSeg, INTERSECTIONS &aIp) const
Find all intersection points between our line chain and the segment aSeg.
void Replace(int aStartIndex, int aEndIndex, const VECTOR2I &aP)
Replace points with indices in range [start_index, end_index] with a single point aP.
virtual size_t GetPointCount() const override
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
const VECTOR2I NearestPoint(const VECTOR2I &aP, bool aAllowInternalShapePoints=true) const
Find a point on the line chain that is closest to point aP.
std::vector< INTERSECTION > INTERSECTIONS
const std::vector< VECTOR2I > & CPoints() const
SHAPE_LINE_CHAIN & Outline(int aIndex)
Return the reference to aIndex-th outline in the set.
SPIN_STYLE MirrorX()
Mirror the label spin style across the X axis or simply swaps up and bottom.
Definition: sch_label.cpp:124
SPIN_STYLE MirrorY()
Mirror the label spin style across the Y axis or simply swaps left and right.
Definition: sch_label.cpp:140
SPIN_STYLE RotateCCW()
Definition: sch_label.cpp:108
Simple container to manage line stroke parameters.
Definition: stroke_params.h:94
virtual void SetShowPinNumbers(bool aShow)
Set or clear the pin number visibility flag.
Definition: symbol.h:164
virtual void SetShowPinNames(bool aShow)
Set or clear the pin name visibility flag.
Definition: symbol.h:158
wxString wx_str() const
Definition: utf8.cpp:45
T EuclideanNorm() const
Compute the Euclidean norm of the vector, which is defined as sqrt(x ** 2 + y ** 2).
Definition: vector2d.h:283
#define DEFAULT_WIRE_WIDTH_MILS
The default bus width in mils. (can be changed in preference menu)
#define _(s)
static constexpr EDA_ANGLE ANGLE_0
Definition: eda_angle.h:404
static constexpr EDA_ANGLE ANGLE_90
Definition: eda_angle.h:406
static constexpr EDA_ANGLE ANGLE_VERTICAL
Definition: eda_angle.h:401
static constexpr EDA_ANGLE ANGLE_HORIZONTAL
Definition: eda_angle.h:400
static constexpr EDA_ANGLE ANGLE_45
Definition: eda_angle.h:405
static constexpr EDA_ANGLE ANGLE_270
Definition: eda_angle.h:409
static constexpr EDA_ANGLE ANGLE_180
Definition: eda_angle.h:408
static constexpr EDA_ANGLE ANGLE_135
Definition: eda_angle.h:407
#define IGNORE_PARENT_GROUP
Definition: eda_item.h:54
static const std::string KiCadSchematicFileExtension
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:39
SCH_LAYER_ID
Eeschema drawing layers.
Definition: layer_ids.h:438
@ LAYER_DEVICE
Definition: layer_ids.h:455
@ LAYER_WIRE
Definition: layer_ids.h:441
@ LAYER_NOTES
Definition: layer_ids.h:456
@ LAYER_BUS
Definition: layer_ids.h:442
This file contains miscellaneous commonly used macros and functions.
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition: macros.h:83
constexpr void MIRROR(T &aPoint, const T &aMirrorRef)
Updates aPoint with the mirror of aPoint relative to the aMirrorRef.
Definition: mirror.h:45
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition: kicad_algo.h:100
ELECTRICAL_PINTYPE
The symbol library pin object electrical types used in ERC tests.
Definition: pin_type.h:36
@ RPT_SEVERITY_WARNING
@ RPT_SEVERITY_ERROR
@ AUTOPLACE_AUTO
Definition: sch_item.h:71
Definition of the SCH_SHEET_PATH and SCH_SHEET_LIST classes for Eeschema.
std::vector< SCH_FIELD > SCH_FIELDS
A container for several SCH_FIELD items.
Definition: sch_symbol.h:63
#define SIM_DEVICE_FIELD
Definition: sim_model.h:52
#define SIM_PARAMS_FIELD
Definition: sim_model.h:55
void wxStringSplit(const wxString &aText, wxArrayString &aStrings, wxChar aSplitter)
Split aString to a string list separated at aSplitter.
bool ReplaceIllegalFileNameChars(std::string *aName, int aReplaceChar)
Checks aName for illegal file name characters.
wxString EscapeString(const wxString &aSource, ESCAPE_CONTEXT aContext)
The Escape/Unescape routines use HTML-entity-reference-style encoding to handle characters which are:...
@ CTX_LIBID
Definition: string_utils.h:54
LINE_STYLE
Dashed line types.
Definition: stroke_params.h:46
std::map< ATTRIBUTE_ID, ATTRCOL > AttributeColors
JUSTIFICATION Justification
Note: Justification has no effect on single lines of text.
ALIGNMENT Alignment
In CADSTAR The default alignment for a TEXT object (when "(No Alignment()" is selected) Bottom Left o...
bool HasLocation
Flag to know if this ATTRIBUTE_VALUE has a location i.e.
std::map< LINECODE_ID, LINECODE > LineCodes
std::map< ATTRIBUTE_ID, ATTRNAME > AttributeNames
std::map< ROUTECODE_ID, ROUTECODE > RouteCodes
std::map< TEXTCODE_ID, TEXTCODE > TextCodes
Represent a cutout in a closed shape (e.g.
long ScaleRatioNumerator
Documentation symbols can be arbitrarily scaled when added to a design.
long ScaleRatioDenominator
Documentation symbols can be arbitrarily scaled when added to a design.
POINT Origin
Origin of the component (this is used as the reference point when placing the component in the design...
LAYER_ID LayerID
Move all objects in the Symdef to this layer.
SYMDEF_ID SymdefID
Normally documentation symbols only have TEXT, FIGURE and TEXT_LOCATION objects which are all drawn o...
long Modifier1
It seems this is related to weight. 400=Normal, 700=Bold.
GRID ScreenGrid
From CADSTAR Help: "There is one Screen Grid, which is visible as dots on the screen.
long Param1
Either Units or X step, depending on Type (see GRID_TYPE for more details)
long Param2
Either Divisor or Y step, depending on Type (see GRID_TYPE for more details)
wxString Name
This is undefined (wxEmptyString) if the net is unnamed.
long SignalNum
This is undefined if the net has been given a name.
std::map< TEXT_FIELD_NAME, wxString > TextFieldToValuesMap
Values for the text field elements used in the CADSTAR design extracted from the text element instanc...
std::map< wxString, wxString > FilenamesToTextMap
CADSTAR doesn't have user defined text fields but does allow loading text from a file.
std::set< TEXT_FIELD_NAME > InconsistentTextFields
Text fields need to be updated in CADSTAR and it is possible that they are not consistent across text...
std::map< PART_ID, PART > PartDefinitions
bool HidePinNames
Specifies whether to display the pin names/identifier in the schematic symbol or not.
std::map< ATTRIBUTE_ID, ATTRIBUTE_VALUE > AttributeValues
Some attributes are defined within the part definition, whilst others are defined in the part.
std::map< PART_DEFINITION_PIN_ID, PIN > Pins
std::map< ATTRIBUTE_ID, ATTRIBUTE_VALUE > AttributeValues
Some attributes are defined within the part definition, whilst others are defined in the part itself.
Represent a point in x,y coordinates.
SHAPE_POLY_SET ConvertToPolySet(const std::function< VECTOR2I(const VECTOR2I &)> aCadstarToKicadPointCallback, int aAccuracy) const
std::vector< CUTOUT > Cutouts
Not Applicable to OPENSHAPE Type.
std::map< FIGURE_ID, FIGURE > Figures
std::map< ATTRIBUTE_ID, TEXT_LOCATION > TextLocations
This contains location of any attributes, including designator position.
POINT Origin
Origin of the component (this is used as the reference point when placing the component in the design...
wxString Alternate
This is in addition to ReferenceName.
std::map< ATTRIBUTE_ID, ATTRIBUTE_VALUE > AttributeValues
These attributes might also have a location.
long Width
Defaults to 0 if using system fonts or, if using CADSTAR font, default to equal height (1:1 aspect ra...
Corresponds to CADSTAR "origin".
ALIGNMENT Alignment
In CADSTAR The default alignment for a TEXT object (when "(No Alignment()" is selected) Bottom Left o...
JUSTIFICATION Justification
Note: Justification has no effect on single lines of text.
< Nodename = "VARIANT" or "VMASTER" (master variant
Represents a vertex in a shape.
SHAPE_ARC BuildArc(const VECTOR2I &aPrevPoint, const std::function< VECTOR2I(const VECTOR2I &)> aCadstarToKicadPointCallback) const
CADSTAR Parts Library (*.lib) model - a data structure describing the contents of the file format.
std::vector< CADSTAR_PART_ENTRY > m_PartEntries
std::string m_ComponentStem
std::map< std::string, std::vector< CADSTAR_PART_PIN > > m_HiddenPins
Pins with an implied electrical connection to a net, not part of any symbol (Note: we probably will n...
std::map< std::string, CADSTAR_ATTRIBUTE_VALUE > m_SchAttributes
Dollar sign ($) line $[!]<SCM Attribute name>(<Attribute value>) Attributes related to the schematic ...
std::map< std::string, CADSTAR_ATTRIBUTE_VALUE > m_SchAndPcbAttributes
At symbol (@) line [@[!]<SCM/PCB Attribute name>(<Attribute value>)] Attributes related to the PCB co...
std::vector< CADSTAR_PART_SYMBOL_ENTRY > m_Symbols
Symbols that form this part.
std::map< std::string, std::string > m_UserAttributes
Star (*) line *<User-defined name> This line is ignored by CADSTAR.
std::map< long, std::string > m_PinNamesMap
Map of pin identifiers to alphanumeric pin names.
std::optional< std::string > m_AcceptancePartName
bool m_PinsVisible
std::optional< std::string > m_Pcb_alternate
std::optional< std::string > m_Version
std::string m_Name
std::optional< std::string > m_Description
std::optional< std::string > m_Number
std::string m_Pcb_component
std::optional< std::string > m_SpiceModel
std::map< std::string, CADSTAR_ATTRIBUTE_VALUE > m_PcbAttributes
Percentage sign (%) line %[!]<PCB Attribute name>(<Attribute value>) Attributes related to the PCB co...
std::optional< std::string > m_Value
std::map< std::string, CADSTAR_ATTRIBUTE_VALUE > m_PartAttributes
Tilde (~) line ~[!]<Parts Library Attribute Name>(<Attribute Value>) Attributes related to the Part i...
std::map< long, std::string > m_PinLabelsMap
Map of pin identifiers to alphanumeric pin labels.
std::string m_SymbolName
std::vector< CADSTAR_PART_PIN > m_Pins
std::optional< std::string > m_SymbolAlternateName
TYPE Type
Determines what the associated layer is, whether parent, child or clone.
LAYER_ID LayerID
The sheet block is on (TODO: verify this is true)
LAYER_ID AssocLayerID
Parent or Child linked sheet.
std::map< TERMINAL_ID, TERMINAL > Terminals
LAYER_ID LayerID
Sheet on which bus is located.
std::map< REUSEBLOCK_ID, REUSEBLOCK > ReuseBlocks
std::map< DOCUMENTATION_SYMBOL_ID, DOCUMENTATION_SYMBOL > DocumentationSymbols
std::map< SYMDEF_ID, SYMDEF_SCM > SymbolDefinitions
std::map< NETELEMENT_ID, DANGLER > Danglers
std::map< NETELEMENT_ID, SYM_TERM > Terminals
std::map< NETELEMENT_ID, BUS_TERM > BusTerminals
std::map< NETELEMENT_ID, BLOCK_TERM > BlockTerminals
std::map< NETELEMENT_ID, JUNCTION_SCH > Junctions
std::vector< LAYER_ID > SheetOrder
A vector to also store the order in which sheets are to be displayed.
std::map< LAYER_ID, SHEET_NAME > SheetNames
LAYER_ID LayerID
Sheet on which symbol is located.
std::map< ATTRIBUTE_ID, ATTRIBUTE_VALUE > AttributeValues
GATE_ID GateID
The gate this symbol represents within the associated Part.
long ScaleRatioNumerator
Symbols can be arbitrarily scaled in CADSTAR.
std::map< TERMINAL_ID, SYMPINNAME_LABEL > PinNames
Identifier of the pin in the PCB Equivalent to KiCad's Pin Number.
std::map< TERMINAL_ID, PIN_NUM > PinNumbers
This seems to only appear in older designs and is similar to PinNames but only allowing numerical val...
std::map< TERMINAL_ID, PIN_NUM_LABEL_LOC > PinLabelLocations
std::map< TERMINAL_ID, PIN_NUM_LABEL_LOC > PinNumberLocations
std::map< TERMINAL_ID, TERMINAL > Terminals
POINT Position
Pad position within the component's coordinate frame.
constexpr int IUToMils(int iu) const
Definition: base_units.h:103
const double IU_PER_MILS
Definition: base_units.h:77
constexpr int MilsToIU(int mils) const
Definition: base_units.h:97
bool cw
VECTOR2I end
constexpr int delta
@ GR_TEXT_H_ALIGN_CENTER
@ GR_TEXT_H_ALIGN_RIGHT
@ GR_TEXT_H_ALIGN_LEFT
@ GR_TEXT_V_ALIGN_BOTTOM
@ GR_TEXT_V_ALIGN_CENTER
@ GR_TEXT_V_ALIGN_TOP
void RotatePoint(int *pX, int *pY, const EDA_ANGLE &aAngle)
Calculate the new point of coord coord pX, pY, for a rotation center 0, 0.
Definition: trigo.cpp:229
@ SCH_SYMBOL_T
Definition: typeinfo.h:172
@ SCH_FIELD_T
Definition: typeinfo.h:150
@ SCH_SHAPE_T
Definition: typeinfo.h:149
@ SCH_SHEET_PIN_T
Definition: typeinfo.h:174
@ SCH_TEXT_T
Definition: typeinfo.h:151
constexpr int sign(T val)
Definition: util.h:159
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695
constexpr int LexicographicalCompare(const VECTOR2< T > &aA, const VECTOR2< T > &aB)
Definition: vector2d.h:644
Definition of file extensions used in Kicad.