KiCad PCB EDA Suite
cadstar_pcb_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 <roberto.fer.bau@gmail.com>
5  * Copyright (C) 2020-2021 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 
26 #include <cadstar_pcb_archive_loader.h>
27 
28 #include <board_stackup_manager/stackup_predefined_prms.h> // KEY_COPPER, KEY_CORE, KEY_PREPREG
29 #include <board.h>
30 #include <dimension.h>
31 #include <pcb_shape.h>
32 #include <fp_shape.h>
33 #include <footprint.h>
34 #include <pcb_text.h>
35 #include <project.h>
36 #include <track.h>
37 #include <zone.h>
38 #include <convert_basic_shapes_to_polygon.h>
39 #include <trigo.h>
40 
41 #include <limits> // std::numeric_limits
42 
43 
44 void CADSTAR_PCB_ARCHIVE_LOADER::Load( BOARD* aBoard, PROJECT* aProject )
45 {
46  m_board = aBoard;
47  m_project = aProject;
48 
49  Parse();
50 
51  LONGPOINT designLimit = Assignments.Technology.DesignLimit;
52 
53  //Note: can't use getKiCadPoint() due wxPoint being int - need long long to make the check
54  long long designSizeXkicad = (long long) designLimit.x * KiCadUnitMultiplier;
55  long long designSizeYkicad = (long long) designLimit.y * KiCadUnitMultiplier;
56 
57  // Max size limited by the positive dimension of wxPoint (which is an int)
58  long long maxDesignSizekicad = std::numeric_limits<int>::max();
59 
60  if( designSizeXkicad > maxDesignSizekicad || designSizeYkicad > maxDesignSizekicad )
61  {
62  THROW_IO_ERROR( wxString::Format(
63  _( "The design is too large and cannot be imported into KiCad. \n"
64  "Please reduce the maximum design size in CADSTAR by navigating to: \n"
65  "Design Tab -> Properties -> Design Options -> Maximum Design Size. \n"
66  "Current Design size: %.2f, %.2f millimeters. \n"
67  "Maximum permitted design size: %.2f, %.2f millimeters.\n" ),
68  (double) designSizeXkicad / PCB_IU_PER_MM,
69  (double) designSizeYkicad / PCB_IU_PER_MM,
70  (double) maxDesignSizekicad / PCB_IU_PER_MM,
71  (double) maxDesignSizekicad / PCB_IU_PER_MM ) );
72  }
73 
74  m_designCenter =
75  ( Assignments.Technology.DesignArea.first + Assignments.Technology.DesignArea.second )
76  / 2;
77 
78  if( Layout.NetSynch == NETSYNCH::WARNING )
79  {
80  wxLogWarning(
81  _( "The selected file indicates that nets might be out of synchronisation "
82  "with the schematic. It is recommended that you carry out an 'Align Nets' "
83  "procedure in CADSTAR and re-import, to avoid inconsistencies between the "
84  "PCB and the schematic. " ) );
85  }
86 
87  loadBoardStackup();
88  remapUnsureLayers();
89  loadDesignRules();
90  loadComponentLibrary();
91  loadGroups();
92  loadBoards();
93  loadFigures();
94  loadTexts();
95  loadDimensions();
96  loadAreas();
97  loadComponents();
98  loadDocumentationSymbols();
99  loadTemplates();
100  loadCoppers();
101  calculateZonePriorities();
102  loadNets();
103  loadTextVariables();
104 
105  if( Layout.Trunks.size() > 0 )
106  {
107  wxLogWarning(
108  _( "The CADSTAR design contains Trunk routing elements, which have no KiCad "
109  "equivalent. These elements were not loaded." ) );
110  }
111 
112  if( Layout.VariantHierarchy.Variants.size() > 0 )
113  {
114  wxLogWarning( wxString::Format(
115  _( "The CADSTAR design contains variants which has no KiCad equivalent. Only "
116  "the variant '%s' was loaded." ),
117  Layout.VariantHierarchy.Variants.begin()->second.Name ) );
118  }
119 
120  if( Layout.ReuseBlocks.size() > 0 )
121  {
122  wxLogWarning(
123  _( "The CADSTAR design contains re-use blocks which has no KiCad equivalent. The "
124  "re-use block information has been discarded during the import." ) );
125  }
126 
127  wxLogMessage(
128  _( "The CADSTAR design has been imported successfully.\n"
129  "Please review the import errors and warnings (if any)." ) );
130 }
131 
132 std::vector<FOOTPRINT*> CADSTAR_PCB_ARCHIVE_LOADER::GetLoadedLibraryFootpints() const
133 {
134  std::vector<FOOTPRINT*> retval;
135 
136  for( std::pair<SYMDEF_ID, FOOTPRINT*> fpPair : m_libraryMap )
137  {
138  retval.push_back( static_cast<FOOTPRINT*>( fpPair.second->Clone() ) );
139  }
140 
141  return retval;
142 }
143 
144 
145 void CADSTAR_PCB_ARCHIVE_LOADER::logBoardStackupWarning(
146  const wxString& aCadstarLayerName,
147  const PCB_LAYER_ID& aKiCadLayer )
148 {
149  if( m_logLayerWarnings )
150  {
151  wxLogWarning( wxString::Format(
152  _( "The CADSTAR layer '%s' has no KiCad equivalent. All elements on this "
153  "layer have been mapped to KiCad layer '%s' instead." ),
154  aCadstarLayerName, LSET::Name( aKiCadLayer ) ) );
155  }
156 }
157 
158 
159 void CADSTAR_PCB_ARCHIVE_LOADER::logBoardStackupMessage( const wxString& aCadstarLayerName,
160  const PCB_LAYER_ID& aKiCadLayer )
161 {
162  if( m_logLayerWarnings )
163  {
164  wxLogMessage( wxString::Format(
165  _( "The CADSTAR layer '%s' has been assumed to be a technical layer. All "
166  "elements on this layer have been mapped to KiCad layer '%s'." ),
167  aCadstarLayerName, LSET::Name( aKiCadLayer ) ) );
168  }
169 }
170 
171 
172 void CADSTAR_PCB_ARCHIVE_LOADER::initStackupItem( const LAYER& aCadstarLayer,
173  BOARD_STACKUP_ITEM* aKiCadItem,
174  int aDielectricSublayer )
175 {
176  if( !aCadstarLayer.MaterialId.IsEmpty() )
177  {
178  MATERIAL material = Assignments.Layerdefs.Materials.at( aCadstarLayer.MaterialId );
179 
180  aKiCadItem->SetMaterial( material.Name, aDielectricSublayer );
181  aKiCadItem->SetEpsilonR( material.Permittivity.GetDouble(), aDielectricSublayer );
182  aKiCadItem->SetLossTangent( material.LossTangent.GetDouble(), aDielectricSublayer );
183  //TODO add Resistivity when KiCad supports it
184  }
185 
186  aKiCadItem->SetLayerName( aCadstarLayer.Name );
187  aKiCadItem->SetThickness( getKiCadLength( aCadstarLayer.Thickness ), aDielectricSublayer );
188 }
189 
190 
191 void CADSTAR_PCB_ARCHIVE_LOADER::loadBoardStackup()
192 {
193  // Structure describing an electrical layer with optional dielectric layers below it
194  // (construction layers in CADSTAR)
195  struct LAYER_BLOCK
196  {
197  LAYER_ID ElecLayerID = wxEmptyString; // Normally not empty, but could be empty if the
198  // first layer in the stackup is a construction
199  // layer
200  std::vector<LAYER_ID> ConstructionLayers; // Normally empty for the last electrical layer
201  // but it is possible to build a board in CADSTAR
202  // with no construction layers or with the bottom
203  // layer being a construction layer
204 
205  bool IsInitialised() { return !ElecLayerID.IsEmpty() || ConstructionLayers.size() > 0; };
206  };
207 
208  std::vector<LAYER_BLOCK> cadstarBoardStackup;
209  LAYER_BLOCK currentBlock;
210 
211  // Find the electrical and construction (dielectric) layers in the stackup
212  for( LAYER_ID cadstarLayerID : Assignments.Layerdefs.LayerStack )
213  {
214  LAYER cadstarLayer = Assignments.Layerdefs.Layers.at( cadstarLayerID );
215 
216  if( cadstarLayer.Type == LAYER_TYPE::JUMPERLAYER ||
217  cadstarLayer.Type == LAYER_TYPE::POWER ||
218  cadstarLayer.Type == LAYER_TYPE::ELEC )
219  {
220  if( currentBlock.IsInitialised() )
221  {
222  cadstarBoardStackup.push_back( currentBlock );
223  currentBlock = LAYER_BLOCK(); // reset the block
224  }
225 
226  currentBlock.ElecLayerID = cadstarLayerID;
227  }
228  else if( cadstarLayer.Type == LAYER_TYPE::CONSTRUCTION )
229  {
230  currentBlock.ConstructionLayers.push_back( cadstarLayerID );
231  }
232  }
233 
234  if( currentBlock.IsInitialised() )
235  cadstarBoardStackup.push_back( currentBlock );
236 
237  int totalCopperLayers = cadstarBoardStackup.size();
238 
239  // Special case: last layer in the stackup is a construction layer, we need to use B.Cu as a
240  // dummy layer
241  if( cadstarBoardStackup.back().ConstructionLayers.size() > 0 )
242  {
243  cadstarBoardStackup.push_back( LAYER_BLOCK() ); //Add dummy layer at the end
244  ++totalCopperLayers;
245  }
246 
247  // Make sure it is an even number of layers (KiCad doesn't yet support unbalanced stack-ups)
248  if( ( totalCopperLayers % 2 ) != 0 )
249  {
250  LAYER_BLOCK bottomLayer = cadstarBoardStackup.back();
251  cadstarBoardStackup.pop_back();
252 
253  LAYER_BLOCK secondToLastLayer = cadstarBoardStackup.back();
254  cadstarBoardStackup.pop_back();
255 
256  LAYER_BLOCK dummyLayer;
257  LAYER_ID lastConstruction = secondToLastLayer.ConstructionLayers.back();
258 
259  if( secondToLastLayer.ConstructionLayers.size() > 1 )
260  {
261  // At least two construction layers, lets remove it here and use it in the dummy layer
262  secondToLastLayer.ConstructionLayers.pop_back();
263  }
264  else
265  {
266  // There is only one construction layer, lets halve its thickness so it is split evenly
267  // between this layer and the dummy layer
268  Assignments.Layerdefs.Layers.at( lastConstruction ).Thickness /= 2;
269  }
270 
271  dummyLayer.ConstructionLayers.push_back( lastConstruction );
272  cadstarBoardStackup.push_back( secondToLastLayer );
273  cadstarBoardStackup.push_back( dummyLayer );
274  cadstarBoardStackup.push_back( bottomLayer );
275  ++totalCopperLayers;
276  }
277 
278  wxASSERT( totalCopperLayers == cadstarBoardStackup.size() );
279  wxASSERT( cadstarBoardStackup.back().ConstructionLayers.size() == 0 );
280 
281 
282  // Create a new stackup from default stackup list
283  BOARD_STACKUP& stackup = m_board->GetDesignSettings().GetStackupDescriptor();
284  stackup.RemoveAll();
285  m_board->SetEnabledLayers( LSET::AllLayersMask() );
286  m_board->SetVisibleLayers( LSET::AllLayersMask() );
287  m_board->SetCopperLayerCount( totalCopperLayers );
288  stackup.BuildDefaultStackupList( &m_board->GetDesignSettings(), totalCopperLayers );
289 
290  size_t stackIndex = 0;
291 
292  for( BOARD_STACKUP_ITEM* item : stackup.GetList() )
293  {
294  if( item->GetType() == BOARD_STACKUP_ITEM_TYPE::BS_ITEM_TYPE_COPPER )
295  {
296  LAYER_ID layerID = cadstarBoardStackup.at( stackIndex ).ElecLayerID;
297 
298  if( layerID.IsEmpty() )
299  {
300  // Loading a dummy layer. Make zero thickness so it doesn't affect overall stackup
301  item->SetThickness( 0 );
302  }
303  else
304  {
305  LAYER copperLayer = Assignments.Layerdefs.Layers.at( layerID );
306  initStackupItem( copperLayer, item, 0 );
307  LAYER_T copperType = LAYER_T::LT_SIGNAL;
308 
309  switch( copperLayer.Type )
310  {
311  case LAYER_TYPE::JUMPERLAYER:
312  copperType = LAYER_T::LT_JUMPER;
313  break;
314 
315  case LAYER_TYPE::ELEC:
316  copperType = LAYER_T::LT_SIGNAL;
317  break;
318 
319  case LAYER_TYPE::POWER:
320  copperType = LAYER_T::LT_POWER;
321  m_powerPlaneLayers.push_back( copperLayer.ID ); //need to add a Copper zone
322  break;
323 
324  default:
325  wxFAIL_MSG( "Unexpected Layer type. Was expecting an electrical type" );
326  break;
327  }
328 
329  m_board->SetLayerType( item->GetBrdLayerId(), copperType );
330  m_board->SetLayerName( item->GetBrdLayerId(), item->GetLayerName() );
331  m_layermap.insert( { copperLayer.ID, item->GetBrdLayerId() } );
332  }
333  }
334  else if( item->GetType() == BOARD_STACKUP_ITEM_TYPE::BS_ITEM_TYPE_DIELECTRIC )
335  {
336  LAYER_BLOCK layerBlock = cadstarBoardStackup.at( stackIndex );
337  LAYER_BLOCK layerBlockBelow = cadstarBoardStackup.at( stackIndex + 1 );
338 
339  // We should have made sure all layer blocks have at least one construction layer
340  wxASSERT( layerBlock.ConstructionLayers.size() > 0 );
341 
342  int dielectricId = stackIndex + 1;
343  // item->SetBrdLayerId();
344  item->SetDielectricLayerId( dielectricId );
345 
346  //Prepreg or core?
347  //Look at CADSTAR layer embedding (see LAYER->Embedding) to check whether the electrical
348  //layer embeds above and below to decide if current layer is prepreg or core
349  if( layerBlock.ElecLayerID.IsEmpty() )
350  {
351  //Dummy electrical layer, assume prepreg
352  item->SetTypeName( KEY_PREPREG );
353  }
354  else
355  {
356  LAYER copperLayer = Assignments.Layerdefs.Layers.at( layerBlock.ElecLayerID );
357 
358  if( layerBlockBelow.ElecLayerID.IsEmpty() )
359  {
360  // Dummy layer below, just use current layer to decide
361 
362  if( copperLayer.Embedding == EMBEDDING::ABOVE )
363  item->SetTypeName( KEY_CORE );
364  else
365  item->SetTypeName( KEY_PREPREG );
366  }
367  else
368  {
369  LAYER copperLayerBelow =
370  Assignments.Layerdefs.Layers.at( layerBlockBelow.ElecLayerID );
371 
372  if( copperLayer.Embedding == EMBEDDING::ABOVE )
373  {
374  // Need to check layer below is embedding downwards
375  if( copperLayerBelow.Embedding == EMBEDDING::BELOW )
376  item->SetTypeName( KEY_CORE );
377  else
378  item->SetTypeName( KEY_PREPREG );
379  }
380  else
381  {
382  item->SetTypeName( KEY_PREPREG );
383  }
384  }
385  }
386 
387  int dielectricSublayer = 0;
388 
389  for( LAYER_ID constructionLaID : layerBlock.ConstructionLayers )
390  {
391  LAYER dielectricLayer = Assignments.Layerdefs.Layers.at( constructionLaID );
392 
393  if( dielectricSublayer )
394  item->AddDielectricPrms( dielectricSublayer );
395 
396  initStackupItem( dielectricLayer, item, dielectricSublayer );
397  m_board->SetLayerName( item->GetBrdLayerId(), item->GetLayerName() );
398  m_layermap.insert( { dielectricLayer.ID, item->GetBrdLayerId() } );
399  ++dielectricSublayer;
400  }
401 
402  ++stackIndex;
403  }
404  }
405 
406  int numElecAndPowerLayers = 0;
407 
408  for( LAYER_ID cadstarLayerID : Assignments.Layerdefs.LayerStack )
409  {
410  LAYER curLayer = Assignments.Layerdefs.Layers.at( cadstarLayerID );
411  PCB_LAYER_ID kicadLayerID = PCB_LAYER_ID::UNDEFINED_LAYER;
412  wxString layerName = curLayer.Name.Lower();
413 
414  enum class LOG_LEVEL
415  {
416  NONE,
417  MSG,
418  WARN
419  };
420 
421  auto selectLayerID =
422  [&]( PCB_LAYER_ID aFront, PCB_LAYER_ID aBack, LOG_LEVEL aLogType )
423  {
424  if( numElecAndPowerLayers > 0 )
425  kicadLayerID = aBack;
426  else
427  kicadLayerID = aFront;
428 
429  switch( aLogType )
430  {
431  case LOG_LEVEL::NONE:
432  break;
433 
434  case LOG_LEVEL::MSG:
435  logBoardStackupMessage( curLayer.Name, kicadLayerID );
436  break;
437 
438  case LOG_LEVEL::WARN:
439  logBoardStackupMessage( curLayer.Name, kicadLayerID );
440  break;
441  }
442  };
443 
444  switch( curLayer.Type )
445  {
446  case LAYER_TYPE::ALLDOC:
447  case LAYER_TYPE::ALLELEC:
448  case LAYER_TYPE::ALLLAYER:
449  case LAYER_TYPE::ASSCOMPCOPP:
450  case LAYER_TYPE::NOLAYER:
451  //Shouldn't be here if CPA file is correctly parsed and not corrupt
452  THROW_IO_ERROR( wxString::Format(
453  _( "Unexpected layer '%s' in layer stack." ), curLayer.Name ) );
454  break;
455 
456  case LAYER_TYPE::JUMPERLAYER:
457  case LAYER_TYPE::ELEC:
458  case LAYER_TYPE::POWER:
459  ++numElecAndPowerLayers;
460  KI_FALLTHROUGH;
461  case LAYER_TYPE::CONSTRUCTION:
462  //Already dealt with these when loading board stackup
463  break;
464 
465  case LAYER_TYPE::DOC:
466  selectLayerID( PCB_LAYER_ID::Dwgs_User, PCB_LAYER_ID::Cmts_User, LOG_LEVEL::WARN );
467  break;
468 
469  case LAYER_TYPE::NONELEC:
470  switch( curLayer.SubType )
471  {
472  case LAYER_SUBTYPE::LAYERSUBTYPE_ASSEMBLY:
473  selectLayerID( PCB_LAYER_ID::F_Fab, PCB_LAYER_ID::B_Fab, LOG_LEVEL::NONE );
474  break;
475 
476  case LAYER_SUBTYPE::LAYERSUBTYPE_PLACEMENT:
477  selectLayerID( PCB_LAYER_ID::F_CrtYd, PCB_LAYER_ID::B_CrtYd, LOG_LEVEL::NONE );
478  break;
479 
480  case LAYER_SUBTYPE::LAYERSUBTYPE_NONE:
481  // Generic Non-electrical layer (older CADSTAR versions).
482  // Attempt to detect technical layers by string matching.
483  if( layerName.Contains( "glue" ) || layerName.Contains( "adhesive" ) )
484  {
485  selectLayerID( PCB_LAYER_ID::F_Adhes, PCB_LAYER_ID::B_Adhes, LOG_LEVEL::MSG );
486  }
487  else if( layerName.Contains( "silk" ) || layerName.Contains( "legend" ) )
488  {
489  selectLayerID( PCB_LAYER_ID::F_SilkS, PCB_LAYER_ID::B_SilkS, LOG_LEVEL::MSG );
490  }
491  else if( layerName.Contains( "assembly" ) || layerName.Contains( "fabrication" ) )
492  {
493  selectLayerID( PCB_LAYER_ID::F_Fab, PCB_LAYER_ID::B_Fab, LOG_LEVEL::MSG );
494  }
495  else if( layerName.Contains( "resist" ) || layerName.Contains( "mask" ) )
496  {
497  selectLayerID( PCB_LAYER_ID::F_Mask, PCB_LAYER_ID::B_Mask, LOG_LEVEL::MSG );
498  }
499  else if( layerName.Contains( "paste" ) )
500  {
501  selectLayerID( PCB_LAYER_ID::F_Paste, PCB_LAYER_ID::B_Paste, LOG_LEVEL::MSG );
502  }
503  else
504  {
505  // Does not appear to be a technical layer - Map to Eco layers for now.
506  selectLayerID( PCB_LAYER_ID::Eco1_User, PCB_LAYER_ID::Eco2_User,
507  LOG_LEVEL::WARN );
508  }
509  break;
510 
511  case LAYER_SUBTYPE::LAYERSUBTYPE_PASTE:
512  selectLayerID( PCB_LAYER_ID::F_Paste, PCB_LAYER_ID::B_Paste, LOG_LEVEL::MSG );
513  break;
514 
515  case LAYER_SUBTYPE::LAYERSUBTYPE_SILKSCREEN:
516  selectLayerID( PCB_LAYER_ID::F_SilkS, PCB_LAYER_ID::B_SilkS, LOG_LEVEL::MSG );
517  break;
518 
519  case LAYER_SUBTYPE::LAYERSUBTYPE_SOLDERRESIST:
520  selectLayerID( PCB_LAYER_ID::F_Mask, PCB_LAYER_ID::B_Mask, LOG_LEVEL::MSG );
521  break;
522 
523  case LAYER_SUBTYPE::LAYERSUBTYPE_ROUT:
524  case LAYER_SUBTYPE::LAYERSUBTYPE_CLEARANCE:
525  //Unsure what these layer types are used for. Map to Eco layers for now.
526  selectLayerID( PCB_LAYER_ID::Eco1_User, PCB_LAYER_ID::Eco2_User, LOG_LEVEL::WARN );
527  break;
528 
529  default:
530  wxFAIL_MSG( "Unknown CADSTAR Layer Sub-type" );
531  break;
532  }
533  break;
534 
535  default:
536  wxFAIL_MSG( "Unknown CADSTAR Layer Type" );
537  break;
538  }
539 
540  m_layermap.insert( { curLayer.ID, kicadLayerID } );
541  }
542 }
543 
544 
545 void CADSTAR_PCB_ARCHIVE_LOADER::remapUnsureLayers()
546 {
547  LSET enabledLayers = m_board->GetEnabledLayers();
548  LSET validRemappingLayers = enabledLayers | LSET::AllBoardTechMask() |
549  LSET::UserMask() | LSET::UserDefinedLayers();
550 
551  std::vector<INPUT_LAYER_DESC> inputLayers;
552  std::map<wxString, LAYER_ID> cadstarLayerNameMap;
553 
554  for( std::pair<LAYER_ID, PCB_LAYER_ID> layerPair : m_layermap )
555  {
556  LAYER* curLayer = &Assignments.Layerdefs.Layers.at( layerPair.first );
557 
558  //Only remap layers that we aren't sure about
559  if( curLayer->Type == LAYER_TYPE::DOC
560  || ( curLayer->Type == LAYER_TYPE::NONELEC
561  && curLayer->SubType == LAYER_SUBTYPE::LAYERSUBTYPE_NONE )
562  || ( curLayer->Type == LAYER_TYPE::NONELEC
563  && curLayer->SubType == LAYER_SUBTYPE::LAYERSUBTYPE_ROUT )
564  || ( curLayer->Type == LAYER_TYPE::NONELEC
565  && curLayer->SubType == LAYER_SUBTYPE::LAYERSUBTYPE_CLEARANCE ) )
566  {
567  INPUT_LAYER_DESC iLdesc;
568  iLdesc.Name = curLayer->Name;
569  iLdesc.PermittedLayers = validRemappingLayers;
570  iLdesc.AutoMapLayer = layerPair.second;
571 
572  inputLayers.push_back( iLdesc );
573  cadstarLayerNameMap.insert( { curLayer->Name, curLayer->ID } );
574  }
575  }
576 
577  if( inputLayers.size() == 0 )
578  return;
579 
580  // Callback:
581  std::map<wxString, PCB_LAYER_ID> reMappedLayers = m_layerMappingHandler( inputLayers );
582 
583  for( std::pair<wxString, PCB_LAYER_ID> layerPair : reMappedLayers )
584  {
585  if( layerPair.second == PCB_LAYER_ID::UNDEFINED_LAYER )
586  {
587  wxFAIL_MSG( "Unexpected Layer ID" );
588  continue;
589  }
590 
591  LAYER_ID cadstarLayerID = cadstarLayerNameMap.at( layerPair.first );
592  m_layermap.at( cadstarLayerID ) = layerPair.second;
593  enabledLayers |= LSET( layerPair.second );
594  }
595 
596  m_board->SetEnabledLayers( enabledLayers );
597  m_board->SetVisibleLayers( enabledLayers );
598 }
599 
600 
601 void CADSTAR_PCB_ARCHIVE_LOADER::loadDesignRules()
602 {
603  BOARD_DESIGN_SETTINGS& ds = m_board->GetDesignSettings();
604  std::map<SPACINGCODE_ID, SPACINGCODE>& spacingCodes = Assignments.Codedefs.SpacingCodes;
605 
606  auto applyRule =
607  [&]( wxString aID, int* aVal )
608  {
609  if( spacingCodes.find( aID ) == spacingCodes.end() )
610  wxLogWarning( _( "Design rule %s was not found. This was ignored." ) );
611  else
612  *aVal = getKiCadLength( spacingCodes.at( aID ).Spacing );
613  };
614 
615  //Note: for details on the different spacing codes see SPACINGCODE::ID
616 
617  applyRule( "T_T", &ds.m_MinClearance );
618  applyRule( "C_B", &ds.m_CopperEdgeClearance );
619  applyRule( "H_H", &ds.m_HoleToHoleMin );
620 
621  ds.m_TrackMinWidth = getKiCadLength( Assignments.Technology.MinRouteWidth );
622  ds.m_ViasMinSize = ds.m_TrackMinWidth; // Not specified, assumed same as track width
623  ds.m_ViasMinAnnulus = ds.m_TrackMinWidth / 2; // Not specified, assumed half track width
624  ds.m_MinThroughDrill = 0; // CADSTAR does not specify a minimum hole size
625  ds.m_HoleClearance = ds.m_CopperEdgeClearance; // Not specified, assumed same as edge
626 
627  auto applyNetClassRule = [&]( wxString aID, NETCLASS* aNetClassPtr,
628  void ( NETCLASS::*aFunc )( int ) ) {
629  int value = -1;
630  applyRule( aID, &value );
631 
632  if( value != -1 )
633  ( aNetClassPtr->*aFunc )( value );
634  };
635 
636  applyNetClassRule( "T_T", ds.GetDefault(), &::NETCLASS::SetClearance );
637 
638  m_board->m_LegacyNetclassesLoaded = true;
639 
640  wxLogWarning( _( "KiCad design rules are different from CADSTAR ones. Only the compatible "
641  "design rules were imported. It is recommended that you review the design "
642  "rules that have been applied." ) );
643 }
644 
645 
646 void CADSTAR_PCB_ARCHIVE_LOADER::loadComponentLibrary()
647 {
648  for( std::pair<SYMDEF_ID, SYMDEF_PCB> symPair : Library.ComponentDefinitions )
649  {
650  SYMDEF_ID key = symPair.first;
651  SYMDEF_PCB component = symPair.second;
652  wxString fpName = component.ReferenceName + ( ( component.Alternate.size() > 0 ) ?
653  ( wxT( " (" ) + component.Alternate + wxT( ")" ) ) :
654  wxT( "" ) );
655  FOOTPRINT* footprint = new FOOTPRINT( m_board );
656  footprint->SetPosition( getKiCadPoint( component.Origin ) );
657 
658  LIB_ID libID;
659  libID.Parse( fpName, true );
660 
661  footprint->SetFPID( libID );
662  loadLibraryFigures( component, footprint );
663  loadLibraryCoppers( component, footprint );
664  loadLibraryAreas( component, footprint );
665  loadLibraryPads( component, footprint );
666 
667  m_libraryMap.insert( std::make_pair( key, footprint ) );
668  }
669 }
670 
671 
672 void CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryFigures( const SYMDEF_PCB& aComponent,
673  FOOTPRINT* aFootprint )
674 {
675  for( std::pair<FIGURE_ID, FIGURE> figPair : aComponent.Figures )
676  {
677  FIGURE& fig = figPair.second;
678 
679  drawCadstarShape( fig.Shape, getKiCadLayer( fig.LayerID ),
680  getLineThickness( fig.LineCodeID ),
681  wxString::Format( "Component %s:%s -> Figure %s",
682  aComponent.ReferenceName,
683  aComponent.Alternate,
684  fig.ID ),
685  aFootprint );
686  }
687 }
688 
689 
690 void CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryCoppers( const SYMDEF_PCB& aComponent, FOOTPRINT* aFootprint )
691 {
692  for( COMPONENT_COPPER compCopper : aComponent.ComponentCoppers )
693  {
694  int lineThickness = getKiCadLength( getCopperCode( compCopper.CopperCodeID ).CopperWidth );
695 
696  drawCadstarShape( compCopper.Shape, getKiCadLayer( compCopper.LayerID ), lineThickness,
697  wxString::Format( "Component %s:%s -> Copper element",
698  aComponent.ReferenceName,
699  aComponent.Alternate ),
700  aFootprint );
701  }
702 }
703 
704 
705 void CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryAreas( const SYMDEF_PCB& aComponent,
706  FOOTPRINT* aFootprint )
707 {
708  for( std::pair<COMP_AREA_ID, COMPONENT_AREA> areaPair : aComponent.ComponentAreas )
709  {
710  COMPONENT_AREA& area = areaPair.second;
711 
712  if( area.NoVias || area.NoTracks )
713  {
714  ZONE* zone = getZoneFromCadstarShape( area.Shape, getLineThickness( area.LineCodeID ),
715  aFootprint );
716 
717  aFootprint->Add( zone, ADD_MODE::APPEND );
718 
719  if( isLayerSet( area.LayerID ) )
720  zone->SetLayerSet( getKiCadLayerSet( area.LayerID ) );
721  else
722  zone->SetLayer( getKiCadLayer( area.LayerID ) );
723 
724  zone->SetIsRuleArea( true ); //import all CADSTAR areas as Keepout zones
725  zone->SetDoNotAllowPads( false ); //no CADSTAR equivalent
726  zone->SetZoneName( area.ID );
727 
728  //There is no distinction between tracks and copper pours in CADSTAR Keepout zones
729  zone->SetDoNotAllowTracks( area.NoTracks );
730  zone->SetDoNotAllowCopperPour( area.NoTracks );
731 
732  zone->SetDoNotAllowVias( area.NoVias );
733  }
734  else
735  {
736  wxString libName = aComponent.ReferenceName;
737 
738  if( !aComponent.Alternate.IsEmpty() )
739  libName << wxT( " (" ) << aComponent.Alternate << wxT( ")" );
740 
741  wxLogError(
742  wxString::Format( _( "The CADSTAR area '%s' in library component '%s' does not "
743  "have a KiCad equivalent. The area is neither a via nor "
744  "route keepout area. The area was not imported." ),
745  area.ID, libName ) );
746  }
747  }
748 }
749 
750 
751 void CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryPads( const SYMDEF_PCB& aComponent,
752  FOOTPRINT* aFootprint )
753 {
754  for( std::pair<PAD_ID, COMPONENT_PAD> padPair : aComponent.ComponentPads )
755  {
756  PAD* pad = getKiCadPad( padPair.second, aFootprint );
757  aFootprint->Add( pad, ADD_MODE::INSERT ); // insert so that we get correct behaviour
758  // when finding pads by PAD_ID - see loadNets()
759  }
760 }
761 
762 
763 PAD* CADSTAR_PCB_ARCHIVE_LOADER::getKiCadPad( const COMPONENT_PAD& aCadstarPad, FOOTPRINT* aParent )
764 {
765  PADCODE csPadcode = getPadCode( aCadstarPad.PadCodeID );
766 
767  PAD* pad = new PAD( aParent );
768 
769  switch( aCadstarPad.Side )
770  {
771  case PAD_SIDE::MAXIMUM: //Bottom side
772  pad->SetAttribute( PAD_ATTR_T::PAD_ATTRIB_SMD );
773  pad->SetLayerSet( LSET( 3, B_Cu, B_Paste, B_Mask ) );
774  break;
775 
776  case PAD_SIDE::MINIMUM: //TOP side
777  pad->SetAttribute( PAD_ATTR_T::PAD_ATTRIB_SMD );
778  pad->SetLayerSet( LSET( 3, F_Cu, F_Paste, F_Mask ) );
779  break;
780 
781  case PAD_SIDE::THROUGH_HOLE:
782  if( csPadcode.Plated )
783  pad->SetAttribute( PAD_ATTR_T::PAD_ATTRIB_PTH );
784  else
785  pad->SetAttribute( PAD_ATTR_T::PAD_ATTRIB_NPTH );
786 
787  pad->SetLayerSet( pad->PTHMask() ); // for now we will assume no paste layers
788  //TODO: We need to read the csPad->Reassigns vector to make sure no paste
789  break;
790 
791  default:
792  wxFAIL_MSG( "Unknown Pad type" );
793  }
794 
795  pad->SetName( aCadstarPad.Identifier.IsEmpty() ?
796  wxString::Format( wxT( "%ld" ), aCadstarPad.ID ) :
797  aCadstarPad.Identifier );
798 
799  if( csPadcode.Shape.Size == 0 )
800  {
801  if( csPadcode.DrillDiameter == UNDEFINED_VALUE
802  && aCadstarPad.Side == PAD_SIDE::THROUGH_HOLE )
803  {
804  // Through-hole, zero sized pad?. Lets load this just on the F_Mask for now to
805  // prevent DRC errors.
806  // TODO: This could be a custom padstack, update when KiCad supports padstacks
807  pad->SetAttribute( PAD_ATTR_T::PAD_ATTRIB_SMD );
808  pad->SetLayerSet( LSET( 1, F_Mask ) );
809  }
810 
811  // zero sized pads seems to break KiCad so lets make it very small instead
812  csPadcode.Shape.Size = 1;
813  }
814 
815  wxPoint padOffset = { 0, 0 }; // offset of the pad origin (before rotating)
816  wxPoint drillOffset = { 0, 0 }; // offset of the drill origin w.r.t. the pad (before rotating)
817 
818  switch( csPadcode.Shape.ShapeType )
819  {
820  case PAD_SHAPE_TYPE::ANNULUS:
821  //todo fix: use custom shape instead (Donught shape, i.e. a circle with a hole)
822  pad->SetShape( PAD_SHAPE_T::PAD_SHAPE_CIRCLE );
823  pad->SetSize( { getKiCadLength( csPadcode.Shape.Size ),
824  getKiCadLength( csPadcode.Shape.Size ) } );
825  break;
826 
827  case PAD_SHAPE_TYPE::BULLET:
828  pad->SetShape( PAD_SHAPE_T::PAD_SHAPE_CHAMFERED_RECT );
829  pad->SetSize( { getKiCadLength( (long long) csPadcode.Shape.Size
830  + (long long) csPadcode.Shape.LeftLength
831  + (long long) csPadcode.Shape.RightLength ),
832  getKiCadLength( csPadcode.Shape.Size ) } );
833  pad->SetChamferPositions( RECT_CHAMFER_POSITIONS::RECT_CHAMFER_BOTTOM_LEFT
834  | RECT_CHAMFER_POSITIONS::RECT_CHAMFER_TOP_LEFT );
835  pad->SetRoundRectRadiusRatio( 0.5 );
836  pad->SetChamferRectRatio( 0.0 );
837 
838  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
839  ( (long long) csPadcode.Shape.RightLength / 2 ) );
840  break;
841 
842  case PAD_SHAPE_TYPE::CIRCLE:
843  pad->SetShape( PAD_SHAPE_T::PAD_SHAPE_CIRCLE );
844  pad->SetSize( { getKiCadLength( csPadcode.Shape.Size ),
845  getKiCadLength( csPadcode.Shape.Size ) } );
846  break;
847 
848  case PAD_SHAPE_TYPE::DIAMOND:
849  {
850  // Cadstar diamond shape is a square rotated 45 degrees
851  // We convert it in KiCad to a square with chamfered edges
852  int sizeOfSquare = (double) getKiCadLength( csPadcode.Shape.Size ) * sqrt(2.0);
853  pad->SetShape( PAD_SHAPE_T::PAD_SHAPE_RECT );
854  pad->SetChamferRectRatio( 0.5 );
855  pad->SetSize( { sizeOfSquare, sizeOfSquare } );
856 
857  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
858  ( (long long) csPadcode.Shape.RightLength / 2 ) );
859  }
860  break;
861 
862  case PAD_SHAPE_TYPE::FINGER:
863  pad->SetShape( PAD_SHAPE_T::PAD_SHAPE_OVAL );
864  pad->SetSize( { getKiCadLength( (long long) csPadcode.Shape.Size
865  + (long long) csPadcode.Shape.LeftLength
866  + (long long) csPadcode.Shape.RightLength ),
867  getKiCadLength( csPadcode.Shape.Size ) } );
868 
869  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
870  ( (long long) csPadcode.Shape.RightLength / 2 ) );
871  break;
872 
873  case PAD_SHAPE_TYPE::OCTAGON:
874  pad->SetShape( PAD_SHAPE_CHAMFERED_RECT );
875  pad->SetChamferPositions( RECT_CHAMFER_POSITIONS::RECT_CHAMFER_ALL );
876  pad->SetChamferRectRatio( 0.25 );
877  pad->SetSize( { getKiCadLength( csPadcode.Shape.Size ),
878  getKiCadLength( csPadcode.Shape.Size ) } );
879  break;
880 
881  case PAD_SHAPE_TYPE::RECTANGLE:
882  pad->SetShape( PAD_SHAPE_T::PAD_SHAPE_RECT );
883  pad->SetSize( { getKiCadLength( (long long) csPadcode.Shape.Size
884  + (long long) csPadcode.Shape.LeftLength
885  + (long long) csPadcode.Shape.RightLength ),
886  getKiCadLength( csPadcode.Shape.Size ) } );
887 
888  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
889  ( (long long) csPadcode.Shape.RightLength / 2 ) );
890  break;
891 
892  case PAD_SHAPE_TYPE::ROUNDED_RECT:
893  pad->SetShape( PAD_SHAPE_T::PAD_SHAPE_RECT );
894  pad->SetRoundRectCornerRadius( getKiCadLength( csPadcode.Shape.InternalFeature ) );
895  pad->SetSize( { getKiCadLength( (long long) csPadcode.Shape.Size
896  + (long long) csPadcode.Shape.LeftLength
897  + (long long) csPadcode.Shape.RightLength ),
898  getKiCadLength( csPadcode.Shape.Size ) } );
899 
900  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
901  ( (long long) csPadcode.Shape.RightLength / 2 ) );
902  break;
903 
904 
905  case PAD_SHAPE_TYPE::SQUARE:
906  pad->SetShape( PAD_SHAPE_T::PAD_SHAPE_RECT );
907  pad->SetSize( { getKiCadLength( csPadcode.Shape.Size ),
908  getKiCadLength( csPadcode.Shape.Size ) } );
909  break;
910 
911  default:
912  wxFAIL_MSG( "Unknown Pad Shape" );
913  }
914 
915  if( csPadcode.ReliefClearance != UNDEFINED_VALUE )
916  pad->SetThermalGap( getKiCadLength( csPadcode.ReliefClearance ) );
917 
918  if( csPadcode.ReliefWidth != UNDEFINED_VALUE )
919  pad->SetThermalSpokeWidth( getKiCadLength( csPadcode.ReliefWidth ) );
920 
921 
922  if( csPadcode.DrillDiameter != UNDEFINED_VALUE )
923  {
924  if( csPadcode.SlotLength != UNDEFINED_VALUE )
925  {
926  pad->SetDrillShape( PAD_DRILL_SHAPE_T::PAD_DRILL_SHAPE_OBLONG );
927  pad->SetDrillSize( { getKiCadLength( (long long) csPadcode.SlotLength +
928  (long long) csPadcode.DrillDiameter ),
929  getKiCadLength( csPadcode.DrillDiameter ) } );
930  }
931  else
932  {
933  pad->SetDrillShape( PAD_DRILL_SHAPE_T::PAD_DRILL_SHAPE_CIRCLE );
934  pad->SetDrillSize( { getKiCadLength( csPadcode.DrillDiameter ),
935  getKiCadLength( csPadcode.DrillDiameter ) } );
936  }
937 
938  drillOffset.x = -getKiCadLength( csPadcode.DrillXoffset );
939  drillOffset.y = getKiCadLength( csPadcode.DrillYoffset );
940  }
941  else
942  {
943  pad->SetDrillSize( { 0, 0 } );
944  }
945 
946 
947  if( csPadcode.SlotOrientation != 0 )
948  {
949  LSET lset = pad->GetLayerSet();
950  lset &= LSET::AllCuMask();
951 
952  if( lset.size() > 0 )
953  {
954  SHAPE_POLY_SET padOutline;
955  PCB_LAYER_ID layer = lset.Seq().at( 0 );
956  int maxError = m_board->GetDesignSettings().m_MaxError;
957 
958  pad->SetPosition( { 0, 0 } );
959  pad->SetPos0( { 0, 0 } );
960  pad->TransformShapeWithClearanceToPolygon( padOutline, layer, 0, maxError,
961  ERROR_LOC::ERROR_INSIDE );
962 
963  PCB_SHAPE* padShape = new PCB_SHAPE;
964  padShape->SetShape( S_POLYGON );
965  padShape->SetFilled( true );
966  padShape->SetPolyShape( padOutline );
967  padShape->SetWidth( 0 );
968  padShape->Move( padOffset - drillOffset );
969  padShape->Rotate( wxPoint( 0, 0 ), 1800.0 - getAngleTenthDegree( csPadcode.SlotOrientation ) );
970 
971 
972  SHAPE_POLY_SET editedPadOutline = padShape->GetPolyShape();
973 
974  if( editedPadOutline.Contains( { 0, 0 } ) )
975  {
976  pad->SetAnchorPadShape( PAD_SHAPE_T::PAD_SHAPE_RECT );
977  pad->SetSize( wxSize( { 4, 4 } ) );
978  pad->SetShape( PAD_SHAPE_T::PAD_SHAPE_CUSTOM );
979  pad->AddPrimitive( padShape );
980  padOffset = { 0, 0 };
981  }
982  else
983  {
984  // The CADSTAR pad has the hole shape outside the pad shape
985  // Lets just put the hole in the center of the pad instead
986  csPadcode.SlotOrientation = 0;
987  drillOffset = { 0, 0 };
988 
989  if( m_padcodesTested.find( csPadcode.ID ) == m_padcodesTested.end() )
990  {
991  wxLogError( wxString::Format(
992  _( "The CADSTAR pad definition '%s' has the hole shape outside the "
993  "pad shape. The hole has been moved to the center of the pad." ),
994  csPadcode.Name ) );
995 
996  m_padcodesTested.insert( csPadcode.ID );
997  }
998  }
999 
1000  }
1001  else
1002  {
1003  wxFAIL_MSG( "No copper layers defined in the pad?" );
1004  csPadcode.SlotOrientation = 0;
1005  pad->SetOffset( drillOffset );
1006  }
1007  }
1008  else
1009  {
1010  pad->SetOffset( drillOffset );
1011  }
1012 
1013  double padOrientation = getAngleTenthDegree( aCadstarPad.OrientAngle )
1014  + getAngleTenthDegree( csPadcode.Shape.OrientAngle );
1015 
1016  RotatePoint( &padOffset, padOrientation );
1017  RotatePoint( &drillOffset, padOrientation );
1018  pad->SetPos0( getKiCadPoint( aCadstarPad.Position ) - aParent->GetPosition() - padOffset
1019  - drillOffset );
1020  pad->SetOrientation( padOrientation + getAngleTenthDegree( csPadcode.SlotOrientation ) );
1021 
1022  //TODO handle csPadcode.Reassigns when KiCad supports full padstacks
1023 
1024  return pad;
1025 }
1026 
1027 
1028 void CADSTAR_PCB_ARCHIVE_LOADER::loadGroups()
1029 {
1030  for( std::pair<GROUP_ID, GROUP> groupPair : Layout.Groups )
1031  {
1032  GROUP& csGroup = groupPair.second;
1033 
1034  PCB_GROUP* kiGroup = new PCB_GROUP( m_board );
1035 
1036  m_board->Add( kiGroup );
1037  kiGroup->SetName( csGroup.Name );
1038  kiGroup->SetLocked( csGroup.Fixed );
1039 
1040  m_groupMap.insert( { csGroup.ID, kiGroup } );
1041  }
1042 
1043  //now add any groups to their parent group
1044  for( std::pair<GROUP_ID, GROUP> groupPair : Layout.Groups )
1045  {
1046  GROUP& csGroup = groupPair.second;
1047 
1048  if( !csGroup.GroupID.IsEmpty() )
1049  {
1050  if( m_groupMap.find( csGroup.ID ) == m_groupMap.end() )
1051  {
1052  THROW_IO_ERROR( wxString::Format(
1053  _( "The file appears to be corrupt. Unable to find group ID %s "
1054  "in the group definitions." ),
1055  csGroup.ID ) );
1056  }
1057  else if( m_groupMap.find( csGroup.ID ) == m_groupMap.end() )
1058  {
1059  THROW_IO_ERROR( wxString::Format(
1060  _( "The file appears to be corrupt. Unable to find sub group %s "
1061  "in the group map (parent group ID=%s, Name=%s)." ),
1062  csGroup.GroupID, csGroup.ID, csGroup.Name ) );
1063  }
1064  else
1065  {
1066  PCB_GROUP* kiCadGroup = m_groupMap.at( csGroup.ID );
1067  PCB_GROUP* parentGroup = m_groupMap.at( csGroup.GroupID );
1068  parentGroup->AddItem( kiCadGroup );
1069  }
1070  }
1071  }
1072 }
1073 
1074 
1075 void CADSTAR_PCB_ARCHIVE_LOADER::loadBoards()
1076 {
1077  for( std::pair<BOARD_ID, CADSTAR_BOARD> boardPair : Layout.Boards )
1078  {
1079  CADSTAR_BOARD& board = boardPair.second;
1080  GROUP_ID boardGroup = createUniqueGroupID( wxT( "Board" ) );
1081  drawCadstarShape( board.Shape, PCB_LAYER_ID::Edge_Cuts,
1082  getLineThickness( board.LineCodeID ), wxString::Format( "BOARD %s", board.ID ),
1083  m_board, boardGroup );
1084 
1085  if( !board.GroupID.IsEmpty() )
1086  {
1087  addToGroup( board.GroupID, getKiCadGroup( boardGroup ) );
1088  }
1089 
1090  //TODO process board attributes when KiCad supports them
1091  }
1092 }
1093 
1094 
1095 void CADSTAR_PCB_ARCHIVE_LOADER::loadFigures()
1096 {
1097  for( std::pair<FIGURE_ID, FIGURE> figPair : Layout.Figures )
1098  {
1099  FIGURE& fig = figPair.second;
1100  drawCadstarShape( fig.Shape, getKiCadLayer( fig.LayerID ),
1101  getLineThickness( fig.LineCodeID ), wxString::Format( "FIGURE %s", fig.ID ), m_board,
1102  fig.GroupID );
1103 
1104  //TODO process "swaprule" (doesn't seem to apply to Layout Figures?)
1105  //TODO process re-use block when KiCad Supports it
1106  //TODO process attributes when KiCad Supports attributes in figures
1107  }
1108 }
1109 
1110 
1111 void CADSTAR_PCB_ARCHIVE_LOADER::loadTexts()
1112 {
1113  for( std::pair<TEXT_ID, TEXT> txtPair : Layout.Texts )
1114  {
1115  TEXT& csTxt = txtPair.second;
1116  drawCadstarText( csTxt, m_board );
1117  }
1118 }
1119 
1120 
1121 void CADSTAR_PCB_ARCHIVE_LOADER::loadDimensions()
1122 {
1123  for( std::pair<DIMENSION_ID, DIMENSION> dimPair : Layout.Dimensions )
1124  {
1125  DIMENSION& csDim = dimPair.second;
1126 
1127  switch( csDim.Type )
1128  {
1129  case DIMENSION::TYPE::LINEARDIM:
1130  switch( csDim.Subtype )
1131  {
1132  case DIMENSION::SUBTYPE::ANGLED:
1133  wxLogWarning( wxString::Format( _( "Dimension ID %s is an angled dimension, which "
1134  "has no KiCad equivalent. An aligned dimension "
1135  "was loaded instead." ),
1136  csDim.ID ) );
1137  KI_FALLTHROUGH;
1138  case DIMENSION::SUBTYPE::DIRECT:
1139  case DIMENSION::SUBTYPE::ORTHOGONAL:
1140  {
1141  if( csDim.Line.Style == DIMENSION::LINE::STYLE::EXTERNAL )
1142  {
1143  wxLogWarning( wxString::Format(
1144  _( "Dimension ID %s has 'External' style in CADSTAR. External "
1145  "dimension styles are not yet supported in KiCad. The dimension "
1146  "object was imported with an internal dimension style instead." ),
1147  csDim.ID ) );
1148  }
1149 
1150  ALIGNED_DIMENSION* dimension = nullptr;
1151 
1152  if( csDim.Subtype == DIMENSION::SUBTYPE::ORTHOGONAL )
1153  {
1154  dimension = new ORTHOGONAL_DIMENSION( m_board );
1155  ORTHOGONAL_DIMENSION* orDim = static_cast<ORTHOGONAL_DIMENSION*>( dimension );
1156 
1157  if( csDim.ExtensionLineParams.Start.x == csDim.Line.Start.x )
1158  orDim->SetOrientation( ORTHOGONAL_DIMENSION::DIR::HORIZONTAL );
1159  else
1160  orDim->SetOrientation( ORTHOGONAL_DIMENSION::DIR::VERTICAL );
1161  }
1162  else
1163  {
1164  dimension = new ALIGNED_DIMENSION( m_board );
1165  }
1166 
1167  m_board->Add( dimension, ADD_MODE::APPEND );
1168  applyDimensionSettings( csDim, dimension );
1169 
1170  dimension->SetExtensionHeight(
1171  getKiCadLength( csDim.ExtensionLineParams.Overshoot ) );
1172 
1173  // Calculate height:
1174  wxPoint crossbarStart = getKiCadPoint( csDim.Line.Start );
1175  wxPoint crossbarEnd = getKiCadPoint( csDim.Line.End );
1176  VECTOR2I crossbarVector = crossbarEnd - crossbarStart;
1177  VECTOR2I heightVector = crossbarStart - dimension->GetStart();
1178  double height = 0.0;
1179 
1180  if( csDim.Subtype == DIMENSION::SUBTYPE::ORTHOGONAL )
1181  {
1182  if( csDim.ExtensionLineParams.Start.x == csDim.Line.Start.x )
1183  height = heightVector.y;
1184  else
1185  height = heightVector.x;
1186  }
1187  else
1188  {
1189  double angle = crossbarVector.Angle() + ( M_PI / 2 );
1190  height = heightVector.x * cos( angle ) + heightVector.y * sin( angle );
1191  }
1192 
1193  dimension->SetHeight( height );
1194  }
1195  break;
1196 
1197  default:
1198  // Radius and diameter dimensions are LEADERDIM (even if not actually leader)
1199  // Angular dimensions are always ANGLEDIM
1200  wxLogError( wxString::Format(
1201  _( "Unexpected Dimension type (ID %s). This was not imported" ),
1202  csDim.ID ) );
1203  continue;
1204  }
1205  break;
1206 
1207  case DIMENSION::TYPE::LEADERDIM:
1208  //TODO: update import when KiCad supports radius and diameter dimensions
1209 
1210  if( csDim.Line.Style == DIMENSION::LINE::STYLE::INTERNAL )
1211  {
1212  // "internal" is a simple double sided arrow from start to end (no extension lines)
1213  ALIGNED_DIMENSION* dimension = new ALIGNED_DIMENSION( m_board );
1214  m_board->Add( dimension, ADD_MODE::APPEND );
1215  applyDimensionSettings( csDim, dimension );
1216 
1217  // Lets set again start/end:
1218  dimension->SetStart( getKiCadPoint( csDim.Line.Start ) );
1219  dimension->SetEnd( getKiCadPoint( csDim.Line.End ) );
1220 
1221  // Do not use any extension lines:
1222  dimension->SetExtensionOffset( 0 );
1223  dimension->SetExtensionHeight( 0 );
1224  dimension->SetHeight( 0 );
1225  }
1226  else
1227  {
1228  // "external" is a "leader" style dimension
1229  LEADER* leaderDim = new LEADER( m_board );
1230  m_board->Add( leaderDim, ADD_MODE::APPEND );
1231 
1232  applyDimensionSettings( csDim, leaderDim );
1233  leaderDim->SetStart( getKiCadPoint( csDim.Line.End ) );
1234 
1235  /*
1236  * In CADSTAR, the resulting shape orientation of the leader dimension depends on
1237  * on the positions of the #Start (S) and #End (E) points as shown below. In the
1238  * diagrams below, the leader angle (angRad) is represented by HEV
1239  *
1240  * Orientation 1: (orientX = -1, | Orientation 2: (orientX = 1,
1241  * orientY = 1) | orientY = 1)
1242  * |
1243  * --------V | V----------
1244  * \ | /
1245  * \ | /
1246  * H _E/ | \E_ H
1247  * |
1248  * S | S
1249  * |
1250  *
1251  * Orientation 3: (orientX = -1, | Orientation 4: (orientX = 1,
1252  * orientY = -1) | orientY = -1)
1253  * |
1254  * S | S
1255  * _ | _
1256  * H E\ | /E H
1257  * / | \
1258  * / | \
1259  * ----------V | V-----------
1260  * |
1261  *
1262  * Corner cases:
1263  *
1264  * It is not possible to generate a leader object with start and end point being
1265  * identical. Assume Orientation 2 if start and end points are identical.
1266  *
1267  * If start and end points are aligned vertically (i.e. S.x == E.x):
1268  * - If E.y > S.y - Orientation 2
1269  * - If E.y < S.y - Orientation 4
1270  *
1271  * If start and end points are aligned horitontally (i.e. S.y == E.y):
1272  * - If E.x > S.x - Orientation 2
1273  * - If E.x < S.x - Orientation 1
1274  */
1275  double angRad = DEG2RAD( getAngleDegrees( csDim.Line.LeaderAngle ) );
1276 
1277  double orientX = 1;
1278  double orientY = 1;
1279 
1280  if( csDim.Line.End.x >= csDim.Line.Start.x )
1281  {
1282  if( csDim.Line.End.y >= csDim.Line.Start.y )
1283  {
1284  //Orientation 2
1285  orientX = 1;
1286  orientY = 1;
1287  }
1288  else
1289  {
1290  //Orientation 4
1291  orientX = 1;
1292  orientY = -1;
1293  }
1294  }
1295  else
1296  {
1297  if( csDim.Line.End.y >= csDim.Line.Start.y )
1298  {
1299  //Orientation 1
1300  orientX = -1;
1301  orientY = 1;
1302  }
1303  else
1304  {
1305  //Orientation 3
1306  orientX = -1;
1307  orientY = -1;
1308  }
1309  }
1310 
1311  wxPoint endOffset( csDim.Line.LeaderLineLength * cos( angRad ) * orientX,
1312  csDim.Line.LeaderLineLength * sin( angRad ) * orientY );
1313 
1314  wxPoint endPoint = csDim.Line.End + endOffset;
1315  wxPoint txtPoint( endPoint.x + ( csDim.Line.LeaderLineExtensionLength * orientX ),
1316  endPoint.y );
1317 
1318  leaderDim->SetEnd( getKiCadPoint( endPoint ) );
1319  leaderDim->Text().SetTextPos( getKiCadPoint( txtPoint ) );
1320  leaderDim->SetText( ParseTextFields( csDim.Text.Text, &m_context ) );
1321  leaderDim->SetPrefix( wxEmptyString );
1322  leaderDim->SetSuffix( wxEmptyString );
1323  leaderDim->SetUnitsFormat( DIM_UNITS_FORMAT::NO_SUFFIX );
1324 
1325  if( orientX == 1 )
1326  leaderDim->Text().SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
1327  else
1328  leaderDim->Text().SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
1329 
1330  leaderDim->SetExtensionOffset( 0 );
1331  }
1332  break;
1333 
1334  case DIMENSION::TYPE::ANGLEDIM:
1335  //TODO: update import when KiCad supports angular dimensions
1336  wxLogError( wxString::Format(
1337  _( "Dimension ID %s is an angular dimension which has no KiCad equivalent. "
1338  "The object was not imported." ),
1339  csDim.ID ) );
1340  break;
1341  }
1342  }
1343 }
1344 
1345 
1346 void CADSTAR_PCB_ARCHIVE_LOADER::loadAreas()
1347 {
1348  for( std::pair<AREA_ID, AREA> areaPair : Layout.Areas )
1349  {
1350  AREA& area = areaPair.second;
1351 
1352  if( area.NoVias || area.NoTracks || area.Keepout || area.Routing )
1353  {
1354  ZONE* zone = getZoneFromCadstarShape( area.Shape, getLineThickness( area.LineCodeID ),
1355  m_board );
1356 
1357  m_board->Add( zone, ADD_MODE::APPEND );
1358 
1359  if( isLayerSet( area.LayerID ) )
1360  zone->SetLayerSet( getKiCadLayerSet( area.LayerID ) );
1361  else
1362  zone->SetLayer( getKiCadLayer( area.LayerID ) );
1363 
1364  zone->SetIsRuleArea( true ); //import all CADSTAR areas as Keepout zones
1365  zone->SetDoNotAllowPads( false ); //no CADSTAR equivalent
1366  zone->SetZoneName( area.Name );
1367 
1368  zone->SetDoNotAllowFootprints( area.Keepout );
1369 
1370  zone->SetDoNotAllowTracks( area.NoTracks );
1371  zone->SetDoNotAllowCopperPour( area.NoTracks );
1372 
1373  zone->SetDoNotAllowVias( area.NoVias );
1374 
1375  if( area.Placement )
1376  wxLogWarning( wxString::Format(
1377  _( "The CADSTAR area '%s' is marked as a placement area in CADSTAR. "
1378  "Placement areas are not supported in KiCad. Only the supported "
1379  "elements for the area were imported." ),
1380  area.Name ) );
1381  }
1382  else
1383  {
1384  wxLogError(
1385  wxString::Format( _( "The CADSTAR area '%s' does not have a KiCad equivalent. "
1386  "Pure Placement areas are not supported." ),
1387  area.Name ) );
1388  }
1389 
1390  //todo Process area.AreaHeight when KiCad supports 3D design rules
1391  //TODO process attributes
1392  //TODO process addition to a group
1393  //TODO process "swaprule"
1394  //TODO process re-use block
1395  }
1396 }
1397 
1398 
1399 void CADSTAR_PCB_ARCHIVE_LOADER::loadComponents()
1400 {
1401  for( std::pair<COMPONENT_ID, COMPONENT> compPair : Layout.Components )
1402  {
1403  COMPONENT& comp = compPair.second;
1404 
1405  if( !comp.VariantID.empty() && comp.VariantParentComponentID != comp.ID )
1406  continue; // Only load master Variant
1407 
1408  auto fpIter = m_libraryMap.find( comp.SymdefID );
1409 
1410  if( fpIter == m_libraryMap.end() )
1411  {
1412  THROW_IO_ERROR( wxString::Format( _( "Unable to find component '%s' in the library"
1413  "(Symdef ID: '%s')" ),
1414  comp.Name, comp.SymdefID ) );
1415  }
1416 
1417  FOOTPRINT* libFootprint = fpIter->second;
1418 
1419  // Use Duplicate() to ensure unique KIID for all objects
1420  FOOTPRINT* footprint = static_cast<FOOTPRINT*>( libFootprint->Duplicate() );
1421 
1422  m_board->Add( footprint, ADD_MODE::APPEND );
1423 
1424  // First lets fix the pad names on the footprint.
1425  // CADSTAR defines the pad name in the PART definition and the SYMDEF (i.e. the PCB
1426  // footprint definition) uses a numerical sequence. COMP is the only object that has
1427  // visibility of both the SYMDEF and PART.
1428  if( Parts.PartDefinitions.find( comp.PartID ) != Parts.PartDefinitions.end() )
1429  {
1430  PART part = Parts.PartDefinitions.at( comp.PartID );
1431 
1432  // Only do this when the number of pins in the part definition equals the number of
1433  // pads in the footprint.
1434  if( part.Definition.Pins.size() == footprint->Pads().size() )
1435  {
1436  for( std::pair<PART_DEFINITION_PIN_ID, PART::DEFINITION::PIN> pinPair :
1437  part.Definition.Pins )
1438  {
1439  PART::DEFINITION::PIN pin = pinPair.second;
1440  wxString pinName = pin.Name;
1441 
1442  if( pinName.empty() )
1443  pinName = pin.Identifier;
1444 
1445  if( pinName.empty() )
1446  pinName = wxString::Format( wxT( "%ld" ), pin.ID );
1447 
1448  footprint->Pads().at( pin.ID - (long long) 1 )->SetName( pinName );
1449  }
1450  }
1451  }
1452 
1453  //Override pads with pad exceptions
1454  if( comp.PadExceptions.size() > 0 )
1455  {
1456  SYMDEF_PCB fpLibEntry = Library.ComponentDefinitions.at( comp.SymdefID );
1457 
1458  for( std::pair<PAD_ID, PADEXCEPTION> padPair : comp.PadExceptions )
1459  {
1460  PADEXCEPTION& padEx = padPair.second;
1461  COMPONENT_PAD csPad = fpLibEntry.ComponentPads.at( padPair.first );
1462 
1463  if( !padEx.PadCode.IsEmpty() )
1464  csPad.PadCodeID = padEx.PadCode;
1465 
1466  if( padEx.OverrideExits )
1467  csPad.Exits = padEx.Exits;
1468 
1469  if( padEx.OverrideOrientation )
1470  csPad.OrientAngle = padEx.OrientAngle;
1471 
1472  if( padEx.OverrideSide )
1473  csPad.Side = padEx.Side;
1474 
1475  // Find the pad in the footprint definition
1476  PAD* kiPad = footprint->Pads().at( padEx.ID - (long long) 1 );
1477  wxString padName = kiPad->GetName();
1478 
1479  if( kiPad )
1480  delete kiPad;
1481 
1482  kiPad = getKiCadPad( csPad, footprint );
1483  kiPad->SetName( padName );
1484  footprint->Pads().at( padEx.ID - (long long) 1 ) = kiPad;
1485  }
1486  }
1487 
1488  //set to empty string to avoid duplication when loading attributes:
1489  footprint->SetValue( wxEmptyString );
1490 
1491  footprint->SetPosition( getKiCadPoint( comp.Origin ) );
1492  footprint->SetOrientation( getAngleTenthDegree( comp.OrientAngle ) );
1493  footprint->SetReference( comp.Name );
1494 
1495  if( comp.Mirror )
1496  {
1497  double mirroredAngle = - getAngleTenthDegree( comp.OrientAngle );
1498  NORMALIZE_ANGLE_180( mirroredAngle );
1499  footprint->SetOrientation( mirroredAngle );
1500  footprint->Flip( getKiCadPoint( comp.Origin ), true );
1501  }
1502 
1503  loadComponentAttributes( comp, footprint );
1504 
1505  if( !comp.PartID.IsEmpty() && comp.PartID != wxT( "NO_PART" ) )
1506  footprint->SetDescription( getPart( comp.PartID ).Definition.Name );
1507 
1508  m_componentMap.insert( { comp.ID, footprint } );
1509  }
1510 }
1511 
1512 
1513 void CADSTAR_PCB_ARCHIVE_LOADER::loadDocumentationSymbols()
1514 {
1515  //No KiCad equivalent. Loaded as graphic and text elements instead
1516 
1517  for( std::pair<DOCUMENTATION_SYMBOL_ID, DOCUMENTATION_SYMBOL> docPair :
1518  Layout.DocumentationSymbols )
1519  {
1520  DOCUMENTATION_SYMBOL& docSymInstance = docPair.second;
1521 
1522 
1523  auto docSymIter = Library.ComponentDefinitions.find( docSymInstance.SymdefID );
1524 
1525  if( docSymIter == Library.ComponentDefinitions.end() )
1526  {
1527  THROW_IO_ERROR( wxString::Format( _( "Unable to find documentation symbol in the "
1528  "library (Symdef ID: '%s')" ),
1529  docSymInstance.SymdefID ) );
1530  }
1531 
1532  SYMDEF_PCB& docSymDefinition = ( *docSymIter ).second;
1533  wxPoint moveVector =
1534  getKiCadPoint( docSymInstance.Origin ) - getKiCadPoint( docSymDefinition.Origin );
1535  double rotationAngle = getAngleTenthDegree( docSymInstance.OrientAngle );
1536  double scalingFactor = (double) docSymInstance.ScaleRatioNumerator
1537  / (double) docSymInstance.ScaleRatioDenominator;
1538  wxPoint centreOfTransform = getKiCadPoint( docSymDefinition.Origin );
1539  bool mirrorInvert = docSymInstance.Mirror;
1540 
1541  //create a group to store the items in
1542  wxString groupName = docSymDefinition.ReferenceName;
1543 
1544  if( !docSymDefinition.Alternate.IsEmpty() )
1545  groupName += wxT( " (" ) + docSymDefinition.Alternate + wxT( ")" );
1546 
1547  GROUP_ID groupID = createUniqueGroupID( groupName );
1548 
1549  LSEQ layers = getKiCadLayerSet( docSymInstance.LayerID ).Seq();
1550 
1551  for( PCB_LAYER_ID layer : layers )
1552  {
1553  for( std::pair<FIGURE_ID, FIGURE> figPair : docSymDefinition.Figures )
1554  {
1555  FIGURE fig = figPair.second;
1556  drawCadstarShape( fig.Shape, layer, getLineThickness( fig.LineCodeID ),
1557  wxString::Format( "DOCUMENTATION SYMBOL %s, FIGURE %s",
1558  docSymDefinition.ReferenceName, fig.ID ),
1559  m_board, groupID, moveVector, rotationAngle, scalingFactor,
1560  centreOfTransform, mirrorInvert );
1561  }
1562  }
1563 
1564  for( std::pair<TEXT_ID, TEXT> textPair : docSymDefinition.Texts )
1565  {
1566  TEXT txt = textPair.second;
1567  drawCadstarText( txt, m_board, groupID, docSymInstance.LayerID, moveVector,
1568  rotationAngle, scalingFactor, centreOfTransform, mirrorInvert );
1569  }
1570  }
1571 }
1572 
1573 
1574 void CADSTAR_PCB_ARCHIVE_LOADER::loadTemplates()
1575 {
1576  for( std::pair<TEMPLATE_ID, TEMPLATE> tempPair : Layout.Templates )
1577  {
1578  TEMPLATE& csTemplate = tempPair.second;
1579 
1580  int zonelinethickness = 0; // The line thickness in CADSTAR is only for display purposes but
1581  // does not affect the end copper result.
1582  ZONE* zone = getZoneFromCadstarShape( csTemplate.Shape, zonelinethickness, m_board );
1583 
1584  m_board->Add( zone, ADD_MODE::APPEND );
1585 
1586  zone->SetZoneName( csTemplate.Name );
1587  zone->SetLayer( getKiCadLayer( csTemplate.LayerID ) );
1588  zone->SetPriority( 1 ); // initially 1, we will increase in calculateZonePriorities
1589 
1590  if( !( csTemplate.NetID.IsEmpty() || csTemplate.NetID == wxT( "NONE" ) ) )
1591  zone->SetNet( getKiCadNet( csTemplate.NetID ) );
1592 
1593  if( csTemplate.Pouring.AllowInNoRouting )
1594  {
1595  wxLogWarning( wxString::Format(
1596  _( "The CADSTAR template '%s' has the setting 'Allow in No Routing Areas' "
1597  "enabled. This setting has no KiCad equivalent, so it has been ignored." ),
1598  csTemplate.Name ) );
1599  }
1600 
1601  if( csTemplate.Pouring.BoxIsolatedPins )
1602  {
1603  wxLogWarning( wxString::Format(
1604  _( "The CADSTAR template '%s' has the setting 'Box Isolated Pins' "
1605  "enabled. This setting has no KiCad equivalent, so it has been ignored." ),
1606  csTemplate.Name ) );
1607  }
1608 
1609  if( csTemplate.Pouring.AutomaticRepour )
1610  {
1611  wxLogWarning( wxString::Format(
1612  _( "The CADSTAR template '%s' has the setting 'Automatic Repour' "
1613  "enabled. This setting has no KiCad equivalent, so it has been ignored." ),
1614  csTemplate.Name ) );
1615  }
1616 
1617  // Sliver width has different behaviour to KiCad Zone's minimum thickness
1618  // In Cadstar 'Sliver width' has to be greater than the Copper thickness, whereas in
1619  // Kicad it is the opposite.
1620  if( csTemplate.Pouring.SliverWidth != 0 )
1621  {
1622  wxLogWarning( wxString::Format(
1623  _( "The CADSTAR template '%s' has a non-zero value defined for the "
1624  "'Sliver Width' setting. There is no KiCad equivalent for "
1625  "this, so this setting was ignored." ),
1626  csTemplate.Name ) );
1627  }
1628 
1629 
1630  if( csTemplate.Pouring.MinIsolatedCopper != csTemplate.Pouring.MinDisjointCopper )
1631  {
1632  wxLogWarning( wxString::Format(
1633  _( "The CADSTAR template '%s' has different settings for 'Retain Poured Copper "
1634  "- Disjoint' and 'Retain Poured Copper - Isolated'. KiCad does not "
1635  "distinguish between these two settings. The setting for disjoint copper "
1636  "has been applied as the minimum island area of the KiCad Zone." ),
1637  csTemplate.Name ) );
1638  }
1639 
1640  long long minIslandArea = -1;
1641 
1642  if( csTemplate.Pouring.MinDisjointCopper != UNDEFINED_VALUE )
1643  {
1644  minIslandArea = (long long) getKiCadLength( csTemplate.Pouring.MinDisjointCopper )
1645  * (long long) getKiCadLength( csTemplate.Pouring.MinDisjointCopper );
1646 
1647  zone->SetIslandRemovalMode( ISLAND_REMOVAL_MODE::AREA );
1648  }
1649  else
1650  {
1651  zone->SetIslandRemovalMode( ISLAND_REMOVAL_MODE::ALWAYS );
1652  }
1653 
1654  zone->SetMinIslandArea( minIslandArea );
1655 
1656  // In cadstar zone clearance is in addition to the design rule "copper to copper"
1657  int clearance = getKiCadLength( csTemplate.Pouring.AdditionalIsolation );
1658 
1659  if( Assignments.Codedefs.SpacingCodes.find( wxT( "C_C" ) )
1660  != Assignments.Codedefs.SpacingCodes.end() )
1661  {
1662  int copperToCopper = Assignments.Codedefs.SpacingCodes.at( wxT( "C_C" ) ).Spacing;
1663  clearance += getKiCadLength( copperToCopper );
1664  }
1665  else
1666  {
1667  clearance += m_board->GetDesignSettings().m_MinClearance;
1668  }
1669 
1670  zone->SetLocalClearance( clearance );
1671 
1672  COPPERCODE pouringCopperCode = getCopperCode( csTemplate.Pouring.CopperCodeID );
1673  int minThickness = getKiCadLength( pouringCopperCode.CopperWidth );
1674  zone->SetMinThickness( minThickness );
1675 
1676  if( csTemplate.Pouring.FillType == TEMPLATE::POURING::COPPER_FILL_TYPE::HATCHED )
1677  {
1678  zone->SetFillMode( ZONE_FILL_MODE::HATCH_PATTERN );
1679  zone->SetHatchGap( getKiCadHatchCodeGap( csTemplate.Pouring.HatchCodeID ) );
1680  zone->SetHatchThickness( getKiCadHatchCodeThickness( csTemplate.Pouring.HatchCodeID ) );
1681  zone->SetHatchOrientation( getHatchCodeAngleDegrees( csTemplate.Pouring.HatchCodeID ) );
1682  }
1683  else
1684  {
1685  zone->SetFillMode( ZONE_FILL_MODE::POLYGONS );
1686  }
1687 
1688  if( csTemplate.Pouring.ThermalReliefOnPads != csTemplate.Pouring.ThermalReliefOnVias
1689  || csTemplate.Pouring.ThermalReliefPadsAngle
1690  != csTemplate.Pouring.ThermalReliefViasAngle )
1691  {
1692  wxLogWarning( wxString::Format(
1693  _( "The CADSTAR template '%s' has different settings for thermal relief "
1694  "in pads and vias. KiCad only supports one single setting for both. The "
1695  "setting for pads has been applied." ),
1696  csTemplate.Name ) );
1697  }
1698 
1699  COPPERCODE reliefCopperCode = getCopperCode( csTemplate.Pouring.ReliefCopperCodeID );
1700  int spokeWidth = getKiCadLength( reliefCopperCode.CopperWidth );
1701  int reliefWidth = getKiCadLength( csTemplate.Pouring.ClearanceWidth );
1702 
1703  // Cadstar supports having a spoke width thinner than the minimum thickness of the zone, but
1704  // this is not permitted in KiCad. We load it as solid fill instead.
1705  if( csTemplate.Pouring.ThermalReliefOnPads && reliefWidth > 0 && spokeWidth > minThickness )
1706  {
1707  zone->SetThermalReliefGap( reliefWidth );
1708  zone->SetThermalReliefSpokeWidth( spokeWidth );
1709  zone->SetPadConnection( ZONE_CONNECTION::THERMAL );
1710  }
1711  else
1712  {
1713  if( csTemplate.Pouring.ThermalReliefOnPads && spokeWidth > minThickness )
1714  {
1715  wxLogWarning( wxString::Format(
1716  _( "The CADSTAR template '%s' has thermal reliefs in the original design "
1717  "but there is no KiCad equivalent to the original CADSTAR settings. "
1718  "Solid fill has been applied instead. When the template is re-filled "
1719  "the thermal reliefs will be removed." ),
1720  csTemplate.Name ) );
1721  }
1722 
1723  zone->SetPadConnection( ZONE_CONNECTION::FULL );
1724  }
1725 
1726  m_zonesMap.insert( { csTemplate.ID, zone } );
1727  }
1728 
1729  //Now create power plane layers:
1730  for( LAYER_ID layer : m_powerPlaneLayers )
1731  {
1732  wxASSERT(
1733  Assignments.Layerdefs.Layers.find( layer ) != Assignments.Layerdefs.Layers.end() );
1734 
1735  //The net name will equal the layer name
1736  wxString powerPlaneLayerName = Assignments.Layerdefs.Layers.at( layer ).Name;
1737  NET_ID netid = wxEmptyString;
1738 
1739  for( std::pair<NET_ID, NET_PCB> netPair : Layout.Nets )
1740  {
1741  NET_PCB net = netPair.second;
1742 
1743  if( net.Name == powerPlaneLayerName )
1744  {
1745  netid = net.ID;
1746  break;
1747  }
1748  }
1749 
1750  if( netid.IsEmpty() )
1751  {
1752  wxLogError( wxString::Format(
1753  _( "The CADSTAR layer '%s' is defined as a power plane layer. However no "
1754  "net with such name exists. The layer has been loaded but no copper zone "
1755  "was created." ),
1756  powerPlaneLayerName ) );
1757  }
1758  else
1759  {
1760  for( std::pair<BOARD_ID, CADSTAR_BOARD> boardPair : Layout.Boards )
1761  {
1762  //create a zone in each board shape
1763  BOARD_DESIGN_SETTINGS& bds = m_board->GetDesignSettings();
1764  CADSTAR_BOARD& board = boardPair.second;
1765  int defaultLineThicknesss = bds.GetLineThickness( PCB_LAYER_ID::Edge_Cuts );
1766  ZONE* zone = getZoneFromCadstarShape( board.Shape, defaultLineThicknesss, m_board );
1767 
1768  m_board->Add( zone, ADD_MODE::APPEND );
1769 
1770  zone->SetZoneName( powerPlaneLayerName );
1771  zone->SetLayer( getKiCadLayer( layer ) );
1772  zone->SetFillMode( ZONE_FILL_MODE::POLYGONS );
1773  zone->SetPadConnection( ZONE_CONNECTION::FULL );
1774  zone->SetMinIslandArea( -1 );
1775  zone->SetPriority( 0 ); // Priority always 0 (lowest priority) for implied power planes.
1776  zone->SetNet( getKiCadNet( netid ) );
1777  }
1778  }
1779  }
1780 }
1781 
1782 
1783 void CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers()
1784 {
1785  for( std::pair<COPPER_ID, COPPER> copPair : Layout.Coppers )
1786  {
1787  COPPER& csCopper = copPair.second;
1788 
1789  if( !csCopper.PouredTemplateID.IsEmpty() )
1790  {
1791  ZONE* pouredZone = m_zonesMap.at( csCopper.PouredTemplateID );
1792  SHAPE_POLY_SET rawPolys;
1793 
1794  int copperWidth = getKiCadLength( getCopperCode( csCopper.CopperCodeID ).CopperWidth );
1795 
1796  if( csCopper.Shape.Type == SHAPE_TYPE::OPENSHAPE )
1797  {
1798  // This is usually for themal reliefs. They are lines of copper with a thickness.
1799  // We convert them to an oval in most cases, but handle also the possibility of
1800  // encountering arcs in here.
1801 
1802  std::vector<PCB_SHAPE*> outlineSegments =
1803  getDrawSegmentsFromVertices( csCopper.Shape.Vertices );
1804 
1805  for( auto& seg : outlineSegments )
1806  {
1807  SHAPE_POLY_SET segment;
1808 
1809  if( seg->GetShape() == PCB_SHAPE_TYPE_T::S_ARC )
1810  {
1811  TransformArcToPolygon( segment, seg->GetStart(), seg->GetArcMid(),
1812  seg->GetEnd(), copperWidth, ARC_HIGH_DEF,
1813  ERROR_LOC::ERROR_INSIDE );
1814  }
1815  else
1816  {
1817  TransformOvalToPolygon( segment, seg->GetStart(), seg->GetEnd(),
1818  copperWidth, ARC_HIGH_DEF, ERROR_LOC::ERROR_INSIDE );
1819  }
1820 
1821  rawPolys.BooleanAdd( segment, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
1822  }
1823 
1824  }
1825  else
1826  {
1827  rawPolys = getPolySetFromCadstarShape( csCopper.Shape, -1 );
1828  rawPolys.Inflate( copperWidth / 2, 32 );
1829  }
1830 
1831 
1832  if( pouredZone->HasFilledPolysForLayer( getKiCadLayer( csCopper.LayerID ) ) )
1833  {
1834  rawPolys.BooleanAdd( pouredZone->RawPolysList( getKiCadLayer( csCopper.LayerID )),
1835  SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
1836  }
1837 
1838  SHAPE_POLY_SET finalPolys = rawPolys;
1839  finalPolys.Fracture( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
1840 
1841  pouredZone->SetFillVersion( 6 );
1842  pouredZone->SetRawPolysList( getKiCadLayer( csCopper.LayerID ), rawPolys );
1843  pouredZone->SetFilledPolysList( getKiCadLayer( csCopper.LayerID ), finalPolys );
1844  pouredZone->SetIsFilled( true );
1845  pouredZone->SetNeedRefill( false );
1846  continue;
1847  }
1848 
1849  // For now we are going to load coppers to a KiCad zone however this isn't perfect
1850  //TODO: Load onto a graphical polygon with a net (when KiCad has this feature)
1851 
1852  if( !m_doneCopperWarning )
1853  {
1854  wxLogWarning(
1855  _( "The CADSTAR design contains COPPER elements, which have no direct KiCad "
1856  "equivalent. These have been imported as a KiCad Zone if solid or hatch "
1857  "filled, or as a KiCad Track if the shape was an unfilled outline (open or "
1858  "closed)." ) );
1859  m_doneCopperWarning = true;
1860  }
1861 
1862 
1863  if( csCopper.Shape.Type == SHAPE_TYPE::OPENSHAPE
1864  || csCopper.Shape.Type == SHAPE_TYPE::OUTLINE )
1865  {
1866  std::vector<PCB_SHAPE*> outlineSegments =
1867  getDrawSegmentsFromVertices( csCopper.Shape.Vertices );
1868 
1869  std::vector<TRACK*> outlineTracks = makeTracksFromDrawsegments( outlineSegments, m_board,
1870  getKiCadNet( csCopper.NetRef.NetID ), getKiCadLayer( csCopper.LayerID ),
1871  getKiCadLength( getCopperCode( csCopper.CopperCodeID ).CopperWidth ) );
1872 
1873  //cleanup
1874  for( PCB_SHAPE* seg : outlineSegments )
1875  delete seg;
1876 
1877  for( CUTOUT cutout : csCopper.Shape.Cutouts )
1878  {
1879  std::vector<PCB_SHAPE*> cutoutSeg =
1880  getDrawSegmentsFromVertices( cutout.Vertices );
1881 
1882  std::vector<TRACK*> cutoutTracks = makeTracksFromDrawsegments( cutoutSeg, m_board,
1883  getKiCadNet( csCopper.NetRef.NetID ), getKiCadLayer( csCopper.LayerID ),
1884  getKiCadLength( getCopperCode( csCopper.CopperCodeID ).CopperWidth ) );
1885 
1886  //cleanup
1887  for( PCB_SHAPE* seg : cutoutSeg )
1888  delete seg;
1889  }
1890  }
1891  else
1892  {
1893  ZONE* zone = getZoneFromCadstarShape( csCopper.Shape,
1894  getKiCadLength( getCopperCode( csCopper.CopperCodeID ).CopperWidth ),
1895  m_board );
1896 
1897  m_board->Add( zone, ADD_MODE::APPEND );
1898 
1899  zone->SetZoneName( csCopper.ID );
1900  zone->SetLayer( getKiCadLayer( csCopper.LayerID ) );
1901  zone->SetHatchStyle( ZONE_BORDER_DISPLAY_STYLE::NO_HATCH );
1902 
1903  if( csCopper.Shape.Type == SHAPE_TYPE::HATCHED )
1904  {
1905  zone->SetFillMode( ZONE_FILL_MODE::HATCH_PATTERN );
1906  zone->SetHatchGap( getKiCadHatchCodeGap( csCopper.Shape.HatchCodeID ) );
1907  zone->SetHatchThickness( getKiCadHatchCodeThickness( csCopper.Shape.HatchCodeID ) );
1908  zone->SetHatchOrientation( getHatchCodeAngleDegrees( csCopper.Shape.HatchCodeID ) );
1909  }
1910  else
1911  {
1912  zone->SetFillMode( ZONE_FILL_MODE::POLYGONS );
1913  }
1914 
1915  zone->SetIslandRemovalMode( ISLAND_REMOVAL_MODE::NEVER );
1916  zone->SetPadConnection( ZONE_CONNECTION::FULL );
1917  zone->SetNet( getKiCadNet( csCopper.NetRef.NetID ) );
1918  zone->SetPriority( m_zonesMap.size() + 1 ); // Highest priority (always fill first)
1919  zone->SetRawPolysList( getKiCadLayer( csCopper.LayerID ), *zone->Outline() );
1920 
1921  SHAPE_POLY_SET fillePolys( *zone->Outline() );
1922  fillePolys.Fracture( SHAPE_POLY_SET::POLYGON_MODE::PM_STRICTLY_SIMPLE );
1923 
1924  zone->SetFillVersion( 6 );
1925  zone->SetFilledPolysList( getKiCadLayer( csCopper.LayerID ), fillePolys );
1926  }
1927  }
1928 }
1929 
1930 
1931 void CADSTAR_PCB_ARCHIVE_LOADER::loadNets()
1932 {
1933  for( std::pair<NET_ID, NET_PCB> netPair : Layout.Nets )
1934  {
1935  NET_PCB net = netPair.second;
1936  wxString netnameForErrorReporting = net.Name;
1937 
1938  if( netnameForErrorReporting.IsEmpty() )
1939  netnameForErrorReporting = wxString::Format( "$%ld", net.SignalNum );
1940 
1941  for( NET_PCB::CONNECTION_PCB connection : net.Connections )
1942  {
1943  if( !connection.Unrouted )
1944  loadNetTracks( net.ID, connection.Route );
1945 
1946  //TODO: all other elements
1947  }
1948 
1949  for( std::pair<NETELEMENT_ID, NET_PCB::VIA> viaPair : net.Vias )
1950  {
1951  NET_PCB::VIA via = viaPair.second;
1952  loadNetVia( net.ID, via );
1953  }
1954 
1955  for( std::pair<NETELEMENT_ID, NET_PCB::PIN> pinPair : net.Pins )
1956  {
1957  NET_PCB::PIN pin = pinPair.second;
1958  FOOTPRINT* footprint = getFootprintFromCadstarID( pin.ComponentID );
1959 
1960  if( footprint == nullptr )
1961  {
1962  wxLogWarning( wxString::Format(
1963  _( "The net '%s' references component ID '%s' which does not exist. "
1964  "This has been ignored." ),
1965  netnameForErrorReporting, pin.ComponentID ) );
1966  }
1967  else if( ( pin.PadID - (long) 1 ) > footprint->Pads().size() )
1968  {
1969  wxLogWarning( wxString::Format( _( "The net '%s' references non-existent pad index"
1970  " '%d' in component '%s'. This has been ignored." ),
1971  netnameForErrorReporting,
1972  pin.PadID,
1973  footprint->GetReference() ) );
1974  }
1975  else
1976  {
1977  // The below works because we have added the pads in the correct order to the
1978  // footprint and the PAD_ID in Cadstar is a sequential, numerical ID
1979  footprint->Pads().at( pin.PadID - (long) 1 )->SetNet( getKiCadNet( net.ID ) );
1980  }
1981  }
1982  }
1983 }
1984 
1985 
1986 void CADSTAR_PCB_ARCHIVE_LOADER::loadTextVariables()
1987 {
1988  auto findAndReplaceTextField =
1989  [&]( TEXT_FIELD_NAME aField, wxString aValue )
1990  {
1991  if( m_context.TextFieldToValuesMap.find( aField ) !=
1992  m_context.TextFieldToValuesMap.end() )
1993  {
1994  if( m_context.TextFieldToValuesMap.at( aField ) != aValue )
1995  {
1996  m_context.TextFieldToValuesMap.at( aField ) = aValue;
1997  m_context.InconsistentTextFields.insert( aField );
1998  return false;
1999  }
2000  }
2001  else
2002  {
2003  m_context.TextFieldToValuesMap.insert( { aField, aValue } );
2004  }
2005 
2006  return true;
2007  };
2008 
2009  if( m_project )
2010  {
2011  std::map<wxString, wxString>& txtVars = m_project->GetTextVars();
2012 
2013  // Most of the design text fields can be derived from other elements
2014  if( Layout.VariantHierarchy.Variants.size() > 0 )
2015  {
2016  VARIANT loadedVar = Layout.VariantHierarchy.Variants.begin()->second;
2017 
2018  findAndReplaceTextField( TEXT_FIELD_NAME::VARIANT_NAME, loadedVar.Name );
2019  findAndReplaceTextField( TEXT_FIELD_NAME::VARIANT_DESCRIPTION, loadedVar.Description );
2020  }
2021 
2022  findAndReplaceTextField( TEXT_FIELD_NAME::DESIGN_TITLE, Header.JobTitle );
2023 
2024  for( std::pair<TEXT_FIELD_NAME, wxString> txtvalue : m_context.TextFieldToValuesMap )
2025  {
2026  wxString varName = CADSTAR_TO_KICAD_FIELDS.at( txtvalue.first );
2027  wxString varValue = txtvalue.second;
2028 
2029  txtVars.insert( { varName, varValue } );
2030  }
2031 
2032  for( std::pair<wxString, wxString> txtvalue : m_context.FilenamesToTextMap )
2033  {
2034  wxString varName = txtvalue.first;
2035  wxString varValue = txtvalue.second;
2036 
2037  txtVars.insert( { varName, varValue } );
2038  }
2039  }
2040  else
2041  {
2042  wxLogError( _( "Text Variables could not be set as there is no project loaded." ) );
2043  }
2044 }
2045 
2046 
2047 void CADSTAR_PCB_ARCHIVE_LOADER::loadComponentAttributes( const COMPONENT& aComponent,
2048  FOOTPRINT* aFootprint )
2049 {
2050  for( std::pair<ATTRIBUTE_ID, ATTRIBUTE_VALUE> attrPair : aComponent.AttributeValues )
2051  {
2052  ATTRIBUTE_VALUE& attrval = attrPair.second;
2053 
2054  if( attrval.HasLocation ) //only import attributes with location. Ignore the rest
2055  {
2056  addAttribute( attrval.AttributeLocation, attrval.AttributeID, aFootprint,
2057  attrval.Value );
2058  }
2059  }
2060 
2061  for( std::pair<ATTRIBUTE_ID, TEXT_LOCATION> textlocPair : aComponent.TextLocations )
2062  {
2063  TEXT_LOCATION& textloc = textlocPair.second;
2064  wxString attrval;
2065 
2066  if( textloc.AttributeID == COMPONENT_NAME_ATTRID )
2067  {
2068  attrval = wxEmptyString; // Designator is loaded separately
2069  }
2070  else if( textloc.AttributeID == COMPONENT_NAME_2_ATTRID )
2071  {
2072  attrval = wxT( "${REFERENCE}" );
2073  }
2074  else if( textloc.AttributeID == PART_NAME_ATTRID )
2075  {
2076  attrval = getPart( aComponent.PartID ).Name;
2077  }
2078  else
2079  attrval = getAttributeValue( textloc.AttributeID, aComponent.AttributeValues );
2080 
2081  addAttribute( textloc, textloc.AttributeID, aFootprint, attrval );
2082  }
2083 }
2084 
2085 
2086 void CADSTAR_PCB_ARCHIVE_LOADER::loadNetTracks(
2087  const NET_ID& aCadstarNetID, const NET_PCB::ROUTE& aCadstarRoute )
2088 {
2089  std::vector<PCB_SHAPE*> shapes;
2090 
2091  POINT prevEnd = aCadstarRoute.StartPoint;
2092 
2093  for( const NET_PCB::ROUTE_VERTEX& v : aCadstarRoute.RouteVertices )
2094  {
2095  PCB_SHAPE* shape = getDrawSegmentFromVertex( prevEnd, v.Vertex );
2096  shape->SetLayer( getKiCadLayer( aCadstarRoute.LayerID ) );
2097  shape->SetWidth( getKiCadLength( v.RouteWidth ) );
2098  shapes.push_back( shape );
2099  prevEnd = v.Vertex.End;
2100  }
2101 
2102  //Todo add real netcode to the tracks
2103  std::vector<TRACK*> tracks =
2104  makeTracksFromDrawsegments( shapes, m_board, getKiCadNet( aCadstarNetID ) );
2105 
2106  //cleanup
2107  for( PCB_SHAPE* shape : shapes )
2108  delete shape;
2109 }
2110 
2111 
2112 void CADSTAR_PCB_ARCHIVE_LOADER::loadNetVia(
2113  const NET_ID& aCadstarNetID, const NET_PCB::VIA& aCadstarVia )
2114 {
2115  VIA* via = new VIA( m_board );
2116  m_board->Add( via, ADD_MODE::APPEND );
2117 
2118  VIACODE csViaCode = getViaCode( aCadstarVia.ViaCodeID );
2119  LAYERPAIR csLayerPair = getLayerPair( aCadstarVia.LayerPairID );
2120 
2121  via->SetPosition( getKiCadPoint( aCadstarVia.Location ) );
2122  via->SetDrill( getKiCadLength( csViaCode.DrillDiameter ) );
2123  via->SetLocked( aCadstarVia.Fixed );
2124 
2125  if( csViaCode.Shape.ShapeType != PAD_SHAPE_TYPE::CIRCLE )
2126  wxLogError( wxString::Format(
2127  _( "The CADSTAR via code '%s' has different shape from a circle defined. "
2128  "KiCad only supports circular vias so this via type has been changed to "
2129  "be a via with circular shape of %.2f mm diameter." ),
2130  csViaCode.Name,
2131  (double) ( (double) getKiCadLength( csViaCode.Shape.Size ) / 1E6 ) ) );
2132 
2133  via->SetWidth( getKiCadLength( csViaCode.Shape.Size ) );
2134 
2135  bool start_layer_outside =
2136  csLayerPair.PhysicalLayerStart == 1
2137  || csLayerPair.PhysicalLayerStart == Assignments.Technology.MaxPhysicalLayer;
2138  bool end_layer_outside =
2139  csLayerPair.PhysicalLayerEnd == 1
2140  || csLayerPair.PhysicalLayerEnd == Assignments.Technology.MaxPhysicalLayer;
2141 
2142  if( start_layer_outside && end_layer_outside )
2143  {
2144  via->SetViaType( VIATYPE::THROUGH );
2145  }
2146  else if( ( !start_layer_outside ) && ( !end_layer_outside ) )
2147  {
2148  via->SetViaType( VIATYPE::BLIND_BURIED );
2149  }
2150  else
2151  {
2152  via->SetViaType( VIATYPE::MICROVIA );
2153  }
2154 
2155  via->SetLayerPair( getKiCadCopperLayerID( csLayerPair.PhysicalLayerStart ),
2156  getKiCadCopperLayerID( csLayerPair.PhysicalLayerEnd ) );
2157  via->SetNet( getKiCadNet( aCadstarNetID ) );
2159 }
2160 
2161 
2162 void CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarText( const TEXT& aCadstarText,
2163  BOARD_ITEM_CONTAINER* aContainer, const GROUP_ID& aCadstarGroupID,
2164  const LAYER_ID& aCadstarLayerOverride, const wxPoint& aMoveVector,
2165  const double& aRotationAngle, const double& aScalingFactor, const wxPoint& aTransformCentre,
2166  const bool& aMirrorInvert )
2167 {
2168  PCB_TEXT* txt = new PCB_TEXT( aContainer );
2169  aContainer->Add( txt );
2170  txt->SetText( aCadstarText.Text );
2171 
2172  wxPoint rotatedTextPos = getKiCadPoint( aCadstarText.Position );
2173  RotatePoint( &rotatedTextPos, aTransformCentre, aRotationAngle );
2174  rotatedTextPos.x =
2175  KiROUND( (double) ( rotatedTextPos.x - aTransformCentre.x ) * aScalingFactor );
2176  rotatedTextPos.y =
2177  KiROUND( (double) ( rotatedTextPos.y - aTransformCentre.y ) * aScalingFactor );
2178  rotatedTextPos += aTransformCentre;
2179  txt->SetTextPos( rotatedTextPos );
2180  txt->SetPosition( rotatedTextPos );
2181 
2182  txt->SetTextAngle( getAngleTenthDegree( aCadstarText.OrientAngle ) + aRotationAngle );
2183 
2184  if( aCadstarText.Mirror != aMirrorInvert ) // If mirroring, invert angle to match CADSTAR
2185  txt->SetTextAngle( -txt->GetTextAngle() );
2186 
2187  txt->SetMirrored( aCadstarText.Mirror );
2188 
2189  TEXTCODE tc = getTextCode( aCadstarText.TextCodeID );
2190 
2191  txt->SetTextThickness( getKiCadLength( tc.LineWidth ) );
2192 
2193  wxSize unscaledTextSize;
2194  unscaledTextSize.x = getKiCadLength( tc.Width );
2195 
2196  // The width is zero for all non-cadstar fonts. Using a width equal to the height seems
2197  // to work well for most fonts.
2198  if( unscaledTextSize.x == 0 )
2199  unscaledTextSize.x = getKiCadLength( tc.Height );
2200 
2201  unscaledTextSize.y = KiROUND( TXT_HEIGHT_RATIO * (double) getKiCadLength( tc.Height ) );
2202  txt->SetTextSize( unscaledTextSize );
2203 
2204  switch( aCadstarText.Alignment )
2205  {
2206  case ALIGNMENT::NO_ALIGNMENT: // Default for Single line text is Bottom Left
2207  case ALIGNMENT::BOTTOMLEFT:
2208  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
2209  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
2210  break;
2211 
2212  case ALIGNMENT::BOTTOMCENTER:
2213  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
2214  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
2215  break;
2216 
2217  case ALIGNMENT::BOTTOMRIGHT:
2218  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
2219  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
2220  break;
2221 
2222  case ALIGNMENT::CENTERLEFT:
2223  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
2224  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
2225  break;
2226 
2227  case ALIGNMENT::CENTERCENTER:
2228  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
2229  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
2230  break;
2231 
2232  case ALIGNMENT::CENTERRIGHT:
2233  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
2234  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
2235  break;
2236 
2237  case ALIGNMENT::TOPLEFT:
2238  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
2239  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
2240  break;
2241 
2242  case ALIGNMENT::TOPCENTER:
2243  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
2244  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
2245  break;
2246 
2247  case ALIGNMENT::TOPRIGHT:
2248  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
2249  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
2250  break;
2251 
2252  default:
2253  wxFAIL_MSG( "Unknown Aligment - needs review!" );
2254  }
2255 
2256  if( aMirrorInvert )
2257  {
2258  txt->Flip( aTransformCentre, true );
2259  }
2260 
2261  //scale it after flipping:
2262  if( aScalingFactor != 1.0 )
2263  {
2264  wxSize scaledTextSize;
2265  scaledTextSize.x = KiROUND( (double) unscaledTextSize.x * aScalingFactor );
2266  scaledTextSize.y = KiROUND( (double) unscaledTextSize.y * aScalingFactor );
2267  txt->SetTextSize( scaledTextSize );
2268  txt->SetTextThickness(
2269  KiROUND( (double) getKiCadLength( tc.LineWidth ) * aScalingFactor ) );
2270  }
2271 
2272  txt->Move( aMoveVector );
2273 
2274  if( aCadstarText.Alignment == ALIGNMENT::NO_ALIGNMENT )
2275  FixTextPositionNoAlignment( txt );
2276 
2277  LAYER_ID layersToDrawOn = aCadstarLayerOverride;
2278 
2279  if( layersToDrawOn.IsEmpty() )
2280  layersToDrawOn = aCadstarText.LayerID;
2281 
2282  if( isLayerSet( layersToDrawOn ) )
2283  {
2284  //Make a copy on each layer
2285 
2286  LSEQ layers = getKiCadLayerSet( layersToDrawOn ).Seq();
2287  PCB_TEXT* newtxt;
2288 
2289  for( PCB_LAYER_ID layer : layers )
2290  {
2291  txt->SetLayer( layer );
2292  newtxt = static_cast<PCB_TEXT*>( txt->Duplicate() );
2293  m_board->Add( newtxt, ADD_MODE::APPEND );
2294 
2295  if( !aCadstarGroupID.IsEmpty() )
2296  addToGroup( aCadstarGroupID, newtxt );
2297  }
2298 
2299  m_board->Remove( txt );
2300  delete txt;
2301  }
2302  else
2303  {
2304  txt->SetLayer( getKiCadLayer( layersToDrawOn ) );
2305 
2306  if( !aCadstarGroupID.IsEmpty() )
2307  addToGroup( aCadstarGroupID, txt );
2308  }
2309  //TODO Handle different font types when KiCad can support it.
2310 }
2311 
2312 
2313 void CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarShape( const SHAPE& aCadstarShape,
2314  const PCB_LAYER_ID& aKiCadLayer,
2315  const int& aLineThickness,
2316  const wxString& aShapeName,
2317  BOARD_ITEM_CONTAINER* aContainer,
2318  const GROUP_ID& aCadstarGroupID,
2319  const wxPoint& aMoveVector,
2320  const double& aRotationAngle,
2321  const double& aScalingFactor,
2322  const wxPoint& aTransformCentre,
2323  const bool& aMirrorInvert )
2324 {
2325  switch( aCadstarShape.Type )
2326  {
2327  case SHAPE_TYPE::OPENSHAPE:
2328  case SHAPE_TYPE::OUTLINE:
2330  drawCadstarVerticesAsSegments( aCadstarShape.Vertices, aKiCadLayer, aLineThickness,
2331  aContainer, aCadstarGroupID, aMoveVector, aRotationAngle, aScalingFactor,
2332  aTransformCentre, aMirrorInvert );
2333  drawCadstarCutoutsAsSegments( aCadstarShape.Cutouts, aKiCadLayer, aLineThickness,
2334  aContainer, aCadstarGroupID, aMoveVector, aRotationAngle, aScalingFactor,
2335  aTransformCentre, aMirrorInvert );
2336  break;
2337 
2338  case SHAPE_TYPE::HATCHED:
2340  wxLogWarning( wxString::Format(
2341  _( "The shape for '%s' is Hatch filled in CADSTAR, which has no KiCad equivalent. "
2342  "Using solid fill instead." ),
2343  aShapeName ) );
2344 
2345  case SHAPE_TYPE::SOLID:
2346  {
2347  PCB_SHAPE* shape;
2348 
2349  if( isFootprint( aContainer ) )
2350  {
2351  shape = new FP_SHAPE( (FOOTPRINT*) aContainer, S_POLYGON );
2352  }
2353  else
2354  {
2355  shape = new PCB_SHAPE( aContainer );
2356  shape->SetShape( S_POLYGON );
2357  }
2358 
2359  shape->SetFilled( true );
2360 
2361  SHAPE_POLY_SET shapePolys = getPolySetFromCadstarShape(
2362  aCadstarShape, -1, aContainer, aMoveVector, aRotationAngle, aScalingFactor,
2363  aTransformCentre, aMirrorInvert );
2364 
2365  shapePolys.Fracture( SHAPE_POLY_SET::POLYGON_MODE::PM_STRICTLY_SIMPLE );
2366 
2367  shape->SetPolyShape( shapePolys );
2368  shape->SetWidth( aLineThickness );
2369  shape->SetLayer( aKiCadLayer );
2370  aContainer->Add( shape, ADD_MODE::APPEND );
2371 
2372  if( !aCadstarGroupID.IsEmpty() )
2373  addToGroup( aCadstarGroupID, shape );
2374  }
2375  break;
2376  }
2377 }
2378 
2379 
2380 void CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarCutoutsAsSegments( const std::vector<CUTOUT>& aCutouts,
2381  const PCB_LAYER_ID& aKiCadLayer,
2382  const int& aLineThickness,
2383  BOARD_ITEM_CONTAINER* aContainer,
2384  const GROUP_ID& aCadstarGroupID,
2385  const wxPoint& aMoveVector,
2386  const double& aRotationAngle,
2387  const double& aScalingFactor,
2388  const wxPoint& aTransformCentre,
2389  const bool& aMirrorInvert )
2390 {
2391  for( CUTOUT cutout : aCutouts )
2392  {
2393  drawCadstarVerticesAsSegments( cutout.Vertices, aKiCadLayer, aLineThickness, aContainer,
2394  aCadstarGroupID, aMoveVector, aRotationAngle, aScalingFactor,
2395  aTransformCentre, aMirrorInvert );
2396  }
2397 }
2398 
2399 
2400 void CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarVerticesAsSegments(
2401  const std::vector<VERTEX>& aCadstarVertices, const PCB_LAYER_ID& aKiCadLayer,
2402  const int& aLineThickness, BOARD_ITEM_CONTAINER* aContainer,
2403  const GROUP_ID& aCadstarGroupID, const wxPoint& aMoveVector, const double& aRotationAngle,
2404  const double& aScalingFactor, const wxPoint& aTransformCentre, const bool& aMirrorInvert )
2405 {
2406  std::vector<PCB_SHAPE*> drawSegments =
2407  getDrawSegmentsFromVertices( aCadstarVertices, aContainer, aCadstarGroupID, aMoveVector,
2408  aRotationAngle, aScalingFactor, aTransformCentre, aMirrorInvert );
2409 
2410  for( PCB_SHAPE* ds : drawSegments )
2411  {
2412  ds->SetWidth( aLineThickness );
2413  ds->SetLayer( aKiCadLayer );
2414  ds->SetParent( aContainer );
2415  aContainer->Add( ds, ADD_MODE::APPEND );
2416  }
2417 }
2418 
2419 
2420 std::vector<PCB_SHAPE*> CADSTAR_PCB_ARCHIVE_LOADER::getDrawSegmentsFromVertices(
2421  const std::vector<VERTEX>& aCadstarVertices, BOARD_ITEM_CONTAINER* aContainer,
2422  const GROUP_ID& aCadstarGroupID, const wxPoint& aMoveVector, const double& aRotationAngle,
2423  const double& aScalingFactor, const wxPoint& aTransformCentre, const bool& aMirrorInvert )
2424 {
2425  std::vector<PCB_SHAPE*> drawSegments;
2426 
2427  if( aCadstarVertices.size() < 2 )
2428  //need at least two points to draw a segment! (unlikely but possible to have only one)
2429  return drawSegments;
2430 
2431  const VERTEX* prev = &aCadstarVertices.at( 0 ); // first one should always be a point vertex
2432  const VERTEX* cur;
2433 
2434  for( size_t i = 1; i < aCadstarVertices.size(); i++ )
2435  {
2436  cur = &aCadstarVertices.at( i );
2437  drawSegments.push_back(
2438  getDrawSegmentFromVertex( prev->End, *cur, aContainer, aCadstarGroupID, aMoveVector,
2439  aRotationAngle, aScalingFactor, aTransformCentre, aMirrorInvert ) );
2440  prev = cur;
2441  }
2442 
2443  return drawSegments;
2444 }
2445 
2446 
2447 PCB_SHAPE* CADSTAR_PCB_ARCHIVE_LOADER::getDrawSegmentFromVertex( const POINT& aCadstarStartPoint,
2448  const VERTEX& aCadstarVertex,
2449  BOARD_ITEM_CONTAINER* aContainer,
2450  const GROUP_ID& aCadstarGroupID,
2451  const wxPoint& aMoveVector,
2452  const double& aRotationAngle,
2453  const double& aScalingFactor,
2454  const wxPoint& aTransformCentre,
2455  const bool& aMirrorInvert )
2456 {
2457  PCB_SHAPE* ds = nullptr;
2458  bool cw = false;
2459  double arcStartAngle, arcEndAngle, arcAngle;
2460 
2461  wxPoint startPoint = getKiCadPoint( aCadstarStartPoint );
2462  wxPoint endPoint = getKiCadPoint( aCadstarVertex.End );
2463  wxPoint centerPoint;
2464 
2465  if( aCadstarVertex.Type == VERTEX_TYPE::ANTICLOCKWISE_SEMICIRCLE
2466  || aCadstarVertex.Type == VERTEX_TYPE::CLOCKWISE_SEMICIRCLE )
2467  centerPoint = ( startPoint + endPoint ) / 2;
2468  else
2469  centerPoint = getKiCadPoint( aCadstarVertex.Center );
2470 
2471  switch( aCadstarVertex.Type )
2472  {
2473 
2474  case VERTEX_TYPE::POINT:
2475 
2476  if( isFootprint( aContainer ) )
2477  {
2478  ds = new FP_SHAPE( static_cast<FOOTPRINT*>( aContainer ), S_SEGMENT );
2479  }
2480  else
2481  {
2482  ds = new PCB_SHAPE( aContainer );
2483  ds->SetShape( S_SEGMENT );
2484  }
2485 
2486  ds->SetStart( startPoint );
2487  ds->SetEnd( endPoint );
2488  break;
2489 
2490  case VERTEX_TYPE::CLOCKWISE_SEMICIRCLE:
2491  case VERTEX_TYPE::CLOCKWISE_ARC:
2492  cw = true;
2493  KI_FALLTHROUGH;
2494 
2495  case VERTEX_TYPE::ANTICLOCKWISE_SEMICIRCLE:
2496  case VERTEX_TYPE::ANTICLOCKWISE_ARC:
2497 
2498  if( isFootprint( aContainer ) )
2499  {
2500  ds = new FP_SHAPE((FOOTPRINT*) aContainer, S_ARC );
2501  }
2502  else
2503  {
2504  ds = new PCB_SHAPE( aContainer );
2505  ds->SetShape( S_ARC );
2506  }
2507 
2508  ds->SetArcStart( startPoint );
2509  ds->SetCenter( centerPoint );
2510 
2511  arcStartAngle = getPolarAngle( startPoint - centerPoint );
2512  arcEndAngle = getPolarAngle( endPoint - centerPoint );
2513  arcAngle = arcEndAngle - arcStartAngle;
2514  //TODO: detect if we are supposed to draw a circle instead (i.e. two SEMICIRCLEs
2515  // with opposite start/end points and same centre point)
2516 
2517  if( cw )
2518  ds->SetAngle( NormalizeAnglePos( arcAngle ) );
2519  else
2520  ds->SetAngle( NormalizeAngleNeg( arcAngle ) );
2521 
2522  break;
2523  }
2524 
2525  //Apply transforms
2526  if( aMirrorInvert )
2527  ds->Flip( aTransformCentre, true );
2528 
2529  if( aScalingFactor != 1.0 )
2530  {
2531  ds->Move( -aTransformCentre );
2532  ds->Scale( aScalingFactor );
2533  ds->Move( aTransformCentre );
2534  }
2535 
2536  if( aRotationAngle != 0.0 )
2537  ds->Rotate( aTransformCentre, aRotationAngle );
2538 
2539  if( aMoveVector != wxPoint{ 0, 0 } )
2540  ds->Move( aMoveVector );
2541 
2542  if( isFootprint( aContainer ) && ds != nullptr )
2543  static_cast<FP_SHAPE*>( ds )->SetLocalCoord();
2544 
2545  if( !aCadstarGroupID.IsEmpty() )
2546  addToGroup( aCadstarGroupID, ds );
2547 
2548  return ds;
2549 }
2550 
2551 
2552 ZONE* CADSTAR_PCB_ARCHIVE_LOADER::getZoneFromCadstarShape( const SHAPE& aCadstarShape,
2553  const int& aLineThickness,
2554  BOARD_ITEM_CONTAINER* aParentContainer )
2555 {
2556  ZONE* zone = new ZONE( aParentContainer, isFootprint( aParentContainer ) );
2557 
2558  if( aCadstarShape.Type == SHAPE_TYPE::HATCHED )
2559  {
2560  zone->SetFillMode( ZONE_FILL_MODE::HATCH_PATTERN );
2561  zone->SetHatchStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_FULL );
2562  }
2563  else
2564  {
2565  zone->SetHatchStyle( ZONE_BORDER_DISPLAY_STYLE::NO_HATCH );
2566  }
2567 
2568  SHAPE_POLY_SET polygon = getPolySetFromCadstarShape( aCadstarShape, aLineThickness );
2569 
2570  zone->AddPolygon( polygon.COutline( 0 ) );
2571 
2572  for( int i = 0; i < polygon.HoleCount( 0 ); i++ )
2573  zone->AddPolygon( polygon.CHole( 0, i ) );
2574 
2575  return zone;
2576 }
2577 
2578 
2579 SHAPE_POLY_SET CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape( const SHAPE& aCadstarShape,
2580  const int& aLineThickness,
2581  BOARD_ITEM_CONTAINER* aContainer,
2582  const wxPoint& aMoveVector,
2583  const double& aRotationAngle,
2584  const double& aScalingFactor,
2585  const wxPoint& aTransformCentre,
2586  const bool& aMirrorInvert )
2587 {
2588  GROUP_ID noGroup = wxEmptyString;
2589 
2590  std::vector<PCB_SHAPE*> outlineSegments = getDrawSegmentsFromVertices( aCadstarShape.Vertices,
2591  aContainer, noGroup,
2592  aMoveVector,
2593  aRotationAngle,
2594  aScalingFactor,
2595  aTransformCentre,
2596  aMirrorInvert );
2597 
2598  SHAPE_POLY_SET polySet( getLineChainFromDrawsegments( outlineSegments ) );
2599 
2600  //cleanup
2601  for( PCB_SHAPE* seg : outlineSegments )
2602  delete seg;
2603 
2604  for( CUTOUT cutout : aCadstarShape.Cutouts )
2605  {
2606  std::vector<PCB_SHAPE*> cutoutSeg = getDrawSegmentsFromVertices( cutout.Vertices,
2607  aContainer, noGroup,
2608  aMoveVector,
2609  aRotationAngle,
2610  aScalingFactor,
2611  aTransformCentre,
2612  aMirrorInvert );
2613 
2614  polySet.AddHole( getLineChainFromDrawsegments( cutoutSeg ) );
2615 
2616  //cleanup
2617  for( PCB_SHAPE* seg : cutoutSeg )
2618  delete seg;
2619  }
2620 
2621  if( aLineThickness > 0 )
2622  polySet.Inflate( aLineThickness / 2, 32, SHAPE_POLY_SET::CORNER_STRATEGY::ROUND_ALL_CORNERS );
2623 
2624 #ifdef DEBUG
2625  for( int i = 0; i < polySet.OutlineCount(); ++i )
2626  {
2627  wxASSERT( polySet.Outline( i ).PointCount() > 2 );
2628 
2629  for( int j = 0; j < polySet.HoleCount( i ); ++j )
2630  {
2631  wxASSERT( polySet.Hole( i, j ).PointCount() > 2 );
2632  }
2633  }
2634 #endif
2635 
2636  return polySet;
2637 }
2638 
2639 
2640 SHAPE_LINE_CHAIN CADSTAR_PCB_ARCHIVE_LOADER::getLineChainFromDrawsegments( const std::vector<PCB_SHAPE*> aDrawsegments )
2641 {
2642  SHAPE_LINE_CHAIN lineChain;
2643 
2644  for( PCB_SHAPE* ds : aDrawsegments )
2645  {
2646  switch( ds->GetShape() )
2647  {
2648  case S_ARC:
2649  {
2650  if( ds->GetClass() == wxT( "MGRAPHIC" ) )
2651  {
2652  FP_SHAPE* em = (FP_SHAPE*) ds;
2653  SHAPE_ARC arc( em->GetStart0(), em->GetEnd0(), (double) em->GetAngle() / 10.0 );
2654  lineChain.Append( arc );
2655  }
2656  else
2657  {
2658  SHAPE_ARC arc( ds->GetCenter(), ds->GetArcStart(), (double) ds->GetAngle() / 10.0 );
2659  lineChain.Append( arc );
2660  }
2661  }
2662  break;
2663  case S_SEGMENT:
2664  if( ds->GetClass() == wxT( "MGRAPHIC" ) )
2665  {
2666  FP_SHAPE* em = (FP_SHAPE*) ds;
2667  lineChain.Append( em->GetStart0().x, em->GetStart0().y );
2668  lineChain.Append( em->GetEnd0().x, em->GetEnd0().y );
2669  }
2670  else
2671  {
2672  lineChain.Append( ds->GetStartX(), ds->GetStartY() );
2673  lineChain.Append( ds->GetEndX(), ds->GetEndY() );
2674  }
2675  break;
2676 
2677  default:
2678  wxFAIL_MSG( "Drawsegment type is unexpected. Ignored." );
2679  }
2680  }
2681 
2682  // Shouldn't have less than 3 points to make a closed shape!
2683  wxASSERT( lineChain.PointCount() > 2 );
2684 
2685  // Check if it is closed
2686  if( lineChain.GetPoint( 0 ) != lineChain.GetPoint( lineChain.PointCount() - 1 ) )
2687  {
2688  lineChain.Append( lineChain.GetPoint( 0 ) );
2689  }
2690 
2691  lineChain.SetClosed( true );
2692 
2693  return lineChain;
2694 }
2695 
2696 
2697 std::vector<TRACK*> CADSTAR_PCB_ARCHIVE_LOADER::makeTracksFromDrawsegments(
2698  const std::vector<PCB_SHAPE*> aDrawsegments,
2699  BOARD_ITEM_CONTAINER* aParentContainer,
2700  NETINFO_ITEM* aNet, PCB_LAYER_ID aLayerOverride,
2701  int aWidthOverride )
2702 {
2703  std::vector<TRACK*> tracks;
2704 
2705  for( PCB_SHAPE* ds : aDrawsegments )
2706  {
2707  TRACK* track;
2708 
2709  switch( ds->GetShape() )
2710  {
2711  case S_ARC:
2712  if( ds->GetClass() == wxT( "MGRAPHIC" ) )
2713  {
2714  FP_SHAPE* em = (FP_SHAPE*) ds;
2715  SHAPE_ARC arc( em->GetStart0(), em->GetEnd0(), (double) em->GetAngle() / 10.0 );
2716  track = new ARC( aParentContainer, &arc );
2717  }
2718  else
2719  {
2720  SHAPE_ARC arc( ds->GetCenter(), ds->GetArcStart(), (double) ds->GetAngle() / 10.0 );
2721  track = new ARC( aParentContainer, &arc );
2722  }
2723  break;
2724  case S_SEGMENT:
2725  if( ds->GetClass() == wxT( "MGRAPHIC" ) )
2726  {
2727  FP_SHAPE* em = (FP_SHAPE*) ds;
2728  track = new TRACK( aParentContainer );
2729  track->SetStart( em->GetStart0() );
2730  track->SetEnd( em->GetEnd0() );
2731  }
2732  else
2733  {
2734  track = new TRACK( aParentContainer );
2735  track->SetStart( ds->GetStart() );
2736  track->SetEnd( ds->GetEnd() );
2737  }
2738  break;
2739 
2740  default:
2741  wxFAIL_MSG( "Drawsegment type is unexpected. Ignored." );
2742  continue;
2743  }
2744 
2745  if( aWidthOverride == -1 )
2746  track->SetWidth( ds->GetWidth() );
2747  else
2748  track->SetWidth( aWidthOverride );
2749 
2750  if( aLayerOverride == PCB_LAYER_ID::UNDEFINED_LAYER )
2751  track->SetLayer( ds->GetLayer() );
2752  else
2753  track->SetLayer( aLayerOverride );
2754 
2755  if( aNet != nullptr )
2756  track->SetNet( aNet );
2757 
2758  tracks.push_back( track );
2759  aParentContainer->Add( track, ADD_MODE::APPEND );
2760  }
2761 
2762  return tracks;
2763 }
2764 
2765 
2766 void CADSTAR_PCB_ARCHIVE_LOADER::addAttribute( const ATTRIBUTE_LOCATION& aCadstarAttrLoc,
2767  const ATTRIBUTE_ID& aCadstarAttributeID,
2768  FOOTPRINT* aFootprint,
2769  const wxString& aAttributeValue )
2770 {
2771  FP_TEXT* txt;
2772 
2773  if( aCadstarAttributeID == COMPONENT_NAME_ATTRID )
2774  {
2775  txt = &aFootprint->Reference(); //text should be set outside this function
2776  }
2777  else if( aCadstarAttributeID == PART_NAME_ATTRID )
2778  {
2779  if( aFootprint->Value().GetText().IsEmpty() )
2780  {
2781  // Use PART_NAME_ATTRID as the value is value field is blank
2782  aFootprint->SetValue( aAttributeValue );
2783  txt = &aFootprint->Value();
2784  }
2785  else
2786  {
2787  txt = new FP_TEXT( aFootprint );
2788  aFootprint->Add( txt );
2789  txt->SetText( aAttributeValue );
2790  }
2791  txt->SetVisible( false ); //make invisible to avoid clutter.
2792  }
2793  else if( aCadstarAttributeID != COMPONENT_NAME_2_ATTRID
2794  && getAttributeName( aCadstarAttributeID ) == wxT( "Value" ) )
2795  {
2796  if( !aFootprint->Value().GetText().IsEmpty() )
2797  {
2798  //copy the object
2799  aFootprint->Add( aFootprint->Value().Duplicate() );
2800  }
2801 
2802  aFootprint->SetValue( aAttributeValue );
2803  txt = &aFootprint->Value();
2804  txt->SetVisible( false ); //make invisible to avoid clutter.
2805  }
2806  else
2807  {
2808  txt = new FP_TEXT( aFootprint );
2809  aFootprint->Add( txt );
2810  txt->SetText( aAttributeValue );
2811  txt->SetVisible( false ); //make all user attributes invisible to avoid clutter.
2812  //TODO: Future improvement - allow user to decide what to do with attributes
2813  }
2814 
2815  wxPoint rotatedTextPos = getKiCadPoint( aCadstarAttrLoc.Position ) - aFootprint->GetPosition();
2816  RotatePoint( &rotatedTextPos, -aFootprint->GetOrientation() );
2817 
2818  txt->SetTextPos( getKiCadPoint( aCadstarAttrLoc.Position ) );
2819  txt->SetPos0( rotatedTextPos );
2820  txt->SetLayer( getKiCadLayer( aCadstarAttrLoc.LayerID ) );
2821  txt->SetMirrored( aCadstarAttrLoc.Mirror );
2822  txt->SetTextAngle(
2823  getAngleTenthDegree( aCadstarAttrLoc.OrientAngle ) - aFootprint->GetOrientation() );
2824 
2825  if( aCadstarAttrLoc.Mirror ) // If mirroring, invert angle to match CADSTAR
2826  txt->SetTextAngle( -txt->GetTextAngle() );
2827 
2828  TEXTCODE tc = getTextCode( aCadstarAttrLoc.TextCodeID );
2829 
2830  txt->SetTextThickness( getKiCadLength( tc.LineWidth ) );
2831 
2832  wxSize txtSize;
2833  txtSize.x = getKiCadLength( tc.Width );
2834 
2835  // The width is zero for all non-cadstar fonts. Using a width equal to the height seems
2836  // to work well for most fonts.
2837  if( txtSize.x == 0 )
2838  txtSize.x = getKiCadLength( tc.Height );
2839 
2840  txtSize.y = KiROUND( TXT_HEIGHT_RATIO * (double) getKiCadLength( tc.Height ) );
2841  txt->SetTextSize( txtSize );
2842  txt->SetKeepUpright( false ); //Keeping it upright seems to result in incorrect orientation
2843 
2844  switch( aCadstarAttrLoc.Alignment )
2845  {
2846  case ALIGNMENT::NO_ALIGNMENT: // Default for Single line text is Bottom Left
2847  FixTextPositionNoAlignment( txt );
2848  KI_FALLTHROUGH;
2849  case ALIGNMENT::BOTTOMLEFT:
2850  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
2851  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
2852  break;
2853 
2854  case ALIGNMENT::BOTTOMCENTER:
2855  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
2856  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
2857  break;
2858 
2859  case ALIGNMENT::BOTTOMRIGHT:
2860  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
2861  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
2862  break;
2863 
2864  case ALIGNMENT::CENTERLEFT:
2865  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
2866  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
2867  break;
2868 
2869  case ALIGNMENT::CENTERCENTER:
2870  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
2871  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
2872  break;
2873 
2874  case ALIGNMENT::CENTERRIGHT:
2875  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
2876  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
2877  break;
2878 
2879  case ALIGNMENT::TOPLEFT:
2880  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
2881  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
2882  break;
2883 
2884  case ALIGNMENT::TOPCENTER:
2885  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
2886  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
2887  break;
2888 
2889  case ALIGNMENT::TOPRIGHT:
2890  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
2891  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
2892  break;
2893 
2894  default:
2895  wxFAIL_MSG( "Unknown Aligment - needs review!" );
2896  }
2897 
2898  //TODO Handle different font types when KiCad can support it.
2899 }
2900 
2901 
2902 int CADSTAR_PCB_ARCHIVE_LOADER::getLineThickness( const LINECODE_ID& aCadstarLineCodeID )
2903 {
2904  wxCHECK( Assignments.Codedefs.LineCodes.find( aCadstarLineCodeID )
2905  != Assignments.Codedefs.LineCodes.end(),
2906  m_board->GetDesignSettings().GetLineThickness( PCB_LAYER_ID::Edge_Cuts ) );
2907 
2908  return getKiCadLength( Assignments.Codedefs.LineCodes.at( aCadstarLineCodeID ).Width );
2909 }
2910 
2911 
2912 CADSTAR_PCB_ARCHIVE_LOADER::COPPERCODE CADSTAR_PCB_ARCHIVE_LOADER::getCopperCode(
2913  const COPPERCODE_ID& aCadstaCopperCodeID )
2914 {
2915  wxCHECK( Assignments.Codedefs.CopperCodes.find( aCadstaCopperCodeID )
2916  != Assignments.Codedefs.CopperCodes.end(),
2917  COPPERCODE() );
2918 
2919  return Assignments.Codedefs.CopperCodes.at( aCadstaCopperCodeID );
2920 }
2921 
2922 
2923 CADSTAR_PCB_ARCHIVE_LOADER::TEXTCODE CADSTAR_PCB_ARCHIVE_LOADER::getTextCode(
2924  const TEXTCODE_ID& aCadstarTextCodeID )
2925 {
2926  wxCHECK( Assignments.Codedefs.TextCodes.find( aCadstarTextCodeID )
2927  != Assignments.Codedefs.TextCodes.end(),
2928  TEXTCODE() );
2929 
2930  return Assignments.Codedefs.TextCodes.at( aCadstarTextCodeID );
2931 }
2932 
2933 
2934 CADSTAR_PCB_ARCHIVE_LOADER::PADCODE CADSTAR_PCB_ARCHIVE_LOADER::getPadCode(
2935  const PADCODE_ID& aCadstarPadCodeID )
2936 {
2937  wxCHECK( Assignments.Codedefs.PadCodes.find( aCadstarPadCodeID )
2938  != Assignments.Codedefs.PadCodes.end(),
2939  PADCODE() );
2940 
2941  return Assignments.Codedefs.PadCodes.at( aCadstarPadCodeID );
2942 }
2943 
2944 
2945 CADSTAR_PCB_ARCHIVE_LOADER::VIACODE CADSTAR_PCB_ARCHIVE_LOADER::getViaCode(
2946  const VIACODE_ID& aCadstarViaCodeID )
2947 {
2948  wxCHECK( Assignments.Codedefs.ViaCodes.find( aCadstarViaCodeID )
2949  != Assignments.Codedefs.ViaCodes.end(),
2950  VIACODE() );
2951 
2952  return Assignments.Codedefs.ViaCodes.at( aCadstarViaCodeID );
2953 }
2954 
2955 
2956 CADSTAR_PCB_ARCHIVE_LOADER::LAYERPAIR CADSTAR_PCB_ARCHIVE_LOADER::getLayerPair(
2957  const LAYERPAIR_ID& aCadstarLayerPairID )
2958 {
2959  wxCHECK( Assignments.Codedefs.LayerPairs.find( aCadstarLayerPairID )
2960  != Assignments.Codedefs.LayerPairs.end(),
2961  LAYERPAIR() );
2962 
2963  return Assignments.Codedefs.LayerPairs.at( aCadstarLayerPairID );
2964 }
2965 
2966 
2967 wxString CADSTAR_PCB_ARCHIVE_LOADER::getAttributeName( const ATTRIBUTE_ID& aCadstarAttributeID )
2968 {
2969  wxCHECK( Assignments.Codedefs.AttributeNames.find( aCadstarAttributeID )
2970  != Assignments.Codedefs.AttributeNames.end(),
2971  wxEmptyString );
2972 
2973  return Assignments.Codedefs.AttributeNames.at( aCadstarAttributeID ).Name;
2974 }
2975 
2976 
2977 wxString CADSTAR_PCB_ARCHIVE_LOADER::getAttributeValue( const ATTRIBUTE_ID& aCadstarAttributeID,
2978  const std::map<ATTRIBUTE_ID, ATTRIBUTE_VALUE>& aCadstarAttributeMap )
2979 {
2980  wxCHECK( aCadstarAttributeMap.find( aCadstarAttributeID ) != aCadstarAttributeMap.end(),
2981  wxEmptyString );
2982 
2983  return aCadstarAttributeMap.at( aCadstarAttributeID ).Value;
2984 }
2985 
2986 
2987 CADSTAR_PCB_ARCHIVE_LOADER::PART CADSTAR_PCB_ARCHIVE_LOADER::getPart(
2988  const PART_ID& aCadstarPartID )
2989 {
2990  wxCHECK( Parts.PartDefinitions.find( aCadstarPartID ) != Parts.PartDefinitions.end(), PART() );
2991 
2992  return Parts.PartDefinitions.at( aCadstarPartID );
2993 }
2994 
2995 
2996 CADSTAR_PCB_ARCHIVE_LOADER::ROUTECODE CADSTAR_PCB_ARCHIVE_LOADER::getRouteCode(
2997  const ROUTECODE_ID& aCadstarRouteCodeID )
2998 {
2999  wxCHECK( Assignments.Codedefs.RouteCodes.find( aCadstarRouteCodeID )
3000  != Assignments.Codedefs.RouteCodes.end(),
3001  ROUTECODE() );
3002 
3003  return Assignments.Codedefs.RouteCodes.at( aCadstarRouteCodeID );
3004 }
3005 
3006 
3007 CADSTAR_PCB_ARCHIVE_LOADER::HATCHCODE CADSTAR_PCB_ARCHIVE_LOADER::getHatchCode(
3008  const HATCHCODE_ID& aCadstarHatchcodeID )
3009 {
3010  wxCHECK( Assignments.Codedefs.HatchCodes.find( aCadstarHatchcodeID )
3011  != Assignments.Codedefs.HatchCodes.end(),
3012  HATCHCODE() );
3013 
3014  return Assignments.Codedefs.HatchCodes.at( aCadstarHatchcodeID );
3015 }
3016 
3017 
3018 double CADSTAR_PCB_ARCHIVE_LOADER::getHatchCodeAngleDegrees(
3019  const HATCHCODE_ID& aCadstarHatchcodeID )
3020 {
3021  checkAndLogHatchCode( aCadstarHatchcodeID );
3022  HATCHCODE hcode = getHatchCode( aCadstarHatchcodeID );
3023 
3024  if( hcode.Hatches.size() < 1 )
3025  return m_board->GetDesignSettings().GetDefaultZoneSettings().m_HatchOrientation;
3026  else
3027  return getAngleDegrees( hcode.Hatches.at( 0 ).OrientAngle );
3028 }
3029 
3030 
3031 int CADSTAR_PCB_ARCHIVE_LOADER::getKiCadHatchCodeThickness(
3032  const HATCHCODE_ID& aCadstarHatchcodeID )
3033 {
3034  checkAndLogHatchCode( aCadstarHatchcodeID );
3035  HATCHCODE hcode = getHatchCode( aCadstarHatchcodeID );
3036 
3037  if( hcode.Hatches.size() < 1 )
3038  return m_board->GetDesignSettings().GetDefaultZoneSettings().m_HatchThickness;
3039  else
3040  return getKiCadLength( hcode.Hatches.at( 0 ).LineWidth );
3041 }
3042 
3043 
3044 int CADSTAR_PCB_ARCHIVE_LOADER::getKiCadHatchCodeGap( const HATCHCODE_ID& aCadstarHatchcodeID )
3045 {
3046  checkAndLogHatchCode( aCadstarHatchcodeID );
3047  HATCHCODE hcode = getHatchCode( aCadstarHatchcodeID );
3048 
3049  if( hcode.Hatches.size() < 1 )
3050  return m_board->GetDesignSettings().GetDefaultZoneSettings().m_HatchGap;
3051  else
3052  return getKiCadLength( hcode.Hatches.at( 0 ).Step );
3053 }
3054 
3055 
3056 PCB_GROUP* CADSTAR_PCB_ARCHIVE_LOADER::getKiCadGroup( const GROUP_ID& aCadstarGroupID )
3057 {
3058  wxCHECK( m_groupMap.find( aCadstarGroupID ) != m_groupMap.end(), nullptr );
3059 
3060  return m_groupMap.at( aCadstarGroupID );
3061 }
3062 
3063 
3064 void CADSTAR_PCB_ARCHIVE_LOADER::checkAndLogHatchCode( const HATCHCODE_ID& aCadstarHatchcodeID )
3065 {
3066  if( m_hatchcodesTested.find( aCadstarHatchcodeID ) != m_hatchcodesTested.end() )
3067  {
3068  return; //already checked
3069  }
3070  else
3071  {
3072  HATCHCODE hcode = getHatchCode( aCadstarHatchcodeID );
3073 
3074  if( hcode.Hatches.size() != 2 )
3075  {
3076  wxLogWarning( wxString::Format(
3077  _( "The CADSTAR Hatching code '%s' has %d hatches defined. "
3078  "KiCad only supports 2 hatches (crosshatching) 90 degrees apart. "
3079  "The imported hatching is crosshatched." ),
3080  hcode.Name, (int) hcode.Hatches.size() ) );
3081  }
3082  else
3083  {
3084  if( hcode.Hatches.at( 0 ).LineWidth != hcode.Hatches.at( 1 ).LineWidth )
3085  {
3086  wxLogWarning( wxString::Format(
3087  _( "The CADSTAR Hatching code '%s' has different line widths for each "
3088  "hatch. KiCad only supports one width for the haching. The imported "
3089  "hatching uses the width defined in the first hatch definition, i.e. "
3090  "%.2f mm." ),
3091  hcode.Name,
3092  (double) ( (double) getKiCadLength( hcode.Hatches.at( 0 ).LineWidth ) )
3093  / 1E6 ) );
3094  }
3095 
3096  if( hcode.Hatches.at( 0 ).Step != hcode.Hatches.at( 1 ).Step )
3097  {
3098  wxLogWarning( wxString::Format(
3099  _( "The CADSTAR Hatching code '%s' has different step sizes for each "
3100  "hatch. KiCad only supports one step size for the haching. The imported "
3101  "hatching uses the step size defined in the first hatching definition, "
3102  "i.e. %.2f mm." ),
3103  hcode.Name,
3104  (double) ( (double) getKiCadLength( hcode.Hatches.at( 0 ).Step ) )
3105  / 1E6 ) );
3106  }
3107 
3108  if( abs( hcode.Hatches.at( 0 ).OrientAngle - hcode.Hatches.at( 1 ).OrientAngle )
3109  != 90000 )
3110  {
3111  wxLogWarning( wxString::Format(
3112  _( "The hatches in CADSTAR Hatching code '%s' have an angle "
3113  "difference of %.1f degrees. KiCad only supports hatching 90 "
3114  "degrees apart. The imported hatching has two hatches 90 "
3115  "degrees apart, oriented %.1f degrees from horizontal." ),
3116  hcode.Name,
3117  getAngleDegrees( abs( hcode.Hatches.at( 0 ).OrientAngle
3118  - hcode.Hatches.at( 1 ).OrientAngle ) ),
3119  getAngleDegrees( hcode.Hatches.at( 0 ).OrientAngle ) ) );
3120  }
3121  }
3122 
3123  m_hatchcodesTested.insert( aCadstarHatchcodeID );
3124  }
3125 }
3126 
3127 
3128 void CADSTAR_PCB_ARCHIVE_LOADER::applyDimensionSettings( const DIMENSION& aCadstarDim,
3129  DIMENSION_BASE* aKiCadDim )
3130 {
3131  UNITS dimensionUnits = aCadstarDim.LinearUnits;
3132  TEXTCODE txtCode = getTextCode( aCadstarDim.Text.TextCodeID );
3133  int correctedHeight = KiROUND( TXT_HEIGHT_RATIO * (double) getKiCadLength( txtCode.Height ) );
3134  wxSize txtSize( getKiCadLength( txtCode.Width ), correctedHeight );
3135  LINECODE linecode = Assignments.Codedefs.LineCodes.at( aCadstarDim.Line.LineCodeID );
3136 
3137  aKiCadDim->SetLayer( getKiCadLayer( aCadstarDim.LayerID ) );
3138  aKiCadDim->SetPrecision( aCadstarDim.Precision );
3139  aKiCadDim->SetStart( getKiCadPoint( aCadstarDim.ExtensionLineParams.Start ) );
3140  aKiCadDim->SetEnd( getKiCadPoint( aCadstarDim.ExtensionLineParams.End ) );
3141  aKiCadDim->SetExtensionOffset( getKiCadLength( aCadstarDim.ExtensionLineParams.Offset ) );
3142  aKiCadDim->SetLineThickness( getKiCadLength( linecode.Width ) );
3143  aKiCadDim->Text().SetTextThickness( getKiCadLength( txtCode.LineWidth ) );
3144  aKiCadDim->Text().SetTextSize( txtSize );
3145 
3146  // Find prefix and suffix:
3147  wxString prefix = wxEmptyString;
3148  wxString suffix = wxEmptyString;
3149  size_t startpos = aCadstarDim.Text.Text.Find( wxT( "<@DISTANCE" ) );
3150 
3151  if( startpos != wxNOT_FOUND )
3152  {
3153  prefix = ParseTextFields( aCadstarDim.Text.Text.SubString( 0, startpos - 1 ), &m_context );
3154  wxString remainingStr = aCadstarDim.Text.Text.Mid( startpos );
3155  size_t endpos = remainingStr.Find( "@>" );
3156  suffix = ParseTextFields( remainingStr.Mid( endpos + 2 ), &m_context );
3157  }
3158 
3159  if( suffix.StartsWith( "mm" ) )
3160  {
3161  aKiCadDim->SetUnitsFormat( DIM_UNITS_FORMAT::BARE_SUFFIX );
3162  suffix = suffix.Mid( 2 );
3163  }
3164  else
3165  {
3166  aKiCadDim->SetUnitsFormat( DIM_UNITS_FORMAT::NO_SUFFIX );
3167  }
3168 
3169  aKiCadDim->SetPrefix( prefix );
3170  aKiCadDim->SetSuffix( suffix );
3171 
3172  if( aCadstarDim.LinearUnits == UNITS::DESIGN )
3173  {
3174  // For now we will hardcode the units as per the original CADSTAR design.
3175  // TODO: update this when KiCad supports design units
3176  aKiCadDim->SetPrecision( Assignments.Technology.UnitDisplPrecision );
3177  dimensionUnits = Assignments.Technology.Units;
3178  }
3179 
3180  switch( dimensionUnits )
3181  {
3182  case UNITS::METER:
3183  case UNITS::CENTIMETER:
3184  case UNITS::MICROMETRE:
3185  wxLogWarning( wxString::Format( _( "Dimension ID %s uses a type of unit that "
3186  "is not supported in KiCad. Milimetres were "
3187  "applied instead." ),
3188  aCadstarDim.ID ) );
3189  KI_FALLTHROUGH;
3190  case UNITS::MM:
3191  aKiCadDim->SetUnitsMode( DIM_UNITS_MODE::MILLIMETRES );
3192  break;
3193 
3194  case UNITS::INCH:
3195  aKiCadDim->SetUnitsMode( DIM_UNITS_MODE::INCHES );
3196  break;
3197 
3198  case UNITS::THOU:
3199  aKiCadDim->SetUnitsMode( DIM_UNITS_MODE::MILS );
3200  break;
3201 
3202  case UNITS::DESIGN:
3203  wxFAIL_MSG( "We should have handled design units before coming here!" );
3204  break;
3205  }
3206 }
3207 
3208 
3209 void CADSTAR_PCB_ARCHIVE_LOADER::calculateZonePriorities()
3210 {
3211  std::map<TEMPLATE_ID, std::set<TEMPLATE_ID>> winningOverlaps;
3212  std::set<std::pair<TEMPLATE_ID, TEMPLATE_ID>> scheduleInferPriorityFromOutline;
3213 
3214  // Calculate the intesection between aPolygon and the outline of aZone
3215  auto intersectionArea = [&]( SHAPE_POLY_SET aPolygon, ZONE* aZone ) -> double
3216  {
3217  SHAPE_POLY_SET intersectShape( *aZone->Outline() );
3218 
3219  intersectShape.BooleanIntersection( aPolygon,
3220  SHAPE_POLY_SET::PM_FAST );
3221  return intersectShape.Area();
3222  };
3223 
3224  // Lambda to determine if the zone with template ID 'a' is lower priority than 'b'
3225  auto isLowerPriority = [&]( const TEMPLATE_ID& a, const TEMPLATE_ID& b ) -> bool
3226  {
3227  return winningOverlaps[b].count( a ) > 0;
3228  };
3229 
3230  for( std::map<TEMPLATE_ID, ZONE*>::iterator it1 = m_zonesMap.begin();
3231  it1 != m_zonesMap.end(); ++it1 )
3232  {
3233  TEMPLATE thisTemplate = Layout.Templates.at( it1->first );
3234  PCB_LAYER_ID thisLayer = getKiCadLayer( thisTemplate.LayerID );
3235  ZONE* thisZone = it1->second;
3236 
3237  for( std::map<TEMPLATE_ID, ZONE*>::iterator it2 = it1;
3238  it2 != m_zonesMap.end(); ++it2 )
3239  {
3240  TEMPLATE otherTemplate = Layout.Templates.at( it2->first );
3241  PCB_LAYER_ID otherLayer = getKiCadLayer( otherTemplate.LayerID );
3242  ZONE* otherZone = it2->second;
3243 
3244  if( thisTemplate.ID == otherTemplate.ID )
3245  continue;
3246 
3247  if( thisLayer != otherLayer )
3248  continue;
3249 
3250  SHAPE_POLY_SET thisZonePolyFill = thisZone->GetFilledPolysList( thisLayer );
3251  SHAPE_POLY_SET otherZonePolyFill = otherZone->GetFilledPolysList( otherLayer );
3252 
3253  if( thisZonePolyFill.Area() > 0.0 && otherZonePolyFill.Area() > 0.0 )
3254  {
3255  // Intersect the filled polygons of thisZone with the *outline* of otherZone
3256  double areaThis = intersectionArea( thisZonePolyFill, otherZone );
3257  // Viceversa
3258  double areaOther = intersectionArea( otherZonePolyFill, thisZone );
3259 
3260  // Best effort: Compare Areas
3261  // If thisZone's fill polygons overlap otherZone's outline *and* the opposite
3262  // is true: otherZone's fill polygons overlap thisZone's outline then compare the
3263  // intersection areas to decide which of the two zones should have higher priority
3264  // There are some edge cases where this might not work, but it is in the minority.
3265  if( areaThis > areaOther )
3266  {
3267  winningOverlaps[thisTemplate.ID].insert( otherTemplate.ID );
3268  }
3269  else if( areaOther > 0.0 )
3270  {
3271  winningOverlaps[otherTemplate.ID].insert( thisTemplate.ID );
3272  }
3273  else
3274  {
3275  scheduleInferPriorityFromOutline.insert(
3276  { thisTemplate.ID, otherTemplate.ID } );
3277  }
3278  }
3279  else
3280  {
3281  // One of the templates is not poured in the original CADSTAR design.
3282  // Lets infer the priority based of the outlines instead
3283  scheduleInferPriorityFromOutline.insert( { thisTemplate.ID, otherTemplate.ID } );
3284  }
3285  }
3286  }
3287 
3288  // Build a set of unique TEMPLATE_IDs of all the zones that intersect with another one
3289  std::set<TEMPLATE_ID> intersectingIDs;
3290 
3291  for( const std::pair<TEMPLATE_ID, std::set<TEMPLATE_ID>>& idPair : winningOverlaps )
3292  {
3293  intersectingIDs.insert( idPair.first );
3294  intersectingIDs.insert( idPair.second.begin(), idPair.second.end() );
3295  }
3296 
3297  // Now store them in a vector
3298  std::vector<TEMPLATE_ID> sortedIDs;
3299 
3300  for( const TEMPLATE_ID& id : intersectingIDs )
3301  {
3302  sortedIDs.push_back( id );
3303  }
3304 
3305  // sort by priority
3306  std::sort( sortedIDs.begin(), sortedIDs.end(), isLowerPriority );
3307 
3308  TEMPLATE_ID prevID = wxEmptyString;
3309 
3310  for( const TEMPLATE_ID& id : sortedIDs )
3311  {
3312  if( prevID.IsEmpty() )
3313  {
3314  prevID = id;
3315  continue;
3316  }
3317 
3318  wxASSERT( !isLowerPriority( id, prevID ) );
3319 
3320  int newPriority = m_zonesMap.at( prevID )->GetPriority();
3321 
3322  // Only increase priority of the current zone
3323  if( isLowerPriority( prevID, id ) )
3324  newPriority++;
3325 
3326  m_zonesMap.at( id )->SetPriority( newPriority );
3327  prevID = id;
3328  }
3329 
3330 }
3331 
3332 
3333 FOOTPRINT* CADSTAR_PCB_ARCHIVE_LOADER::getFootprintFromCadstarID( const COMPONENT_ID& aCadstarComponentID )
3334 {
3335  if( m_componentMap.find( aCadstarComponentID ) == m_componentMap.end() )
3336  return nullptr;
3337  else
3338  return m_componentMap.at( aCadstarComponentID );
3339 }
3340 
3341 
3342 wxPoint CADSTAR_PCB_ARCHIVE_LOADER::getKiCadPoint( wxPoint aCadstarPoint )
3343 {
3344  wxPoint retval;
3345 
3346  retval.x = ( aCadstarPoint.x - m_designCenter.x ) * KiCadUnitMultiplier;
3347  retval.y = -( aCadstarPoint.y - m_designCenter.y ) * KiCadUnitMultiplier;
3348 
3349  return retval;
3350 }
3351 
3352 
3353 double CADSTAR_PCB_ARCHIVE_LOADER::getPolarAngle( wxPoint aPoint )
3354 {
3355 
3356  return NormalizeAnglePos( ArcTangente( aPoint.y, aPoint.x ) );
3357 }
3358 
3359 
3360 NETINFO_ITEM* CADSTAR_PCB_ARCHIVE_LOADER::getKiCadNet( const NET_ID& aCadstarNetID )
3361 {
3362  if( aCadstarNetID.IsEmpty() )
3363  return nullptr;
3364  else if( m_netMap.find( aCadstarNetID ) != m_netMap.end() )
3365  {
3366  return m_netMap.at( aCadstarNetID );
3367  }
3368  else
3369  {
3370  wxCHECK( Layout.Nets.find( aCadstarNetID ) != Layout.Nets.end(), nullptr );
3371 
3372  NET_PCB csNet = Layout.Nets.at( aCadstarNetID );
3373  wxString newName = csNet.Name;
3374 
3375  if( csNet.Name.IsEmpty() )
3376  {
3377  if( csNet.Pins.size() > 0 )
3378  {
3379  // Create default KiCad net naming:
3380 
3381  NET_PCB::PIN firstPin = ( *csNet.Pins.begin() ).second;
3382  //we should have already loaded the component with loadComponents() :
3383  FOOTPRINT* m = getFootprintFromCadstarID( firstPin.ComponentID );
3384  newName = wxT( "Net-(" );
3385  newName << m->Reference().GetText();
3386  newName << "-Pad" << wxString::Format( "%ld", firstPin.PadID ) << ")";
3387  }
3388  else
3389  {
3390  wxFAIL_MSG( "A net with no pins associated?" );
3391  newName = wxT( "csNet-" );
3392  newName << wxString::Format( "%i", csNet.SignalNum );
3393  }
3394  }
3395 
3396  if( !m_doneNetClassWarning && !csNet.NetClassID.IsEmpty()
3397  && csNet.NetClassID != wxT( "NONE" ) )
3398  {
3399  wxLogMessage(
3400  _( "The CADSTAR design contains nets with a 'Net Class' assigned. KiCad does "
3401  "not have an equivalent to CADSTAR's Net Class so these elements were not "
3402  "imported. Note: KiCad's version of 'Net Class' is closer to CADSTAR's "
3403  "'Net Route Code' (which has been imported for all nets)." ) );
3404  m_doneNetClassWarning = true;
3405  }
3406 
3407  if( !m_doneSpacingClassWarning && !csNet.SpacingClassID.IsEmpty()
3408  && csNet.SpacingClassID != wxT( "NONE" ) )
3409  {
3410  wxLogWarning( _( "The CADSTAR design contains nets with a 'Spacing Class' assigned. "
3411  "KiCad does not have an equivalent to CADSTAR's Spacing Class so "
3412  "these elements were not imported. Please review the design rules as "
3413  "copper pours will affected by this." ) );
3414  m_doneSpacingClassWarning = true;
3415  }
3416 
3417  NETINFO_ITEM* netInfo = new NETINFO_ITEM( m_board, newName, ++m_numNets );
3418  m_board->Add( netInfo, ADD_MODE::APPEND );
3419 
3420  if( m_netClassMap.find( csNet.RouteCodeID ) != m_netClassMap.end() )
3421  {
3422  NETCLASSPTR netclass = m_netClassMap.at( csNet.RouteCodeID );
3423  netInfo->SetNetClass( netclass );
3424  }
3425  else
3426  {
3427  ROUTECODE rc = getRouteCode( csNet.RouteCodeID );
3428  NETCLASSPTR netclass( new NETCLASS( rc.Name ) );
3429  netclass->SetTrackWidth( getKiCadLength( rc.OptimalWidth ) );
3430  netInfo->SetNetClass( netclass );
3431  m_netClassMap.insert( { csNet.RouteCodeID, netclass } );
3432  }
3433 
3434  m_netMap.insert( { aCadstarNetID, netInfo } );
3435  return netInfo;
3436  }
3437 
3438  return nullptr;
3439 }
3440 
3441 
3442 PCB_LAYER_ID CADSTAR_PCB_ARCHIVE_LOADER::getKiCadCopperLayerID( unsigned int aLayerNum, bool aDetectMaxLayer )
3443 {
3444  if( aDetectMaxLayer && aLayerNum == Assignments.Technology.MaxPhysicalLayer )
3445  return PCB_LAYER_ID::B_Cu;
3446 
3447  switch( aLayerNum )
3448  {
3449  case 1: return PCB_LAYER_ID::F_Cu;
3450  case 2: return PCB_LAYER_ID::In1_Cu;
3451  case 3: return PCB_LAYER_ID::In2_Cu;
3452  case 4: return PCB_LAYER_ID::In3_Cu;
3453  case 5: return PCB_LAYER_ID::In4_Cu;
3454  case 6: return PCB_LAYER_ID::In5_Cu;
3455  case 7: return PCB_LAYER_ID::In6_Cu;
3456  case 8: return PCB_LAYER_ID::In7_Cu;
3457  case 9: return PCB_LAYER_ID::In8_Cu;
3458  case 10: return PCB_LAYER_ID::In9_Cu;
3459  case 11: return PCB_LAYER_ID::In10_Cu;
3460  case 12: return PCB_LAYER_ID::In11_Cu;
3461  case 13: return PCB_LAYER_ID::In12_Cu;
3462  case 14: return PCB_LAYER_ID::In13_Cu;
3463  case 15: return PCB_LAYER_ID::In14_Cu;
3464  case 16: return PCB_LAYER_ID::In15_Cu;
3465  case 17: return PCB_LAYER_ID::In16_Cu;
3466  case 18: return PCB_LAYER_ID::In17_Cu;
3467  case 19: return PCB_LAYER_ID::In18_Cu;
3468  case 20: return PCB_LAYER_ID::In19_Cu;
3469  case 21: return PCB_LAYER_ID::In20_Cu;
3470  case 22: return PCB_LAYER_ID::In21_Cu;
3471  case 23: return PCB_LAYER_ID::In22_Cu;
3472  case 24: return PCB_LAYER_ID::In23_Cu;
3473  case 25: return PCB_LAYER_ID::In24_Cu;
3474  case 26: return PCB_LAYER_ID::In25_Cu;
3475  case 27: return PCB_LAYER_ID::In26_Cu;
3476  case 28: return PCB_LAYER_ID::In27_Cu;
3477  case 29: return PCB_LAYER_ID::In28_Cu;
3478  case 30: return PCB_LAYER_ID::In29_Cu;
3479  case 31: return PCB_LAYER_ID::In30_Cu;
3480  case 32: return PCB_LAYER_ID::B_Cu;
3481  }
3482 
3483  return PCB_LAYER_ID::UNDEFINED_LAYER;
3484 }
3485 
3486 bool CADSTAR_PCB_ARCHIVE_LOADER::isLayerSet( const LAYER_ID& aCadstarLayerID )
3487 {
3488  wxCHECK( Assignments.Layerdefs.Layers.find( aCadstarLayerID )
3489  != Assignments.Layerdefs.Layers.end(),
3490  false );
3491 
3492  LAYER& layer = Assignments.Layerdefs.Layers.at( aCadstarLayerID );
3493 
3494  switch( layer.Type )
3495  {
3496  case LAYER_TYPE::ALLDOC:
3497  case LAYER_TYPE::ALLELEC:
3498  case LAYER_TYPE::ALLLAYER:
3499  return true;
3500 
3501  default:
3502  return false;
3503  }
3504 
3505  return false;
3506 }
3507 
3508 
3509 PCB_LAYER_ID CADSTAR_PCB_ARCHIVE_LOADER::getKiCadLayer( const LAYER_ID& aCadstarLayerID )
3510 {
3511  if( Assignments.Layerdefs.Layers.find( aCadstarLayerID ) != Assignments.Layerdefs.Layers.end() )
3512  {
3513  if( Assignments.Layerdefs.Layers.at( aCadstarLayerID ).Type == LAYER_TYPE::NOLAYER )
3514  //The "no layer" is common for CADSTAR documentation symbols
3515  //map it to undefined layer for later processing
3516  return PCB_LAYER_ID::UNDEFINED_LAYER;
3517  }
3518 
3519  wxCHECK( m_layermap.find( aCadstarLayerID ) != m_layermap.end(), PCB_LAYER_ID::UNDEFINED_LAYER );
3520 
3521  return m_layermap.at( aCadstarLayerID );
3522 }
3523 
3524 
3525 LSET CADSTAR_PCB_ARCHIVE_LOADER::getKiCadLayerSet( const LAYER_ID& aCadstarLayerID )
3526 {
3527  LAYER& layer = Assignments.Layerdefs.Layers.at( aCadstarLayerID );
3528 
3529  switch( layer.Type )
3530  {
3531  case LAYER_TYPE::ALLDOC:
3532  return LSET( 4, PCB_LAYER_ID::Dwgs_User, PCB_LAYER_ID::Cmts_User, PCB_LAYER_ID::Eco1_User,
3533  PCB_LAYER_ID::Eco2_User );
3534 
3535  case LAYER_TYPE::ALLELEC:
3536  return LSET::AllCuMask();
3537 
3538  case LAYER_TYPE::ALLLAYER:
3539  return LSET::AllLayersMask();
3540 
3541  default:
3542  return LSET( getKiCadLayer( aCadstarLayerID ) );
3543  }
3544 }
3545 
3546 
3547 void CADSTAR_PCB_ARCHIVE_LOADER::addToGroup(
3548  const GROUP_ID& aCadstarGroupID, BOARD_ITEM* aKiCadItem )
3549 {
3550  wxCHECK( m_groupMap.find( aCadstarGroupID ) != m_groupMap.end(), );
3551 
3552  PCB_GROUP* parentGroup = m_groupMap.at( aCadstarGroupID );
3553  parentGroup->AddItem( aKiCadItem );
3554 }
3555 
3556 
3557 CADSTAR_PCB_ARCHIVE_LOADER::GROUP_ID CADSTAR_PCB_ARCHIVE_LOADER::createUniqueGroupID(
3558  const wxString& aName )
3559 {
3560  wxString groupName = aName;
3561  int num = 0;
3562 
3563  while( m_groupMap.find( groupName ) != m_groupMap.end() )
3564  {
3565  groupName = aName + wxT( "_" ) + wxString::Format( "%i", ++num );
3566  }
3567 
3568  PCB_GROUP* docSymGroup = new PCB_GROUP( m_board );
3569  m_board->Add( docSymGroup );
3570  docSymGroup->SetName( groupName );
3571  GROUP_ID groupID( groupName );
3572  m_groupMap.insert( { groupID, docSymGroup } );
3573 
3574  return groupID;
3575 }
EDA_TEXT::SetMirrored
void SetMirrored(bool isMirrored)
Definition: eda_text.h:195
FP_SHAPE
Definition: fp_shape.h:39
FOOTPRINT::SetReference
void SetReference(const wxString &aReference)
Definition: footprint.h:432
LSET::UserDefinedLayers
static LSET UserDefinedLayers()
Return a mask with all of the allowable user defined layers.
Definition: lset.cpp:856
CADSTAR_ARCHIVE_PARSER::TEXT_FIELD_NAME::VARIANT_NAME
LSET::AllCuMask
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:750
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE::Name
wxString Name
Definition: cadstar_pcb_archive_parser.h:299
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE_TYPE::ANNULUS
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_PAD::OrientAngle
long OrientAngle
Definition: cadstar_pcb_archive_parser.h:531
CADSTAR_ARCHIVE_PARSER::CUTOUT::Vertices
std::vector< VERTEX > Vertices
Definition: cadstar_archive_parser.h:432
CADSTAR_ARCHIVE_PARSER::SHAPE::Type
SHAPE_TYPE Type
Definition: cadstar_archive_parser.h:449
CADSTAR_PCB_ARCHIVE_LOADER::getCopperCode
COPPERCODE getCopperCode(const COPPERCODE_ID &aCadstaCopperCodeID)
Definition: cadstar_pcb_archive_loader.cpp:2912
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT::VariantParentComponentID
COMPONENT_ID VariantParentComponentID
Definition: cadstar_pcb_archive_parser.h:904
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE::Shape
PAD_SHAPE Shape
Definition: cadstar_pcb_archive_parser.h:300
In29_Cu
Definition: layers_id_colors_and_visibility.h:104
ZONE_BORDER_DISPLAY_STYLE::NO_HATCH
CADSTAR_PCB_ARCHIVE_LOADER::getKiCadLength
int getKiCadLength(long long aCadstarLength)
Definition: cadstar_pcb_archive_loader.h:399
CADSTAR_PCB_ARCHIVE_PARSER::PADEXCEPTION::ID
PAD_ID ID
Definition: cadstar_pcb_archive_parser.h:880
In27_Cu
Definition: layers_id_colors_and_visibility.h:102
BS_ITEM_TYPE_DIELECTRIC
Definition: class_board_stackup.h:44
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_VALUE::Value
wxString Value
Definition: cadstar_archive_parser.h:727
CADSTAR_ARCHIVE_PARSER::DOCUMENTATION_SYMBOL::LayerID
LAYER_ID LayerID
Move all objects in the Symdef to this layer.
Definition: cadstar_archive_parser.h:1197
PCB_GROUP::AddItem
bool AddItem(BOARD_ITEM *aItem)
Add item to group.
Definition: pcb_group.cpp:38
CADSTAR_PCB_ARCHIVE_LOADER::addAttribute
void addAttribute(const ATTRIBUTE_LOCATION &aCadstarAttrLoc, const ATTRIBUTE_ID &aCadstarAttributeID, FOOTPRINT *aFootprint, const wxString &aAttributeValue)
Adds a CADSTAR Attribute to a KiCad footprint.
Definition: cadstar_pcb_archive_loader.cpp:2766
CADSTAR_PCB_ARCHIVE_LOADER::getKiCadHatchCodeGap
int getKiCadHatchCodeGap(const HATCHCODE_ID &aCadstarHatchcodeID)
Definition: cadstar_pcb_archive_loader.cpp:3044
BOARD_ITEM_CONTAINER::Add
virtual void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT)=0
Adds an item to the container.
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_TYPE::NONELEC
This type has subtypes.
ZONE::SetIslandRemovalMode
void SetIslandRemovalMode(ISLAND_REMOVAL_MODE aRemove)
Definition: zone.h:770
PAD::SetOffset
void SetOffset(const wxPoint &aOffset)
Definition: pad.h:248
CADSTAR_PCB_ARCHIVE_PARSER::PADEXCEPTION::OverrideExits
bool OverrideExits
Definition: cadstar_pcb_archive_parser.h:882
VIA
Definition: track.h:343
PROJECT::GetTextVars
virtual std::map< wxString, wxString > & GetTextVars() const
Definition: common/project.cpp:78
CADSTAR_PCB_ARCHIVE_PARSER::LAYERPAIR
Definition: cadstar_pcb_archive_parser.h:342
CADSTAR_ARCHIVE_PARSER::CODEDEFS::RouteCodes
std::map< ROUTECODE_ID, ROUTECODE > RouteCodes
Definition: cadstar_archive_parser.h:780
ZONE::SetHatchThickness
void SetHatchThickness(int aThickness)
Definition: zone.h:257
CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Layerdefs
LAYERDEFS Layerdefs
Definition: cadstar_pcb_archive_parser.h:424
NormalizeAngleNeg
T NormalizeAngleNeg(T Angle)
Normalize angle to be in the 0.0 .
Definition: trigo.h:267
CADSTAR_ARCHIVE_PARSER::SYMDEF_ID
wxString SYMDEF_ID
Definition: cadstar_archive_parser.h:94
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::Pouring
POURING Pouring
Copper pour settings (e.g. relief / hatching /etc.)
Definition: cadstar_pcb_archive_parser.h:1100
CADSTAR_PCB_ARCHIVE_PARSER::PADEXCEPTION::PadCode
PADCODE_ID PadCode
If not empty, override padcode.
Definition: cadstar_pcb_archive_parser.h:881
CADSTAR_PCB_ARCHIVE_PARSER::MATERIAL::Name
wxString Name
Definition: cadstar_pcb_archive_parser.h:92
CADSTAR_PCB_ARCHIVE_PARSER::VIACODE::Name
wxString Name
Definition: cadstar_pcb_archive_parser.h:329
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_AREA::Shape
SHAPE Shape
Definition: cadstar_pcb_archive_parser.h:460
CADSTAR_PCB_ARCHIVE_PARSER::Parts
PARTS Parts
Definition: cadstar_pcb_archive_parser.h:1205
CADSTAR_PCB_ARCHIVE_LOADER::loadTextVariables
void loadTextVariables()
Definition: cadstar_pcb_archive_loader.cpp:1986
ZONE::HasFilledPolysForLayer
bool HasFilledPolysForLayer(PCB_LAYER_ID aLayer) const
Definition: zone.h:645
FP_TEXT
Definition: fp_text.h:39
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_TYPE::ALLDOC
Inbuilt layer type (cannot be assigned to user layers)
ADD_MODE::INSERT
SHAPE_POLY_SET::OutlineCount
int OutlineCount() const
Return the number of vertices in a given outline/hole.
Definition: shape_poly_set.h:626
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_TYPE::ALLLAYER
Inbuilt layer type (cannot be assigned to user layers)
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_TYPE::NOLAYER
Inbuilt layer type (cannot be assigned to user layers)
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::LINE::LeaderAngle
long LeaderAngle
Only for TYPE=LEADERLINE subnode "LEADERANG".
Definition: cadstar_pcb_archive_parser.h:683
ZONE::SetZoneName
void SetZoneName(const wxString &aName)
Definition: zone.h:132
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::ThermalReliefOnVias
bool ThermalReliefOnVias
false when subnode "NOVIARELIEF" is present
Definition: cadstar_pcb_archive_parser.h:1082
CADSTAR_ARCHIVE_PARSER::TXT_HEIGHT_RATIO
static const double TXT_HEIGHT_RATIO
CADSTAR fonts are drawn on a 24x24 integer matrix, where the each axis goes from 0 to 24.
Definition: cadstar_archive_parser.h:122
CADSTAR_ARCHIVE_PARSER::UNITS::THOU
CADSTAR_PCB_ARCHIVE_LOADER::getKiCadNet
NETINFO_ITEM * getKiCadNet(const NET_ID &aCadstarNetID)
Searches m_netMap and returns the NETINFO_ITEM pointer if exists.
Definition: cadstar_pcb_archive_loader.cpp:3360
PROJECT
Container for project specific data.
Definition: project.h:62
CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::Pins
std::map< PART_DEFINITION_PIN_ID, PIN > Pins
Definition: cadstar_archive_parser.h:1075
CADSTAR_PCB_ARCHIVE_PARSER::NET_PCB::Pins
std::map< NETELEMENT_ID, PIN > Pins
Definition: cadstar_pcb_archive_parser.h:1013
CADSTAR_ARCHIVE_PARSER::VERTEX_TYPE::ANTICLOCKWISE_SEMICIRCLE
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_COPPER::Shape
SHAPE Shape
Definition: cadstar_pcb_archive_parser.h:442
ZONE::SetDoNotAllowTracks
void SetDoNotAllowTracks(bool aEnable)
Definition: zone.h:765
CADSTAR_ARCHIVE_PARSER::SETTINGS::DesignArea
std::pair< POINT, POINT > DesignArea
Definition: cadstar_archive_parser.h:537
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_VALUE::AttributeID
ATTRIBUTE_ID AttributeID
Definition: cadstar_archive_parser.h:726
In12_Cu
Definition: layers_id_colors_and_visibility.h:87
CADSTAR_PCB_ARCHIVE_PARSER::MATERIAL
Definition: cadstar_pcb_archive_parser.h:89
DIMENSION_BASE::SetStart
virtual void SetStart(const wxPoint &aPoint)
Definition: dimension.h:122
CADSTAR_PCB_ARCHIVE_PARSER::LAYER::ID
LAYER_ID ID
Definition: cadstar_pcb_archive_parser.h:152
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::CopperCodeID
COPPERCODE_ID CopperCodeID
From CADSTAR Help: "Copper Code is for selecting the width of the line used to draw the outline and f...
Definition: cadstar_pcb_archive_parser.h:1052
PCB_SHAPE::GetPolyShape
SHAPE_POLY_SET & GetPolyShape()
Definition: pcb_shape.h:268
CADSTAR_PCB_ARCHIVE_LOADER::getAngleDegrees
double getAngleDegrees(const long long &aCadstarAngle)
Definition: cadstar_pcb_archive_loader.h:429
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::EXTENSION_LINE::Offset
long Offset
Offset from the measurement point.
Definition: cadstar_pcb_archive_parser.h:648
CADSTAR_ARCHIVE_PARSER::SYMDEF::ReferenceName
wxString ReferenceName
This is the name which identifies the symbol in the library Multiple components may exist with the sa...
Definition: cadstar_archive_parser.h:897
BOARD::m_LegacyNetclassesLoaded
bool m_LegacyNetclassesLoaded
True if netclasses were loaded from the file.
Definition: board.h:342
CADSTAR_PCB_ARCHIVE_LOADER::getZoneFromCadstarShape
ZONE * getZoneFromCadstarShape(const SHAPE &aCadstarShape, const int &aLineThickness, BOARD_ITEM_CONTAINER *aParentContainer)
Definition: cadstar_pcb_archive_loader.cpp:2552
PCB_TEXT::SetPosition
virtual void SetPosition(const wxPoint &aPos) override
Definition: pcb_text.h:77
CADSTAR_ARCHIVE_PARSER::HATCHCODE::Hatches
std::vector< HATCH > Hatches
Definition: cadstar_archive_parser.h:303
CADSTAR_PCB_ARCHIVE_PARSER::LAYER
Definition: cadstar_pcb_archive_parser.h:150
CADSTAR_ARCHIVE_PARSER::NET::SignalNum
long SignalNum
This is undefined if the net has been given a name.
Definition: cadstar_archive_parser.h:1168
CADSTAR_PCB_ARCHIVE_PARSER::LAYER::Name
wxString Name
Definition: cadstar_pcb_archive_parser.h:153
CADSTAR_PCB_ARCHIVE_LOADER::m_componentMap
std::map< COMPONENT_ID, FOOTPRINT * > m_componentMap
Map between Cadstar and KiCad components on the board.
Definition: cadstar_pcb_archive_loader.h:95
SHAPE_POLY_SET::BooleanAdd
void BooleanAdd(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset difference For aFastMode meaning, see function booleanOp.
Definition: shape_poly_set.cpp:510
BOARD_STACKUP
this class manage the layers needed to make a physical board they are solder mask,...
Definition: class_board_stackup.h:210
VIA::SetPosition
void SetPosition(const wxPoint &aPoint) override
Definition: track.h:412
CADSTAR_ARCHIVE_PARSER::CODEDEFS::AttributeNames
std::map< ATTRIBUTE_ID, ATTRNAME > AttributeNames
Definition: cadstar_archive_parser.h:781
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_AREA::NoVias
bool NoVias
From CADSTAR Help: "Check this button to specify that any area created by the Rectangle,...
Definition: cadstar_pcb_archive_parser.h:467
PCB_TEXT::Flip
void Flip(const wxPoint &aCentre, bool aFlipLeftRight) override
Flip this object, i.e.
Definition: pcb_text.cpp:151
BOARD_ITEM::SetLayer
virtual void SetLayer(PCB_LAYER_ID aLayer)
Set the layer this item is on.
Definition: board_item.h:194
CADSTAR_PCB_ARCHIVE_LOADER::getAngleTenthDegree
double getAngleTenthDegree(const long long &aCadstarAngle)
Definition: cadstar_pcb_archive_loader.h:409
PAD_SHAPE_CIRCLE
Definition: pad_shapes.h:34
CADSTAR_PCB_ARCHIVE_LOADER::loadAreas
void loadAreas()
Definition: cadstar_pcb_archive_loader.cpp:1346
BOARD_ITEM
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
CADSTAR_ARCHIVE_PARSER::DOCUMENTATION_SYMBOL::ScaleRatioNumerator
long ScaleRatioNumerator
Documentation symbols can be arbitrarily scaled when added to a design.
Definition: cadstar_archive_parser.h:1208
TRACK::SetEnd
void SetEnd(const wxPoint &aEnd)
Definition: track.h:112
PCB_SHAPE::Scale
void Scale(double aScale)
Definition: pcb_shape.cpp:147
CADSTAR_ARCHIVE_PARSER::TEXT::Position
POINT Position
Definition: cadstar_archive_parser.h:874
ZONE::SetHatchStyle
void SetHatchStyle(ZONE_BORDER_DISPLAY_STYLE aStyle)
Definition: zone.h:621
CADSTAR_ARCHIVE_PARSER::TEXT_FIELD_NAME
TEXT_FIELD_NAME
These are speccial fields in text objects enclosed between the tokens '<@' and '>' such as <@[FIELD_N...
Definition: cadstar_archive_parser.h:128
CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarShape
void drawCadstarShape(const SHAPE &aCadstarShape, const PCB_LAYER_ID &aKiCadLayer, const int &aLineThickness, const wxString &aShapeName, BOARD_ITEM_CONTAINER *aContainer, const GROUP_ID &aCadstarGroupID=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
Definition: cadstar_pcb_archive_loader.cpp:2313
LT_POWER
Definition: board.h:67
GR_TEXT_HJUSTIFY_RIGHT
Definition: eda_text.h:64
Edge_Cuts
Definition: layers_id_colors_and_visibility.h:124
PAD::SetThermalSpokeWidth
void SetThermalSpokeWidth(int aWidth)
Set the width of the thermal spokes connecting the pad to a zone.
Definition: pad.h:482
CADSTAR_ARCHIVE_PARSER::GROUP::ID
GROUP_ID ID
Definition: cadstar_archive_parser.h:839
CADSTAR_PCB_ARCHIVE_PARSER::SYMDEF_PCB::ComponentAreas
std::map< COMP_AREA_ID, COMPONENT_AREA > ComponentAreas
Definition: cadstar_pcb_archive_parser.h:780
CADSTAR_ARCHIVE_PARSER::VARIANT_HIERARCHY::Variants
std::map< VARIANT_ID, VARIANT > Variants
Definition: cadstar_archive_parser.h:262
CADSTAR_PCB_ARCHIVE_LOADER::loadBoardStackup
void loadBoardStackup()
Definition: cadstar_pcb_archive_loader.cpp:191
CADSTAR_ARCHIVE_PARSER::NET::ID
NET_ID ID
Definition: cadstar_archive_parser.h:1166
ADD_MODE::APPEND
CADSTAR_PCB_ARCHIVE_PARSER::COPPER::ID
COPPER_ID ID
Definition: cadstar_pcb_archive_parser.h:1132
PCB_TEXT::SetTextAngle
void SetTextAngle(double aAngle) override
Definition: pcb_text.cpp:102
PCB_GROUP
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:50
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::Name
wxString Name
Definition: cadstar_pcb_archive_parser.h:1097
CADSTAR_PCB_ARCHIVE_PARSER::MATERIAL::LossTangent
EVALUE LossTangent
Definition: cadstar_pcb_archive_parser.h:95
CADSTAR_ARCHIVE_PARSER::CODEDEFS::LineCodes
std::map< LINECODE_ID, LINECODE > LineCodes
Definition: cadstar_archive_parser.h:777
CADSTAR_PCB_ARCHIVE_LOADER::loadNetTracks
void loadNetTracks(const NET_ID &aCadstarNetID, const NET_PCB::ROUTE &aCadstarRoute)
Definition: cadstar_pcb_archive_loader.cpp:2086
RECT_CHAMFER_ALL
Definition: convert_basic_shapes_to_polygon.h:44
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE_TYPE::ROUNDED_RECT
Keyword "ROUNDED".
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_ID
wxString ATTRIBUTE_ID
Definition: cadstar_archive_parser.h:93
PCB_SHAPE::SetFilled
void SetFilled(bool aFlag)
Definition: pcb_shape.h:94
CADSTAR_PCB_ARCHIVE_LOADER::getAttributeValue
wxString getAttributeValue(const ATTRIBUTE_ID &aCadstarAttributeID, const std::map< ATTRIBUTE_ID, ATTRIBUTE_VALUE > &aCadstarAttributeMap)
Definition: cadstar_pcb_archive_loader.cpp:2977
CADSTAR_PCB_ARCHIVE_LOADER::m_layerMappingHandler
LAYER_MAPPING_HANDLER m_layerMappingHandler
Callback to get layer mapping.
Definition: cadstar_pcb_archive_loader.h:81
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::ExtensionLineParams
EXTENSION_LINE ExtensionLineParams
Not applicable to TYPE=LEADERDIM.
Definition: cadstar_pcb_archive_parser.h:704
FP_TEXT::SetTextAngle
void SetTextAngle(double aAngle) override
Definition: fp_text.cpp:70
ZONE::SetLayerSet
void SetLayerSet(LSET aLayerSet) override
Definition: zone.cpp:243
In20_Cu
Definition: layers_id_colors_and_visibility.h:95
PAD_DRILL_SHAPE_CIRCLE
Definition: pad_shapes.h:68
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_COPPER::CopperCodeID
COPPERCODE_ID CopperCodeID
Definition: cadstar_pcb_archive_parser.h:440
ZONE::Outline
SHAPE_POLY_SET * Outline()
Definition: zone.h:323
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_TYPE::CONSTRUCTION
DIMENSION_BASE::SetLayer
void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
Definition: dimension.cpp:212
CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::Areas
std::map< AREA_ID, AREA > Areas
Definition: cadstar_pcb_archive_parser.h:1184
COMPONENT_NAME_2_ATTRID
#define COMPONENT_NAME_2_ATTRID
Component Name 2 Attribute ID - typically used for indicating the placement of designators in placeme...
Definition: cadstar_archive_parser.h:67
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::LayerID
LAYER_ID LayerID
Definition: cadstar_pcb_archive_parser.h:1099
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE_TYPE::RECTANGLE
CADSTAR_PCB_ARCHIVE_PARSER::CADSTAR_BOARD::LineCodeID
LINECODE_ID LineCodeID
Definition: cadstar_pcb_archive_parser.h:799
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::BoxIsolatedPins
bool BoxIsolatedPins
true when subnode "BOXPINS" is present
Definition: cadstar_pcb_archive_parser.h:1084
ZONE_SETTINGS::m_HatchGap
int m_HatchGap
Definition: zone_settings.h:85
CADSTAR_PCB_ARCHIVE_PARSER::PADEXCEPTION::Exits
PAD_EXITS Exits
Definition: cadstar_pcb_archive_parser.h:883
CADSTAR_PCB_ARCHIVE_LOADER::m_designCenter
wxPoint m_designCenter
Used for calculating the required offset to apply to the Cadstar design so that it fits in KiCad canv...
Definition: cadstar_pcb_archive_loader.h:105
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::Line
LINE Line
Definition: cadstar_pcb_archive_parser.h:705
CADSTAR_ARCHIVE_PARSER::ALIGNMENT::TOPLEFT
In19_Cu
Definition: layers_id_colors_and_visibility.h:94
CADSTAR_PCB_ARCHIVE_PARSER::SYMDEF_PCB
Definition: cadstar_pcb_archive_parser.h:774
CADSTAR_ARCHIVE_PARSER::ROUTECODE_ID
wxString ROUTECODE_ID
Definition: cadstar_archive_parser.h:87
pcb_shape.h
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_AREA::NoTracks
bool NoTracks
From CADSTAR Help: "Check this button to specify that any area created by the Rectangle,...
Definition: cadstar_pcb_archive_parser.h:463
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE_ID
wxString TEMPLATE_ID
Definition: cadstar_pcb_archive_parser.h:72
CADSTAR_ARCHIVE_PARSER::SHAPE_TYPE::HATCHED
Filled closed shape (hatch fill).
PAD::SetAnchorPadShape
void SetAnchorPadShape(PAD_SHAPE_T aShape)
Set the shape of the anchor pad for custom shaped pads.
Definition: pad.h:208
PAD_ATTRIB_SMD
Smd pad, appears on the solder paste layer (default)
Definition: pad_shapes.h:81
DIMENSION_BASE::GetStart
virtual const wxPoint & GetStart() const
The dimension's origin is the first feature point for the dimension.
Definition: dimension.h:121
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_AREA::LineCodeID
LINECODE_ID LineCodeID
Definition: cadstar_pcb_archive_parser.h:458
EDA_TEXT::SetTextPos
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:253
In1_Cu
Definition: layers_id_colors_and_visibility.h:76
CADSTAR_PCB_ARCHIVE_LOADER::getKiCadGroup
PCB_GROUP * getKiCadGroup(const GROUP_ID &aCadstarGroupID)
Definition: cadstar_pcb_archive_loader.cpp:3056
CADSTAR_PCB_ARCHIVE_LOADER::getLayerPair
LAYERPAIR getLayerPair(const LAYERPAIR_ID &aCadstarLayerPairID)
Definition: cadstar_pcb_archive_loader.cpp:2956
S_POLYGON
polygon (not yet used for tracks, but could be in microwave apps)
Definition: board_item.h:54
CADSTAR_PCB_ARCHIVE_PARSER::LAYERPAIR::PhysicalLayerStart
PHYSICAL_LAYER_ID PhysicalLayerStart
Definition: cadstar_pcb_archive_parser.h:346
EDA_TEXT::SetVisible
void SetVisible(bool aVisible)
Definition: eda_text.h:192
PAD::SetName
void SetName(const wxString &aName)
Set the pad name (sometimes called pad number, although it can be an array reference like AA12).
Definition: pad.h:132
DIMENSION_BASE::SetUnitsFormat
void SetUnitsFormat(const DIM_UNITS_FORMAT aFormat)
Definition: dimension.h:167
CADSTAR_ARCHIVE_PARSER::SYMDEF::Figures
std::map< FIGURE_ID, FIGURE > Figures
Definition: cadstar_archive_parser.h:912
DIMENSION_BASE::SetPrefix
void SetPrefix(const wxString &aPrefix)
Definition: dimension.cpp:132
FOOTPRINT::GetOrientation
double GetOrientation() const
Definition: footprint.h:186
CADSTAR_PCB_ARCHIVE_PARSER::VIACODE::DrillDiameter
long DrillDiameter
Definition: cadstar_pcb_archive_parser.h:333
EDA_TEXT::GetTextAngle
double GetTextAngle() const
Definition: eda_text.h:181
BOARD::SetCopperLayerCount
void SetCopperLayerCount(int aCount)
Definition: board.cpp:441
CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::Trunks
std::map< TRUNK_ID, TRUNK > Trunks
Definition: cadstar_pcb_archive_parser.h:1187
CADSTAR_ARCHIVE_PARSER::DOCUMENTATION_SYMBOL::ScaleRatioDenominator
long ScaleRatioDenominator
Documentation symbols can be arbitrarily scaled when added to a design.
Definition: cadstar_archive_parser.h:1210
B_Cu
Definition: layers_id_colors_and_visibility.h:106
CADSTAR_PCB_ARCHIVE_LOADER::remapUnsureLayers
void remapUnsureLayers()
Callback m_layerMappingHandler for layers we aren't sure of.
Definition: cadstar_pcb_archive_loader.cpp:545
CADSTAR_ARCHIVE_PARSER::PART
Definition: cadstar_archive_parser.h:925
CADSTAR_PCB_ARCHIVE_PARSER::COPPER::NETREF::NetID
NET_ID NetID
Definition: cadstar_pcb_archive_parser.h:1125
PAD_SHAPE_CHAMFERED_RECT
Definition: pad_shapes.h:41
SHAPE_POLY_SET::Hole
SHAPE_LINE_CHAIN & Hole(int aOutline, int aHole)
Return the aIndex-th subpolygon in the set.
Definition: shape_poly_set.h:671
FP_SHAPE::GetStart0
const wxPoint & GetStart0() const
Definition: fp_shape.h:112
CADSTAR_ARCHIVE_PARSER::m_context
PARSER_CONTEXT m_context
Definition: cadstar_archive_parser.h:1382
S_SEGMENT
usual segment : line with rounded ends
Definition: board_item.h:50
SHAPE_POLY_SET::Area
double Area()
Appends a vertex at the end of the given outline/hole (default: the last outline)
Definition: shape_poly_set.cpp:458
CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::CopperCodes
std::map< COPPERCODE_ID, COPPERCODE > CopperCodes
Definition: cadstar_pcb_archive_parser.h:386
CADSTAR_ARCHIVE_PARSER::TEXTCODE::LineWidth
long LineWidth
Definition: cadstar_archive_parser.h:332
BOARD_DESIGN_SETTINGS::m_MaxError
int m_MaxError
Definition: board_design_settings.h:719
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE_TYPE::OCTAGON
CADSTAR_PCB_ARCHIVE_PARSER::LAYERDEFS::Materials
std::map< MATERIAL_ID, MATERIAL > Materials
Definition: cadstar_pcb_archive_parser.h:175
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE::Size
long Size
Definition: cadstar_pcb_archive_parser.h:276
CADSTAR_ARCHIVE_PARSER::LONGPOINT::y
long y
Definition: cadstar_archive_parser.h:398
CADSTAR_PCB_ARCHIVE_PARSER::NET_PCB::Connections
std::vector< CONNECTION_PCB > Connections
Definition: cadstar_pcb_archive_parser.h:1017
COMPONENT_NAME_ATTRID
#define COMPONENT_NAME_ATTRID
Component Name Attribute ID - typically used for placement of designators on silk screen.
Definition: cadstar_archive_parser.h:61
CADSTAR_PCB_ARCHIVE_LOADER::m_doneSpacingClassWarning
bool m_doneSpacingClassWarning
Used by getKiCadNet() to avoid multiple duplicate warnings.
Definition: cadstar_pcb_archive_loader.h:114
CADSTAR_PCB_ARCHIVE_LOADER::m_libraryMap
std::map< SYMDEF_ID, FOOTPRINT * > m_libraryMap
Map between Cadstar and KiCad components in the library.
Definition: cadstar_pcb_archive_loader.h:87
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT::Name
wxString Name
Designator e.g. "C1", "R1", etc.
Definition: cadstar_pcb_archive_parser.h:896
BOARD::GetDesignSettings
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Definition: board.h:591
CADSTAR_ARCHIVE_PARSER::TEXTCODE
Definition: cadstar_archive_parser.h:328
CADSTAR_ARCHIVE_PARSER::TEXT::Text
wxString Text
Definition: cadstar_archive_parser.h:871
E6
Definition: eserie.h:39
CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::ViaCodes
std::map< VIACODE_ID, VIACODE > ViaCodes
Definition: cadstar_pcb_archive_parser.h:390
CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs
CODEDEFS_PCB Codedefs
Definition: cadstar_pcb_archive_parser.h:425
S_ARC
Arcs (with rounded ends)
Definition: board_item.h:52
CADSTAR_PCB_ARCHIVE_LOADER::getRouteCode
ROUTECODE getRouteCode(const ROUTECODE_ID &aCadstarRouteCodeID)
Definition: cadstar_pcb_archive_loader.cpp:2996
KI_FALLTHROUGH
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition: macros.h:83
CADSTAR_PCB_ARCHIVE_PARSER::AREA
From CADSTAR Help: "Area is for creating areas within which, and nowhere else, certain operations are...
Definition: cadstar_pcb_archive_parser.h:818
ZONE::GetFilledPolysList
const SHAPE_POLY_SET & GetFilledPolysList(PCB_LAYER_ID aLayer) const
Function GetFilledPolysList returns a reference to the list of filled polygons.
Definition: zone.h:655
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_VALUE::HasLocation
bool HasLocation
Flag to know if this ATTRIBUTE_VALUE has a location i.e.
Definition: cadstar_archive_parser.h:729
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::LINE::Style
STYLE Style
Subnode="DIMLINETYPE".
Definition: cadstar_pcb_archive_parser.h:677
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::MinIsolatedCopper
long MinIsolatedCopper
The value is the length of one side of a notional square.
Definition: cadstar_pcb_archive_parser.h:1074
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_SUBTYPE::LAYERSUBTYPE_ROUT
CADSTAR_PCB_ARCHIVE_LOADER::loadDimensions
void loadDimensions()
Definition: cadstar_pcb_archive_loader.cpp:1121
SHAPE_POLY_SET::CHole
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
Definition: shape_poly_set.h:697
BOARD::GetEnabledLayers
LSET GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings Returns a bit-mask of all t...
Definition: board.cpp:447
CADSTAR_ARCHIVE_PARSER::FIGURE::LayerID
LAYER_ID LayerID
Definition: cadstar_archive_parser.h:855
CADSTAR_ARCHIVE_PARSER::TEXT::Alignment
ALIGNMENT Alignment
In CADSTAR The default alignment for a TEXT object (when "(No Alignment()" is selected) Bottom Left o...
Definition: cadstar_archive_parser.h:881
Eco1_User
Definition: layers_id_colors_and_visibility.h:122
CADSTAR_PCB_ARCHIVE_LOADER::checkAndLogHatchCode
void checkAndLogHatchCode(const HATCHCODE_ID &aCadstarHatchcodeID)
Definition: cadstar_pcb_archive_loader.cpp:3064
SHAPE_ARC
Definition: shape_arc.h:35
ISLAND_REMOVAL_MODE::AREA
EDA_TEXT::SetTextSize
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:244
CADSTAR_PCB_ARCHIVE_LOADER::m_hatchcodesTested
std::set< HATCHCODE_ID > m_hatchcodesTested
Used by checkAndLogHatchCode() to avoid multiple duplicate warnings.
Definition: cadstar_pcb_archive_loader.h:108
BOARD_ITEM::SetLocked
virtual void SetLocked(bool aLocked)
Modify the 'lock' status for of the item.
Definition: board_item.h:257
PAD::SetSize
void SetSize(const wxSize &aSize)
Definition: pad.h:231
CADSTAR_PCB_ARCHIVE_LOADER::loadComponentAttributes
void loadComponentAttributes(const COMPONENT &aComponent, FOOTPRINT *aFootprint)
Definition: cadstar_pcb_archive_loader.cpp:2047
SHAPE_POLY_SET::Contains
bool Contains(const VECTOR2I &aP, int aSubpolyIndex=-1, int aAccuracy=0, bool aUseBBoxCaches=false) const
Return true if a given subpolygon contains the point aP.
Definition: shape_poly_set.cpp:1540
CADSTAR_PCB_ARCHIVE_PARSER::VIACODE_ID
wxString VIACODE_ID
Definition: cadstar_pcb_archive_parser.h:62
In7_Cu
Definition: layers_id_colors_and_visibility.h:82
CADSTAR_ARCHIVE_PARSER::ALIGNMENT::BOTTOMCENTER
ALTIUM_RECORD::VIA
CADSTAR_PCB_ARCHIVE_LOADER::loadDocumentationSymbols
void loadDocumentationSymbols()
Definition: cadstar_pcb_archive_loader.cpp:1513
BOARD::SetLayerType
bool SetLayerType(PCB_LAYER_ID aLayer, LAYER_T aLayerType)
Change the type of the layer given by aLayer.
Definition: board.cpp:390
NORMALIZE_ANGLE_180
void NORMALIZE_ANGLE_180(T &Angle)
Definition: trigo.h:385
CADSTAR_ARCHIVE_PARSER::GROUP::Fixed
bool Fixed
Definition: cadstar_archive_parser.h:841
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT::VariantID
VARIANT_ID VariantID
Definition: cadstar_pcb_archive_parser.h:905
CADSTAR_ARCHIVE_PARSER::SYMDEF::Texts
std::map< TEXT_ID, TEXT > Texts
Definition: cadstar_archive_parser.h:913
RotatePoint
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:228
CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::VariantHierarchy
VARIANT_HIERARCHY VariantHierarchy
Definition: cadstar_pcb_archive_parser.h:1194
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::LayerID
LAYER_ID LayerID
ID on which to draw this [param1].
Definition: cadstar_pcb_archive_parser.h:696
ISLAND_REMOVAL_MODE::NEVER
SHAPE_POLY_SET::Inflate
void Inflate(int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
Perform outline inflation/deflation.
Definition: shape_poly_set.cpp:561
PAD_ATTRIB_NPTH
like PAD_PTH, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:85
CADSTAR_PCB_ARCHIVE_LOADER::loadNetVia
void loadNetVia(const NET_ID &aCadstarNetID, const NET_PCB::VIA &aCadstarVia)
Definition: cadstar_pcb_archive_loader.cpp:2112
LIB_ID
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:51
In4_Cu
Definition: layers_id_colors_and_visibility.h:79
CADSTAR_PCB_ARCHIVE_PARSER::COPPERCODE::CopperWidth
long CopperWidth
Definition: cadstar_pcb_archive_parser.h:196
CADSTAR_ARCHIVE_PARSER::UNITS::CENTIMETER
CADSTAR_PCB_ARCHIVE_PARSER::AREA::Routing
bool Routing
From CADSTAR Help: "Area can be used to place routes during Automatic Routing.
Definition: cadstar_pcb_archive_parser.h:833
CADSTAR_ARCHIVE_PARSER::PARSER_CONTEXT::FilenamesToTextMap
std::map< wxString, wxString > FilenamesToTextMap
CADSTAR doesn't have user defined text fields but does allow loading text from a file.
Definition: cadstar_archive_parser.h:167
CADSTAR_PCB_ARCHIVE_LOADER::logBoardStackupWarning
void logBoardStackupWarning(const wxString &aCadstarLayerName, const PCB_LAYER_ID &aKiCadLayer)
Definition: cadstar_pcb_archive_loader.cpp:145
PCB_SHAPE::Rotate
virtual void Rotate(const wxPoint &aRotCentre, double aAngle) override
Rotate this object.
Definition: pcb_shape.cpp:197
CADSTAR_PCB_ARCHIVE_PARSER::LAYERDEFS::Layers
std::map< LAYER_ID, LAYER > Layers
Definition: cadstar_pcb_archive_parser.h:176
CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryPads
void loadLibraryPads(const SYMDEF_PCB &aComponent, FOOTPRINT *aFootprint)
Definition: cadstar_pcb_archive_loader.cpp:751
CADSTAR_PCB_ARCHIVE_PARSER::LAYER::Embedding
EMBEDDING Embedding
Definition: cadstar_pcb_archive_parser.h:165
CADSTAR_ARCHIVE_PARSER::VARIANT::Name
wxString Name
Definition: cadstar_archive_parser.h:253
SHAPE_LINE_CHAIN::PointCount
int PointCount() const
Function PointCount()
Definition: shape_line_chain.h:248
LSET::Seq
LSEQ Seq(const PCB_LAYER_ID *aWishListSequence, unsigned aCount) const
Return an LSEQ from the union of this LSET and a desired sequence.
Definition: lset.cpp:411
ZONE::SetPriority
void SetPriority(unsigned aPriority)
Function SetPriority.
Definition: zone.h:118
CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::LayerPairs
std::map< LAYERPAIR_ID, LAYERPAIR > LayerPairs
Default vias to use between pairs of layers.
Definition: cadstar_pcb_archive_parser.h:392
ZONE_FILL_MODE::POLYGONS
CADSTAR_PCB_ARCHIVE_PARSER::PADEXCEPTION::Side
PAD_SIDE Side
Definition: cadstar_pcb_archive_parser.h:885
INPUT_LAYER_DESC
Describes an imported layer and how it could be mapped to KiCad Layers.
Definition: plugin_common_layer_mapping.h:33
CADSTAR_ARCHIVE_PARSER::PART::Definition
DEFINITION Definition
Definition: cadstar_archive_parser.h:1101
pcb_text.h
ZONE::SetFillMode
void SetFillMode(ZONE_FILL_MODE aFillMode)
Definition: zone.h:185
CADSTAR_PCB_ARCHIVE_PARSER::LAYER::Thickness
long Thickness
Note: Units of length are defined in file header.
Definition: cadstar_pcb_archive_parser.h:163
CADSTAR_ARCHIVE_PARSER::FIGURE
Definition: cadstar_archive_parser.h:851
CADSTAR_ARCHIVE_PARSER::DOCUMENTATION_SYMBOL::Origin
POINT Origin
Origin of the component (this is used as the reference point when placing the component in the design...
Definition: cadstar_archive_parser.h:1198
CADSTAR_PCB_ARCHIVE_PARSER::EMBEDDING::ABOVE
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::LinearUnits
UNITS LinearUnits
Definition: cadstar_pcb_archive_parser.h:700
CADSTAR_PCB_ARCHIVE_PARSER::TECHNOLOGY_SECTION::MaxPhysicalLayer
long MaxPhysicalLayer
Should equal number of copper layers.
Definition: cadstar_pcb_archive_parser.h:408
ALTIUM_SCH_RECORD::ARC
CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::Templates
std::map< TEMPLATE_ID, TEMPLATE > Templates
Definition: cadstar_pcb_archive_parser.h:1189
CADSTAR_PCB_ARCHIVE_PARSER::LAYERPAIR_ID
wxString LAYERPAIR_ID
Definition: cadstar_pcb_archive_parser.h:64
CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::Name
wxString Name
This name can be different to the PART name.
Definition: cadstar_archive_parser.h:1059
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Alignment
ALIGNMENT Alignment
In CADSTAR The default alignment for a TEXT object (when "(No Alignment()" is selected) Bottom Left o...
Definition: cadstar_archive_parser.h:667
SHAPE_LINE_CHAIN::Append
void Append(int aX, int aY, bool aAllowDuplication=false)
Function Append()
Definition: shape_line_chain.h:431
FOOTPRINT::Pads
PADS & Pads()
Definition: footprint.h:164
CADSTAR_PCB_ARCHIVE_PARSER::VIACODE
Definition: cadstar_pcb_archive_parser.h:326
CADSTAR_ARCHIVE_PARSER::SETTINGS::Units
UNITS Units
Units to display for linear dimensions.
Definition: cadstar_archive_parser.h:525
TRACK::SetWidth
void SetWidth(int aWidth)
Definition: track.h:109
In28_Cu
Definition: layers_id_colors_and_visibility.h:103
FOOTPRINT::Value
FP_TEXT & Value()
read/write accessors:
Definition: footprint.h:459
FOOTPRINT::SetDescription
void SetDescription(const wxString &aDoc)
Definition: footprint.h:194
CADSTAR_ARCHIVE_PARSER::TEXT::LayerID
LAYER_ID LayerID
Definition: cadstar_archive_parser.h:873
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT::ID
COMPONENT_ID ID
Definition: cadstar_pcb_archive_parser.h:895
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_SUBTYPE::LAYERSUBTYPE_NONE
CADSTAR_PCB_ARCHIVE_PARSER::PADEXCEPTION::OverrideSide
bool OverrideSide
Definition: cadstar_pcb_archive_parser.h:884
CADSTAR_PCB_ARCHIVE_PARSER::VIACODE::Shape
PAD_SHAPE Shape
Definition: cadstar_pcb_archive_parser.h:330
CADSTAR_ARCHIVE_PARSER::SHAPE::HatchCodeID
wxString HatchCodeID
Only Applicable for HATCHED Type.
Definition: cadstar_archive_parser.h:452
CADSTAR_PCB_ARCHIVE_LOADER::GetLoadedLibraryFootpints
std::vector< FOOTPRINT * > GetLoadedLibraryFootpints() const
Return a copy of the loaded library footprints (caller owns the objects)
Definition: cadstar_pcb_archive_loader.cpp:132
ZONE::SetIsRuleArea
void SetIsRuleArea(bool aEnable)
Definition: zone.h:762
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_VALUE::AttributeLocation
ATTRIBUTE_LOCATION AttributeLocation
Definition: cadstar_archive_parser.h:731
B_CrtYd
Definition: layers_id_colors_and_visibility.h:127
FOOTPRINT::Reference
FP_TEXT & Reference()
Definition: footprint.h:460
CADSTAR_ARCHIVE_PARSER::PARSER_CONTEXT::InconsistentTextFields
std::set< TEXT_FIELD_NAME > InconsistentTextFields
Text fields need to be updated in CADSTAR and it is possible that they are not consistent accross tex...
Definition: cadstar_archive_parser.h:185
ALIGNED_DIMENSION::SetExtensionHeight
void SetExtensionHeight(int aHeight)
Definition: dimension.h:380
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_AREA
From CADSTAR Help: "Area is for creating areas within which, and nowhere else, certain operations are...
Definition: cadstar_pcb_archive_parser.h:455
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE::ReliefWidth
long ReliefWidth
if undefined inherits from design
Definition: cadstar_pcb_archive_parser.h:302
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_SUBTYPE::LAYERSUBTYPE_PLACEMENT
TransformOvalToPolygon
void TransformOvalToPolygon(SHAPE_POLY_SET &aCornerBuffer, wxPoint aStart, wxPoint aEnd, int aWidth, int aError, ERROR_LOC aErrorLoc)
convert a oblong shape to a polygon, using multiple segments It is similar to TransformRoundedEndsSeg...
Definition: convert_basic_shapes_to_polygon.cpp:95
CADSTAR_PCB_ARCHIVE_LOADER::loadBoards
void loadBoards()
Definition: cadstar_pcb_archive_loader.cpp:1075
CADSTAR_PCB_ARCHIVE_LOADER::applyDimensionSettings
void applyDimensionSettings(const DIMENSION &aCadstarDim, DIMENSION_BASE *aKiCadDim)
Definition: cadstar_pcb_archive_loader.cpp:3128
Dwgs_User
Definition: layers_id_colors_and_visibility.h:120
CADSTAR_PCB_ARCHIVE_LOADER::m_board
BOARD * m_board
Definition: cadstar_pcb_archive_loader.h:83
BOARD_DESIGN_SETTINGS::GetLineThickness
int GetLineThickness(PCB_LAYER_ID aLayer) const
Return the default graphic segment thickness from the layer class for the given layer.
Definition: board_design_settings.cpp:1110
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_COPPER
A shape of copper in the component footprint.
Definition: cadstar_pcb_archive_parser.h:438
CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::Nets
std::map< NET_ID, NET_PCB > Nets
Contains tracks and vias.
Definition: cadstar_pcb_archive_parser.h:1188
CADSTAR_ARCHIVE_PARSER::FIGURE::GroupID
GROUP_ID GroupID
If not empty, this FIGURE is part of a group.
Definition: cadstar_archive_parser.h:858
CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarText
void drawCadstarText(const TEXT &aCadstarText, BOARD_ITEM_CONTAINER *aContainer, const GROUP_ID &aCadstarGroupID=wxEmptyString, const LAYER_ID &aCadstarLayerOverride=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
Definition: cadstar_pcb_archive_loader.cpp:2162
PCB_SHAPE::Move
virtual void Move(const wxPoint &aMoveVector) override
Move this object.
Definition: pcb_shape.cpp:112
CADSTAR_PCB_ARCHIVE_LOADER::m_groupMap
std::map< GROUP_ID, PCB_GROUP * > m_groupMap
Map between Cadstar and KiCad groups.
Definition: cadstar_pcb_archive_loader.h:91
DIMENSION_BASE::SetText
void SetText(const wxString &aNewText)
Sets the override text - has no effect if m_overrideValue == false.
Definition: dimension.cpp:199
CADSTAR_ARCHIVE_PARSER::VARIANT::Description
wxString Description
Definition: cadstar_archive_parser.h:254
CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarVerticesAsSegments
void drawCadstarVerticesAsSegments(const std::vector< VERTEX > &aCadstarVertices, const PCB_LAYER_ID &aKiCadLayer, const int &aLineThickness, BOARD_ITEM_CONTAINER *aContainer, const GROUP_ID &aCadstarGroupID=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
Uses PCB_SHAPE to draw the vertices on m_board object.
Definition: cadstar_pcb_archive_loader.cpp:2400
BOARD::Add
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT) override
Adds an item to the container.
Definition: board.cpp:563
CADSTAR_PCB_ARCHIVE_PARSER::Parse
void Parse()
Parses the file.
Definition: cadstar_pcb_archive_parser.cpp:31
BOARD_STACKUP_ITEM::SetLayerName
void SetLayerName(const wxString &aName)
Definition: class_board_stackup.h:190
SHAPE_LINE_CHAIN::SetClosed
void SetClosed(bool aClosed)
Function SetClosed()
Definition: shape_line_chain.h:187
CADSTAR_PCB_ARCHIVE_PARSER::CADSTAR_BOARD::ID
BOARD_ID ID
Definition: cadstar_pcb_archive_parser.h:798
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE::DrillXoffset
long DrillXoffset
Definition: cadstar_pcb_archive_parser.h:308
GR_TEXT_VJUSTIFY_BOTTOM
Definition: eda_text.h:71
CADSTAR_PCB_ARCHIVE_PARSER::LAYER::SubType
LAYER_SUBTYPE SubType
Definition: cadstar_pcb_archive_parser.h:156
CADSTAR_ARCHIVE_PARSER::SETTINGS::UnitDisplPrecision
long UnitDisplPrecision
Number of decimal points to display for linear dimensions.
Definition: cadstar_archive_parser.h:526
BOARD_DESIGN_SETTINGS::GetStackupDescriptor
BOARD_STACKUP & GetStackupDescriptor()
Definition: board_design_settings.h:231
CADSTAR_ARCHIVE_PARSER::SHAPE_TYPE::OUTLINE
Unfilled closed shape.
CADSTAR_PCB_ARCHIVE_PARSER::PADEXCEPTION::OverrideOrientation
bool OverrideOrientation
Definition: cadstar_pcb_archive_parser.h:886
CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryAreas
void loadLibraryAreas(const SYMDEF_PCB &aComponent, FOOTPRINT *aFootprint)
Definition: cadstar_pcb_archive_loader.cpp:705
PCB_LAYER_ID
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layers_id_colors_and_visibility.h:69
CADSTAR_ARCHIVE_PARSER::GROUP_ID
wxString GROUP_ID
Definition: cadstar_archive_parser.h:102
CADSTAR_PCB_ARCHIVE_LOADER::getKiCadPad
PAD * getKiCadPad(const COMPONENT_PAD &aCadstarPad, FOOTPRINT *aParent)
Definition: cadstar_pcb_archive_loader.cpp:763
CADSTAR_PCB_ARCHIVE_LOADER::m_doneNetClassWarning
bool m_doneNetClassWarning
Used by getKiCadNet() to avoid multiple duplicate warnings.
Definition: cadstar_pcb_archive_loader.h:116
BOARD_DESIGN_SETTINGS::m_HoleToHoleMin
int m_HoleToHoleMin
Definition: board_design_settings.h:691
CADSTAR_ARCHIVE_PARSER::VERTEX_TYPE::CLOCKWISE_SEMICIRCLE
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE_ID
wxString PADCODE_ID
Definition: cadstar_pcb_archive_parser.h:61
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_SUBTYPE::LAYERSUBTYPE_ASSEMBLY
ALIGNED_DIMENSION::SetHeight
void SetHeight(int aHeight)
Sets the distance from the feature points to the crossbar line.
Definition: dimension.h:371
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE_TYPE::SQUARE
CADSTAR_ARCHIVE_PARSER::GROUP
Definition: cadstar_archive_parser.h:837
CADSTAR_ARCHIVE_PARSER::UNITS::DESIGN
Inherits from design units (assumed Assignments->Technology->Units)
LSET
LSET is a set of PCB_LAYER_IDs.
Definition: layers_id_colors_and_visibility.h:507
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE
Definition: cadstar_pcb_archive_parser.h:296
CADSTAR_ARCHIVE_PARSER::FIGURE::ID
FIGURE_ID ID
Definition: cadstar_archive_parser.h:853
CADSTAR_ARCHIVE_PARSER::TEXT::OrientAngle
long OrientAngle
Definition: cadstar_archive_parser.h:875
ZONE_CONNECTION::FULL
pads are covered by copper
CADSTAR_ARCHIVE_PARSER::TEXT_FIELD_NAME::VARIANT_DESCRIPTION
CADSTAR_ARCHIVE_PARSER::POINT
Represents a point in x,y coordinates.
Definition: cadstar_archive_parser.h:385
CADSTAR_PCB_ARCHIVE_PARSER::PADEXCEPTION::OrientAngle
long OrientAngle
Definition: cadstar_pcb_archive_parser.h:887
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::OrientAngle
long OrientAngle
Definition: cadstar_archive_parser.h:662
CADSTAR_PCB_ARCHIVE_PARSER::AREA::LineCodeID
LINECODE_ID LineCodeID
Definition: cadstar_pcb_archive_parser.h:821
EDA_TEXT::SetText
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:121
CADSTAR_PCB_ARCHIVE_LOADER::getPart
PART getPart(const PART_ID &aCadstarPartID)
Definition: cadstar_pcb_archive_loader.cpp:2987
RECT_CHAMFER_BOTTOM_LEFT
Definition: convert_basic_shapes_to_polygon.h:42
VIA
Normal via.
Definition: router_tool.cpp:67
ZONE::SetHatchGap
void SetHatchGap(int aStep)
Definition: zone.h:260
In9_Cu
Definition: layers_id_colors_and_visibility.h:84
PAD::SetPos0
void SetPos0(const wxPoint &aPos)
Definition: pad.h:225
CADSTAR_ARCHIVE_PARSER::DOCUMENTATION_SYMBOL
Definition: cadstar_archive_parser.h:1189
PCB_SHAPE::SetShape
void SetShape(PCB_SHAPE_TYPE_T aShape)
Definition: pcb_shape.h:129
F_CrtYd
Definition: layers_id_colors_and_visibility.h:128
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::ThermalReliefPadsAngle
long ThermalReliefPadsAngle
Orientation for the thermal reliefs. Disabled when !ThermalReliefOnPads (param5)
Definition: cadstar_pcb_archive_parser.h:1072
B_SilkS
Definition: layers_id_colors_and_visibility.h:114
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_PAD::Side
PAD_SIDE Side
See PAD_SIDE.
Definition: cadstar_pcb_archive_parser.h:530
CADSTAR_ARCHIVE_PARSER::SHAPE
Definition: cadstar_archive_parser.h:447
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::EXTENSION_LINE::End
POINT End
Definition: cadstar_pcb_archive_parser.h:646
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_SUBTYPE::LAYERSUBTYPE_SILKSCREEN
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_SUBTYPE::LAYERSUBTYPE_CLEARANCE
CADSTAR_PCB_ARCHIVE_LOADER::initStackupItem
void initStackupItem(const LAYER &aCadstarLayer, BOARD_STACKUP_ITEM *aKiCadItem, int aDielectricSublayer)
Definition: cadstar_pcb_archive_loader.cpp:172
CADSTAR_PCB_ARCHIVE_PARSER::Header
HEADER Header
Definition: cadstar_pcb_archive_parser.h:1202
BS_ITEM_TYPE_COPPER
Definition: class_board_stackup.h:43
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::AllowInNoRouting
bool AllowInNoRouting
true when subnode "IGNORETRN" is present
Definition: cadstar_pcb_archive_parser.h:1083
LSET::Name
static const wxChar * Name(PCB_LAYER_ID aLayerId)
Return the fixed name association with aLayerId.
Definition: lset.cpp:82
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::HatchCodeID
HATCHCODE_ID HatchCodeID
Only for FillType = HATCHED.
Definition: cadstar_pcb_archive_parser.h:1090
CADSTAR_ARCHIVE_PARSER::ALIGNMENT::TOPCENTER
Eco2_User
Definition: layers_id_colors_and_visibility.h:123
LEADER
A leader is a dimension-like object pointing to a specific point.
Definition: dimension.h:477
PAD::SetThermalGap
void SetThermalGap(int aGap)
Definition: pad.h:490
CADSTAR_PCB_ARCHIVE_PARSER::SYMDEF_PCB::ComponentPads
std::map< PAD_ID, COMPONENT_PAD > ComponentPads
Definition: cadstar_pcb_archive_parser.h:781
ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_FULL
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Mirror
bool Mirror
Definition: cadstar_archive_parser.h:663
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_SUBTYPE::LAYERSUBTYPE_PASTE
In14_Cu
Definition: layers_id_colors_and_visibility.h:89
ZONE::SetDoNotAllowPads
void SetDoNotAllowPads(bool aEnable)
Definition: zone.h:766
CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryCoppers
void loadLibraryCoppers(const SYMDEF_PCB &aComponent, FOOTPRINT *aFootprint)
Definition: cadstar_pcb_archive_loader.cpp:690
CADSTAR_ARCHIVE_PARSER::SETTINGS::DesignLimit
LONGPOINT DesignLimit
Definition: cadstar_archive_parser.h:539
NETCLASS::SetClearance
void SetClearance(int aClearance)
Definition: netclass.h:125
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::LINE::End
POINT End
[point2]
Definition: cadstar_pcb_archive_parser.h:680
SHAPE_POLY_SET
Represent a set of closed polygons.
Definition: shape_poly_set.h:64
CADSTAR_ARCHIVE_PARSER::PARTS::PartDefinitions
std::map< PART_ID, PART > PartDefinitions
Definition: cadstar_archive_parser.h:1122
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::ID
DIMENSION_ID ID
Some ID (doesn't seem to be used) subnode="DIMREF".
Definition: cadstar_pcb_archive_parser.h:695
CADSTAR_PCB_ARCHIVE_LOADER::loadDesignRules
void loadDesignRules()
Definition: cadstar_pcb_archive_loader.cpp:601
PCB_IU_PER_MM
constexpr double PCB_IU_PER_MM
Definition: convert_to_biu.h:70
BOARD::SetVisibleLayers
void SetVisibleLayers(LSET aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings changes the bit-mask of vis...
Definition: board.cpp:473
SHAPE_POLY_SET::Outline
SHAPE_LINE_CHAIN & Outline(int aIndex)
Definition: shape_poly_set.h:644
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_TYPE::ELEC
CADSTAR_PCB_ARCHIVE_PARSER::AREA::Placement
bool Placement
From CADSTAR Help: "Auto Placement can place components within this area.
Definition: cadstar_pcb_archive_parser.h:831
CADSTAR_PCB_ARCHIVE_LOADER::isFootprint
bool isFootprint(BOARD_ITEM_CONTAINER *aContainer)
Definition: cadstar_pcb_archive_loader.h:479
CADSTAR_ARCHIVE_PARSER::GROUP::GroupID
GROUP_ID GroupID
If not empty, this GROUP is part of another GROUP.
Definition: cadstar_archive_parser.h:843
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::Precision
long Precision
Number of decimal points to display in the measurement [param3].
Definition: cadstar_pcb_archive_parser.h:698
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::LINE::LineCodeID
LINECODE_ID LineCodeID
param0
Definition: cadstar_pcb_archive_parser.h:676
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::LINE::LeaderLineLength
long LeaderLineLength
Only for TYPE=LEADERLINE Length of the angled part of the leader line [param5].
Definition: cadstar_pcb_archive_parser.h:684
CADSTAR_ARCHIVE_PARSER::TEXTCODE::Width
long Width
Defaults to 0 if using system fonts or, if using CADSTAR font, default to equal height (1:1 aspect ra...
Definition: cadstar_archive_parser.h:334
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_TYPE::JUMPERLAYER
Inbuilt layer type (cannot be assigned to user layers)
cadstar_pcb_archive_loader.h
Loads a cpa file into a KiCad BOARD object.
BOARD_DESIGN_SETTINGS::m_TrackMinWidth
int m_TrackMinWidth
Definition: board_design_settings.h:683
FOOTPRINT::SetOrientation
void SetOrientation(double aNewAngle)
Definition: footprint.cpp:1549
CADSTAR_PCB_ARCHIVE_LOADER::m_padcodesTested
std::set< PADCODE_ID > m_padcodesTested
Used by getKiCadPad() to avoid multiple duplicate warnings.
Definition: cadstar_pcb_archive_loader.h:110
CADSTAR_ARCHIVE_PARSER::LONGPOINT
Definition: cadstar_archive_parser.h:395
EDA_TEXT::SetVertJustify
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:209
CADSTAR_ARCHIVE_PARSER::ALIGNMENT::TOPRIGHT
CADSTAR_PCB_ARCHIVE_LOADER::getKiCadCopperLayerID
PCB_LAYER_ID getKiCadCopperLayerID(unsigned int aLayerNum, bool aDetectMaxLayer=true)
Definition: cadstar_pcb_archive_loader.cpp:3442
CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Technology
TECHNOLOGY_SECTION Technology
Definition: cadstar_pcb_archive_parser.h:426
INPUT_LAYER_DESC::PermittedLayers
LSET PermittedLayers
KiCad layers that the imported layer can be mapped onto.
Definition: plugin_common_layer_mapping.h:36
Cmts_User
Definition: layers_id_colors_and_visibility.h:121
CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::PadCodes
std::map< PADCODE_ID, PADCODE > PadCodes
Definition: cadstar_pcb_archive_parser.h:389
BOARD_DESIGN_SETTINGS::m_ViasMinSize
int m_ViasMinSize
Definition: board_design_settings.h:685
PAD::SetDrillSize
void SetDrillSize(const wxSize &aSize)
Definition: pad.h:241
ORTHOGONAL_DIMENSION::DIR::VERTICAL
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SIDE::MAXIMUM
The highest PHYSICAL_LAYER_ID currently defined (i.e.
BOARD_DESIGN_SETTINGS::m_HoleClearance
int m_HoleClearance
Definition: board_design_settings.h:690
DIMENSION_BASE::Text
PCB_TEXT & Text()
Definition: dimension.h:209
CADSTAR_ARCHIVE_PARSER::ROUTECODE::Name
wxString Name
Definition: cadstar_archive_parser.h:358
NETCLASS
A collection of nets and the parameters used to route or test these nets.
Definition: netclass.h:46
CADSTAR_PCB_ARCHIVE_PARSER::AREA::Shape
SHAPE Shape
Definition: cadstar_pcb_archive_parser.h:824
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE::SlotLength
long SlotLength
Definition: cadstar_pcb_archive_parser.h:306
CADSTAR_PCB_ARCHIVE_PARSER::COPPER::Shape
SHAPE Shape
Definition: cadstar_pcb_archive_parser.h:1136
CADSTAR_PCB_ARCHIVE_LOADER::getLineChainFromDrawsegments
SHAPE_LINE_CHAIN getLineChainFromDrawsegments(const std::vector< PCB_SHAPE * > aDrawSegments)
Returns a SHAPE_LINE_CHAIN object from a series of PCB_SHAPE objects.
Definition: cadstar_pcb_archive_loader.cpp:2640
FOOTPRINT::Flip
void Flip(const wxPoint &aCentre, bool aFlipLeftRight) override
Flip this object, i.e.
Definition: footprint.cpp:1366
BOARD::SetLayerName
bool SetLayerName(PCB_LAYER_ID aLayer, const wxString &aLayerName)
Changes the name of the layer given by aLayer.
Definition: board.cpp:358
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::ThermalReliefOnPads
bool ThermalReliefOnPads
false when subnode "NOPINRELIEF" is present
Definition: cadstar_pcb_archive_parser.h:1081
CADSTAR_PCB_ARCHIVE_PARSER::LIBRARY::ComponentDefinitions
std::map< SYMDEF_ID, SYMDEF_PCB > ComponentDefinitions
Definition: cadstar_pcb_archive_parser.h:790
ORTHOGONAL_DIMENSION
An orthogonal dimension is like an aligned dimension, but the extension lines are locked to the X or ...
Definition: dimension.h:414
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT::Mirror
bool Mirror
Definition: cadstar_pcb_archive_parser.h:909
PAD::GetName
const wxString & GetName() const
Definition: pad.h:133
CADSTAR_PCB_ARCHIVE_LOADER::getPolarAngle
double getPolarAngle(wxPoint aPoint)
Definition: cadstar_pcb_archive_loader.cpp:3353
CADSTAR_ARCHIVE_PARSER::TEXT::Mirror
bool Mirror
Definition: cadstar_archive_parser.h:876
CADSTAR_PCB_ARCHIVE_PARSER::SYMDEF_PCB::ComponentCoppers
std::vector< COMPONENT_COPPER > ComponentCoppers
Definition: cadstar_pcb_archive_parser.h:779
In8_Cu
Definition: layers_id_colors_and_visibility.h:83
In24_Cu
Definition: layers_id_colors_and_visibility.h:99
PAD::PTHMask
static LSET PTHMask()
layer set for a through hole pad
Definition: pcbnew/pad.cpp:147
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_ID
wxString COMPONENT_ID
Definition: cadstar_pcb_archive_parser.h:71
CADSTAR_PCB_ARCHIVE_PARSER::COPPERCODE_ID
wxString COPPERCODE_ID
Definition: cadstar_pcb_archive_parser.h:60
CADSTAR_PCB_ARCHIVE_PARSER::MATERIAL::Permittivity
EVALUE Permittivity
Definition: cadstar_pcb_archive_parser.h:94
CADSTAR_ARCHIVE_PARSER::TEXT::TextCodeID
TEXTCODE_ID TextCodeID
Definition: cadstar_archive_parser.h:872
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE::ShapeType
PAD_SHAPE_TYPE ShapeType
Definition: cadstar_pcb_archive_parser.h:275
PCB_SHAPE
Definition: pcb_shape.h:43
B_Adhes
Definition: layers_id_colors_and_visibility.h:108
In18_Cu
Definition: layers_id_colors_and_visibility.h:93
DIMENSION_BASE::SetEnd
virtual void SetEnd(const wxPoint &aPoint)
Definition: dimension.h:125
FOOTPRINT::GetReference
const wxString & GetReference() const
Definition: footprint.h:423
F_Adhes
Definition: layers_id_colors_and_visibility.h:109
CADSTAR_PCB_ARCHIVE_PARSER::Assignments
ASSIGNMENTS Assignments
Definition: cadstar_pcb_archive_parser.h:1203
F_Mask
Definition: layers_id_colors_and_visibility.h:118
CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers
void loadCoppers()
Definition: cadstar_pcb_archive_loader.cpp:1783
ZONE::SetDoNotAllowVias
void SetDoNotAllowVias(bool aEnable)
Definition: zone.h:764
CADSTAR_PCB_ARCHIVE_PARSER::NETSYNCH::WARNING
FOOTPRINT::Duplicate
BOARD_ITEM * Duplicate() const override
Create a copy of a of this BOARD_ITEM.
Definition: footprint.cpp:1593
CADSTAR_ARCHIVE_PARSER::DOCUMENTATION_SYMBOL::SymdefID
SYMDEF_ID SymdefID
Normally documentation symbols only have TEXT, FIGURE and TEXT_LOCATION objects which are all drawn o...
Definition: cadstar_archive_parser.h:1193
fp_shape.h
LSET::AllLayersMask
static LSET AllLayersMask()
Definition: lset.cpp:787
CADSTAR_ARCHIVE_PARSER::ALIGNMENT::CENTERCENTER
VIA::SetLayerPair
void SetLayerPair(PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer)
Function SetLayerPair For a via m_layer contains the top layer, the other layer is in m_bottomLayer.
Definition: track.cpp:414
BOARD_STACKUP_ITEM::SetMaterial
void SetMaterial(const wxString &aName, int aDielectricSubLayer=0)
Definition: class_board_stackup.cpp:209
ZONE
ZONE handles a list of polygons defining a copper zone.
Definition: zone.h:57
PAD::GetLayerSet
LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: pad.h:360
CADSTAR_ARCHIVE_PARSER::ALIGNMENT::CENTERLEFT
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT::PartID
PART_ID PartID
Definition: cadstar_pcb_archive_parser.h:897
B_Paste
Definition: layers_id_colors_and_visibility.h:111
CADSTAR_PCB_ARCHIVE_LOADER::getKiCadHatchCodeThickness
int getKiCadHatchCodeThickness(const HATCHCODE_ID &aCadstarHatchcodeID)
Definition: cadstar_pcb_archive_loader.cpp:3031
CADSTAR_PCB_ARCHIVE_LOADER::Load
void Load(BOARD *aBoard, PROJECT *aProject)
Loads a CADSTAR PCB Archive file into the KiCad BOARD object given.
Definition: cadstar_pcb_archive_loader.cpp:44
PART_NAME_ATTRID
#define PART_NAME_ATTRID
Definition: cadstar_archive_parser.h:75
DIMENSION_BASE::SetExtensionOffset
void SetExtensionOffset(int aOffset)
Definition: dimension.h:184
ZONE::SetMinThickness
void SetMinThickness(int aMinThickness)
Definition: zone.h:248
BOARD_DESIGN_SETTINGS::m_CopperEdgeClearance
int m_CopperEdgeClearance
Definition: board_design_settings.h:689
In3_Cu
Definition: layers_id_colors_and_visibility.h:78
CADSTAR_ARCHIVE_PARSER::VERTEX::Type
VERTEX_TYPE Type
Definition: cadstar_archive_parser.h:419
PCB_SHAPE::SetCenter
void SetCenter(const wxPoint &aCenterPoint)
For arcs and circles:
Definition: pcb_shape.h:229
ZONE::SetIsFilled
void SetIsFilled(bool isFilled)
Definition: zone.h:238
ALTIUM_DIMENSION_KIND::LEADER
CADSTAR_ARCHIVE_PARSER::HATCHCODE
Definition: cadstar_archive_parser.h:299
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Position
POINT Position
Definition: cadstar_archive_parser.h:661
CADSTAR_ARCHIVE_PARSER::FixTextPositionNoAlignment
static void FixTextPositionNoAlignment(EDA_TEXT *aKiCadTextItem)
Corrects the position of a text element that had NO_ALIGNMENT in CADSTAR.
Definition: cadstar_archive_parser.cpp:2526
CADSTAR_PCB_ARCHIVE_LOADER::m_zonesMap
std::map< TEMPLATE_ID, ZONE * > m_zonesMap
Map between Cadstar and KiCad zones.
Definition: cadstar_pcb_archive_loader.h:101
FOOTPRINT::SetValue
void SetValue(const wxString &aValue)
Definition: footprint.h:453
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_PAD::Identifier
wxString Identifier
This is an identifier that is displayed to the user.
Definition: cadstar_pcb_archive_parser.h:534
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SIDE::THROUGH_HOLE
All physical layers currently defined.
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::AutomaticRepour
bool AutomaticRepour
true when subnode "REGENERATE" is present
Definition: cadstar_pcb_archive_parser.h:1085
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE::DrillYoffset
long DrillYoffset
Definition: cadstar_pcb_archive_parser.h:309
VECTOR2::Angle
double Angle() const
Compute the angle of the vector.
Definition: vector2d.h:307
In16_Cu
Definition: layers_id_colors_and_visibility.h:91
KEY_PREPREG
#define KEY_PREPREG
Definition: stackup_predefined_prms.h:42
F_Fab
Definition: layers_id_colors_and_visibility.h:131
F_Cu
Definition: layers_id_colors_and_visibility.h:75
PAD::SetShape
void SetShape(PAD_SHAPE_T aShape)
Set the new shape of this pad.
Definition: pad.h:160
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SIDE::MINIMUM
PHYSICAL_LAYER_ID 1 (i.e.
DIMENSION_BASE::SetSuffix
void SetSuffix(const wxString &aSuffix)
Definition: dimension.cpp:138
CADSTAR_ARCHIVE_PARSER::PART_ID
wxString PART_ID
Definition: cadstar_archive_parser.h:95
In25_Cu
Definition: layers_id_colors_and_visibility.h:100
CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::Figures
std::map< FIGURE_ID, FIGURE > Figures
Definition: cadstar_pcb_archive_parser.h:1183
CADSTAR_ARCHIVE_PARSER::TEXTCODE::Height
long Height
Definition: cadstar_archive_parser.h:333
SHAPE_POLY_SET::BooleanIntersection
void BooleanIntersection(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset union between a and b, store the result in it self For aFastMode meaning,...
Definition: shape_poly_set.cpp:522
CADSTAR_ARCHIVE_PARSER::TEXT
Definition: cadstar_archive_parser.h:868
F_Paste
Definition: layers_id_colors_and_visibility.h:112
CADSTAR_PCB_ARCHIVE_LOADER::getAttributeName
wxString getAttributeName(const ATTRIBUTE_ID &aCadstarAttributeID)
Definition: cadstar_pcb_archive_loader.cpp:2967
CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::LayerID
LAYER_ID LayerID
Definition: cadstar_archive_parser.h:660
BOARD_STACKUP_ITEM
this class manage one layer needed to make a physical board it can be a solder mask,...
Definition: class_board_stackup.h:88
SHAPE_POLY_SET::HoleCount
int HoleCount(int aOutline) const
Return the reference to aIndex-th outline in the set.
Definition: shape_poly_set.h:632
ISLAND_REMOVAL_MODE::ALWAYS
CADSTAR_PCB_ARCHIVE_PARSER::Library
LIBRARY Library
Definition: cadstar_pcb_archive_parser.h:1204
PAD::SetRoundRectRadiusRatio
void SetRoundRectRadiusRatio(double aRadiusScale)
Has meaning only for rounded rectangle pads.
Definition: pcbnew/pad.cpp:252
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE_TYPE::CIRCLE
Keyword "ROUND".
B_Fab
Definition: layers_id_colors_and_visibility.h:130
CADSTAR_ARCHIVE_PARSER::SYMDEF::Origin
POINT Origin
Origin of the component (this is used as the reference point when placing the component in the design...
Definition: cadstar_archive_parser.h:901
CADSTAR_PCB_ARCHIVE_PARSER::CADSTAR_BOARD::GroupID
GROUP_ID GroupID
If not empty, this CADSTAR_BOARD is part of a group.
Definition: cadstar_pcb_archive_parser.h:804
CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::ReuseBlocks
std::map< REUSEBLOCK_ID, REUSEBLOCK > ReuseBlocks
Definition: cadstar_pcb_archive_parser.h:1179
ORTHOGONAL_DIMENSION::SetOrientation
void SetOrientation(DIR aOrientation)
Sets the orientation of the dimension line (so, perpendicular to the feature lines)
Definition: dimension.h:447
CADSTAR_ARCHIVE_PARSER::UNDEFINED_VALUE
static const long UNDEFINED_VALUE
Definition: cadstar_archive_parser.h:109
CADSTAR_PCB_ARCHIVE_PARSER::EMBEDDING::BELOW
CADSTAR_ARCHIVE_PARSER::VERTEX::End
POINT End
Definition: cadstar_archive_parser.h:421
CADSTAR_ARCHIVE_PARSER::TEXT_LOCATION
Corresponds to CADSTAR "origin".
Definition: cadstar_archive_parser.h:742
SHAPE_LINE_CHAIN::GetPoint
virtual const VECTOR2I GetPoint(int aIndex) const override
Definition: shape_line_chain.h:758
SHAPE_POLY_SET::Fracture
void Fracture(POLYGON_MODE aFastMode)
Convert a single outline slitted ("fractured") polygon into a set ouf outlines with holes.
Definition: shape_poly_set.cpp:874
SHAPE_POLY_SET::AddHole
int AddHole(const SHAPE_LINE_CHAIN &aHole, int aOutline=-1)
Return the area of this poly set.
Definition: shape_poly_set.cpp:439
LSEQ
LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
Definition: layers_id_colors_and_visibility.h:468
CADSTAR_PCB_ARCHIVE_LOADER::loadGroups
void loadGroups()
Definition: cadstar_pcb_archive_loader.cpp:1028
CADSTAR_ARCHIVE_PARSER::SHAPE::Vertices
std::vector< VERTEX > Vertices
Definition: cadstar_archive_parser.h:450
CADSTAR_ARCHIVE_PARSER::VARIANT
< Nodename = "VARIANT" or "VMASTER" (master variant
Definition: cadstar_archive_parser.h:249
BOARD_STACKUP_ITEM::SetEpsilonR
void SetEpsilonR(double aEpsilon, int aDielectricSubLayer=0)
Definition: class_board_stackup.cpp:191
PAD::SetDrillShape
void SetDrillShape(PAD_DRILL_SHAPE_T aShape)
Definition: pad.h:345
FP_TEXT::SetPos0
void SetPos0(const wxPoint &aPos)
Definition: fp_text.h:165
ZONE::SetFilledPolysList
void SetFilledPolysList(PCB_LAYER_ID aLayer, const SHAPE_POLY_SET &aPolysList)
Function SetFilledPolysList sets the list of filled polygons.
Definition: zone.h:670
CADSTAR_ARCHIVE_PARSER::HATCHCODE::Name
wxString Name
Definition: cadstar_archive_parser.h:302
CADSTAR_ARCHIVE_PARSER::EVALUE::GetDouble
double GetDouble()
Definition: cadstar_archive_parser.cpp:376
GR_TEXT_HJUSTIFY_LEFT
Definition: eda_text.h:62
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE::SlotOrientation
long SlotOrientation
Definition: cadstar_pcb_archive_parser.h:307
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE_TYPE::DIAMOND
BOARD_STACKUP_ITEM::SetThickness
void SetThickness(int aThickness, int aDielectricSubLayer=0)
Definition: class_board_stackup.cpp:173
CADSTAR_ARCHIVE_PARSER::TEXTCODE_ID
wxString TEXTCODE_ID
Definition: cadstar_archive_parser.h:90
CADSTAR_PCB_ARCHIVE_PARSER::AREA::Name
wxString Name
Definition: cadstar_pcb_archive_parser.h:822
PCB_TEXT
Definition: pcb_text.h:36
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_SUBTYPE::LAYERSUBTYPE_SOLDERRESIST
PAD::SetRoundRectCornerRadius
void SetRoundRectCornerRadius(double aRadius)
Has meaning only for rounded rectangle pads.
Definition: pcbnew/pad.cpp:243
In10_Cu
Definition: layers_id_colors_and_visibility.h:85
CADSTAR_PCB_ARCHIVE_LOADER::loadComponentLibrary
void loadComponentLibrary()
Definition: cadstar_pcb_archive_loader.cpp:646
In21_Cu
Definition: layers_id_colors_and_visibility.h:96
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_COPPER::LayerID
LAYER_ID LayerID
Definition: cadstar_pcb_archive_parser.h:441
Format
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
CADSTAR_PCB_ARCHIVE_LOADER::m_project
PROJECT * m_project
Definition: cadstar_pcb_archive_loader.h:84
CADSTAR_PCB_ARCHIVE_PARSER::LAYERDEFS::LayerStack
std::vector< LAYER_ID > LayerStack
Definition: cadstar_pcb_archive_parser.h:177
UNDEFINED_LAYER
Definition: layers_id_colors_and_visibility.h:71
CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::SpacingCodes
std::map< SPACINGCODE_ID, SPACINGCODE > SpacingCodes
Spacing Design Rules.
Definition: cadstar_pcb_archive_parser.h:387
PAD::SetChamferPositions
void SetChamferPositions(int aPositions)
Has meaning only for chamfered rectangular pads.
Definition: pad.h:533
In11_Cu
Definition: layers_id_colors_and_visibility.h:86
CADSTAR_PCB_ARCHIVE_LOADER::getPadCode
PADCODE getPadCode(const PADCODE_ID &aCadstarPadCodeID)
Definition: cadstar_pcb_archive_loader.cpp:2934
BOARD_DESIGN_SETTINGS::m_MinThroughDrill
int m_MinThroughDrill
Definition: board_design_settings.h:686
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::NetID
NET_ID NetID
Definition: cadstar_pcb_archive_parser.h:1098
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::ID
TEMPLATE_ID ID
Definition: cadstar_pcb_archive_parser.h:1095
KIGFX::NONE
No updates are required.
Definition: view_item.h:51
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_PAD
Definition: cadstar_pcb_archive_parser.h:525
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT::PadExceptions
std::map< PAD_ID, PADEXCEPTION > PadExceptions
Override pad definitions for this instance.
Definition: cadstar_pcb_archive_parser.h:922
CADSTAR_PCB_ARCHIVE_LOADER::getTextCode
TEXTCODE getTextCode(const TEXTCODE_ID &aCadstarTextCodeID)
Definition: cadstar_pcb_archive_loader.cpp:2923
ZONE_CONNECTION::THERMAL
Use thermal relief for pads.
FOOTPRINT::SetFPID
void SetFPID(const LIB_ID &aFPID)
Definition: footprint.h:191
FP_TEXT::SetKeepUpright
void SetKeepUpright(bool aKeepUpright)
Definition: fp_text.h:115
CADSTAR_PCB_ARCHIVE_PARSER::AREA::Keepout
bool Keepout
From CADSTAR Help: "Auto Placement cannot place components within this area.
Definition: cadstar_pcb_archive_parser.h:835
CADSTAR_PCB_ARCHIVE_LOADER::getLineThickness
int getLineThickness(const LINECODE_ID &aCadstarLineCodeID)
Definition: cadstar_pcb_archive_loader.cpp:2902
PAD::TransformShapeWithClearanceToPolygon
void TransformShapeWithClearanceToPolygon(SHAPE_POLY_SET &aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aMaxError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=false) const override
Convert the pad shape to a closed polygon.
Definition: board_items_to_polygon_shape_transform.cpp:601
PCB_TEXT::Move
void Move(const wxPoint &aMoveVector) override
Move this object.
Definition: pcb_text.h:82
CADSTAR_ARCHIVE_PARSER::UNITS::MM
CADSTAR_PCB_ARCHIVE_PARSER::COPPER
Definition: cadstar_pcb_archive_parser.h:1112
NETINFO_ITEM
Handle the data for a net.
Definition: netinfo.h:64
BOARD_DESIGN_SETTINGS::m_MinClearance
int m_MinClearance
Definition: board_design_settings.h:682
CADSTAR_ARCHIVE_PARSER::SHAPE::Cutouts
std::vector< CUTOUT > Cutouts
Not Applicable to OPENSHAPE Type.
Definition: cadstar_archive_parser.h:451
CADSTAR_ARCHIVE_PARSER::LONGPOINT::x
long x
Definition: cadstar_archive_parser.h:397
LIB_ID::Parse
int Parse(const UTF8 &aId, bool aFix=false)
Parse LIB_ID with the information from aId.
Definition: lib_id.cpp:122
ZONE::SetPadConnection
void SetPadConnection(ZONE_CONNECTION aPadConnection)
Definition: zone.h:245
CADSTAR_ARCHIVE_PARSER::CODEDEFS::TextCodes
std::map< TEXTCODE_ID, TEXTCODE > TextCodes
Definition: cadstar_archive_parser.h:779
GR_TEXT_VJUSTIFY_TOP
Definition: eda_text.h:69
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE::Plated
bool Plated
Definition: cadstar_pcb_archive_parser.h:303
PAD::SetLayerSet
void SetLayerSet(LSET aLayers) override
Definition: pad.h:359
CADSTAR_PCB_ARCHIVE_PARSER::COPPER::PouredTemplateID
TEMPLATE_ID PouredTemplateID
If not empty, it means this COPPER is part of a poured template.
Definition: cadstar_pcb_archive_parser.h:1137
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_PAD::Exits
PAD_EXITS Exits
See PAD_EXITS.
Definition: cadstar_pcb_archive_parser.h:532
ZONE::SetMinIslandArea
void SetMinIslandArea(long long int aArea)
Definition: zone.h:774
CADSTAR_PCB_ARCHIVE_LOADER::getDrawSegmentFromVertex
PCB_SHAPE * getDrawSegmentFromVertex(const POINT &aCadstarStartPoint, const VERTEX &aCadstarVertex, BOARD_ITEM_CONTAINER *aContainer=nullptr, const GROUP_ID &aCadstarGroupID=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
Returns a pointer to a PCB_SHAPE object.
Definition: cadstar_pcb_archive_loader.cpp:2447
BOARD_CONNECTED_ITEM::SetNet
void SetNet(NETINFO_ITEM *aNetInfo)
Set a NET_INFO object for the item.
Definition: board_connected_item.h:85
BOARD_STACKUP::RemoveAll
void RemoveAll()
Delete all items in list and clear the list.
Definition: class_board_stackup.cpp:365
CADSTAR_ARCHIVE_PARSER::UNITS
UNITS
Definition: cadstar_archive_parser.h:459
CADSTAR_PCB_ARCHIVE_PARSER::Layout
LAYOUT Layout
Definition: cadstar_pcb_archive_parser.h:1206
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::Shape
SHAPE Shape
Definition: cadstar_pcb_archive_parser.h:1101
CADSTAR_PCB_ARCHIVE_PARSER::NET_PCB::Vias
std::map< NETELEMENT_ID, VIA > Vias
Definition: cadstar_pcb_archive_parser.h:1015
ERROR_INSIDE
Definition: geometry_utils.h:45
In23_Cu
Definition: layers_id_colors_and_visibility.h:98
CADSTAR_ARCHIVE_PARSER::UNITS::INCH
CADSTAR_PCB_ARCHIVE_PARSER::LAYER_TYPE::ALLELEC
Inbuilt layer type (cannot be assigned to user layers)
CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::Dimensions
std::map< DIMENSION_ID, DIMENSION > Dimensions
Definition: cadstar_pcb_archive_parser.h:1192
CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE_TYPE::BULLET
CADSTAR_PCB_ARCHIVE_PARSER::AREA::NoTracks
bool NoTracks
From CADSTAR Help: "Area cannot be used to place routes during automatic routing.
Definition: cadstar_pcb_archive_parser.h:837
In6_Cu
Definition: layers_id_colors_and_visibility.h:81
CADSTAR_ARCHIVE_PARSER::VERTEX_TYPE::ANTICLOCKWISE_ARC
CADSTAR_PCB_ARCHIVE_PARSER::NET_PCB
Definition: cadstar_pcb_archive_parser.h:938
DEG2RAD
double DEG2RAD(double deg)
Definition: trigo.h:231
In13_Cu
Definition: layers_id_colors_and_visibility.h:88
PCB_SHAPE::SetStart
void SetStart(const wxPoint &aStart)
Definition: pcb_shape.h:148
CADSTAR_PCB_ARCHIVE_LOADER::m_netMap
std::map< NET_ID, NETINFO_ITEM * > m_netMap
Map between Cadstar and KiCad Nets.
Definition: cadstar_pcb_archive_loader.h:99
stackup_predefined_prms.h
BOARD
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:190
CADSTAR_ARCHIVE_PARSER::UNITS::MICROMETRE
GR_TEXT_HJUSTIFY_CENTER
Definition: eda_text.h:63
CADSTAR_ARCHIVE_PARSER::NET::Name
wxString Name
This is undefined (wxEmptyString) if the net is unnamed.
Definition: cadstar_archive_parser.h:1170
CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::EXTENSION_LINE::Start
POINT Start
Definition: cadstar_pcb_archive_parser.h:645
CADSTAR_PCB_ARCHIVE_PARSER::PADCODE::DrillDiameter
long DrillDiameter
Definition: cadstar_pcb_archive_parser.h:304
EDA_TEXT::SetHorizJustify
void SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
Definition: eda_text.h:208
CADSTAR_PCB_ARCHIVE_LOADER::m_logLayerWarnings
bool m_logLayerWarnings
Used in loadBoardStackup()
Definition: cadstar_pcb_archive_loader.h:82
ZONE::SetDoNotAllowCopperPour
void SetDoNotAllowCopperPour(bool aEnable)
Definition: zone.h:763
In22_Cu
Definition: layers_id_colors_and_visibility.h:97
INPUT_LAYER_DESC::Name
wxString Name
Imported layer name as displayed in original application.
Definition: plugin_common_layer_mapping.h:35
PAD_DRILL_SHAPE_OBLONG
Definition: pad_shapes.h:69
_
#define _(s)
Definition: 3d_actions.cpp:33
CADSTAR_PCB_ARCHIVE_LOADER::createUniqueGroupID
GROUP_ID createUniqueGroupID(const wxString &aName)
Adds a new PCB_GROUP* to m_groupMap.
Definition: cadstar_pcb_archive_loader.cpp:3557
SHAPE_LINE_CHAIN
SHAPE_LINE_CHAIN.
Definition: shape_line_chain.h:46
DIMENSION_BASE::SetPrecision
void SetPrecision(int aPrecision)
Definition: dimension.h:170
CADSTAR_PCB_ARCHIVE_LOADER::m_doneCopperWarning
bool m_doneCopperWarning
Used by loadCoppers() to avoid multiple duplicate warnings.
Definition: cadstar_pcb_archive_loader.h:112
ORTHOGONAL_DIMENSION::DIR::HORIZONTAL
CADSTAR_ARCHIVE_PARSER::ROUTECODE
Definition: cadstar_archive_parser.h:355
CADSTAR_ARCHIVE_PARSER::ALIGNMENT::BOTTOMLEFT
SHAPE_POLY_SET::COutline
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
Definition: shape_poly_set.h:692
CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::Coppers
std::map< COPPER_ID, COPPER > Coppers
Definition: cadstar_pcb_archive_parser.h:1190
NormalizeAnglePos
T NormalizeAnglePos(T Angle)
Normalize angle to be in the 0.0 .
Definition: trigo.h:279
CADSTAR_PCB_ARCHIVE_LOADER::getKiCadLayer
PCB_LAYER_ID getKiCadLayer(const LAYER_ID &aCadstarLayerID)
Definition: cadstar_pcb_archive_loader.cpp:3509
CADSTAR_ARCHIVE_PARSER::CODEDEFS::HatchCodes
std::map< HATCHCODE_ID, HATCHCODE > HatchCodes
Definition: cadstar_archive_parser.h:778
ZONE_SETTINGS::m_HatchThickness
int m_HatchThickness
Definition: zone_settings.h:84
PNS::angle
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
Definition: pns_diff_pair.cpp:178
PAD::SetPosition
void SetPosition(const wxPoint &aPos) override
Definition: pad.h:171
CADSTAR_PCB_ARCHIVE_LOADER::addToGroup
void addToGroup(const GROUP_ID &aCadstarGroupID, BOARD_ITEM *aKiCadItem)
Definition: cadstar_pcb_archive_loader.cpp:3547
CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::POURING::SliverWidth
long SliverWidth
Minimum width of copper that may be created.
Definition: cadstar_pcb_archive_parser.h:1068
RECT_CHAMFER_TOP_LEFT
Definition: convert_basic_shapes_to_polygon.h:40
CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_PAD::ID
PAD_ID ID
Definition: cadstar_pcb_archive_parser.h:527
CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarCutoutsAsSegments
void drawCadstarCutoutsAsSegments(const std::vector< CUTOUT > &aCutouts, const PCB_LAYER_ID &aKiCadLayer, const int &aLineThickness, BOARD_ITEM_CONTAINER *aContainer, const GROUP_ID &aCadstarGroupID=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
Uses PCB_SHAPE to draw the cutouts on m_board object.
Definition: cadstar_pcb_archive_loader.cpp:2380
In5_Cu
Definition: layers_id_colors_and_visibility.h:80
CADSTAR_ARCHIVE_PARSER::DOCUMENTATION_SYMBOL::OrientAngle
long OrientAngle
Definition: cadstar_archive_parser.h:1203
PCB_SHAPE::GetAngle
double GetAngle() const
Definition: pcb_shape.h:127
CADSTAR_ARCHIVE_PARSER::TEXT_FIELD_NAME::DESIGN_TITLE
BOARD_DESIGN_SETTINGS::m_ViasMinAnnulus
int m_ViasMinAnnulus
Definition: board_design_settings.h:684
CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryFigures
void loadLibraryFigures(const SYMDEF_PCB &aComponent, FOOTPRINT *aFootprint)
Definition: cadstar_pcb_archive_loader.cpp:672
PAD_ATTRIB_PTH
Plated through hole pad.
Definition: pad_shapes.h:80
PAD_SHAPE_CUSTOM
Definition: pad_shapes.h:42
VIA::SetDrill
void SetDrill(int aDrill)
Function SetDrill sets the drill value for vias.
Definition: track.h:474
BOARD_DESIGN_SETTINGS::GetDefault
NETCLASS * GetDefault() const
Definition: board_design_settings.h:267
CADSTAR_ARCHIVE_PARSER::ALIGNMENT::BOTTOMRIGHT
FP_SHAPE::GetEnd0
const wxPoint & GetEnd0() const
Definition: fp_shape.h:115
PAD::AddPrimitive
void AddPrimitive(PCB_SHAPE *aPrimitive)
Add item to the custom shape primitives list.
Definition: pad_custom_shape_functions.cpp:167
PCB_SHAPE::SetWidth
void SetWidth(int aWidth)
Definition: pcb_shape.h:117
In17_Cu
Definition: layers_id_colors_and_visibility.h:92